0 - en to sv-SE translation catalogue (133 entries)

en: Kernel
sv-SE: Kärna

en: Hierarchy
sv-SE: Hierarki

en: Basic Commands
sv-SE: Grundläggande kommandon

en: Short Remedial Course
sv-SE: Kort snabbkurs

en: Even though this book primarily targets administrators and “power-users”, we wouldn't like to exclude motivated beginners. This appendix will therefore be a crash-course describing the fundamental concepts involved in handling a Unix computer.
sv-SE: Även om denna bok i huvudsak har administratörer och avancerade användare som målgrupp vill vi inte exkludera motiverade nybörjare. Denna bilaga kommer därför att utgöra en snabbkurs som beskriver de grundläggande koncepten som inbegrips i att hantera en Unix-dator.

en: Shell and Basic Commands
sv-SE: Skalet och grundläggande kommandon

en: In the Unix world, every administrator has to use the command line sooner or later; for example, when the system fails to start properly and only provides a command-line rescue mode. Being able to handle such an interface, therefore, is a basic survival skill for these circumstances.
sv-SE: I Unix-världen måste varje administratör använda kommandoraden förr eller senare; till exempel när systemet misslyckas med att starta upp korrekt och endast tillgängliggör ett räddningsläge med en kommandorad. Att kunna hantera ett sådant gränssnitt är därför en grundläggande överlevnadskunskap under dessa förutsättningar.

en: <emphasis>QUICK LOOK</emphasis> Starting the command interpreter
sv-SE: <emphasis>SNABBTITT</emphasis> Starta kommandotolken

en: This section only gives a quick peek at the commands. They all have many options not described here, so please refer to the abundant documentation in their respective manual pages.
sv-SE: Detta avsnitt ger endast en snabbtitt på kommandona. De har alla flertalet flaggor som inte beskrivs här, så referera till den rikliga dokumentationen i deras respektive manualsidor.

en: Browsing the Directory Tree and Managing Files
sv-SE: Att bläddra i katalogstrukturen och att hantera filer

en: Once a session is open, the <command>pwd</command> command (which stands for <emphasis>print working directory</emphasis>) displays the current location in the filesystem. The current directory is changed with the <command>cd <replaceable>directory</replaceable></command> command (<command>cd</command> is for <emphasis>change directory</emphasis>). The parent directory is always called <literal>..</literal> (two dots), whereas the current directory is also known as <literal>.</literal> (one dot). The <command>ls</command> command allows <emphasis>listing</emphasis> the contents of a directory. If no parameters are given, it operates on the current directory.
sv-SE: När en session är öppen visar kommandot <command>pwd</command> (som står för <emphasis>print working directory</emphasis>, skriv ut arbetskatalog) den aktuella platsen i filsystemet. Den aktuella katalogen ändras med kommandot <command>cd <replaceable>katalog</replaceable></command> (<command>cd</command> är kort för <emphasis>change directory</emphasis>, byt katalog). Föräldrakatalogen kallas alltid <literal>..</literal> (två punkter), medan den aktuella katalogen också är känd som <literal>.</literal> (en punkt). Kommandot <command>ls</command> möjliggör <emphasis>listning</emphasis> av innehållet i en katalog. Om inga parametrar anges arbetar det på den aktuella katalogen.

en: A new directory can be created with <command>mkdir <replaceable>directory</replaceable></command>, and an existing (empty) directory can be removed with <command>rmdir <replaceable>directory</replaceable></command>. The <command>mv</command> command allows <emphasis>moving</emphasis> and/or renaming files and directories; <emphasis>removing</emphasis> a file is achieved with <command>rm <replaceable>file</replaceable></command>.
sv-SE: En ny katalog kan skapas med <command>mkdir <replaceable>katalog</replaceable></command>, och en existerande (tom) katalog kan tas bort med <command>rmdir <replaceable>katalog</replaceable></command>. Kommandot <command>mv</command> möjliggör <emphasis>förflyttning</emphasis> (moving) och/eller namnbyte för filer och kataloger; <emphasis>borttagning</emphasis> av en fil åstadkoms med <command>rm <replaceable>fil</replaceable></command>.

en: Displaying and Modifying Text Files
sv-SE: Visa och modifiera textfiler

en: The <command>cat <replaceable>file</replaceable></command> command (intended to <emphasis>concatenate</emphasis> files to the standard output device) reads a file and displays its contents on the terminal. If the file is too big to fit on a screen, use a pager such as <command>less</command> (or <command>more</command>) to display it page by page.
sv-SE: Kommandot <command>cat <replaceable>fil</replaceable></command> (avsett att <emphasis>konkatenera</emphasis> filer till enheten standard ut) läser en fil och visar dess innehåll i terminalen. Om en fil är för stor för att få plats på en skärm, använd en sidvisare så som <command>less</command> (eller <command>more</command>) för att visa den sida för sida.

en: The <command>editor</command> command starts a text editor (such as <command>vi</command> or <command>nano</command>) and allows creating, modifying and reading text files. The simplest files can sometimes be created directly from the command interpreter thanks to redirection: <command>echo "<replaceable>text</replaceable>" &gt;<replaceable>file</replaceable></command> creates a file named <replaceable>file</replaceable> with “<replaceable>text</replaceable>” as its contents. Adding a line at the end of this file is possible too, with a command such as <command>echo "<replaceable>moretext</replaceable>" &gt;&gt;<replaceable>file</replaceable></command>. Note the <literal>&gt;&gt;</literal> in this example.
sv-SE: Kommandot <command>editor</command> startar en textredigerare (så som <command>vi</command> eller <command>nano</command>) och tillåter skapande, modifiering och läsning av textfiler. De enklaste filerna kan ibland skapas direkt från kommandotolken tack vare omdirigering: <command>echo "<replaceable>text</replaceable>" &gt; <replaceable>fil</replaceable></command> skapar en fil vid namn <replaceable>fil</replaceable> med innehållet ”<replaceable>text</replaceable>”. Att lägga till en rad på slutet av filen är också möjligt, med ett kommando så som <command>echo "<replaceable>mertext</replaceable>" &gt;&gt;<replaceable>fil</replaceable></command>. Notera <literal>&gt;&gt;</literal> i detta exempel.

en: Searching for Files and within Files
sv-SE: Att söka efter filer och inom filer

en: The <command>find <replaceable>directory</replaceable> <replaceable>criteria</replaceable></command> command looks for files in the hierarchy under <replaceable>directory</replaceable> according to several criteria. The most commonly used criterion is <literal>-name <replaceable>name</replaceable></literal>: that allows looking for a file by its name.
sv-SE: Kommandot <command>find <replaceable>katalog</replaceable> <replaceable>kriterier</replaceable></command> letar efter filer i hierarkin under <replaceable>katalog</replaceable> enligt flertalet kriterier. Det vanligaste kriteriet är <literal>-name <replaceable>namn</replaceable></literal>: detta möjliggör sökning efter en fil efter namn.

en: The <command>grep <replaceable>expression</replaceable> <replaceable>files</replaceable></command> command searches the contents of the files and extracts the lines matching the regular expression (see sidebar <xref linkend="sidebar.regexp" />). Adding the <literal>-r</literal> option enables a recursive search on all files contained in the directory passed as a parameter. This allows looking for a file when only a part of the contents are known.
sv-SE: Kommandot <command>grep <replaceable>uttryck</replaceable> <replaceable>filer</replaceable></command> genomsöker innehållet i filerna och extraherar rader som matchar det reguljära uttrycket (se sidopanelen <xref linkend="sidebar.regexp" />). Att lägga till flaggan <literal>-r</literal> aktiverar en rekursiv sökning av alla filer som finns i katalogen som anges som parameter. Detta möjliggör sökning efter en fil när endast en del av dess innehåll är känt.

en: Managing Processes
sv-SE: Hantera processer

