How did you install jellyfin?

It should not core-dump (read: hard crash, something has gone terribly wrong), at best you should get a configuration error and errors like that.

You can see the logs of any systemd service/unit with this: journalctl -u <name of sevice> so in this case journalctl -u jellyfin (Tip: add -f to follow the output of a running service - useful for monitoring).

Note that some programs log to their own files (and not to stdout) so if the above command comes out empty you should look into /var/log/ directory.

I see other commenters saying you should use docker. And I agree. If you are set on doing this without learning docker, feel free to ignore this comment.

Otherwise, I would argue that learning docker and docker compose is a good investment for your linux learning. The TL;DR of docker is that it is a way to run software like jellyfin, which is prone to issues like you are currently seeing when running on “bare metal” (here defined as simply: not running in docker), in an environment created specifically for that software.

Docker makes it so other (usually really knowledgeable) people can set up a server that runs some software properly. It has all the files in the right place, any recurring jobs happening, all the permissions set up, etc. And then, they create a snapshot of that server and put it in a docker image. That image is publicly distributed and others (like you and me) can take that image to start a container. The terms are not super intuitive. But an image can be thought of as a “snapshot” of a specific computer at a specific time; it is usually set up to run a specific task. And a container is an actually running instance built off one of those snapshots.

To tie this into your use case, the idea is that you use docker to take a popular and robust jellyfin image and use docker to create a container that’s running jellyfin smooth as silk for you to use. Docker is popular amongst the self-hosting community because containers don’t tend to run into issues like you see above. Docker and/or the image itself control what environment variables they receive, what other software might be running with them, and a whole host of other headaches that come with running the service “bare metal.”

Some comments mention Docker Compose. This can be thought of as an extension to docker functionality. To run a container in docker, you’ll run a command like docker run -d <a whole goddamn host of arguments> lscr.io/linuxserver/jellyfin:latest where lscr.io/linuxserver/jellyfin is the image you want to use and latest is the tag (which is essentially the image’s version except that some tags, like latest, change what they point to). This is totally fine and will work. But it’s hard to make updates. The “whole goddamn host of arguments” will have important information about how your host server interacts with the container. It’ll specify things like what ports from your host are forwarded to the container, what files from within the container persist after it has been stopped, and what environment variables the container runs with. With “base” docker, you need to run a command like this to bring up a container, which can get hugely cumbersome if you’rr maintaining a lot of services in containers or are trying to experiment with different container arguments. Docker Compose is a way to specify containers you want to bring up in a YAML file so that you don’t need to type out or remember each service’s command every time. I would strongly recommend using Docker Compose as well.

So, I’d recommend taking the time to install Docker and Docker Compose. And then the little extra learning curve to use them to run jellyfin in a container. It will take more time now, but save you time in the long run. You will know you have installed docker and docker compose correctly if you can run the command docker --version and see your version information and docker compose version and similarly see version information.

Appendix:

• Install Docker - I believe this installation comes with compose too, but it’s been a while.
• LSCR Jellyfin Image - I would recommend this image over the official jellyfin one; it’s easier to set up. It’s the one I use.

My last note: we all started as noobs. I give this advice because it is the advice I would give my earlier self. I believe that the time investment in this now will save you a lot of pain both in avoiding the debugging now and in avoiding this debugging in future. Please feel free to reach out if you have questions.

I highly recommend taking the time to learn docker instead of running directly.

What the fuck is up with all these docker comments?

Check your binaries, might not be the right ones for your platform

I need to see the logs in order to help you.

I personally moved to containers as they are easier to maintain and update

Learn a docker compose deploy. It’s a knowledge that pays off for services other than jellyfin too.

Maybe a docker install would be easier… something like this might help

https://lemmy.dbzer0.com/post/5911320

I haven’t run Jellyfin outside of docker in ages, but looks like you have at least one set of conflicting tags in your exec section of that service file you posted (web something or other I can’t see on mobile once starting this reply - you have a flat setting it and a flag disabling it).

Edit - also do you actually have something set for that list of variables in your exec?

We’re going to need to know as a minimum:

• Linux distribution and version
• Jellyfin install method and version
• what you have already tried- not sure where all those flags are coming from

I would also support the comments here recommending that you use docker. There’s only a small number of Linux distributions and versions where a distribution package installation of jellyfin is fully supported, but even then what you need to do varies across each one. All Linux distributions and versions support docker and the process is essentially the same for all of them.

For possibly more information on why the core is dumping (lol) try running jellyfin from the cli (probably just typing the path to the jellyfin executable and pressing enter)

If nothing interesting is printed, try adding strace before the jellyfin executable (Google strace, it intercepts all system calls and logs them) if that doesn’t work tell strace to follow forks.

Other than that you could start using binary debugging tools to see what shared libraries jellyfin is looking for? Maybe run it in gdb…

Removed by mod

I’m guessing you installed from Flatpak and it doesn’t have the permissions to touch what it needs to outside of the sandbox.

Install plainly, or run a container with the proper permissions.

The easiest way I’ve found is to install CasaOS on Ubuntu. It has a web interface with an app store. Click install and it’s basically done.