en: The <command>ps aux</command> command lists the processes currently running and helps identifying them by showing their <emphasis>pid</emphasis> (process id). Once the <emphasis>pid</emphasis> of a process is known, the <command>kill -<replaceable>signal</replaceable> <replaceable>pid</replaceable></command> command allows sending it a signal (if the process belongs to the current user). Several signals exist; most commonly used are <literal>TERM</literal> (a request to terminate gracefully) and <literal>KILL</literal> (a forced kill).
sv-SE: Kommandot <command>ps aux</command> listar processerna som för närvarande kör och hjälper till att identifiera dem genom att visa deras <emphasis>pid</emphasis> (process-ID). När <emphasis>pid</emphasis> för en process är känt låter kommandot <command>kill -<replaceable>signal</replaceable> <replaceable>pid</replaceable></command> en signal skickas till processen (om processen tillhör den aktuella användaren). Flera signaler existerar; vanligast är <literal>TERM</literal> (en begäran om att graciöst avsluta programmet) och <literal>KILL</literal> (en påtvingad död).

en: The command interpreter can also run programs in the background if the command is followed by a “&amp;”. By using the ampersand, the user resumes control of the shell immediately even though the command is still running (hidden from the user; as a background process). The <command>jobs</command> command lists the processes running in the background; running <command>fg %<replaceable>job-number</replaceable></command> (for <emphasis>foreground</emphasis>) restores a job to the foreground. When a command is running in the foreground (either because it was started normally, or brought back to the foreground with <command>fg</command>), the <keycombo action="simul"><keycap>Control</keycap><keycap>Z</keycap></keycombo> key combination pauses the process and resumes control of the command-line. The process can then be restarted in the background with <command>bg %<replaceable>job-number</replaceable></command> (for <foreignphrase>background</foreignphrase>).
sv-SE: Kommandotolken kan också köra program i bakgrunden om kommandot åtföljs av ett ”&amp;”. Genom att använda och-tecknet återfår användare kontrollen av skalet omedelbart även om programmet fortfarande kör (gömt från användaren; som en bakgrundsprocess). Kommandot <command>jobs</command> listar processerna som kör i bakgrunden; för att återuppta ett jobb i förgrunden kör <command>fg %<replaceable>job-number</replaceable></command> (som i <emphasis>förgrund</emphasis>). När ett kommando kör i förgrunden (antingen för att det startades normalt, eller återupptaget i förgrunden med <command>fg</command>), kan tangentkombinationen <keycombo action="simul"><keycap>Ctrl</keycap><keycap>Z</keycap></keycombo> användas för att pausa processen och återuppta kontrollen av kommandoraden. Processen kan sedan återstartas i bakgrunden med <command> bg %<replaceable>job-number</replaceable></command> (efter <foreignphrase>bakgrund</foreignphrase>).

en: System Information: Memory, Disk Space, Identity
sv-SE: Systeminformation: Minne, diskutrymme, identitet

en: The <command>free</command> command displays information on memory; <command>df</command> (<emphasis>disk free</emphasis>) reports on the available disk space on each of the disks mounted in the filesystem. Its <literal>-h</literal> option (for <emphasis>human readable</emphasis>) converts the sizes into a more legible unit (usually mebibytes or gibibytes). In a similar fashion, the <command>free</command> command supports the <literal>-m</literal> and <literal>-g</literal> options, and displays its data either in mebibytes or in gibibytes, respectively.
sv-SE: Kommandot <command>free</command> visar information om minnet; <command>df</command> (<emphasis>disk free</emphasis>, ledig disk) rapporterar om tillgängligt diskutrymme på vardera av de monterade diskarna i filsystemet. Dess flagga <literal>-h</literal> (för <emphasis>human readable</emphasis>, mänskligt läsbar) konverterar storlekarna till en mer lättförståelig enhet (vanligtvis mebibyte eller gibibyte). På samma sätt har kommandot <command>free</command> stöd för flaggorna <literal>-m</literal> och <literal>-g</literal> och visar då data antingen i mebibyte eller gibibyte.

en: The <command>id</command> command displays the identity of the user running the session, along with the list of groups they belong to. Since access to some files or devices may be limited to group members, checking available group membership may be useful.
sv-SE: Kommandot <command>id</command> visar identiteten för användare som kör sessionen, tillsammans med listan över grupper som de är medlemmar i. Då åtkomst till vissa filer eller enheter kan vara begränsat till gruppmedlemmar kan det vara användbart att kontrollera gruppmedlemskap.

en: Organization of the Filesystem Hierarchy
sv-SE: Organisation av filsystemshierarkin

en: <primary>Filesystem Hierarchy</primary>
sv-SE: <primary>Filsystemshierarki</primary>

en: The Root Directory
sv-SE: Rotkatalogen

en: A Debian system is organized along the <emphasis>Filesystem Hierarchy Standard</emphasis> (FHS). This standard defines the purpose of each directory. For instance, the top-level directories are described as follows:
sv-SE: Ett Debian-system organiseras enligt <emphasis>Filesystem Hierarchy Standard</emphasis> (FHS, Standarden för filsystemshierarki). Denna standard definierar syftet med varje katalog. Toppnivåkatalogerna beskrivs till exempel enligt följande:

en: <filename>/bin/</filename>: basic programs;
sv-SE: <filename>/bin/</filename>: grundläggande program;

en: <filename>/boot/</filename>: Linux kernel and other files required for its early boot process;
sv-SE: <filename>/boot/</filename>: Linux-kärna och andra filer som krävs för dess tidiga uppstart;

en: <filename>/dev/</filename>: device files;
sv-SE: <filename>/dev/</filename>: enhetsfiler;

en: <filename>/etc/</filename>: configuration files;
sv-SE: <filename>/etc/</filename>: konfigurationsfiler;

en: <filename>/home/</filename>: user's personal files;
sv-SE: <filename>/home/</filename>: användares personliga filer;

en: <filename>/lib/</filename>: basic libraries;
sv-SE: <filename>/lib/</filename>: grundläggande bibliotek;

en: <filename>/media/*</filename>: mount points for removable devices (CD-ROM, USB keys and so on);
sv-SE: <filename>/media/*</filename>: monteringspunkter för flyttbara enheter (CD-ROM, USB-nycklar och så vidare);

en: <filename>/mnt/</filename>: temporary mount point;
sv-SE: <filename>/mnt/</filename>: temporär monteringspunkt;

en: <filename>/opt/</filename>: extra applications provided by third parties;
sv-SE: <filename>/opt/</filename>: extra program som tillhandahålls av tredjepart;

en: <filename>/root/</filename>: administrator's (root's) personal files;
sv-SE: <filename>/root/</filename>: administratörens (roots) personliga filer;

en: <filename>/run/</filename>: volatile runtime data that does not persist across reboots;
sv-SE: <filename>/run/</filename>: flyktig körtidsdata som inte består mellan omstarter;

en: <filename>/sbin/</filename>: system programs;
sv-SE: <filename>/sbin/</filename>: systemprogram;

en: <filename>/srv/</filename>: data used by servers hosted on this system;
sv-SE: <filename>/srv/</filename>: data som används av servrar som är värdar på detta system;

en: <filename>/tmp/</filename>: temporary files; this directory is often emptied at boot;
sv-SE: <filename>/tmp/</filename>: temporära filer; denna katalog töms ofta vid uppstart;

en: <filename>/usr/</filename>: applications; this directory is further subdivided into <filename>bin</filename>, <filename>sbin</filename>, <filename>lib</filename> (according to the same logic as in the root directory). Furthermore, <filename>/usr/share/</filename> contains architecture-independent data. <filename>/usr/local/</filename> is meant to be used by the administrator for installing applications manually without overwriting files handled by the packaging system (<command>dpkg</command>).
sv-SE: <filename>/usr/</filename>: program; denna katalog är vidare uppdelad i <filename>bin</filename>, <filename>sbin</filename>, <filename>lib</filename> (enligt samma logik som i rotkatalogen). Vidare innehåller <filename>/usr/share/</filename> arkitekturoberoende data. <filename>/usr/local/</filename> är avsedd att användas av administratören för att installera program manuellt utan att skriva över filer som hanteras av paketsystemet (<command>dpkg</command>).

en: <primary>daemon</primary>
sv-SE: <primary>demoner</primary>

en: <filename>/var/</filename>: variable data handled by daemons. This includes log files, queues, spools, caches and so on.
sv-SE: <filename>/var/</filename>: variabel data som hanteras av demoner. Detta inkluderar loggfiler, köer, köfiler, cachar och så vidare.

en: <filename>/proc/</filename> and <filename>/sys/</filename> are specific to the Linux kernel (and not part of the FHS). They are used by the kernel for exporting data to user space (see <xref linkend="sect.userspace-presentation" /> and <xref linkend="sect.user-space" /> for explanations about this concept).
sv-SE: <filename>/proc/</filename> och <filename>/sys/</filename> är specifika för Linux-kärnan (och är inte en del av FHS). De används av kärnan för att exportera data till användarrymden (se <xref linkend="sect.userspace-presentation" /> och <xref linkend="sect.user-space" /> för förklaringar om detta koncept).

en: <primary>merged <filename>/usr</filename></primary>
sv-SE: <primary>slog samman<filename>/usr/</filename></primary>

en: Note that many modern distributions, Debian included, are shipping <filename>/bin</filename>, <filename>/sbin</filename> and <filename>/lib</filename> as symlinks to the corresponding directories below <filename>/usr</filename> so that all programs and libraries are available in a single tree. It makes it easier to protect the integrity of the system files, and to share those system files among multiple containers, etc.
sv-SE: Observera att många moderna distributioner, inklusive Debian, skeppar <filename>/bin/</filename>, <filename>/sbin/</filename> och <filename>/lib/</filename> som symlänkar till dom motsvarande katalogerna under <filename>/usr/</filename> så att alla program och bibliotek finns tillgängliga i ett enda träd. Detta gör det enklare att skydda systemfilernas integritet och att dela systemfilerna mellan flera containers etc.

en: The User's Home Directory
sv-SE: Användarens hemkatalog

en: The contents of a user's home directory is not standardized, but there are still a few noteworthy conventions. One is that a user's home directory is often referred to by a tilde (“~”). That is useful to know because command interpreters automatically replace a tilde with the correct directory (usually <filename>/home/<replaceable>user</replaceable>/</filename>).
sv-SE: Innehållet i en användares hemkatalog är inte standardiserat, men det finns trots detta ett antal noterbara konventioner. En är att en användares hemkatalog ofta refereras till genom tilde (”~”). Detta är användbart att känna till eftersom kommandotolkar automatiskt ersätter ett tilde med den korrekta katalogen (vanligen <filename>/home/<replaceable>användare</replaceable>/</filename>).

en: Traditionally, application configuration files are often stored directly under the user's home directory, but their names usually start with a dot (for instance, the <command>mutt</command> email client stores its configuration in <filename>~/.muttrc</filename>). Note that filenames that start with a dot are hidden by default; and <command>ls</command> only lists them when the <literal>-a</literal> option is used, and graphical file managers need to be told to display hidden files.
sv-SE: Traditionellt lagras konfigurationsfiler för program direkt under användarens hemkatalog, men deras namn inleds vanligtvis med en punkt (t.ex. så lagrar e-postklienten <command>mutt</command> sin konfiguration i <filename>~/.muttrc</filename>). Notera att filnamn som börjar med punkt göms som standard; och <command>ls</command> listar endast dem när flaggan <literal>-a</literal> används, och grafiska filhanterare måste ombes att visa gömda filer.

en: Graphical desktops usually display the contents of the <filename>~/Desktop/</filename> directory (or whatever the appropriate translation is for systems not configured in English) on the desktop (i.e. what is visible on screen once all applications are closed or iconized).
sv-SE: Grafiska skrivbord visar vanligtvis innehåller i katalogen <filename>~/Skrivbord/</filename> (eller vad nu den lämpliga översättningen är för system som inte konfigurerats på svenska) på skrivbordet (dvs. det som är synligt på skärmen när alla program är stängda eller ikoniserade).

en: Finally, the email system sometimes stores incoming emails into a <filename>~/Mail/</filename> directory.
sv-SE: Avslutningsvis så lagrar e-postsystem inkommande e-postmeddelanden i en katalog <filename>~/Mail/</filename>.

en: Inner Workings of a Computer: the Different Layers Involved
sv-SE: Hur en dator fungerar inuti: de olika lagren som är inblandade

en: A computer is often considered as something rather abstract, and the externally visible interface is much simpler than its internal complexity. Such complexity comes in part from the number of pieces involved. However, these pieces can be viewed in layers, where a layer only interacts with those immediately above or below.
sv-SE: En dator betraktas ofta som något ganska abstrakt, och det synliga externa gränssnittet är mycket enklare än dess inre komplexitet. Sådan komplexitet kommer från antalet delar som är involverade. Dessa delar kan dock betraktas i lager, där ett lager endast interagerar med de direkt ovanför eller under.

en: An end-user can get by without knowing these details… as long as everything works. When confronting a problem such as, “The internet doesn't work!”, the first thing to do is to identify in which layer the problem originates. Is the network card (hardware) working? Is it recognized by the computer? Does the Linux kernel see it? Are the network parameters properly configured? All these questions isolate an appropriate layer and focus on a potential source of the problem.
sv-SE: En slutanvändaren kan klara sig utan att känna till dessa detaljer… så länge allt fungerar. Vid konfrontation med ett problem så som ”Internet fungerar inte!”, är det första man ska göra att försöka identifiera i vilket lager felet uppstår. Fungerar nätverkskortet (hårdvara)? Hittas det av datorn? Kan Linux-kärnan se det? Är nätverksparametrarna korrekt konfigurerade? Alla dessa frågor isolerar ett specifikt lager och fokuserar på en potentiell källa till problemet.

en: The Deepest Layer: the Hardware
sv-SE: Det djupaste lagret: hårdvaran

en: Let us start with a basic reminder that a computer is, first and foremost, a set of hardware elements. There is generally a main board (known as the <emphasis>motherboard</emphasis>), with one (or more) processor(s), some RAM, device controllers, and extension slots for option boards (for other device controllers). Most noteworthy among these controllers are IDE (Parallel ATA), SCSI and Serial ATA, for connecting to storage devices such as hard disks. Other controllers include USB, which is able to host a great variety of devices (ranging from webcams to thermometers, from keyboards to home automation systems) and IEEE 1394 (Firewire). These controllers often allow connecting several devices so the complete subsystem handled by a controller is therefore usually known as a “bus”. Option boards include graphics cards (into which monitor screens will be plugged), sound cards, network interface cards, and so on. Some main boards are pre-built with these features, and don't need option boards.
sv-SE: Låt oss börja med den inledande påminnelsen om att en dator i första hand är en uppsättning hårdvarudelar. Generellt finns det ett huvudkort (känt som <emphasis>moderkort</emphasis>) med en processor (eller flera processorer), lite RAM, styrenheter för andra enheter, platser för expansionskort (med styrenheter för andra enheter). Väsentliga bland dessa styrenheter är IDE (Parallell ATA), SCSI och Seriell ATA, då dessa ansluter lagringsenheter så som hårddiskar. Andra styrenheter inkluderar USB, som kan användas för att ansluta en stor mängd enheter (allt från webbkameror till termometrar, från tangentbord till hemautomationssystem) och IEEE 1394 (Firewire). Dessa styrenheter tillåter ofta anslutning av flera enheter, vilket leder till att det fullständiga undersystemet som hanteras av en styrenhet ofta refereras till som en ”buss”. Expansionskort inkluderar grafikkort (till vilket bildskärmar ansluts), ljudkort, nätverkskort, o.s.v. Vissa moderkort har dessa funktioner inbyggda, och behöver därför inte expansionskort.

en: <emphasis>IN PRACTICE</emphasis> Checking that the hardware works
sv-SE: <emphasis>I PRAKTIKEN</emphasis> Kontrollera att hårdvaran fungerar

en: Checking that a piece of hardware works can be tricky. On the other hand, proving that it doesn't work is sometimes quite simple.
sv-SE: Att kontrollera att en bit hårdvara fungerar kan vara knepigt. Att bevisa att den inte fungerar kan å andra sidan vara ganska enkelt.

en: A hard disk drive is made of spinning platters and moving magnetic heads. When a hard disk is powered up, the platter motor makes a characteristic whir. It also dissipates energy as heat. Consequently, a hard disk drive that stays cold and silent when powered up is broken.
sv-SE: En hårddisk består av snurrande plattor och flyttbara magnetiska huvuden. När en hårddisk strömsätts hörs ett karakteristiskt ljud från motorn som snurrar plattorna. Den avger också energi i form av värme. En hårddisk som förblir kall och tyst när den får ström är därför sannolikt trasig.

en: Network cards often include LEDs displaying the state of the link. If a cable is plugged in and leads to a working network hub or switch, at least one LED will be on. If no LED lights up, either the card itself, the network device, or the cable between them, is faulty. The next step is therefore testing each component individually.
sv-SE: Nätverkskort har ofta LED:ar som visar tillståndet för länken. Om en kabel som leder till en fungerande nätverkshubb eller switch ansluts kommer åtminstone en LED att tändas. Om ingen LED tänds är antingen kortet självt, nätverksenheten eller kabeln mellan dem trasig. Nästa steg är därför att testa varje komponent individuellt.

en: Some option boards — especially 3D video cards — include cooling devices, such as heat sinks and/or fans. If the fan does not spin even though the card is powered up, a plausible explanation is the card overheated. This also applies to the main processor(s) located on the main board.
sv-SE: Vissa expansionskort — speciellt 3D-grafikkort — har kylningsenheter, så som kylflänsar och/eller fläktar. Om fläkten inte snurrar även om kortet är strömsatt är en trolig förklaring att kortet är överhettat. Detta gäller också för processorn som finns på moderkortet.

en: The Starter: the BIOS or UEFI
sv-SE: Uppstartaren: BIOS eller UEFI

en: Hardware, on its own, is unable to perform useful tasks without a corresponding piece of software driving it. Controlling and interacting with the hardware is the purpose of the operating system and applications. These, in turn, require functional hardware to run.
sv-SE: Hårdvara kan inte på egen hand utföra nyttiga uppgifter utan en motsvarande programvara som driver den. Att kontrollera och interagera med hårdvaran är därför syftet för operativsystemet och programmen. Dessa, å sin sida, kräver fungerande hårdvara för att köra.

en: <emphasis>TOOL</emphasis> Setup, the BIOS/UEFI configuration tool
sv-SE: <emphasis>VERKTYG</emphasis> Inställning, BIOS/UEFI-konfigurationsverktyget

en: <primary><emphasis>Setup</emphasis></primary>
sv-SE: <primary><emphasis>Inställning</emphasis></primary>

en: The boot sector (or the EFI partition), in turn, contains another piece of software, called the bootloader, whose purpose is to find and run an operating system. Since this bootloader is not embedded in the main board but loaded from disk, it can be smarter than the BIOS, which explains why the BIOS does not load the operating system by itself. For instance, the bootloader (often GRUB on Linux systems) can list the available operating systems and ask the user to choose one. Usually, a time-out and default choice is provided. Sometimes the user can also choose to add parameters to pass to the kernel, and so on. Eventually, a kernel is found, loaded into memory, and executed.
sv-SE: Startsektorn (eller EFI-partitionen) innehåller en annan bit programvara som kallas startinläsaren, vars uppgift är att hitta och köra ett operativsystem. Då startinläsaren inte är inbyggd på moderkortet, utan läses in från disk, kan den vara smartare än BIOS, vilket förklarar varför BIOS inte läser in operativsystemet själv. Startinläsaren (ofta GRUB på Linux-system) kan till exempel lista de tillgängliga operativsystemen och be användaren att välja ett. Efter en tidsgräns finns vanligtvis ett standardval. Ibland kan användaren också välja att lägga till parametrar att skicka till kärnan, o.s.v. Slutligen hittas en kärna, läses in i minne och exekveras.

en: <emphasis>NOTE</emphasis> UEFI, a modern replacement to the BIOS
sv-SE: <emphasis>NOTERA</emphasis> UEFI, en modern ersättare för BIOS

en: <primary>Secure Boot</primary>
sv-SE: <primary>Säker uppstart</primary>

en: The BIOS/UEFI is also in charge of detecting and initializing a number of devices. Obviously, this includes the IDE/SATA devices (usually hard disk(s) and CD/DVD-ROM drives), but also PCI devices. Detected devices are often listed on screen during the boot process. If this list goes by too fast, use the <keycap>Pause</keycap> key to freeze it for long enough to read. Installed PCI devices that don't appear are a bad omen. At worst, the device is faulty. At best, it is merely incompatible with the current version of the BIOS or main board. PCI specifications evolve, and old main boards are not guaranteed to handle newer PCI devices.
sv-SE: BIOS/UEFI är också ansvarigt för att detektera och initiera ett antal enheter. Detta inkluderar självklart IDE-/SATA-enheter (vanligtvis hårddiskar och CD-/DVD-ROM-enheter), men också PCI-enheter. Detekterade enheter listas ofta på skärmen under uppstarten. Om denna lista går för snabbt kan <keycap>Paus</keycap>-tangenten användas för att frysa den länge nog för att den ska kunna läsas. Installerade PCI-enheter som inte syns här är ett dåligt omen. I värsta fall är enheten trasig. I bästa fall är den endast inkompatibel med den aktuella versionen av BIOS eller moderkortet. PCI-specifikationer utvecklas och gamla moderkort garanterar inte att de kan hantera nyare PCI-enheter.

en: The Kernel
sv-SE: Kärnan

en: Both the BIOS/UEFI and the bootloader only run for a few seconds each; now we are getting to the first piece of software that runs for a longer time, the operating system kernel. This kernel assumes the role of a conductor in an orchestra, and ensures coordination between hardware and software. This role involves several tasks including: driving hardware, managing processes, users and permissions, the filesystem, and so on. The kernel provides a common base to all other programs on the system.
sv-SE: Både BIOS/UEFI och startinläsaren kör endast ett par sekunder vardera; nu får vi den första biten programvara som kör under en längre tid, operativsystemets kärna. Denna kärna får rollen som dirigent i en orkester, och säkerställer koordinationen mellan hårdvara och programvara. Denna roll involverar flera uppgifter, inklusive: köra hårdvara, hantera processer, användare och rättigheter, filsystemet o.s.v. Kärnan tillhandahåller en gemensam bas för alla andra program på systemet.

en: The User Space
sv-SE: Användarrymden

en: Although everything that happens outside of the kernel can be lumped together under “user space”, we can still separate it into software layers. However, their interactions are more complex than before, and the classifications may not be as simple. An application commonly uses libraries, which in turn involve the kernel, but the communications can also involve other programs, or even many libraries calling each other.
sv-SE: Även om allting som händer utanför kärnan kan samlas ihop under uttrycket ”användarrymd”, kan vi fortfarande separera det i olika lager av programvara. Interaktionen mellan dem är mer komplex än tidigare och klassifikationerna är inte lika enkla. Ett program använder vanligen bibliotek, vilka i sin tur blandar in kärnan, men kommunikationen kan också involvera andra program eller flera bibliotek som anropar varandra.

en: Some Tasks Handled by the Kernel
sv-SE: Vissa uppgifter hanteras av kärnan

en: Driving the Hardware
sv-SE: Köra hårdvaran

en: The kernel is, first and foremost, tasked with controlling the hardware parts, detecting them, switching them on when the computer is powered on, and so on. It also makes them available to higher-level software with a simplified programming interface, so applications can take advantage of devices without having to worry about details such as which extension slot the option board is plugged into. The programming interface also provides an abstraction layer; this allows video-conferencing software, for example, to use a webcam independently of its make and model. The software can just use the <emphasis>Video for Linux</emphasis> (V4L) interface, and the kernel translates the function calls of this interface into the actual hardware commands needed by the specific webcam in use.
sv-SE: Kärnan har, i första hand, uppgiften att kontrollera hårdvarudelarna, detektera dem, slå på dem när datorn är strömsatt o.s.v. Den gör dem också tillgängliga för programvara på högre nivå med ett förenklat programmeringsgränssnitt, så att program kan dra nytta av enheter utan att behöva känna till detaljer så som vilken expansionsport expansionskortet sitter i. Programmeringsgränssnittet tillhandahåller också ett abstraktionslager; detta låter till exempel videokonferenssystem använda en webbkamera oberoende av tillverkare och modell. Programvara kan helt enkelt använda gränssnittet <emphasis>Video for Linux</emphasis> (V4L, Video för Linux), varpå kärnan översätter funktionsanropen för detta gränssnitt till de hårdvarukommandon som behövs för den specifika webbkamera som används.

en: Example of information provided by <command>lspci</command> and <command>lsusb</command>
sv-SE: Exempel på information som tillhandahålls av <command>lspci</command> och <command>lsusb</command>

en: These programs have a <literal>-v</literal> option that lists much more detailed (but usually not necessary) information. Finally, the <command>lsdev</command> command (in the <emphasis role="pkg">procinfo</emphasis> package) lists communication resources used by devices.
sv-SE: Dessa program har en flagga <literal>-v</literal> som listar ännu mer detaljerad information (som vanligen inte behövs). Avslutningsvis listar kommandot <command>lsdev</command> (i paketet <emphasis role="pkg">procinfo</emphasis>) kommunikationsresurser som används av enheter.

en: Applications often access devices by way of special files created within <filename>/dev/</filename> (see sidebar <xref linkend="sidebar.special-files" />). These are special files that represent disk drives (for instance, <filename>/dev/hda</filename> and <filename>/dev/sdc</filename>), partitions (<filename>/dev/hda1</filename> or <filename>/dev/sdc3</filename>), mice (<filename>/dev/input/mouse0</filename>), keyboards (<filename>/dev/input/event0</filename>), soundcards (<filename>/dev/snd/*</filename>), serial ports (<filename>/dev/ttyS*</filename>), and so on.
sv-SE: Program får ofta tillgång till enheter genom speciella filer som skapas i <filename>/dev/</filename> (se sidopanel <xref linkend="sidebar.special-files" />). Dessa är speciella filer som representerar diskenheter (till exempel <filename>/dev/hda</filename> och <filename>/dev/sdc</filename>), partitioner (<filename>/dev/hda1/</filename> eller <filename>/dev/sdc3</filename>), möss (<filename>/dev/input/mouse0</filename>), tangentbord (<filename>/dev/input/event0</filename>), ljudkort (<filename>/dev/snd/*</filename>), serieportar (<filename>/dev/ttyS*</filename>), o.s.v.

en: Filesystems
sv-SE: Filsystem

en: <primary>filesystem</primary>
sv-SE: <primary>filsystem</primary>

en: Filesystems are one of the most prominent aspects of the kernel. Unix systems merge all the file stores into a single hierarchy, which allows users (and applications) to access data simply by knowing its location within that hierarchy.
sv-SE: Filsystem är en av de väsentligaste aspekterna av kärnan. Unix-system sammanfogar alla lagrade filer i en enda hierarki, vilket låter användare (och program) komma åt data genom att endast känna till dess plats inom den hierarkin.

en: The starting point of this hierarchical tree is called the root, <filename>/</filename>. This directory can contain named subdirectories. For instance, the <literal>home</literal> subdirectory of <filename>/</filename> is called <filename>/home/</filename>. This subdirectory can, in turn, contain other subdirectories, and so on. Each directory can also contain files, where the actual data will be stored. Thus, the <filename>/home/rmas/Desktop/hello.txt</filename> name refers to a file named <literal>hello.txt</literal> stored in the <literal>Desktop</literal> subdirectory of the <literal>rmas</literal> subdirectory of the <literal>home</literal> directory present in the root. The kernel translates between this naming system and the actual, physical storage on a disk.
sv-SE: Startpunkten för detta hierarkiska träd kallas för roten, <filename>/</filename>. Denna katalog kan innehålla namngivna underkataloger. Till exempel är <literal>home</literal> en underkatalog till <filename>/</filename> som kallas <filename>/home/</filename>. Denna underkatalog kan i sin tur innehålla andra underkataloger, o.s.v. Varje katalog kan också innehålla filer, i vilka faktisk data kommer att lagras. Således refererar namnet <filename>/home/rmas/Skrivbord/hej.txt</filename> till en fil med namnet <literal>hej.txt</literal> lagrad i underkatalogen <literal>Skrivbord</literal> i underkatalogen <literal>rmas</literal> i katalogen <literal>home</literal> som finns i roten. Kärnan översätter mellan detta namngivningssystem och den riktiga fysiska lagringsplatsen på disk.

en: Unlike other systems, there is only one such hierarchy, and it can integrate data from several disks. One of these disks is used as the root, and the others are “mounted” on directories in the hierarchy (the Unix command is called <command>mount</command>); these other disks are then available under these “mount points”. This allows storing users' home directories (traditionally stored within <filename>/home/</filename>) on a second hard disk, which will contain the <literal>rhertzog</literal> and <literal>rmas</literal> directories. Once the disk is mounted on <filename>/home/</filename>, these directories become accessible at their usual locations, and paths such as <filename>/home/rmas/Desktop/hello.txt</filename> keep working.
sv-SE: Till skillnad från andra operativsystem, finns det bara en sådan hierarki, och den kan integrera data från flera diskar. En av dessa diskar används som roten och de andras ”monteras” som kataloger i hierarkin (Unix-kommandot kallas <command>mount</command> (montera)); dess andra diskar är sedan tillgängliga under dessa ”monteringspunkter”. Detta tillåter lagring av användares hemkataloger (vanligtvis lagrade i <filename>/home/</filename>) på en annan hårddisk, vilken kommer att innehålla katalogerna <literal>rhertzog</literal> och <literal>rmas</literal>. När disken är monterad på <filename>/home/</filename> kommer dessa kataloger att kunna nås på deras vanliga platser, och sökvägar så som <filename>/home/rmas/Skrivbord/hej.txt</filename> kommer att fortsätta fungera.

en: There are many filesystem formats, corresponding to many ways of physically storing data on disks. The most widely known are <emphasis>ext3</emphasis> and <emphasis>ext4</emphasis>, but others exist. For instance, <emphasis>vfat</emphasis> is the system that was historically used by DOS and Windows operating systems, which allows using hard disks under Debian as well as under Windows. In any case, a filesystem must be prepared on a disk before it can be mounted and this operation is known as “formatting”. Commands such as <command>mkfs.ext3</command> (where <command>mkfs</command> stands for <emphasis>MaKe FileSystem</emphasis>) handle formatting. These commands require, as a parameter, a device file representing the partition to be formatted (for instance, <filename>/dev/sda1</filename>). This operation is destructive and should only be run once, except if one deliberately wishes to wipe a filesystem and start afresh.
sv-SE: Det finns flera filsystemsformat, vilket motsvaras av att det finns många sätt att fysiskt lagra data på diskar. De mest kända är <emphasis>ext3</emphasis> och <emphasis>ext4</emphasis>, men andra finns också. Till exempel så användes filsystemet <emphasis>vfat</emphasis> historiskt av operativsystemen DOS och Windows, vilket tillåter att hårddiskar kan fungera under Debian såväl som under Windows. Oavsett vilket så måste filsystem förberedas på en disk innan de kan monteras och denna operation kallas ”formatering”. Kommandon så som <command>mkfs.ext3</command> (där <command>mkfs</command> står för <emphasis>MaKe FileSystem</emphasis> (skapa filsystem)) hanterar formatering. Dessa kommandon kräver, som en parameter, en enhetsfil som representerar den partition som ska formateras (till exempel <filename>/dev/sda1</filename>). Denna operation är destruktiv och bör endast köras en gång, förutom om man avsiktligen vill rensa ett filsystem och börja om från början.

en: There are also network filesystems, such as <acronym>NFS</acronym>, where data is not stored on a local disk. Instead, data is transmitted through the network to a server that stores and retrieves them on demand. The filesystem abstraction shields users from having to care: files remain accessible in their usual hierarchical way.
sv-SE: Det finns också nätverksfilsystem, så som <acronym>NFS</acronym>, där data inte lagras på en lokal disk. Istället skickas data över nätverket till en server som lagrar och hämtar data vid behov. Filsystemsabstraktionen skyddar användaren från att behöva bry sig: filer förblir åtkomliga på det vanliga hierarkiska sättet.

en: Shared Functions
sv-SE: Delade funktioner

en: Since a number of the same functions are used by all software, it makes sense to centralize them in the kernel. For instance, shared filesystem handling allows any application to simply open a file by name, without needing to worry where the file is stored physically. The file can be stored in several different slices on a hard disk, or split across several hard disks, or even stored on a remote file server. Shared communication functions are used by applications to exchange data independently of the way the data is transported. For instance, transport could be over any combination of local or wireless networks, or over a telephone landline.
sv-SE: Då ett antal funktioner används av all programvara är det vettigt att centralisera dem i kärnan. Delad filsystemshantering tillåter till exempel vilket program som helst att öppna en fil med namn, utan att behöva bry sig om var filen är lagrad fysiskt. Filen kan lagras på flera olika delar på en hårddisk, eller delad över flera hårddiskar, eller till och med lagrade på en fjärrfilserver. Delade kommunikationsfunktioner används av program för att utbyta data oberoende av hur data transporteras. Till exempel kan transport ske över en kombination av lokala eller trådlösa nätverk eller över en telefonlinje.

en: A process is a running instance of a program. This requires memory to store both the program itself and its operating data. The kernel is in charge of creating and tracking them. When a program runs, the kernel first sets aside some memory, then loads the executable code from the filesystem into it, and then starts the code running. It keeps information about this process, the most visible of which is an identification number known as <emphasis>pid</emphasis> (<emphasis>process identifier</emphasis>).
sv-SE: En process är en körande instans av ett program. Detta kräver minne för att lagra både programmet självt och dess data. Kärnan är ansvarig för att skapa och spåra dem. När ett program kör tilldelar kärnan först lite minne åt programmet, och läser sedan in den körbara koden från filsystem in i detta minne, och börjar sedan köra koden. Den håller information om denna process, det mest väsentliga är ett identifikationsnummer känt som <emphasis>pid</emphasis> (<emphasis>processidentifierare</emphasis>).

en: Unix-like kernels (including Linux), like most other modern operating systems, are capable of “multi-tasking”. In other words, they allow running many processes “at the same time”. There is actually only one running process at any one time, but the kernel cuts time into small slices and runs each process in turn. Since these time slices are very short (in the millisecond range), they create the illusion of processes running in parallel, although they are actually only active during some time intervals and idle the rest of the time. The kernel's job is to adjust its scheduling mechanisms to keep that illusion, while maximizing the global system performance. If the time slices are too long, the application may not appear as responsive as desired. Too short, and the system loses time switching tasks too frequently. These decisions can be tweaked with process priorities. High-priority processes will run for longer and with more frequent time slices than low-priority processes.
sv-SE: Unix-liknande kärnor (inklusive Linux) kan, likt de flera moderna operativsystem, göra flera saker samtidigt. Med andra ord de tillåter att man kör flera processer ”samtidigt”. Det är faktiskt bara en process som kör åt gången, men kärnan delar in tiden i små intervall och kör varje process i turordning. Då dessa tidsintervall är väldigt korta (i storleksordningen millisekunder), ger detta illusionen av att processerna kör parallell, även om de i verkligheten endast är aktiva under vissa tidsintervall och sover resten av tiden. Kärnans jobb är att justera sina schemaläggningsalgoritmer för att behålla den illusionen, medan systemets globala prestanda maximeras. Om tidsintervallen är för långa kan ett program upplevas som att det inte är responsivt. Om intervallen är för korta förlorar systemet tid då uppgifter växlas mellan allt för fort. Dessa beslut kan justeras med processprioriteter. Högprioriterade processer kommer att köra under länge tidsintervall och oftare än lågprioriterade processer.

en: <emphasis>NOTE</emphasis> Multi-processor systems (and variants)
sv-SE: <emphasis>NOT</emphasis> Multiprocessorsystem (och varianter)

en: The limitation described above of only one process being able to run at a time, doesn't always apply. The actual restriction is that there can only be one running process <emphasis>per processor core</emphasis> at a time. Multi-processor, multi-core or “hyper-threaded” systems allow several processes to run in parallel. The same time-slicing system is still used, though, so as to handle cases where there are more active processes than available processor cores. This is far from unusual: a basic system, even a mostly idle one, almost always has tens of running processes.
sv-SE: Begränsningen som beskrivits ovan, om att endast en process kan köra åt gången, gäller inte alltid. Den faktiska restriktionen är att det kan endast finnas en process som kör <emphasis>per processorkärna</emphasis>. Multiprocessorsystem, system med flera kärnor eller ”hypertrådar” låter flera processor köras parallellt. Samma tidsdelningssystem används fortfarande, för att hantera fall där det finns fler aktiva processer än det finns tillgängliga processorkärnor. Detta är långt i från ovanligt: ett grundläggande system, även ett mestadels vilande, har nästan alltid tiotals körande processer.

en: Of course, the kernel allows running several independent instances of the same program. But each can only access its own time slices and memory. Their data thus remain independent.
sv-SE: Kärnan tillåter förstås att flera oberoende instanser av samma program kör samtidigt. Men var och en kan endast använda sina egna tidsintervall och minne. Deras data förblir därmed oberoende.

en: Rights Management
sv-SE: Rättighetshantering

en: Unix-like systems are also multi-user. They provide a rights management system that supports separate users and groups; it also allows control over actions based on permissions. The kernel manages data for each process, allowing it to control permissions. Most of the time, a process is identified by the user who started it. That process is only permitted to take those actions available to its owner. For instance, trying to open a file requires the kernel to check the process identity against access permissions (for more details on this particular example, see <xref linkend="sect.rights-management" />).
sv-SE: Unix-liknande system är också fleranvändarsystem. De tillhandahåller ett rättighetssystem som har stöd för separata användare och grupper; det tillåter också styrning av åtgärder baserade på rättigheter. Kärnan hanterar data för varje process, vilket låter den styra rättigheter. För det mesta identifieras en process av användaren som startade den. Den processen tillåts endast utföra de åtgärder som dess ägare kan utföra. Att försöka öppna en fil kräver till exempel att kärnan kontrollerar processidentiteten mot åtkomsträttigheter (för vidare information om detta specifika exempel se <xref linkend="sect.rights-management" />).

en: <primary>kernel space</primary>
sv-SE: <primary>kärnrymd</primary>

en: “User space” refers to the runtime environment of normal (as opposed to kernel) processes. This does not necessarily mean these processes are actually started by users because a standard system normally has several “daemon” (or background) processes running before the user even opens a session. Daemon processes are also considered user-space processes.
sv-SE: ”Användarrymd” refererar till körtidsmiljön för normala processor (till skillnad mot kärnprocesser). Detta innebär inte nödvändigtvis att dessa processer faktiskt startades av användare då ett standardsystem normalt har flera ”demon”-processer (eller bakgrundsprocesser) körandes innan användaren ens öppnar en session. Demonprocesser anses också vara användarrymdsprocesser.

en: When the kernel gets past its initialization phase, it starts the very first process, <command>init</command>. Process #1 alone is very rarely useful by itself, and Unix-like systems run with many additional processes.
sv-SE: När kärnan kommer förbi sin initieringsfas startar den den allra första processen, <command>init</command>. Process #1 är ensam sällan särskilt användbar, och Unix-liknande system kör med många flera processer.

en: First of all, a process can clone itself (this is known as a <emphasis>fork</emphasis>). The kernel allocates a new (but identical) process memory space, and another process to use it. At this time, the only difference between these two processes is their <emphasis>pid</emphasis>. The new process is usually called a child process, and the original process whose <emphasis>pid</emphasis> doesn't change, is called the parent process.
sv-SE: För det första kan en process klona sig själv (detta är känt som <emphasis>fork</emphasis>). Kärnan allokerar ett nytt (men identiskt) minnesområde för processen, och en ny process som kan använda den. Vid denna tidpunkt är den enda skillnaden mellan dessa två processer deras <emphasis>pid</emphasis>. Den nya processen kallas vanligen en barnprocess, och originalprocessen vars <emphasis>pid</emphasis> inte ändras, kallas för föräldraprocessen.

en: Sometimes, the child process continues to lead its own life independently from its parent, with its own data copied from the parent process. In many cases, though, this child process executes another program. With a few exceptions, its memory is simply replaced by that of the new program, and execution of this new program begins. This is the mechanism used by the init process (with process number 1) to start additional services and execute the whole startup sequence. At some point, one process among <command>init</command>'s offspring starts a graphical interface for users to log in to (the actual sequence of events is described in more details in <xref linkend="sect.system-boot" />).
sv-SE: Ibland fortsätter barnprocessen att leva sitt eget liv, oberoende från sin förälder, med sin egen data kopierad från föräldraprocessen. I många fall exekverar dock denna barnprocess ett annat program. Med ett fåtal undantag ersätts dess minne helt enkelt med det för det nya programmet och exekvering av detta nya program påbörjas. Detta är mekanismen som används av initprocessen (med processnummer 1) för att starta ytterligare tjänster och exekvera hela uppstartssekvensen. Vid en tidpunkt kommer en process bland <command>init</command>s barn att starta ett grafiskt gränssnitt genom vilket användare kan logga in (den faktiska sekvensen av händelser beskrivs i ytterligare detalj i <xref linkend="sect.system-boot" />).

en: When a process finishes the task for which it was started, it terminates. The kernel then recovers the memory assigned to this process, and stops giving it slices of running time. The parent process is told about its child process being terminated, which allows a process to wait for the completion of a task it delegated to a child process. This behavior is plainly visible in command-line interpreters (known as <emphasis>shells</emphasis>). When a command is typed into a shell, the prompt only comes back when the execution of the command is over. Most shells allow for running the command in the background, it is a simple matter of adding an <userinput>&amp;</userinput> to the end of the command. The prompt is displayed again right away, which can lead to problems if the command needs to display data of its own.
sv-SE: När en process avslutar uppgiften som var anledningen till att den startades så avslutas den. Kärnan återhämtar sedan minne som tilldelats till denna process och slutar ge den körtidsintervall. Föräldraprocessen informeras om att dess barnprocess avslutats, vilket låter en process vänta på att en uppgift som delegerats till en barnprocess slutförts. Detta beteende syns tydligt i kommandotolkar (kända som <emphasis>skal</emphasis>). När ett kommando matas in i ett skal, handlar det helt enkelt om att lägga till ett <userinput>&amp;</userinput> på slutet av kommandot. Prompten visas igen inom kort vilket kan leda till problem om kommandot själv behöver skriva ut data.

en: Daemons
sv-SE: Demoner

en: A “daemon” is a process started automatically by the boot sequence. It keeps running (in the background) to perform maintenance tasks or provide services to other processes. This “background task” is actually arbitrary, and does not match anything particular from the system's point of view. They are simply processes, quite similar to other processes, which run in turn when their time slice comes. The distinction is only in the human language: a process that runs with no interaction with a user (in particular, without any graphical interface) is said to be running “in the background” or “as a daemon”.
sv-SE: En ”demon” är en process som startats automatiskt av uppstartssekvensen. Den fortsätter köra (i bakgrunden) för att utföra underhållsuppgifter eller tillhandahålla tjänster till andra processer. Denna ”bakgrundsuppgift” är faktiskt slumpmässig och matchar inte någon särskild typ ur systemets synvinkel. De är helt enkelt processer, liknande andra processer, som kör i turordning när deras tidsintervall kommer. Skillnaden är endast i hur man talar om den: en process som kör utan interaktion med en användare (i synnerhet utan ett grafiskt gränssnitt) kallas för att den kör ”i bakgrunden” eller ”som en demon”.

en: <emphasis>VOCABULARY</emphasis> Daemon, demon, a derogatory term?
sv-SE: <emphasis>VOKABULÄR</emphasis> Demon, ett nedsättande namn?

en: Although <emphasis>daemon</emphasis> term shares its Greek etymology with <emphasis>demon</emphasis>, the former does not imply diabolical evil, instead, it should be understood as a kind of helper spirit. This distinction is subtle enough in English; it is even worse in other languages where the same word is used for both meanings.
sv-SE: Även om namnet <emphasis>demon</emphasis> delar sin grekiska etymologi med <emphasis>demon</emphasis>, implicerar inte den föregående något djävulskt, utan istället bör det förstås som ett slags skyddsande. Denna distinktion är subtil nog på engelska (daemon respektive demon) ; det är än värre på andra språk (till exempel svenska) där samma ord används för båda betydelserna.

en: Several such daemons are described in detail in <xref linkend="unix-services" />.
sv-SE: Flera sådana demoner beskrivs i detalj i <xref linkend="unix-services" />.

en: Inter-Process Communications
sv-SE: Interprocesskommunikation

en: An isolated process, whether a daemon or an interactive application, is rarely useful on its own, which is why there are several methods allowing separate processes to communicate together, either to exchange data or to control one another. The generic term referring to this is <emphasis>inter-process communication</emphasis>, or IPC for short.
sv-SE: En isolerad process, vare sig det är en demon eller ett interaktivt program, är sällan användbar på egen hand, vilket är anledning till att det finns flera sätt att låta separata processer kommunicera med varandra, antingen för att utbyta data eller för att styra varandra. Den generella termen för att referera till detta är <emphasis>interprocesskommunikation</emphasis>, eller IPC (efter engelskans Inter-Process Communication).

en: The simplest IPC system is to use files. The process that wishes to send data writes it into a file (with a name known in advance), while the recipient only has to open the file and read its contents.
sv-SE: Det enklaste IPC-systemet är ett använda filer. Processen som önskar skicka data skriver denna till en fil (med ett förutbestämt namn), medan mottagaren endast behöver öppna filen och läsa dess innehåll.

en: <primary><emphasis>pipe</emphasis></primary>
sv-SE: <primary><emphasis>rörledning</emphasis></primary>

en: In the case where you do not wish to store data on disk, you can use a <emphasis>pipe</emphasis>, which is simply an object with two ends; bytes written in one end are readable at the other. If the ends are controlled by separate processes, this leads to a simple and convenient inter-process communication channel. Pipes can be classified into two categories: named pipes, and anonymous pipes. A named pipe is represented by an entry on the filesystem (although the transmitted data is not stored there), so both processes can open it independently if the location of the named pipe is known beforehand. In cases where the communicating processes are related (for instance, a parent and its child process), the parent process can also create an anonymous pipe before forking, and the child inherits it. Both processes will then be able to exchange data through the pipe without needing the filesystem.
sv-SE: I fallet där du inte önskar spara data på disk kan du använda en <emphasis>rörledning</emphasis>, vilket helt enkelt är ett objekt med två ändar; byte skrivs i en ände och kan läsas i den andra. Om ändarna styrs av olika processer leder detta till en enkel och behändig kanal för interprocesskommunikation. Rörledningar kan klassificeras i två kategorier: namngivna rörledningar och anonyma rörledningar. En namngiven rörledning representeras av en post i filsystemet (även om den överförda datan inte lagras där), så att båda processerna kan öppna den oberoende av varandra så länge platsen för den namngivna rörledningen är förutbestämd. I fall när kommunicerande processer är relaterade (till exempel en föräldraprocess och dess barnprocess) kan föräldraprocessen också skapa en anonym rörledning innan forkning, och därför kommer barnet att ärva den. Båda processerna kommer sedan kunna utbyta data via rörledningen utan att behöva involvera filsystemet.

en: <emphasis>IN PRACTICE</emphasis> A concrete example
sv-SE: <emphasis>I PRAKTIKEN</emphasis> Ett konkret exempel

en: Let's describe in some detail what happens when a complex command (a <emphasis>pipeline</emphasis>) is run from a shell. We assume we have a <command>bash</command> process (the standard user shell on Debian), with <emphasis>pid</emphasis> 4374; into this shell, we type the command: <command>ls | sort</command> .
sv-SE: Låt oss beskriva i detalj vad som händer när ett komplext kommando (en <emphasis>rörledning</emphasis>) körs från ett skal. Vi antar att vi har en <command>bash</command>-process (standardskalet på Debian), med <emphasis>pid</emphasis> 4374; i detta skal matar vi in kommandot: <command>ls | sort</command>.

en: The shell first interprets the command typed in. In our case, it understands there are two programs (<command>ls</command> and <command>sort</command>), with a data stream flowing from one to the other (denoted by the <userinput>|</userinput> character, known as <emphasis>pipe</emphasis>). <command>bash</command> first creates an unnamed pipe (which initially exists only within the <command>bash</command> process itself).
sv-SE: Skalet tolkar först kommandot som matats in. I vårt fall förstår det att det finns två program(<command>ls</command> och <command>sort</command>), med en dataström som flödar från ett till ett annat (betecknat av tecknet <userinput>|</userinput>, känt som <emphasis>rörledning</emphasis>). <command>bash</command> skapar först en icke namngiven rörledning (som i inledningsskedet endast existerar inom <command>bash</command>-processen själv).

en: Then the shell clones itself; this leads to a new <command>bash</command> process, with <emphasis>pid</emphasis> #4521 (<emphasis>pids</emphasis> are abstract numbers, and generally have no particular meaning). Process #4521 inherits the pipe, which means it is able to write in its “input” side; <command>bash</command> redirects its standard output stream to this pipe's input. Then it executes (and replaces itself with) the <command>ls</command> program, which lists the contents of the current directory. Since <command>ls</command> writes on its standard output, and this output has previously been redirected, the results are effectively sent into the pipe.
sv-SE: Sedan klonar skalet sig själv; detta leder till en ny <command>bash</command>-process med <emphasis>pid</emphasis> #4521 (<emphasis>pid</emphasis>:ar är abstrakta nummer och har i allmänhet ingen mening). Process #4521 ärver rörledningen, vilket innebär att den kan skriva till dess ”ingångsände”; <command>bash</command> omdirigerar sin standard ut-ström till denna rörlednings ingång. Sedan exekverar det (och ersätter sig själv med) programmet <command>ls</command>, vilket listar innehållet i den aktuella katalogen. Eftersom <command>ls</command> skriver på sin standard ut och denna utgång tidigare har omdirigerats kommer resultaten i att skickas in i rörledningen.

en: A similar operation happens for the second command: <command>bash</command> clones itself again, leading to a new <command>bash</command> process with pid #4522. Since it is also a child process of #4374, it also inherits the pipe; <command>bash</command> then connects its standard input to the pipe output, then executes (and replaces itself with) the <command>sort</command> command, which sorts its input and displays the results.
sv-SE: En liknande åtgärd händer för det andra kommandot: <command>bash</command> klonar sig själv igen, vilket leder till en ny <command>bash</command>-process med pid #4522. Eftersom detta också är en barn process till #4374, ärver denna också rörledningen; <command>bash</command> ansluter sedan sin standard in till rörledningens utgång, sedan kör det (och ersätter sig själv med) <command>sort</command>-kommandot, vilket sorterar sin indata och skriver ut resultaten.

en: All the pieces of the puzzle are now set up: <command>ls</command> reads the current directory and writes the list of files into the pipe; <command>sort</command> reads this list, sorts it alphabetically, and displays the results. Processes numbers #4521 and #4522 then terminate, and #4374 (which was waiting for them during the operation), resumes control and displays the prompt to allow the user to type in a new command.
sv-SE: Alla delarna i pusslet är nu inställda: <command>ls</command> läser den aktuella katalogen och skriver listan av filer till rörledningen; <command>sort</command> läser denna lista, sorterar den alfabetiskt och skriver ut resultaten. Processnummer #4521 och #4522 avslutas sedan och #4374 (vilken väntat på dem under åtgärden), återtar kontrollen och skriver ut en prompt för att låta användaren mata in ett nytt kommando.

en: Not all inter-process communications are used to move data around, though. In many situations, the only information that needs to be transmitted are control messages such as “pause execution” or “resume execution”. Unix (and Linux) provides a mechanism known as <emphasis>signals</emphasis>, through which a process can simply send a specific signal (chosen from a predefined list of signals) to another process. The only requirement is to know the <emphasis>pid</emphasis> of the target.
sv-SE: Inte all interprocesskommunikation används för att flytta runt data, dock. I många situationer är den enda information som måste överföras kontrollmeddelanden så som ”pausa körning”, eller ”återuppta körning”. Unix (och Linux) tillhandahåller en mekanism känd som <emphasis>signaler</emphasis> genom vilka en process enkelt kan skicka en specifik signal (vald från en fördefinierad lista av signaler) till en annan process. Det enda kravet är att veta målets <emphasis>pid</emphasis>.

en: For more complex communications, there are also mechanisms allowing a process to open access, or share, part of its allocated memory to other processes. Memory now shared between them can be used to move data between the processes.
sv-SE: För mer komplex kommunikation finns det också mekanismer för att låta en process göra tillgängligt, eller dela, en del av sitt allokerade minne till andra processer. Minne som nu delas mellan dem kan användas för att flytta data mellan processerna.

en: Finally, network connections can also help processes communicate; these processes can even be running on different computers, possibly thousands of kilometers apart.
sv-SE: Avslutningsvis kan nätverksanslutningar också hjälpa processer att kommunicera; dessa processer kan till och med köras på olika datorer, tusentals kilometer från varandra.

en: It is quite standard for a typical Unix-like system to make use of all these mechanisms to various degrees.
sv-SE: Det är ganska vanligt för ett typiskt Unix-liknande system att använda alla dessa mekanismer i olika utsträckning.

en: Libraries
sv-SE: Bibliotek

en: <primary>library (of functions)</primary>
sv-SE: <primary>bibliotek (av funktioner)</primary>

en: Function libraries play a crucial role in a Unix-like operating system. They are not proper programs, since they cannot be executed on their own, but collections of code fragments that can be used by standard programs. Among the common libraries, you can find:
sv-SE: Funktionsbibliotek spelar en väsentlig roll i ett Unix-liknande operativsystem. Det är inte egentliga program, då de inte kan köras för sig, utan är samlingar av kodfragment som kan användas av standardprogram. Bland de vanliga biblioteken hittar du:

en: the standard C library (<emphasis>glibc</emphasis>), which contains basic functions such as ones to open files or network connections, and others facilitating interactions with the kernel;
sv-SE: standard C-biblioteket (<emphasis>glibc</emphasis>), vilket innehåller grundläggande funktioner för att öppna filer eller nätverksanslutningar, och andra som möjliggör interaktion med kärnan;

en: graphical toolkits, such as Gtk+ and Qt, allowing many programs to reuse the graphical objects they provide;
sv-SE: grafiska verktygslådor, så som Gtk+ och Qt, vilket låter många program återanvända de grafiska objekten de tillhandahåller;

en: the <emphasis>libpng</emphasis> library, which allows loading, interpreting and saving images in the PNG format.
sv-SE: biblioteket <emphasis>libpng</emphasis>, vilket möjliggör inläsning, tolkning och sparande av bilder i PNG-formatet.

en: Thanks to those libraries, applications can reuse existing code. Application development is simplified since many applications can reuse the same functions. With libraries often developed by different persons, the global development of the system is closer to Unix's historical philosophy.
sv-SE: Tack vare dessa bibliotek, kan program återanvända kod. Programutveckling förenklas då många program kan återanvända samma funktioner. Med bibliotek som utvecklats av olika personer tas den globala utvecklingen av systemet närmre Unix historiska filosofi.

en: <emphasis>CULTURE</emphasis> The Unix Way: one thing at a time
sv-SE: <emphasis>KULTUR</emphasis> Unix-sättet: en sak åt gången

en: One of the fundamental concepts that underlies the Unix family of operating systems is that each tool should only do one thing, and do it well; applications can then reuse these tools to build more advanced logic on top. This philosophy can be seen in many incarnations. Shell scripts may be the best example: they assemble complex sequences of very simple tools (such as <command>grep</command>, <command>wc</command>, <command>sort</command>, <command>uniq</command> and so on). Another implementation of this philosophy can be seen in code libraries: the <emphasis>libpng</emphasis> library allows reading and writing PNG images, with different options and in different ways, but it does only that; no question of including functions that display or edit images.
sv-SE: En av de fundamentala koncepten som underbygger operativsystemen i Unix-familjen är att varje verktyg endast bör göra en sak och göra det bra; program kan sedan återanvända dessa verktyg för att bygga mer avancerad logik ovanpå. Denna filosofi kan ses i många inkarnationer. Skalskript är kanske det bästa exemplet: de förenar komplexa sekvenser från väldigt enkla verktyg (så som <command>grep</command>, <command>wc</command>, <command>sort</command>, <command>uniq</command>, o.s.v.) En annan implementation av denna filosofi kan ses i kodbibliotek: biblioteket <emphasis>libpng</emphasis> tillåter inläsning och skrivning av PNG-bilder, med olika flaggor och på olika sätt, men det gör endast det; det finns ingen chans att det inkluderar funktioner som visar eller redigerar bilder.

en: Moreover, these libraries are often referred to as “shared libraries”, since the kernel is able to only load them into memory once, even if several processes use the same library at the same time. This allows saving memory, when compared with the opposite (hypothetical) situation where the code for a library would be loaded as many times as there are processes using it.
sv-SE: Därutöver refereras dessa bibliotek ofta till som ”delade bibliotek” då kärnan kan läsa in dem i minne endast en gång även om flera processer använder samma bibliotek samtidigt. Detta möjliggör sparande av minne, när det jämförs med den motsatta (hypotetiska) situationen där koden för ett bibliotek måste läsas in lika många gånger som det finns processor som använder det.
