operativsystemkjerne From Wikipedia, the free encyclopedia
Linuxkjernen er en fri og åpen, monolittisk og Unix-liknende operativsystemkjerne som benyttes verden over i operativsystemet Linux. Den anvendes i personlige datamaskiner, arbeidsstasjoner, tjenere og superdatamaskiner, vanligvis i form av Linuxdistribusjoner.
| Linuxkjernen | |||
|---|---|---|---|
 | |||
 | |||
| Skaper(e) | Linus Torvalds[1] | ||
| Utvikler(e) | Linus Torvalds, Alan Cox, Greg Kroah-Hartman, Ingo Molnár, Andrew Morton, Larry W. Finger,[2][3][4] Mauro Carvalho Chehab[5] | ||
| Utgitt | 25. august 1991 | ||
| Nyeste versjon | 6.12-rc1 (Release-kandidat; 29. september 2024)[6] | ||
| Plattform | ARM, AVR, Blackfin, DEC Alpha, ETRAX CRIS, Intel Itanium, MIPS, PA-RISC, PowerPC, SPARC, SuperH, TILE64, Unicore, Xtensa, Motorola 68000-serien, System/390, x86-arkitektur, x86_64, z/Architecture | ||
| Skrevet i | C | ||
| Lisens | GPLv2,[7][8][9] proprietær lisens[8] | ||
| Nettsted | https://www.kernel.org | ||
 | Denne artikkelen har for mange lenker til andre artikler, og kan trenge opprydning for å oppfylle Wikipedias kvalitetskrav. |
Linuxkjernen ble skapt av finnen Linus Torvalds, som lanserte den første utviklingsversjonen 17. september 1991.[10] Første stabile versjon ble sluppet 14. mars 1994.
Kjernen brukes også i robotikk, tingenes internett, smarthus (varme-, ventilasjons- og sanitærteknikk, Smart Grid, smarte strømmålere, lyskontroll etc.), og i innebygde systemer som carputere, nettoper, rutere, trådløse basestasjoner, hustelefonsentraler, TV-mottakere, smart-TVer, digitale videopptakere og nettverkstilsluttede datalagre. Diverse operativsystemer for mobilt internettutstyr, notatblokk-PCer, Nett-PCer, nettbrett, lesebrett, smarttelefoner og smartur benytter modifiserte Linuxkjerner.
Den blir vedlikeholdt av et nettverk av brukere, hvor det inngår en rekke multinasjonale selskaper. I 2015 hadde nesten 12 000 programmerere fra omkring 1 200 selskaper bidratt til kjernens utvikling, mens gruppen «amatører» i 2007 stod for 3,9 % av endringene. Siden 1996 har utviklingsdiskusjoner foregått daglig på Linuxkjernens e-postliste.
Linuxkjernen er skrevet nesten utelukkende i programmeringsspråket C (med noen GNU C syntaksutvidelser) og AT&T assembler. Kildekoden er fri og åpen programvare, som er lisensiert under GNU General Public License versjon 2 (GPLv2), men ikke versjon 3 (GPLv3).
Utdypende artikler: Fri og åpen programvare og GNU General Public License
Utdypende artikler: Operativsystem, Operativsystemets historie og UNIX System V
Linuxkjernen benyttes verden over i operativsystemet Linux.[11] Den er fri og åpen programvare, og er således både fri programvare og åpen kildekode. Den blir lansert under en fri programvarelisens: Alle kan fritt bruke, kopiere, studere og forandre den og kildekoden er åpen slik at folk oppmuntres til å frivillig forbedre den. Dette står i kontrast til proprietær programvare, som er begrenset av opphavsrett og hvor kildekoden vanligvis er skjult for brukerne. Linuxkjernen er lisensiert under GNU General Public License versjon 2 (GPLv2), men ikke versjon 3 (GPLv3). Den er ikke en del av GNU-prosjektet og er heller ikke dette prosjektets offisielle operativsystemkjerne.
Linuxkjernen er en Unix-lignende operativsystemkjerne. Den har arvet mye fra UNIX, men den følger ikke offisielt Single UNIX Specification og derfor har Open Group heller ikke sertifisert den og gitt den varemerket «UNIX». Enkelte Linuxdistribusjoner har imidlertid blitt sertifisert med dette varemerke. Litt forenklet kan vi si at FreeBSD og beslektede Unix-lignende operativsystemer er etterfølgere av Berkeley Software Distribution (BSD), mens Linuxkjernen også har hentet mye fra UNIX System V.
Linuxkjernen har i dag et stort anvendelsesområde. Den anvendes i personlige datamaskiner, arbeidsstasjoner, tjenere og superdatamaskiner,[12][lower-alpha 1] vanligvis i form av Linuxdistribusjoner.[15][lower-alpha 2] Linuxkjernen brukes også i robotikk, tingenes internett, smarthus (varme-, ventilasjons- og sanitærteknikk, Smart Grid, smarte strømmålere, lyskontroll etc.) og i innebygde systemer som carputere, nettoper, rutere, trådløse basestasjoner, hustelefonsentraler, TV-mottakere, smart-TVer,[17] digitale videopptakere[18] og nettverkstilsluttede datalagre. Diverse operativsystemer for mobilt internettutstyr, notatblokk-PCer, Nett-PCer, nettbrett, lesebrett, smarttelefoner og smartur benytter modifiserte Linuxkjerner.[lower-alpha 3]
Linuxkjernen ble skapt av finnen Linus Torvalds (1969–),[19] som lanserte første utviklingsversjon den 17. september 1991.[20] Første stabile versjon kom 14. mars 1994. I dag vedlikeholdes den av et nettverk med brukere, hvor det inngår en rekke multinasjonale selskaper. I 2015 hadde nesten 12 000 programmerere fra omkring 1 200 selskaper bidratt til kjernens utvikling,[21][22] mens gruppen «amatører» i 2007 stod for 3,9 % av endringene.[23] Siden 1996 har utviklingsdiskusjoner foregått daglig på Linuxkjernens e-postliste.[24]
Historien om Linuxkjernen er et viktig kapittel i operativsystemets historie. Denne artikkelen nevner også andre operativsystemer av betydning: Windows 3.0, Windows 3.1, Windows 95, Windows 98, Windows NT, OS/2, Klassisk MacOS, Mac OS X, NeXTSTEP og Novell NetWare. De blir sammenlignet med Linuxkjernen på flere områder, for å skape en større kontekst.
Etterhvert har Linuxkjernen blitt endret fra å støtte kooperativ fleroppgavekjøring til å støtte fleroppgavekjøringen med «forkjøpsrett». Den har også blitt utvidet med symmetrisk flerprosessering, multitråder, delte biblioteker, virtuell hukommelse og behovsbetinget sideveksling, dynamisk lastbare moduler, støtte for et tyvetalls ulike filsystemer, avansert støtte for datanett og kommunikasjon med nettverksoperativsystemer (deriblant Network File System (NFS) og Netware), internett, og støtte for ulike busser for periferienheter etter hvert som disse har utviklet seg.
Opprinnelig ble den utviklet for Intels 32-biter mikroprosessor 80386. I årenes løp har den blitt portert til de fleste datamaskinarkitekturer, deriblant x86-64, Motorola 68000, SPARC, PowerPC, IBM POWER, MIPS, PA-RISC, DEC Alpha, SuperH, IBM System z9, Intel Itanium, ARM og RISC-V.
Linuxkjernen er skrevet nesten utelukkende i programmeringsspråket C (med noen GNU C syntaksutvidelser)[25] og AT&T assembler.[25]
Linuxkjernen har vokst fra 8 413 linjer med C-kode i første utviklingsversjon, som ble lansert 17. september 1991, til å omfatte 26 552 127 linjer med C-kode i versjon 5.2.0 som ble lansert 7. juli 2019.
Den 23. desember 2018 var det 104 258 registrerte brukere på 62 446 registrerte datamaskiner ifølge nettstedet Linux Counter.[26]
Utdypende artikler: Monolittisk kjerne, mikrokjerne og MINIX
Utdypende artikler: GNU Mach, GNU Hurd og debatten mellom Tanenbaum og Torvalds
Linuxkjernen er en monolittisk kjerne. Dette betyr at hele operativsystemet kjører i operativsystemkjernen. I mikrokjerner opererer derimot det absolutt minste antall tjenester innenfor kjernen, og andre tjenester bygges lag på lag omkring den. Unix og Unix-lignende operativsystemer benytter stort sett monolittiske kjerner, som er den tradisjonelle arkitekturen. Mikrokjerner oppstod i 1980-årene som en reaksjon på utfordringer som tradisjonelle kjerner hadde i møtet med den teknologiske utvikling. Stadige teknologiske forandringer gjorde at det stadig måtte utvikles nye utstyrsdrivere, nye nettverksprotokoller og nye filsystemer, såvel som andre deler av operativsystemene. I distribuerte operativsystemer var dette spesielt følbart, fordi datanett kunne bestå av mange ulike datamaskinarkitekturer, som hver enkelt hadde sin egenarter og gjennomgikk sin egen særegne utvikling, noe som igjen førte til enda mer arbeid for utviklere. Mikrokjerner er implementert ved hjelp av modulær programmering: Utstyrsdrivere, nettverksprotokoller, filsystemer og flere ting er fjernet fra kjernen. De er isolert i moduler utenfor kjernen, hvor de er lettere å håndtere og modifisere.
Forløperen til Linuxkjernen var MINIX, og i begynnelsen var Linuxkjernen avhengig av MINIX under oppstart. MINIX ble opprinnelig utviklet av Andrew S. Tanenbaum ved Vrije Universiteit Amsterdam, og første versjon ble lansert i 1987. MINIX er et POSIX-kompatibelt Unix-lignende operativsystem med en mikrokjerne. Den 29. januar 1992 startet Tanenbaum en debatt på Usenets diskusjonsgruppe comp.os.minix. Der hevdet han at mikrokjerner var overlegen i forhold til monolittiske kjerner, og at Linuxkjernen allerede før lanseringen i 1992 var foreldet. Debatten startet saklig, men utviklet seg etterhvert til en «flame war». Emnet ble tatt opp igjen den 9. mai 2006, og den 12. mai 2006 forklarte Tanenbaum på nytt sin holdning til monolittiske kjerner.
Eksempler på mikrokjerner i distribuerte operativsystemer er Amoeba 809, Eden, Mach og V system. De prosessbaserte distribuerte og Unix-lignende operativsystemene LOCUS 845, Accent og QNX hadde derimot en monolittisk kjerne. Windows NT var implementert rundt en mikrokjerne i versjonene 3.1, 3.5 og 3.51. I versjon 4.0 og senere har kjernen vært monolittisk. OS/2, NeXTSTEP, Novell NetWare og det distribuerte operativsystemet Plan 9 benyttet hybridkjerner; det samme gjelder Mac OS X. Klassisk MacOS hadde en monolittisk kjerne på Motorola 68000-serien, men benyttet en såkalt nanokjerne (eller «picokjerne»)[lower-alpha 4] på PowerPC.
Mikrokjernen GNU Mach er GNU-prosjektets offisielle operativsystemkjerne. Den har sin forløper i mikrokjernen Mach fra Carnegie Mellon University, og er kjernen i GNU Hurd. Selv om Debian offisielt er en Linuxdistribusjon, finnes det en uoffisiell avart (Debian GNU/Hurd) som kjører GNU Hurd i stedet for Linuxkjernen. Det samme gjelder Arch Hurd (som er basert på Arch Linux), Guix System Distribution, tidligere avarter av Bee og Gentoo, og den tidligere distribusjon NixOS.
Linuxkjernen er ikke en del av GNU-prosjektet, men er blitt utviklet ved hjelp av GNU C og andre utviklingsverktøy fra GNU. Som allerede nevnt, er den også lisensiert under GNU General Public License versjon 2 (GPLv2), men ikke versjon 3 (GPLv3).
Utdypende artikler: vmlinux, beskyttelsesring og brukermodus
Moderne mikroprosessorer har beskyttelsesringer, som beskytter data og funksjonalitet fra feil. I Linux gjenspeiles de i skillet mellom brukermodus og kjernemodus. Eksempler på programmer som kjører i brukermodus er applikasjonsprogramvare, vindussystemene X, Wayland, Mir og en rekke skrivebordsmiljøer. De har ikke lov til å utføre maskinvarerelaterte kommandoer direkte, men sender systemkall til Linuxkjernen som utfører disse kommandoene. Linuxkjernen er således den betrodde delen av Linux, som utfører maskinvarerelaterte kommandoer direkte. En slik beskyttelse sørger for feiltoleranse, og hindrer at programvarefeil i en nettleser eller et annet brukerprogram krasjer hele operativsystemet. Windows 95 og Windows 98 manglet til sammenligning slik feiltoleranse. Der kunne for eksempel programvarefeil i et videospill havarere hele datasystemet. OS/2 og Windows NT på den andre siden, utnyttet i likhet med Linux den beskyttede modus i x86-arkitekturen hvor disse beskyttelsesringene blir tatt i bruk.
Beskyttelsesringene gir ulike prioritetsnivåer, hvor operativsystemkjernen har større prioritet enn brukerprogrammer, dersom de to kommer i konflikt. Linuxkjernen kjører i prioritetsring 0 (høyest prioritet), mens de øvrige prosesser kjører i prioritetsring 3.
Den monolittiske kjernen gjør at hele Linuxkjernen kjører i ring 0. En mikrokjerne ville ha ført til at kun det absolutt minste antall tjenester hadde kjørt i ring 0, og at de resterende delene av operativsystemkjernen kjørte i ring 3. Dette ville igjen ha svekket ytelsen, fordi ring 3 er tregere enn ring 0, og fordi ulike deler av kjernen hadde vært nødt til å sende systemkall til hverandre i stedet for å utføre kommandoer direkte. Mikrokjerner er enklere å modifisere, men prisen for modulariteten er en svekket ytelse.
Figuren nedenfor viser de ulike lagene i Linux. Den viser også skillet mellom brukermodus og kjernemodus.
Utstyrsdrivere og kjerneutvidelser for skedulering, interprosesskommunikasjon, minnehåndtering, virtuelle filer, datanett, Fieldbus og generiske tellere kjører i operativsystemkjernen (ring 0), med full tilgang til maskinvaren. Dette gjelder også komponentene Advanced Linux Sound Architecture, Security-Enhanced Linux (SELinux), etc. Nevneverdige unntak er virtuelle filsystemer som er basert på Filesystem in Userspace (FUSE) og character in userspace (CUSE), såvel som deler av UIO (utstyrsdrivere i brukermodus).[27][28] Vindussystemet X og Wayland, som de fleste bruker sammen med Linux, kjører i brukermodus. Til forskjell fra tradisjonelle monolittiske kjerner, kan utstyrsdrivere konfigureres som lastbare kjernemoduler, som innlastes og avlastes mens systemet kjører. Utstyrsdrivere også under visse omstendigheter bli deaktivert og aktivert dynamisk, for å håndtere maskinvareavbrudd og for bedre å støtte symmetrisk flerprosessering.[29] Linuxkjernen mangler et binært applikasjonsgrensesnitt (ABI).[30]
Maskinvaren er også en del av filsystemets hierarki. Utstyrsdrivere har et grensesnitt til brukerapplikasjoner gjennom en definisjon i katalogene /dev eller /sys.[31] Prosessinformasjon blir definert i katalogen /proc.[31]
| Brukermodus | Applikasjoner | Bash, LibreOffice, GIMP, Blender, 0 A.D., PostgreSQL, MySQL, MariaDB, Mozilla Thunderbird, Mozilla Firefox, etc. | ||||||
|---|---|---|---|---|---|---|---|---|
| Lavnivå systemkomponenter | Daemoner: systemd, runit, logind, networkd, soundd, … |
Skrivebordsmiljø: GNOME, KDE, Xfce, LXDE, Sugar, MATE, Cinnamon, Enlightenment, LXQt, Budgie Vindussystem: X11, XFree86, Wayland, Mir, SurfaceFlinger (Android) |
Andre biblioteker: GTK+, Qt, EFL, SDL, SFML, FLTK, GNUstep, etc. |
Grafikk: Mesa, AMD Catalyst, … | ||||
| C-standardbiblioteket | open(), exec(), sbrk(), socket(), fopen(), calloc(), … (omkring 2000 subrutiner) glibc er kompatibelt med POSIX og Single UNIX Specification (SUS), uClibc var for innebygde systemer, bionic er skrevet for Android, etc. | |||||||
| Linuxkjernen (kjernemodus) | stat, splice, dup, read, open, ioctl, write, mmap, close, exit, unlink, fork, exec, etc.(omkring 380 POSIX/SUS-kompatible systemkall) | |||||||
| Delsystem for Fieldbus *) |
Delsystem for Generiske tellere *) | |||||||
| Delsystem for skedulering |
Delsystem for interprosesskommunikasjon |
Delsystem for minnehåndtering |
Delsystem for virtuelle filer |
Delsystem for nettverk | ||||
| Andre komponenter: ALSA, DRI, evdev, LVM, device mapper, Linux Network Scheduler, Netfilter Linux Security Modules: SELinux, TOMOYO, AppArmor, Smack | ||||||||
| Maskinvare (mikroprosessor, hovedminne, datalager, etc.) | ||||||||
*) Tilføyd i versjon 5.2
Utdypende artikler: Kooperativ fleroppgavekjøring, fleroppgavekjøring med «forkjøpsrett» og forkjøpsrett i operativsystemkjernen
I likhet med tradisjonell Unix (og de fleste av dagens operativsystemer) har Linuxkjernen støtte for fleroppgavekjøring: Flere programmer kan utføres tilsynelatende samtidig på en og samme datamaskin. Frem til versjon 2.4, som ble lansert 4. januar 2001, benyttet Linuxkjernen kooperativ fleroppgavekjøring. Dette betyr at programmer samarbeider om å dele mikroprosessor-tid mellom seg. En prosess fortsetter å utføre instruksjoner alene på mikroprosessoren helt til den overlater kontrollen til en annen prosess. Det er opp til programmererne å sørge for at programmene gir fra seg tilgangen til mikroprosessoren når de ikke lenger foretar seg noe nyttig. Dersom et program henger seg opp eller utfører langvarige operasjoner uten å slippe kontrollen til andre prosesser, kan hele datasystemet gå i stå.
Som kontrast har Unix støttet den mer sofistikerte fleroppgavekjøringen med «forkjøpsrett». Det har «forkjøpsrett», makt til å avbryte prosessen, og senere gi det andre oppgaver. Slik at den i mellomtiden ikke sperrer andre programmer. Linux støttet dette fra starten, men bare overfor programmer i brukermodus.[32] Når en prosess kjøres, settes den boolske variabelen TASK_RUNNING, som er knyttet til prosessen, lik sann. Prosessen kan avbrytes av andre prosesser, som har en høyere prioritet, og som dermed setter TASK_RUNNING lik falsk. I versjon 2.4 begynte arbeidet med å innføre fleroppgavekjøringen med «forkjøpsrett» også i Linuxkjernen. Arbeidet var fullført med lanseringen av versjon 2.6 den 17. desember 2003. Fleroppgavekjøringen med «forkjøpsrett» er imidlertid ikke gjennomført i alle seksjoner av kjernen.[33]
Linuxkjernen inneholder forskjellige klasser for skedulering.[34] Standard skeduleringsmekanisme er Completely Fair Scheduler, som ble introdusert i versjon 2.6.23 av kjernen den 9. oktober 2007.[35] Internt er denne skeduleringsklassen kjent som SCHED_OTHER. Linuxkjernen inneholder også to POSIX-kompatible[36] sanntidsklasser som kalles SCHED_FIFO (basert på en køstruktur) og SCHED_RR (round robin skedulering).[34]
Ved å benytte programvareendringen PREEMPT_RT, kan full støtte for «forkjøpsrett» bli innført for kritiske seksjoner, avbruddshåndterere og kodesekvenser hvor avbrudd er deaktivert.[37] Denne programvareendringen og dens funksjonalitet er blitt delvis integrert i Linuxkjernen.[38] Bruk av «forkjøpsrett» innebærer mindre latens, gjør responsen raskere, og gjør Linux mer egnet for sanntidsapplikasjoner. Eldre versjoner av Linuxkjernen hadde en stor kjernelås for synkronisering over hele kjernen, men denne ble fjernet av Arnd Bergmann den 25. januar 2011.[39]
En tilleggspolitikk for skedulering kjent som SCHED_DEADLINE, er en implementasjon av algoritmen earliest deadline first skedulering (EDF) og ble tilføyd versjon 3.14 av Linuxkjernen den 30. mars 2014.[40][41]
Kooperativ fleroppgavekjøring ble benyttet i Windows 3.0 og Windows 3.1, så vel som i det klassiske MacOS, RISC OS og i de fleste versjoner av nettverksoperativsystemet NetWare (før versjon 6.5). Windows 95 og Windows 98 benyttet kooperativ fleroppgavekjøring under kjøring av 16-biter programmer, og fleroppgavekjøring med «forkjøpsrett» under kjøring av 32-biter programmer. Fleroppgavekjøringen med «forkjøpsrett» var standard på OS/2 og NeXTSTEP, og har alltid vært det på Windows NT og OS X.
Utdypende artikkel: Symmetrisk flerprosessering
Siden versjon 2.0, som ble lansert 9. juni 1996, har Linuxkjernen støttet symmetrisk flerprosessering. Dette er en flerprosessering som støttes direkte av maskinvaren, mens asymmetrisk flerprosessering besørges indirekte av operativsystemet eller annen programvare. Til sammenligning var dette fraværende i klassisk MacOS så vel som i MS-DOS baserte versjoner av Microsoft Windows. Det ble innført støtte for dette i OS/2 (fra versjon 2.11), og ble standard i Windows NT og MacOS X. Symmetrisk flerprosessering innebærer to eller flere mikroprosessorer i et og samme datasystem.
Symmetrisk flerprosessering faller inn under kategorien SIMD (Single Instructions, Multiple Data) i Flynns taksonomi, og innebærer at to eller flere mikroprosessorer deler et felles dataminne. Dette betyr at flere prosessorkjerner finnes på samme mikrobrikke, at flere mikrobrikker (med en eller flere kjerner) finnes i en enkelt mikroprosessor, eller at flere mikroprosessorer finnes på et hovedkort. Symmetrisk flerprosessering kan også realiseres i et nettverk; da deles et felles dataminne av to eller flere datamaskiner.
Symmetrisk flerprosessering ble første gang lansert i enkelte modeller av stormaskinen IBM System/360. Modell 65, modell 67 og modell 67-2, som kom på markedet i 1965, hadde to mikroprosessorer som kjørte samtidig. Operativsystemene OS/360 M65MP og IBM TSS/360 støttet denne flerprosesseringen, og det samme var tilfelle med Michigan Terminal System. I 1986 innledet Sun Microsystems en ny RISC-familie gjennom spesifikasjonen til datamaskinarkitekturen SPARC, og i 1987 gjorde den sin debut i arbeidsstasjonen «Sunrise». SPARC er en forkortelse for «skalerbar prosessorarkitektur» (Scalable Processor ARChitecture), og arkitekturen kunne skaleres opp til flere tusen mikroprosessorer (superdatamaskiner). Unix-avartene SunOS og Solaris var laget for disse datamaskinene.
Det finnes mange flere eksempler. Her er bare noen systemer nevnt. Sequent Computer Systems lanserte i 1987 datamaskiner med opptil 20 stk 32-biter Intel 80386 mikroprosessorer (Symmetry S-serien). I 1995 ble Intel Pentium Pro lansert, med innebygd logikk for symmetrisk flerprosessering. I 2006 lanserte Intel dobbeltkjerneprosessoren Intel Pentium Dual Core og firekjernersprosessoren Core Quad. I dag er flerkjerners mikroprosessorer stort sett standard.
Utdypende artikler: Tråder, LinuxThreads og Native POSIX Thread Library
Linuxkjernen støtter tråder, som betyr at flere deler av det samme dataprogrammet kjører samtidig. Mens ordinære prosesser er uavhengige, har mye tilstandsinformasjon, separate minneadresser og interne prosess-kommunikasjonsmekanismer, deler tråder informasjonen fra én enkel prosess, samt minne og andre ressurser, direkte; de kan betraktes som asynkrone prosedyrer i et program. Kontekstskifter skjer som regel raskere mellom flere tråder enn mellom prosesser.
Oppgaver med forskjellige ressurskrav kan utføres i forskjellige tråder, ved at for eksempel at skjermen oppdateres mens platelageret, som trenger lite systemressurser, arbeider. Trådene kan også fordeles på ulike mikroprosessorer når flerprosessering er tilstedeværende, for å øke dataprogrammers ytelse.
Forut for versjon 2.6 benyttet Linuxkjernen LinuxThreads. Dette var en delvis implementasjon av POSIX Threads, som er definert av POSIX 1003.1c. LinuxThreads benyttet det nye systemkallet clone() til å skape tråder som delte foreldreprosessens adresseområde. Dette var en avart av systemkallet fork(), som har vært en del av UNIX siden 1971. Tråder ble gitt unike prosessidentifikatorer, og kunne skape problemer for håndteringen av Unix-signaler. Signalene SIGUSR1 og SIGUSR2 ble brukt til å koordinere trådene på en slik måte at de samme signalene ikke kunne brukes av andre programmer. To alternativer vokste etter hvert frem som en mulig etterfølger til LinuxThreads: Next Generation POSIX Threads og Native POSIX Thread Library (NPTL). NTPL vant frem og ble standard i versjon 2.6 av Linuxkjernen.
Utdypende artikler: Virtuell hukommelse, sideveksling og behovsbetinget sideveksling
På samme måte som UNIX, og andre moderne operativsystemer, støtter Linuxkjernen virtuell hukommelse. Det har den gjort helt fra starten av. Virtuell hukommelse gir dataprogrammer inntrykk av at de har tilgang til en kontinuerlig mengde med hovedminne. I virkeligheten befinner deres minne seg fragmentert i hovedminnet, og kan endog overstige den mengden med hovedminne som finnes i datamaskinen. I det sistnevnte tilfelle, brukes datamaskinens harddisk delvis som minne ved å forflytte deler av programmet frem og tilbake mellom hovedminnet og harddisken (swapping).
Fra UNIX arvet Linuxkjernen sideveksling. Denne metode er også i bruk i andre Unix-lignende operativsystemer, og i de fleste moderne operativsystemer. Sideveksling er en form for minnehåndtering hvor datamaskinen lagrer og henter data fra et sekundært datalager for bruk i hovedminnet.[42] Hvert fragment kalles en side, og er 4 Kb i størrelse. Linuxkjernen benytter behovsbetinget sideveksling, som betyr at den kopierer en side inn i den fysiske hukommelsen bare hvis et forsøk blir gjort på å aksessere den og siden ikke allerede er i hukommelsen.[43] I kontrast til sideveksling står segmentering. Under segmentering har hvert segment en maksimal størrelse, men varierer innbyrdes i størrelse. Segmentering ble benyttet i operativsystemet Multics, som var forgjengeren til UNIX.
Linuxkjernen ble opprinnelig utviklet for 32-biter mikroprosessoren Intel 80386, som var en del av x86-familien. De første medlemmer av denne familien var 16-biter mikroprosessorene Intel 8086 og Intel 8088. De benyttet segmenter som var 64 Kb i størrelse, for å være kompatibel med 8-biter mikroprosessoren Intel 8085. Intel 80286 støttet virtuell hukommelse, og «arvet» segmenter på 64 Kb fra sine forgjengere. Dette var også grunnen til at OS/2, som i utgangspunktet var «skreddersydd» for Intel 80286, benyttet en segmentert minnemodell. Det samme gjorde Windows 3.0 og Windows 3.1.
Intel 80386 økte maksimalgrensen på segmentenes størrelse fra 64 Kb til 4 Gb. Den metode som Linuxkjernen benyttet på denne mikroprosessoren, var å ta i bruk bare et enkelt segment og deretter foreta sideveksling innenfor dette segmentet. Slik kunne man «lure» operativsystemet til å tro at den underliggende maskinvaren ikke var segmentert, men støttet sideveksling i utgangspunktet. Denne metoden ble også tatt i bruk av Windows NT på Intel 80386.
Sideveksling gir mindre fragmentering av harddisken enn segmentering.[44]
Utdypende artikkel: Dynamisk lastbare kjernemoduler
Liksom FreeBSD, Solaris, AIX, Mac OS X, Windows NT og det tidligere nettverksoperativsystemet NetWare, har Linuxkjernen støtte for dynamisk lastbare kjernemoduler. Dette er objektfiler som inneholder en utvidelse av operativsystemets kjerne, og som vanligvis brukes for å støtte nyere maskinvare, filsystemer eller for å tilføye nye systemkall. Når deres funksjonalitet ikke lenger er påkrevet, kan de bli lastet ut av kjernen for å frigjøre hukommelse og andre ressurser.
Modulene blir lastet inn og ut av kjernen med kommandoen modprobe. De er lokaliserte i filkatalogen /lib/modules og hadde tidligere filetternavnet .o. Siden versjon 2.6 har de hatt filetternavnet .ko.[45] Programmet modprobe var en del av modutils fra versjon 2.2 til versjon 2.4.x av Linuxkjernen.[46] Fra og med versjon 2.6 blir verktøyet levert sammen med module-init-tools.[47]
Kommandoen lsmod lister ut de lastbare kjernemoduler. I nødstilfeller, når datasystemet ikke starter opp på grunn av feil i modulene, kan spesifikke moduler aktiveres eller deaktiveres ved å modifisere kjernens oppstartsparametere.
Deaktivering av et kjernemodul skjer via kommandoen sysctl med opsjonen /proc/sys/kernel/modules_disabled.[48][49] Et datasystem som benytter RAM-disken initramfs, kan av sikkerhetsmessige hensyn laste spesifikke moduler under oppstart og deretter deaktivere lastingen av moduler. Hvis angripere kan forandre initramfs, kan de også forandre på binærkoden i kjernen.
I motsetning til FreeBSD, Solaris, Mac OS X og Windows NT, har Linuxkjernen intet applikasjonsprogrammeringsgrensesnitt (API) eller binært applikasjonsgrensesnitt (ABI) for kjernemoduler. Dette betyr at det er forskjeller mellom ulike kjerneversjoner hva angår de interne strukturer og funksjoner, noe som kan skape kompatibilitetsproblemer. For å avhjelpe dette, er versjonsdata plassert innenfor seksjonen .modinfo i lastbare ELF-moduler. Versjonsinformasjonen kan sammenlignes med den kjørende kjerne før et modul kjøres. Hvis versjonene er inkompatible, vil modulen ikke bli lastet.
Utdypende artikkel: Delte biblioteker
Likesom de fleste moderne operativsystemer, har Linuxkjernen støtte for delte biblioteker. Et delt bibliotek er en fil som kan deles av eksekverbare filer, og som kan lastes opp under oppstart og under kjøring. De kan bli statisk lenket, hvilket betyr at både biblioteket og programmene allokeres minne når det blir skapt. Alternativt kan bibliotekene bli dynamisk lenket, hvilket betyr at programmene bare kobler seg til biblioteket gjennom en API når det vil ha en bestemt oppgave utført.
Biblioteker ligger i katalogen /usr/lib/. De har prefikset lib, og er etterfulgt av filetternavnet .so.[50] Hvis de er statisk lenket har de filetternavnet .a.
Utdypende artikler: Programmeringsspråket C og GNU Compiler Collection
Kjernen er skrevet nesten utelukkende i programmeringsspråket C (sammen med noen GNU C syntaksutvidelser). Enkelte korte seksjoner av koden er skrevet i AT&T assembler. I versjon 4.1 ble store deler av assemblerkoden skrevet i C.[51], og i versjon 4.2 ble enda mer av assemblerkoden omskrevet i C.[52] GNU C (GCC) var lenge den eneste kompilator som var i stand til å bygge Linuxkjernen på en korrekt måte.
Utdypende artikler: Intel C++ Compiler og Clang
GNU C Compiler (GCC) er standard kompilator for Linuxkjernens kildekode. I 2004 modifiserte Intel sin Intel C++ Compiler, slik at den også var i stand til å kompilere Linuxkjernen.[53] I 2009 ble dette gjort enda en gang på en modifisert utgave av versjon 2.6.22 av Linuxkjernen.[54][55]
Siden 2010 har det pågått et arbeide med å bygge Linuxkjernen med Clang, en C-kompilator som er et alternativ til GCC.[56] Den 12. april 2014 kunne nesten hele den offisielle kjernen bli kompilert med Clang.[57][58] Prosjektet er kjent som LLVMLinux, oppkalt etter infrastrukturen LLVM som ligger til grunn for Clang.[59] LLVMLinux er ikke en fork av Linuxkjernen eller LLVM, men et metaprosjekt som består av programvareoppdateringer som til slutt blir en del av hovedprosjektet. Fordelen med LLVMLinux for Linuxkjernens utviklere, er at Clang er kjent for raskere kompilering enn GCC.[60]
Linuxkjernens grensesnitt er flere grensesnitt mellom kjernen og applikasjoner i brukermodus, såvel som interne grensesnitt i kjernen. Det finnes to typer grensesnitt mellom kjernen og programmer som kjører i brukermodus: applikasjonsprogrammeringsgrensesnitt (API) og binære applikasjonsgrensesnitt (ABI). Internt i kjernen finnes det en rekke applikasjonsprogrammeringsgrensesnitt, men intet binært applikasjonsgrensesnitt.
Utdypende artikler: POSIX, Single UNIX Specification og Linuxkjernens API
Portabilitet i kildekoden sikrer at et C-program som er skrevet i henhold til en standard kan kompileres og kjøres på ethvert system som følger samme standarden. De relevante standarder i sammenheng med Linuxkjernen, og GNU C Library som er tilknyttet den, er POSIX og Single UNIX Specification. Linuxdistribusjonene EulerOS[62][63] og Inspur K-UX,[64][65] som begge er derivater av Red Hat Enterprise Linux, følger offisielt UNIX-03 standarden. Ingen andre Linuxdistribusjoner har fått varemerket «UNIX» av Open Group, hovedsakelig på grunn av kostnadene ved konformitets-testing.
GNU C Library støtter standardene K&R C, ANSI C, ISO C99, ISO C11, ISO C18, Single UNIX Specification (UNIX 93, UNIX 95, UNIX 98, UNIX 03, UNIX V7), POSIX.1c, POSIX.1d, POSIX.1j, POSIX.2, POSIX.1-2001, POSIX-2004, POSIX-2008, POSIX.1-2017, BSD-grensesnitt, System V Interface Definition (SVID), X/Open Portability Guide 4.2 og utvidelser av C-syntaksen som er spesifikke for Linuxkjernen. Biblioteket støtter også C++-standardene C++98, C++03, C++11, C++14, C++17 og den kommende standarden C++20.
Linuxkjernens API består hovedsakelig av systemkall.
Utdypende artikkel: Linux Standard Base
Binærportabilitet betyr at ethvert program som er kompilert for en gitt maskinvareplattform, kan kjøre i kompilert form på enhver annen maskinvareplattform som følger standarden. Binærportabilitet er et essensielt krav for den kommersielle levedyktighet til applikasjoner fra uavhengige programvareleverandører som er bygd for operativsystemer som er basert på Linuxkjernen. Binærkompatibilitet er mye mer krevende enn kildekodeportabilitet. Per januar 2020 er Linux Standard Base (LSB) den eneste standard for binærkompatibilitet.
Flere interne applikasjonsgrensensnitt i kjernen anvendes mellom forskjellige undersystemer og deres undersystemer. Noen har vært stabile over flere versjoner, mens andre har endret seg. Det er ingen garanti for at de vil vedvare; vedlikeholdere og bidragsytere kan fritt endre dem når som helst.[66]
Eksempler er rammeverk for de følgende klasser av utstyrsdrivere:
Linuxkjernen har intet stabilt binærgrensesnitt.[68]
Utdypende artikler: Liste over Linuxkjernens støttede datamaskinarkitekturer og Linuxbasert utstyr
Linuxkjernen ble opprinnelig ikke konstruert som en portabel operativsystemkjerne.[69][70] Den ble laget for 32-biter mikroprosessoren Intel 80386, som på denne tiden hadde vokst i popularitet. Støtten for Intel 80386 forsvant i versjon 3.8 av Linuxkjernen den 28. februar 2013.[71] Den første portering ble gjort til Motorola 68000 av brukere av Amiga, men for å gjøre dette måtte store deler av Linuxkjernen omskrives. Linus Torvalds kalte dette for en fork og for et «Linuxlignende operativsystem».[70] Med denne erfaringen i minne, ledet Torvalds en restrukturering av Linuxkjernen for å oppnå en portering til 64-biter RISC-arkitekturen DEC Alpha, slik at både 80386 og DEC Alpha kunne støttes i et enkelt tre i kildekoden.[70] Idag er Linuxkjernen en av de mest porterte operativsystemkjerner i verden. Den har blitt portert til de fleste datamaskinarkitekturer, deriblant x86-64, SPARC, DEC Alpha, Blackfin, PowerPC, IBM POWER, MIPS, PA-RISC, SuperH, IBM System z9/z10/zEnterprise System, Intel Itanium, ARM og RISC-V.
Linux kjører som det primære operativsystem på Sunway TaihuLight, Tianhe-2, Titan-Cray XK7, IBMs Blue Gene og andre superdatamaskiner. I november 2016 ble Linuxkjernen kjørt på 498 av verdens 500 kraftigste superdatamaskiner, rangert på listen TOP500 (de to andre benyttet AIX og IBM POWER7).[13][14] I november 2017 var dette tallet økt til 500.
Diverse operativsystemer for nettbrett, lesebrett, smarttelefoner og smartur benytter modifiserte Linuxkjerner.[72] Eksempler på slike enheter er iPod og iPhone fra Apple Computer, med iPodLinux og iPhone Linux (iOS fra Apple er derimot basert på Mac OS X). Andre eksempler er Android, WebOS, Tizen, Sailfish OS, Openmoko Linux og Ångström, så vel som de tidligere operativsystemene Familiar Linux, Firefox OS, H5OS, Maemo, MeeGo, Moblin, OpenZaurus og Symbian.[73][74][75] I 2013 ble Android det mest utbredte operativsystemet i verden.
I årenes løp har Linuxkjernen støttet ulike busser for periferienheter etter hvert som disse har utviklet seg:
Linuxkjernens datasikkerhet har vært diskutert, fordi programvarefeil presenterer en potensiell sikkerhetsrisiko. Dette kan muliggjøre privilegie-eskalering og skape tjenestenektangrep. I løpet av årene er flere programvarefeil blitt oppdaget og rettet i Linuxkjernen.[80] Nye egenskaper blir ofte implementert for å forbedre Linuxkjernens sikkerhet.[81][82]
Kritikere har anklaget Linuxkjernens utviklere for å dekke over sikkerhetshull eller for å ikke informere om dem; i juli 2008 reagerte Linus Torvalds på kritikken med følgende uttalelse:[83][84]
Personlig betrakter seg sikkerhetsfeil for å være bare «normale feil». Jeg dekker ikke over dem, men jeg har heller ikke noen tenkelig grunn til å mene at det er en god ide å oppspore dem og kunngjøre dem som noe spesielt ... en grunn til at jeg nekter å bry meg om hele sikkerhets-sirkuset er at jeg mener at dette glorifiserer – og således oppmuntrer til – feil adferd. Det skaper «helter» av sikkerhetsfolk, som om folk som ikke fikser normale feil ikke er viktige. Faktisk er alle de normale kjedelige feilene viktigere, nettopp fordi det er så mange av dem. Jeg tror ikke at et eller annet spektakulært sikkerhetshull burde glorifiseres eller få oppmerksomhet som så mye mer «spesielt» enn et tilfeldig spektakulært krasj som skyldes feil.
Linuxdistribusjoner lanserer ofte sikkerhetsoppdateringer til Linuxkjernen. Noen av dem (deriblant Debian, Ubuntu, Red Hat Enterprise Linux og SUSE Linux) tilbyr egne versjoner med langtidsstøtte hvor en spesiell versjon av Linuxkjernen oppdateres over en lengre periode.
Utdypende artikler: Kjernepanikk og Linuxkjernens oopser
En kjernepanikk er en uopprettelig systemfeil som oppdages av Linuxkjernen, i motsetning til lignende feil som oppdages av kode i brukermodus. Kjernen indikerer en slik tilstand ved å kalle funksjonen panic() i filen sys/system.h. De fleste tilfeller av kjernepanikk skyldes uhåndterte unntak i kjernen, slik som referanser til ugyldige minneadresser. De indikerer typisk en programmeringsfeil et eller annet sted i kjeden av kall som fører til panikken. De kan også indikere en feil med maskinvaren, slik som feil i RAM eller i de aritmetiske funksjoner i mikroprosessoren som er forårsaket av en mikroprosessorfeil, en overhetet eller skadd mikroprosessor eller en myk feil.
En rapport om ikke-fatale programvarefeil i kjernen blir kalt et «oops»; slike avvik fra korrekt adferd av Linuxkjernen kan føre til fortsatt kjøring, men med redusert pålitelighet.[85] Disse krasjrapportene blir automatisk samlet og kan sendes upstream av ulik programvare, slik som for eksempel programmet kernel oops,[86] Automated Bug-Reporting Tool (ABRT) i distribusjonene Fedora, Red Hat Enterprise Linux, CentOS etc.[87] og apport i distribusjonen Ubuntu. KernelOops.org samler disse rapportene og utgir statistikk på deres hjemmeside.[88]
Kjernens panikkmeldinger kan ikke bli skrevet ut på en synlig måte, ved å ta i bruk grafikken på en stasjonær datamaskin. For å avluse slike tilstander må andre metoder benyttes, slik som å tilknytte en serieport.
Oppdateringer av Linuxkjernen, som kan installeres uten å omstarte datamaskinen, er tilgjengelige i form av live patcing. Programvaren Ksplice, som ble lansert 28. april 2008, sørget for dette. Den 21. juli 2011 ble denne oppkjøpt av Oracle Corporation. Den 26. februar 2014 lanserte selskapet Red Hat på sin side programmet kpatch, mens SuSE lanserte kGraft den 27. mars 2014. De utgjør et minimalistisk grunnlag for live patching. De ble integrert i Linuxkjernens versjon 4.0 den 12. april 2015, og danner essensen i kjernens ftrace-funksjonalitet. De danner en API for kjernemodulene og et binærgrensesnitt for programmer i brukermodus.
Versjon 4.0 av Linuxkjernen støtter bare x86-arkitekturen og mangler mekanismer som sikrer konsistens på funksjonsnivå mens oppdateringer pågår. Det pågår imidlertid arbeid med å integrere dette i Linuxkjernen.[89][90][91]
Linuxkjernen har hatt støtte for et tyvetalls ulike filsystemer. Nedenfor er noen av de mest toneangivende beskrevet.
Utdypende artikkel: MINIX file system
Dette filsystemet ble benyttet av MINIX, som var forgjengeren til Linux. Det ble introdusert i 1987 sammen med MINIX 1.0. Det støttes av Linuxkjernen, men er lite brukt av Linuxbrukere i dag.
Utdypende artikkel: extended file system
Dette ble utviklet for å overvinne visse begrensninger i MINIX file system, og hadde en metadatastruktur som var inspirert av Berkeley Fast File System i Berkeley Software Distribution (BSD).[92] ext debuterte den 5. juli 1992 i versjon 0.96c av Linuxkjernen, og var den første implementasjonen som benyttet et virtuelt filsystem. Ext kunne håndtere filer på opptil 2 gigabyte i størrelse.[93] ext ble erstattet av ext2 og xiafs. Den 14. januar 1997 ble ext fjernet fra versjon 2.1.21 av Linuxkjernen, og er ikke lenger i bruk.
Utdypende artikkel: Xiafs
Xiafs ble lansert den 13. mars 1993 i versjon 0.99.7 av Linuxkjernen. Det var ment å erstatte extended file system (ext) og konkurrerte i begynnelsen med ext2. Det ble fjernet den 14. januar 1997 fra versjon 2.1.21 av Linuxkjernen sammen med ext.
Utdypende artikkel: ext2
ext2 eller second extended filesystem («det andre utvidede filsystem») var et POSIX-kompatibelt filsystem som ble lansert den 13. mars 1993 i versjon 0.99.7 av Linuxkjernen. ext2 var en erstatning for extended file system (ext); i begynnelsen konkurrerte det med filsystemet xiafs, men ble etter hvert ledende. Dets metadatastruktur var inspirert av det tidligere Berkeley Fast File System i Berkeley Software Distribution (BSD).[92]
ext2 benyttes fortsatt på lagringsmedia med flashminne (slik som Secure Digital og minnepinner) fordi mangelen på en journal øker ytelsen og minimaliserer antall skrivinger (flashminne har et begrenset antall skrivesykluser). Avhengig av størrelsen på blokkene, hadde ext2 støtte for harddisker på maksimalt 2–32 tebibyte (TiB), og for datafiler med maksimal størrelsesorden på mellom 16 gibibyte (GiB) og 2 tebibyte (TiB). ext2 støttet lagring av datafiler med rett dato innenfor tidsrommet 14. desember 1901 og 18. januar 2038 i den gregorianske kalenderen.
Utdypende artikkel: ext3
ext3 eller third extended filesystem («det tredje utvidede filsystem») er et tidligere POSIX-kompatibelt og journalførende filsystem. Det var etterfølgeren til ext2, og ble en del av versjon 2.4.15 av Linuxkjernen den 23. november 2001.[94] ext3 skilte seg fra ext2 på tre områder. Det første var innføringen av en journal, noe som økte stabiliteten og fjernet behovet for å kjøre en sjekk av filsystemet dersom datamaskinen skulle krasje. Det andre var at filsystemet kunne vokse i tilkoblet (online) tilstand. Det tredje var at HTrær ble benyttet som datastruktur for å indeksere større filkataloger.[95] Dette økte skalerbarheten fra en praktisk grense på noen få tusen filer i ext2 til titalls millioner av filer per filkatalog.
Avhengig av størrelsen på blokkene, hadde ext3 støtte for harddisker på maksimalt 4–32 tebibyte (TiB), og for datafiler med maksimal størrelsesorden på mellom 16 gibibyte (GiB) og 2 tebibyte (TiB). ext3 støttet lagring av datafiler med rett dato innenfor tidsrommet 14. desember 1901 og 18. januar 2038 i den gregorianske kalenderen. ext3 manglet dynamisk inodeallokering og extents. Metadata hadde en fast størrelse, ble plassert på velkjente steder og datastrukturene hadde en viss redundans. Ved alvorlige datakrasj, var filene i ext2 og ext3 i større grad gjenopprettbare enn i et trebasert filsystem.
Den 9. desember 2015 ble ext3 fjernet fra versjon 4.3 av Linuxkjernen.[96]
Utdypende artikkel: XFS
XFS er et 64-biter[97] POSIX-kompatibelt og journalførende filsystem som ble lansert av Silicon Graphics i oktober 1993.[98] Filsystemet var standard i operativsystemet IRIX fra versjon 5.3,[98] som ble lansert i desember 1994. XFS er etterfølgeren til Extent File System (EFS), som var filsystemet til IRIX før versjon 5.3. I mai 2000 ble XFS lisensiert under GNU General Public License (GPL) versjon 2. Den 18. februar 2004 ble XFS innlemmet i versjon 2.4.25 av Linuxkjernen, og den 18. desember 2003 ble filsystemet innlemmet i Linuxkjernens versjon 2.6.
XFS støtter harddisker på opptil 18 exbibyte (EiB) (16 tebibyte (TiB) på 32-biter Linux) og datafiler på opptil 9 exbibyte (TiB) (16 tetibyte (TiB) på 32-biter Linux).[97] Dette er noe mer enn ext4 og noe mindre enn btrfs.
Utdypende artikkel: Journaled File System
Journaled File System (JFS) er et 64-biter journalførende filsystem som er utviklet av IBM. JFS ble lansert i februar 1990 i versjon 3.1 av UNIX-avarten AIX.[99] I september 1994 ble det også tatt i bruk i OS/2 3.0 «Warp».[100] Det finnes to generasjoner av filsystemet, JFS og JFS2.[101][102] JFS2 ble integrert i Linuxkjernen fra versjon 2.4.18[103] og er fri programvare under GNU General Public License.
Utdypende artikkel: Veritas File System
Veritas File System (VxFS), også kalt JFS og OnlineJFS, er et extent-basert filsystem som ble utviklet av AT&Ts Unix System Laboratories, og lansert i 1991 av VERITAS Software.[104] Det er det primære filsystem i operativsystemet HP-UX, med online støtte for defragmentering under navnet OnlineJFS.[105] Det blir også støttes i AIX, Solaris og SCO OpenServer og ble tidligere også støttet av SINIX og UnixWare.
Dette filsystemet ble støttet fra versjon 2.6.0 av Linuxkjernen, og ble tidligere definert av fs/Konfig. Fra versjon 2.6.29 av Linuxkjernen, som ble lansert den 23. mars 2009, har det vært definert av fs/freevxfs/Kconfig.[106]
Veritas File System støtter harddisker på opptil 128 zettabyte (ZB) og filer på opptil 8 exabyte (EB).
Utdypende artikkel: ReiserFS
ReiserFS er et POSIX-kompatibelt journalførende filsystem som ble designet og utviklet av et team hos Namesys ledet av Hans Reiser. ReiserFS var det første journalførende filsystemet som ble støttet av Linuxkjernen; det ble integrert i Linuxkjernens versjon 2.4.1.
ReiserFS støtter harddisker på opptil 6 tetibye (TiB) og datafiler på opptil 1 exbibyte (EiB) (8 tetibyte (TiB) på 32-biter Linux). Datafiler i ext4 kan lagres med rett dato innenfor tidsrommet 14. desember 1901 og 18. januar 2038 i den gregorianske kalenderen.
Utdypende artikkel: Reiser4
Reiser4 er et journalførende filsystem som er utviklet av Hans Reiser og Namesys, som etterfølgeren til ReiserFS. Det ble innlemmet i versjon 3.15 av Linuxkjernen den 14. august 2014. Prosjektet har vært sponset av Defense Advanced Research Projects Agency (DARPA) og Linspire. Filsystemet blir fortsatt utviklet,[107] men det er tvilsomt om disse endringene blir tilføyd Linuxkjernen i nær fremtid, ettersom opphavsmannen soner en fengselsdom.[108]
ZFS (Zettabyte File System) er et kombinert filsystem og en logisk volumhåndterer som ble utviklet av Sun Microsystems for operativsystemet OpenSolaris i 2005.[109] Det ble i utgangspunktet lisensiert under en åpen kildekodelisens, og integrert i Linuxkjernen. Oracle Corporation endret i 2010 lisensen til en proprietær lisens for operativsystemet Solaris.[110] Grunnet lisensieringsproblemer er det ikke mulig å videreutvikle ZFS for Linuxkjernen,[110][111] selv om en rekke Linuxdistribusjoner har hatt støtte for det.[112] Eksempler er Arch Linux, Debian, Fedora, Gentoo, OpenSUSE, Red Hat Enterprise Linux, CentOS og Ubuntu[112].
OpenZFS oppstod som en fork av ZFS i 2010,[113] og støttes også av Linuxkjernen. Ubuntu 16.04 LTS («Xenial Xerus»), som ble lansert den 21. april 2016, gjør det mulig å installere OpenZFS som filsystem.[114][115][116][117]
ZFS innbefatter beskyttelse mot datakorrupsjon, svære lagringskapasiteter, effektiv datakompresjon, integrasjon av konsepter om volumhåndtering, snapshots, og copy-on-write kloner, kontinuerlig integritetssjekking og automatisk reparering, RAID-Z og aksesskontrollister i Network File System versjon 4 (NFSv4). Filsystemet støtter harddisker på 256 zebibytes og datafiler på 16 exibytes.
Lisensieringsproblemene med ZFS har bidratt til at btrfs vokste frem som et alternativ (se nedenfor). ZFS har mange likheter med btrfs, og kunne ha blitt en konkurrent hvis det ikke hadde vært for lisensieringsproblemene som er knyttet til det.[118] ZFS/OpenZFS er copy-on-write filsystemer liksom btrfs. De er imidlertid implementert som hashtabeller, mens btrfs er implementert ved hjelp av B-trær.
Utdypende artikkel: ext4
ext4, eller fourth extended filesystem («det fjerde utvidede filsystem»), er et POSIX-kompatibelt og journalførende filsystem. Det er etterfølgeren til filsystemet ext3, slik ext3 var etterfølgeren til ext2. ext4 er også bakoverkombatibelt med ext3. ext4 er inspirert av finesser som ble utviklet for filsystemet Lustre mellom 2003 og 2006, og som ga økt lagringsplass og ytelsesforbedringer.[119] Den 21. oktober 2008 ble den endelige versjonen lansert i versjon 2.6.28 av Linuxkjernen.
I ext4 ble blokklagringen i ext2 og ext3 erstattet av extents som reduserer fragmentering og gir økt ytelse på store datafiler. En enkel extent i ext4 kan opprette inntil 128 mebibyte (MiB) med kontinuerlig diskplass innenfor en blokk på 4 kibibyte (Kib). Opptil fire extents kan lagres i en inode.[119] Når det er mer enn fire extents i en datafil, blir resten indeksert i et tre.[120] ext4 er hurtigere og mer stabilt enn ext3, fordi datafiler fragmenteres meget sjelden på grunn av «forsinket allokering». ext4 støtter harddisker på opptil 1 exbibyte (EiB), og datafiler på opptil 16 tebibyte (TiB). Datafiler kan lagres med rett dato innenfor tidsrommet 14. desember 1901 og 10. mai 2446 i den gregorianske kalenderen.
Utdypende artikkel: btrfs
Btrfs, en forkortelse for B-tree file system, uttalt butter F S,[121] better F S,[122] eller b-tree F S,[123] er et copy-on-write og journalførende filsystem. Det er etterfølgeren til ext4, og løser problemer knyttet til pooling, snapshots, sjekksummer og datasystemer hvor mange forskjellige typer innmatningsutstyr er integrerte.[124] Filsystemet er POSIX-kompatibelt.[125] En utviklingsversjon ble integrert i versjon 2.6.29 av Linuxkjernen den 23. mars 2009.[126] En stabil versjon ble lansert 29. mars 2013 i versjon 3.10 av Linuxkjernen.[127]
Det støtter defragmentering (også automatisk defragmentering gjennom opsjonen autodefrag),[128] data scrubbing,[128] online endring av størrelsen på diskvolumer,[129] offline filsystemsjekk (fsck),[130] transparent datakompresjon (zlib og Lempel-Ziv-Oberhumer)[131][132] av datafiler eller logiske disker, union mount,[133] etc.
Btrfs støtter harddisker på inntil 16 exbibyte (EiB) og filstørrelser på inntil 16 exbibyte (EiB).[134] Dets datastruktur er et B-tre, en selvbalanserende tredatastruktur, som sorterer data og tillater søking, sekvensiell aksess, innsettelse og sletting i en logaritmisk tid.[135]
I begynnelsen ble Linuxkjernen lansert under en lisens som la ned forbud mot kommersiell bruk.[136] I versjon 0.12 skjedde det en overgang til GNU General Public License (GPL).[137] Lisensen tillater distribusjon og salg av modifiserte og umodifiserte versjoner av Linux, men krever at alle kopiene blir utgitt under samme lisens og er ledsaget av den komplette korresponderende kildekode.
Torvalds beskrev i august 1997 lisensieringen av Linux under GPL som «den beste tingen jeg noensinne har gjort.»[136]
Linuxkjernen er eksplisitt lisensiert under versjon 2 av GPL,[138] uten å velge «enhver senere versjon», som er vanlig. Der har vært debattert om hvor enkelt lisensen kunne utvides til senere GPL versjoner (deriblant versjon 3) og hvorvidt dette er ønskelig.[139] Torvalds poengterte under lanseringen av versjon 2.4.0 at hans egen kode bare ville lansert under GPL versjon 2.[140] Betingelsene for GPL sier likevel at hvis ingen versjon er spesifisert, kan alle senere versjoner bli brukt. Alan Cox har påpekt at svært få bidragsytere til Linux har spesifisert en spesiell versjon av GPL.[141]
Den 25. september 2006 viste en undersøkelse at 28 av 29 nøkkelprogrammerere foretrakk GPLv2 i stedet for utkastet til den daværende GPLv3. Torvalds kommenterte: «Jeg tror at mange utenforstående … trodde at jeg personlig var kun en merkelig mann, fordi jeg så offentlig hadde publisert at jeg ikke var en stor tilhenger av GPLv3».[142] Profilerte kjerneutviklere som Linus Torvalds, Greg Kroah-Hartman og Andrew Morton, uttrykte deres innvendinger mot GPLv3 overfor massemedia,[143] refererte til klausulene om DRM/tivoisering, patenter, «tilleggsrestriksjoner» og advarte mot en «balkanisering» av det «åpne kildekodeuniverset» gjennom GPLv3.[143] Linus Torvalds gjentok kritikken i september 2014.[144]
Det diskuteres hvorvidt lastbare kjernemoduler (LKM) er derivatverk i henhold patentlovgivningen, og faller utenfor betingelsene til GPL. Torvalds har hevdet at kjernemoduler som bruker en begrenset, delmengde av kjernegrensesnittene noen ganger kan betraktes som et ikke-derivatverk, og således tillater noen binære utstyrsdriverere og andre lastbare kjernemoduler som ikke er lisensiert under GPL.
Et eksempel er proprietære grafikkdrivere fra Nvidia som bruker kjernemodulet dma_buf. Modulet gjør det mulig for flere grafikkprosessorer å kopiere data inn i hverandres rammebuffere.[145] En mulig bruk er Nvidia Optimus som kombinerer to raske grafikkprosessorer med en integrert Intel grafikkprosessor, hvor Nvidias prosessor skriver til rammebufferet i Intels prosessor når dette er aktivt. Nvidia kan likevel ikke bruke denne infrastrukturen fordi et teknisk middel tvinger gjennom den regel at den bare kan brukes på en LKM som også er en grafikkprosessor. Alan Cox skrev på Linuxkjernens e-postliste i oktober 2012 at å avvise forespørsler fra en av deres ingeniører ville fjerne denne tekniske tvangen fra APIen.[146] Ikke alle var enig i dette, og Torvalds mener at mange lastbare kjernemoduler per definisjon er derivatverk.[147]
På den andre side har Torvalds også uttalt at «dette grå området er i særdeleshet noe som kan sammenlignes med en utstyrsdriver som opprinnelig ble skrevet for et annet operativsystem (og klart ikke er et derivatarbeid som har Linux som opprinnelse). […] DET er et grått område, og _det_ er det område hvor jeg personlig tror at enkelte moduler kan betraktes å ikke være avledede arbeider kort og godt fordi de ikke var konstruert for Linux og ikke avhenger av noen spesiell Linux-adferd.»[148] Spesielt proprietære grafikkdrivere blir flittig diskutert. Det er det sannsynlig at slike spørsmål bare kan bli avgjort i en rettssal.
Utdypende artikkel: Binary blob
Linuxkjernen bruker firmware «binary blobs» for å støtte diverse maskinvareutstyr. Disse datafilene har forskjellige lisenser. Mange av dem har restriksjoner og deres eksakte underliggende kildekode er vanligvis ukjent.[149]
I februar 2002 hevdet Richard Stallman at slik programvare «krenker GPL» som krever at «en komplett korresponderende kildekode» er tilgjengelig.[150] Den 20. februar 2008 ble Linux-libre lansert av Free Software Foundation Latin America. Dette er en fri variant av Linuxkjernen uten proprietære objekter; den benyttes av de Linuxdistribusjoner som anbefales av Free Software Foundation, men kan også benyttes av de fleste distribusjoner.[151]
Den 15. desember 2010 annonserte Debian Project at den neste stabile versjon av Debian, versjon 6.0 «Squeeze» ville ha en kjerne som var «renset for alle ikke-frie firmware elementer».[152] Dette gjelder også senere stabile versjoner av Debian.
Utdypende artikkel: Linux Mark Institute
Linuxkjernen er et registrert varemerke som tilhører Linus Torvalds i USA, Tyskland, den europeiske union og Japan. Dette ble ufrivillig og indirekte forårsaket av advokaten William R. Della Croce, Jr. fra Boston i Massachusetts, som selv ikke hadde vært involvert i utviklingen av en eneste linje med kode i Linuxkjernen. Ikke desto mindre gjorde han i september 1995 navnet Linux til sitt eget varemerke. I november 1996 sendte han brev til ulike Linuxdistributører og gjorde krav på 10 % royalties av deres salgsinntekter.[153] WorkGroup Solutions, Yggdrasil, Linux Journal, Linux International[lower-alpha 5] og Linus Torvalds saksøkte Della Croce, med krav om at varemerket ble erklært «bedragerisk og oppnådd under falske premisser». Spørsmålet ble avgjort av retten den 20. august 1997, og varemerket ble tildelt Linus Torvalds.[157][158] Varemerket blir administrert av Linux Mark Institute som opprinnelig hadde sitt sete i Monterey, California, men som i dag holder til i Oregon.
Utdypende artikkel: SCO/Linux-kontroversene
Den 6. mars 2003 kunngjorde SCO-gruppen at de ville saksøke IBM; i en sivil rettssak hevdet SCO-gruppen at IBM hadde krenket deres angivelige eiendomsrett til Unix ved å bruke Unix-kode i deres bidrag til utviklingen av Linuxkjernen. SCO-gruppen sendte også brev til en rekke selskaper og advarte dem om at deres bruk av Linux uten en lisens fra SCO-gruppen ville krenke opphavsretten. Overfor pressen sa de også at de ville saksøke individuelle brukere av Linux, og IBM opptrådte derfor som forsvarere på vegne av sine Linux-kunder. SCO-gruppen hadde også saksøkt Novell, den tyske bilforhandleren DaimlerChrysler (delvis frafalt i juli 2004) og den amerikanske detaljisten av bildeler AutoZone; likeledes ble det amerikanske programvareselskapet Red Hat saksøkt med påstand om vedergjelding.[159] Den 15. desember 2014 fikk IBM medhold av retten på de fleste punkter,[160] og den 1. mars 2016 ble de øvrige av SCO-gruppens anklagepunkter avvist av retten.[161]
Den 30. mars 2016 anket SCO-gruppen dommen,[161] og saken er derfor ennå åpen. Den 16. februar 2018 krevde retten at begge parter skulle legge frem en felles statusrapport som skulle være grunnlaget for en endelig dom.[162]
I rettssaken mot Novell spesifiserte SCO-gruppen den 8. mars 2007 detaljene i søksmålet. På tross av påstander om at de var den rettmessige eier av 1 million linjer med kode, spesifiserte de bare 326 linjer med kode, hvorav det meste ikke var mulig å kreve opphavsrett på.[163] Retten avgjorde den 10. august 2007 at SCO aldri har hatt opphavsretten til Unix.[164] Ankedomstolen i den tiende krets avgjorde den 26. august 2009 at spørsmålet om opphavsrett skulle avgjøres av en jury.[165] Juryens dom falt 30. mars 2010 i favør av Novell.[166]
Den 22. desember 2003 forklarte Linus Torvalds overfor nettstedet Groklaw at han var opphavsmannen bak deler av den koden som SCO-gruppen gjorde krav på, og at feilnumrene i filen errno.h ikke stammet fra SCO-UNIX, men fra andre kilder enn UNIX:
«errno.h», og jeg tror virkelig at i det minste i386-versjonen av errno.h egentlig har verdier som er forskjellige fra «virkelig UNIX». Noen av de første matcher, men ikke resten. Dette forklarer jeg ved bare å ha en liste med feilkoder, og ved bare å gi feilkodene i rekkefølge, men kanskje tar jeg feil.Jeg husker spesielt at jeg senere _burde_ ha valgt de samme verdiene, slik at jeg kunne gjøre dem binærkompatible. Tross alt har jeg boken «Intel386 Family Binary Compatibility Specification 2» (copyright Intel corporation, og ikke SCO), og den lister direkte opp feilkodene. De er forskjellige fra hva Linux bruker på x86. Andre arkitekturer fikset denne feilen, men på dette punktet stammer historien om «errno.h» definitivt _ikke_ fra UNIX-kilder.
<...>
For eksempel, lister SCO opp filene«include/linux/ctype.h»og«lib/ctype.h», og litt triviell graving viser at disse filene i virkeligheten er der i den opprinnelige 0.01 distribusjonen av Linux (dvs i september 1991). Og jeg kan derfor si:
- Jeg skrev dem (og dersom vi ser på de opprinnelige filene, skammer jeg meg litt: Makroene«toupper()»og«tolower()») er så grusomt stygge at jeg ikke ville ha innrømmet å ha skrevet dem hvis det ikke var fordi noen andre hevdet at de hadde gjort det.)
Den 30. mai 2003 kommenterte Linus Torvalds saken slik overfor Computerworld:
Santa Cruz Operation (SCO) var et programvareselskap som ble grunnlagt i Santa Cruz, California i 1979. SCO var en av mange bidragsytere til utviklingen av operativsystemet UNIX gjennom blant annet SCO UNIX (senere kjent som SCO Open Desktop og SCO OpenServer) som var en avart av Unix for x86-arkitekturen. I boken The Art of Unix Programming (2003) hevdet Eric Steven Raymond at SCO var «det første Unix-selskapet» i verden.[169] Forut for opprettelsen av SCO var UNIX-markedet dominert av maskinvareprodusenter og teleselskaper. SCO solgte SCO UNIX til Caldera Systems i 2001, og endret sitt navn til Tarantella, Inc. Tarantella, Inc. ble i sin tur oppkjøpt av Sun Microsystems i 2005.
Selskapet Caldera Systems var blitt grunnlagt i oktober 1994 i Utah. I mai 2001 endret det navn til Caldera International, og deretter til SCO-gruppen. At selskapet på dette viset brukte navnet til SCO har ført til forvirring og forveksling av de to selskapene. I 2007 lå SCO-gruppen an til å gå konkurs, og i 2011 ble den oppkjøpt av selskapet UnXis, Inc.
I rettssaken hevdet SCO-gruppen at de fikk enerett på varemerket UNIX da SCO solgte sine rettigheter til Caldera Systems. Det urimelige i et slikt krav er at SCO var en av mange aktører som bidro til utviklingen av UNIX; dette må betraktes som et lagarbeid, og SCO var ikke de eneste bidragsyterne. Kravet fra SCO-gruppen ville bety at ikke bare Linuxkjernen, men også IBM's Unix-avart AIX, såvel som HP-UX fra Hewlett Packard, Solaris fra Sun Microsystems, IRIX fra Silicon Graphics Inc. (SGI), og flere Unix-avarter, var ulovlige. SCO-gruppen var heller ikke identisk med SCO, selv om de brukte navnet til det tidligere selskapet. SCO-gruppen hadde ikke utviklet SCO-UNIX, men hadde kjøpt en av mange avarter av UNIX, og deretter gjort krav på enerett i UNIX-markedet.
Utdypende artikkel: Versjoner av Linuxkjernen
Linuxkjernen vedlikeholdes av et nettverk med brukere, hvor det inngår eller har inngått multinasjonale selskaper som Intel,[170] IBM,[170] Texas Instruments,[171] Advanced Micro Devices,[172] Hewlett-Packard,[20] ARM Holdings,[171] Dell,[173] Red Hat,[170] SuSE,[174] Novell,[24][170] Linaro,[24] Oracle,[170] Nokia,[170] Google,[172] Facebook,[171] Fujitsu[172] og Samsung.[172] I 2015 hadde nesten 12 000 programmerere fra omkring 1 200 selskaper bidratt til kjernens utvikling,[21][22] mens gruppen «amatører» i 2007 stod for 3,9 % av endringene.[23] Siden 1996 har utviklingsdiskusjoner foregått daglig på Linuxkjernens e-postliste.[24]
I 2007 hadde utviklingen av kjernen skiftet fokus. Fra at de 20 mest aktive utviklere skrev 80 % av koden, var det endret til at de 30 mest aktive skrev 30 % av koden. De mest aktive utviklere brukte derimot mer tid på å gjennomgå forandringene.[175] I 2007 ble endringer i kjernen angivelig gjort av 1900 utviklere. Dette kan være et betydelig underestimat fordi utviklere som arbeider i team vanligvis regnes som en. Det er antatt at Linuxkjernens brukernettverk består av mellom 5000 og 6000 personer.
Linux Foundation offentliggjorde i 2016 en rapport[176] for perioden desember 2014 til juli 2016, som viste at omkring 1500 utviklere bidrar til hver versjon fra omkring 200–250 selskaper. De 30 mest aktive utviklere bidro til litt mer enn 16 % av koden. De største bidragsyterne blant selskaper var Intel (12.9 %) og Red Hat (8.0 %); tredje og fjerde plass ble holdt av kategoriene «ingen» (7.7 %) og «ukjent» (6.8 %).
Den 2. juli 2007 uttalte Greg-Kroah Hartmann om versjon 2.6.22.0 at 5 % av koden var en del av «kjernen», mens 52 % var utstyrsdrivere.[175]
Folk som Linus Torvalds og jeg planlegger ikke kjernens utvikling. Vi sitter ikke der og tenker ut et veikart for de neste to år, og deretter tildeler ressurser til de ulike nye egenskaper. Dette er fordi vi ikke har noen ressurser. Ressursene blir alle eid av de forskjellige korporasjoner som bruker og bidrar til Linux, så vel som av alle de forskjellige uavhengige bidragsytere der ute. Det er de folkene som eier ressursene som bestemmer...
Andrew Morton, 2005
Evolusjonen gjør ofte uventede (og ikke nødvendigvis optimale) ting, men ingen av dens inkrementelle forandringer får Linuxkjernen til å bryte sammen på et gitt tidspunkt. Enhver versjon av Linuxkjernen er brukbar, selv om utstyrsdrivere ikke støtter alle egenskapene ved maskinvaren som de er skrevet for.
Arkitekturen til Linuxkjernen har vist seg å fungere på grunn av dens utvidbarhet og tilgangen på utviklere. Mange uavhengige frivillige utviklere har sørget for at de delene som krever mest utvikling — utstyrsdrivere, filsystemer og nettverksprotokoller — blir implementert på en utvidbar måte. Disse systemene er gjort utvidbare ved å bruke en data-abstraksjon, der hver utstyrsdriver er implementert som et separat modul med et felles grensesnitt. En utvikler kan tilføye en ny utstyrsdriver, med minimal interaksjon med andre utviklere.
Det er også enkelt å tilføye flere maskinvareplattformer. Arkitekturen separerer maskinvarespesifikk kode i distinkte moduler innenfor hvert undersystem. På denne måten kan en liten gruppe av utviklere implementere en portering til en ny datamaskinarkitektur ved å utelukkende omskrive de maskinvare-spesifikke delene av kjernen.
Kostnadene ved å utvikle versjon 2.6.0 av Linuxkjernen på nytt i et tradisjonell proprietært miljø har blitt estimert til 612 millioner amerikanske dollar, 467 millioner euro og 394 millioner britiske pund i 2004-priser ved å benytte estimasjonsmodellen årsverk i COCOMO.[180] I 2006 fastslo et studium som ble finansiert av den europeiske union at kostnadene ved å utvikle versjon 2.6.8 eller høyere av Linuxkjernen på nytt til 1.14 milliarder amerikanske dollar, 882 millioner euro og 744 millioner pund.[181]
En studie fra 30. juni 2001 fant at distribusjonen Red Hat Linux 7.1 inneholdt 30 millioner linjer med kildekode. Ved å bruke COCOMO-modellen, fant studien at Red Hat Linux 7.1 ville krevd omtrent åtte tusen årsverk om den skulle blitt utviklet ved konvensjonelle proprietære metoder. Ifølge studien ville dette ha kostet omtrent 1,08 milliarder år-2000-US-dollar å utvikle ved konvensjonelle proprietære metoder.[182] En lignende analyse av Debian 2.2 «potato» viste at denne inneholdt 55 millioner kodelinjer og ville kostet 1,9 milliarder år-2000-US-dollar eller 14 milliarder norske kroner å utvikle med konvensjonelle metoder.[183] En SLOC-studie for Debian 3.1 «sarge» anno 2005 viste at den inneholdt 215 millioner linjer med kode, som tilsvarer en utviklingskostnad på ca. 58 milliarder norske kroner.[184] Debian 4.0 «Etch» inneholdt ifølge en SLOC-studie fra 17. juni 2007 hele 283 millioner linjer med kildekode (76,5 milliarder kroner). Dette var 7 ganger flere linjer enn Windows XP (40 millioner linjer med kildekode og 10,8 milliarder kroner).[185] I januar 2016 estimerte Black Duck Open Hub at Debian 8, «Jessie» (med 74 millioner linjer kode) ville koste omkring 1.4 milliarder dollar å utvikle, ved å bruke en annen metode basert på samme modell.[186][187]
Ved å bruke David A. Wheeler's metodologi, estimerte Amanda McPherson, Brian Proffitt og Ron Hale-Evans i oktober 2008 at det å utvikle versjon 2.6.25 av Linuxkjernen på nytt ville ha kostet 1.3 milliarder dollar. De estimerte kostnadene ved å utvikle Fedora 9 «Sulphur» på nytt (6 772 902 linjer med kildekode) var 10.8 milliarder dollar.[188]
Garcia-Garcia og Alonso de Magdaleno fra Universitetet i Oviedo, Spania, anslo den årlige verdiøkning av kjernen til omkring 100 millioner euro mellom 2005 og 2007 og 225 millioner euro i 2008. Anslagene viste at det ville koste 1 milliarder euro eller 1,4 milliarder dollar per februar 2010 (versjon 2.6.33) å utvikle den på nytt i den europeiske union.[189]
Den 7. mars 2011 ble tilsvarende tall for versjon 2.6.37.x av Linuxkjernen, ved å bruke David A. Wheeler's beregninger, oppgitt til omkring 3 milliarder dollar og 2.2 milliarder euro, og tallene fortsetter å øke.[190]
Den nåværende utviklingsmodellen går ut på at Linus Torvalds lanserer nye «mainline» versjoner («vanillaversjoner») av Linuxkjernen. De utgjør hovedgreinen eller den generiske utviklingsgreinen. Nye versjoner blir offisielt lansert omtrentlig hver tiende uke, etter at Torvalds foretar en innledende runde med å integrere større endringer som er foretatt av andre utviklere, og etter flere runder med feilrettende testutgaver.
Hovedgreinen er ikke den stabile greinen, men inkorporerer alle former for endringer, deriblant de siste egenskaper, sikkerhetsoppdateringer og feilrettinger. Brukere som ikke vil risikere en ny versjon som ikke er grundig testet, kan benytte en separat stabil utviklingsgrein. Den følger hver versjon, og er ment for de som bare ønsker oppdateringer av sikkerhetsmoduler og feilrettinger, men ikke en helt ny versjon. Denne greinen blir vedlikeholdt av det stabile utviklingsteamet, som inkluderer Greg Kroah-Hartman, Chris Wright, Alan Cox, med flere.
Forut for versjon 2.6 fantes det en stabil grein (2.4) for relativt små og trygge endringer, og en ustabil grein (2.5), hvor store endringer og opprettinger var tillatt. Begge greinene ble vedlikeholdt av den samme gruppen utviklere, ledet av Torvalds. Brukerne hadde alltid tilgjengelig en grundig testet 2.4 versjon med de siste sikkerhetsoppdateringer og feilrettinger, men måtte vente på de nye egenskapene i 2.5-greinen. Ulempene var at den stabile versjonen ble akterutseilt. Den støttet ikke lenger ny maskinvare og manglet nødvendige nye egenskaper. På slutten av 2.5-greinens levetid, begynte enkelte vedlikeholdere å portere endringene tilbake til 2.4-serien. Men dette resulterte i introduksjonen av nye feil. 2.5 greinen ble til slutt stabil og omdøpt til 2.6. Men i stedet for å åpne en ustabil 2.7-grein, bestemte kjernens utviklere å fortsette med å tilføye store endringer i 2.6-greinen. Disse versjonene ble lansert i en raskere rekkefølge enn 2.4.x, men tregere enn 2.5.x. Dette gjorde at nye egenskaper ble raskere tilgjengelig og ble mer testet.
Som respons på mangelen på et stabilt kjernetre hvor feilrettinger kunne koordineres, kunngjorde Adrian Bunk i desember 2005 at han ville fortsette med å utgi 2.6.16.y-kjerner, selv om det stabile utviklingsteamet gikk over til 2.6.17.[191][192] Han inkluderte også enkelte oppdatering av utstyrsdrivere, og gjorde vedlikeholdsreglene i 2.6.16-serien svært lik dem i 2.4.[193] Siden da ble en stabil grein dannet, og ble oppdatert med feilopprettinger. I oktober 2009 kunngjorde Adrian Bunk at han ville vedlikeholde 2.6.27 i fem år som en erstatning for 2.6.16.[194] Dermed ble en ny stabil grein dannet, med stadige feilrettinger.[195] Fra versjon 2.6 ønsket noen fortsatt et ustabilt kjernetre. Andrew Morton endret hensikten i sitt -mm tre fra å behandle minnehåndtering til å bli et sted for eksperimentell kode. I september 2007 stanset han vedlikeholdet av dette treet.[196]
Den 12. februar 2008 skapte Stephen Rothwell linux-next treet for å samle patcher som skulle havne i den stabile greinen i neste utviklingssyklus.[197][198] Flere vedlikeholdere av undersystemer adopterte endelsen next på trær med kode som skulle inkluderes i neste stabile versjon. Per 24. mars 2022 holdes utviklingsversjonen av Linuxkjernen i greinen linux-next.[199]
Fra versjon 2.6.16 har det jevnlig blitt utgitt versjoner med langtidsstøtte (LTS). De passer særlig for industrielle og kommersielle miljøer som trenger stabilitet.
Det er blitt utgitt 20 versjoner med langtidsstøtte, hvorav fire er gjeldende:[200]
| LTS # | Versjon | Lansert | Støttet til |
|---|---|---|---|
| 17 | 4.9 | 11. desember 2016 | Januar 2019 |
| 18 | 4.14 | 12. november 2017 | Januar 2020 |
| 19 | 4.19 | 22. oktober 2018 | Desember 2020 |
| 20 | 5.4 | 24. november 2019 | Desember 2021 |
Mange Linuxbrukere kjører en «vanillakjerne» (stabil kjerne) som følger med en Linuxdistribusjon. Flere leverandører av distribusjoner (deriblant Red Hat og Debian) vedlikeholder også et annet sett av Linuxkjernen som blir oppdatert langsommere enn «vanillakjernen». De inneholder vanligvis alle rettinger fra den relevante stabile greinen, men støtter også utstyrsdrivere og egenskaper som ikke har blitt lansert i «vanillaversjonen» som distribusjonen startet sin grein fra.
Red Hat Enterprise Linux 6 «Santiago» leveres for eksempel sammen med versjon 2.6.32 av Linuxkjernen. Denne versjonen hadde langtidsstøtte, og siste offisielle underversjon var 2.6.32.71. Red Hat har laget sine egne uoffisielle oppdateringer, og Red Hat Enterprise Linux 6.10 ble for eksempel lansert sammen med versjon 2.6.32-794 av Linuxkjernen.
Utdypende artikkel: Git
Linuxkjernens kildekode ble tidligere vedlikeholdt uten noe automatisert versjonskontrollsystem, stort sett fordi Linus Torvalds mislikte tanken på et sentralisert system.
I 2002 gikk utviklingsteamet over til å bruke BitKeeper. BitKeeper var tilgjengelig for Linus og flere andre uten kostander, men var ikke fri programvare, noe som ble en kilde til kontrovers. Systemet hadde en viss interoperabilitet med frie versjonskontrollsystemer som Concurrent Versions System (CVS) og Subversion.
I april 2005 prøvde Andrew Tridgell å gjenskape en fri utgave av BitKeeper gjennom omvendt ingeniørkunst. Dette førte til at BitMover, selskapet som utga BitKeeper, stanset støtten til Linuxkjernens brukernettverk. Som en reaksjon skrev Torvalds og andre kildekoden til det nye versjonskontrollsystemet Git. Det nye systemet ble skrevet i løpet av noen uker, og i løpet av to måneder ble det tatt i bruk på den offisielle Linuxkjernen.[201] Versjon 0.99 av Git ble lansert 11. juli 2005. Siste versjon er 2.35.1, som ble lansert 29. januar 2022.
Linuxkjernen har hatt tre forskjellige former for versjonsnummer.
Den første nummereringen ble brukt forut for versjon 1.0. Den første versjonen av kjernen var 0.01. Den ble etterfulgt av 0.02, 0.03, 0.10, 0.11, 0.12 (første versjon lansert under GPL), 0.95, 0.96, 0.97, 0.98, 0.99 og deretter 1.0.[202] Fra 0.95 og fremover var det mange patch-utgaver mellom versjonene.
Etter versjon 1.0 og før versjon 2.6, bestod versjonsnumrene av «a.b.c». Tallet «a» var hovedversjonen, tallet «b» betegnet en større revisjon av versjonen, og tallet «c» indikerte en mindre revisjon. Eksempel på denne nummereringen er 2.2.6. Hovedversjonen endret versjonsnummer i 1994 (versjon 1.0) og i 1996 (versjon 2.0). Versjon 3.0 ble lansert i 2011, men var ingen større endring i kjernen. Heller ikke versjon 4.0 (lansert i 2015), var noen fundamental endring. Endringene ble gjort kort og godt for å forhindre at tallet «b» skulle vokse å bli for stort. De mindre revisjonene bestod av patcher for sikkerhet, feilrettinger eller nye ustyrsdrivere. Testutgaver ble tildelt oddetall i sifferet «b»: 1.1.x, 1.3.x, 2.1.x, 2.3.x og 2.5.x.
Etter lanseringen av versjon 2.6.0 i 2004, oppstod det flere diskusjoner om versjonsnummereringen blant utviklerne.[203][204] Til slutt avgjorde Linus Torvalds og andre at en mye kortere «tidsbasert» utgivelsessyklus ville være egnet. I omkring syv år var de to første tallene «2.6», og et tredje tall ble inkrementert med hver ny versjon, som utkom etter to til tre måneder. Et fjerde tall ble noen ganger tilføyd for å spesifisere en feilretting eller en sikkerhetsoppdatering. Det var slutt på bruken av oddetall for å markere ustabile versjoner. I stedet ble utviklingsversjoner kalt utgivbare kandidater (release candidates), og fikk suffikset «-rc» etterfulgt av et ordinært tall. Utgivbare kandidater er en teknisk betegnelse på noe som kommer etter betaversjoner.
Et fjerde tall ble brukt ved en alvorlig feil som måtte fikses øyeblikkelig. Dette var tilfelle med koden for Network File System (NFS) i versjon 2.6.8, og versjon 2.6.8.1 rettet denne feilen. Det var ikke tilstrekkelig med andre endringer i kjernen for å legitimere en ny mindre versjon, som ville vært 2.6.9. Fra versjon 2.6.11 ble dette en ny offisiell versjonsnummerering. Det ble vanlig praksis å tilføye sikkerhetsoppdateringer og feilrettinger, og indikere dette med et fjerde tall.
Den 29. mai 2011 kunngjorde Linus Torvalds[205] at versjonen etter 2.6.39 ville bli versjon 3.0. Dette var både for å hindre at versjonsnumrene ble for store og for å minnes 20-årsjubileet til Linux. Utgivelsessyklusen skulle fortsatt være tidsbasert, ved å bruke det andre tallet; 3.1 skulle følge etter 3.0 etter noen få måneder. Et tilleggstall (nå det tredje tallet) skulle indikere feilrettinger og sikkerhetsoppdateringer, som for eksempel 3.0.18. Linuxfellesskapet refererer til dette som versjonsnummeret «x.y.z». Etter versjon 3.19 ble det nye versjonsnummeret endret til 4.0.[206][lower-alpha 6]
Versjoner med suffiks som «tip», indikerer en annen utviklingsgrein av Linuxkjernen, ofte med initialene til personen som laget den. «ck» betyr for eksempel Con Kolivas, «ac» står for Alan Cox, etc. Noen ganger er bokstavene relatert til utviklingsgreinens fokus; «wi» (wireless networking) indikerer for eksempel testutgaver for trådløse nettverk. Linuxdistribusjoner kan også ha sine egne suffikser med et annet nummereringssystem på deres stabile men eldre Linuxversjoner for næringslivet.
Flere nåværende og tidligere varianter av Linuxkjernen sørger for tilleggsfunksjonalitet, men tilhører ikke den offisielle utviklingsgreinen.
Av varianter kan nevnes μClinux, Linux-libre, Compute Node Linux, Cooperative Linux, Longene, grsecurity, INK, L4Linux, MkLinux, RTLinux og User-mode Linux. Noen varianter har etterhvert blitt slått sammen med den offisielle utviklingsgreinen.[207]
μClinux var en fork av Linuxkjernen for mikrokontrollere i innebygde systemer uten en minnehåndterer.[208] μClinux ble skapt som en fork av versjon 2.0.33 av Linuxkjernen, og ble gjenforent med hovedversjonen av Linuxkjernen i versjon 2.5.46.
Linux-libre er en kjerne uten binary blobs. Compute Node Linux (CNL) er en avart av Linuxkjernen som kjører på superdatamaskiner fra Cray Inc. Den er basert på SUSE Linux Enterprise Server.[209][210] CNL er en del av Cray Linux Environment. I november 2016 ble CNL kjørt på verdens tredje raskeste superdatamaskin. Cooperative Linux er en tidligere distribusjon som var basert på Slackware og som kunne kjøres i parallell med Microsoft Windows på samme datamaskin. Longene er en variant som har som formål å være binærkompatibel med applikasjonsprogramvare og utstyrsdrivere som er laget for både Microsoft Windows og Linux.[211] Grsecurity er en variant som ivektlegger forbedringer på datasikkerhet,[212] deriblant på webtjenere med nettverkstilgang til usikre steder. INK[213] er konstruert for å kjøre på superdatamaskinen Blue Gene fra IBM.[214][213] L4Linux er en variant av Linuxkjernen som kan kjøre virtualisert på L4 mikrokjernefamilien. MkLinux («mikrokjerne Linux») er en tidligere Linuxdistribusjon som ble startet av Open Software Foundation Research Institute[215] og Apple Computer.[215][216] MkLinux var beregnet på Macintosh med PowerPC mikroprosessorer. RTLinux («real time Linux») er en mikrokjerne for sanntidsoperativsystemer som kjører Linux som en prosess med forkjøpsrett. Sanntidssystemet gjør det mulig å kontrollere roboter, datainnsamling, produksjonsystemer og andre tidssensitive instrumenter og maskiner. User-mode Linux (UML) er en variant av Linuxkjernen som gjør det mulig for flere virtuelle Linuxbaserte operativsystemer (kjent som «gjester») å kjøre som en applikasjon innenfor et Linuxsystem («vert»).
Utdypende artikkel: MINIX
Da UNIX var et ungt operativsystem, var kildekoden åpent tilgjengelig. UNIX versjon 6 ble for eksempel lansert i mai 1975 og kildekoden kunne fritt distribueres på universiteter. John Lions ved University of New South Wales publiserte i mai 1976 boken Lions' Commentary on UNIX 6th Edition, with Source Code som inneholdt en beskrivelse av hver eneste linje i kildekoden.
AT&T oppdaget etter hvert operativsystemets kommersielle potensial, og ved lanseringen av UNIX System III (som var basert på UNIX versjon 7 og PWB/UNIX) i 1982 var kildekoden blitt en forretningshemmelighet som var ulovlig å studere på universiteter.
I denne situasjonen ble MINIX utviklet av Andrew S. Tanenbaum ved Vrije Universiteit Amsterdam. I 1987 publiserte han hele kildekoden med sine 12 649 linjer i en lærebok om operativsystemer.[217]
MINIX 1.0 var blitt utviklet for å kjøre på Intels 16-biter mikroposessorer. MINIX 1.5 (1991) ble portert til Motorola 68000 og SPARC, mens MINIX 2.0 (1997) ble laget for 32-biter Intel 80386 og SPARC.
MINIX 3 som ble lansert 24. oktober 2005 støtter 32-biter Intel 80386 og ARM. Siste versjon av MINIX er 3.3.0, som ble lansert 16. september 2014.
Forløperen til Linuxkjernen var MINIX, og i begynnelsen var Linuxkjernen avhengig av MINIX under oppstart. Og blant brukerne av MINIX var Linus Torvalds.
I 1991 var MINIX 2.0 ennå ikke lansert, og Linus savnet et fritt operativsystem for de nye 32-biter mikroprosessorene Intel 80386 og Intel 80486, som hadde vokst i popularitet. Han begynte arbeidet med å lage et nytt operativsystem for denne nye familien av mikroprosessorer.
Prosjektet ble innledet av Linus den 26. august 1991 med en posting på Usenets diskusjonsgruppe comp.os.minix:
Linus Torvalds[218]
GNU-prosjektet hadde skapt mange komponenter i et fritt operativsystem, men mikrokjernen GNU Mach og operativsystemet GNU Hurd var ennå ikke ferdig utviklet. Avarter av Berkeley Software Distribution (BSD) var ikke frigjort fra juridiske problemstillinger, slik at de kunne distribueres som fri programvare. 386BSD ble lansert 12. mars 1992,[219] og siste versjon ble lansert 12. november 1994.[220] 386BSD ble imidlertid stanset fordi den hadde brutt opphavsretten. NetBSD ble lansert i mai 1993,[221] FreeBSD den 1. november 1993[222] og OpenBSD den 18. oktober 1995.[223]
Pantentene til AT&T og University of California, Berkeley tvang frem et fritt alternativ. Linus hadde ikke noe avansert operativsystem i tankene. Ei heller var det ment for allment bruk. Han ante ikke at prosjektet raskt skulle samle utviklere og brukere, der Minix-hackere tidlig bidro med kode og idéer til Linuxkjernen. Ei heller ante han at kjernen etterhvert skulle få hjelp av flere tusen programvareutviklere.
Minix bestod av en mikrokjerne, som var basert på Mach fra Carnegie Mellon University. Dette representerte avansert nytenkning på denne tiden i universitetsmiljøer. Linux mangler mikrokjerne. Det både var (og er) «monolittisk» liksom den opprinnelige UNIX. Linus benyttet heller ikke segmentert swapping etter modell fra operativsystemet Multics, fordi dette lettere gir et fragmentert minne enn sideveksling. I stedet valgte han samme minnemodell som IBM benyttet tre år senere i OS/2 «Warp» 3.0:
Første versjon ble lansert den 17. september 1991 med versjonsnummeret 0.01. Datoen kan regnes som Linuxkjernens «fødselsdato», selv om den formelt ennå var uferdig. Kjernen hadde da 8 413 linjer med kode, og det ble solgt 90 datamaskiner som var bygd og sentrert omkring den nye operativsystemkjernen.
Versjon 0.02 ble lansert den 5. oktober 1991.[224] Tredje versjon (desember 1991) hadde versjonsnummeret 0.11, og kunne rekompileres uavhengig av MINIX. Ved lanseringen av verjon 0.12 i februar 1992, erstattet Linus sin egen lisens (som ikke tillot kommersiell distribuering) med GNU-lisensen for fri programvare.[225]
Den første postingen på Usenets diskusjonsgruppe alt.os.linux kom den 19. januar 1992.[226]
Den 31. mars 1992 ble den omdøpt til comp.os.linux.[227]
Versjon 0.95 (7. mars 1992) kunne kjøre XFree86, som var en fri klone av vindussystemet X. Hoppet i nummereringen fra 0.12 til 0.95, skyldtes troen på at versjon 1.0 var umiddelbart forestående. Dette var en overoptimistisk antagelse: Versjon 0.95 ble etterfulgt av 0.95a (24. mars 1992), 0.96a (med fire revisjoner), 0.96b (med to revisjoner), 0.96c (med to revisjoner), 0.97 (1. august 1992) og 0.99. Fra 1993 til 1994 ble det lansert 15 oppdaterte versjoner av 0.99.
Den 13. mars 1994 ble versjon 1.0 av Linuxkjernen endelig lansert. En fri operativsystemkjerne for Intel 80386 var en realitet, og er fødselsdatoen til den første stabile Linuxkjernen.
Versjon 1.1 var en utviklingsversjon som kulminerte i lanseringen av den stabile versjon 1.2 den 7. mars 1995. En mer modulær oppbygning av kildekoden gjorde det enklere å portere Linuxkjernen til andre datamaskinarkitekturer enn Intel 80386.
En variant av Linuxkjernen (versjonene 1.2 og 2.0) for Motorola 68000-serien, kalt Linux/mk68, ble utviklet uavhengig av den offisielle Linuxkjernen. Debian's Linuxdistribusjon Debian/mk68k benyttet denne porteringen av versjon 2.0.[228]
Versjon 2.0 ble lansert den 9. juni 1996, etter å ha blitt utviklet gjennom utviklingsversjonen 1.3. Denne nye stabile versjonen ble utviklet ved hjelp av GNU C versjon 2.7.2 og GNU Binutils 2.6.0.14.
Versjon 2.0 hadde bedre støtte for nettverk, med protokollene Point-to-Point Protocol (PPP), Serial Line Internet Protocol (SLIP), Compressed SLIP (CSLIP) og Parallel Line Internet Protocol (PLIP), såvel som DDP (AppleTalk), samt flere utstyrsdrivere. Den støttet symmetrisk flerprosessering med opptil 16 mikroprosessorer på en og samme datamaskin. Den var enda mer modulært oppbygd enn versjon 1.2, og hadde dynamisk opplastbare moduler hvor blant annet aksesskontrollister ble implementert.
Versjon 2.0 var også den første operativsystemkjernen med innebygd støtte for Java.
Versjon 2.2, den stabile utgaven av utviklingsversjonen 2.1, ble lansert den 25. januar 1999.[229] Den ble portert til Motorola 68000-serien, PowerPC, såvel som til 64-biter mikroprosessorene SPARC64 og DEC Alpha. Den støttet også optimaliseringer for x86-kloner fra AMD og Cyrix Corporation. Versjon 2.2 innførte også støtte for Micro Channel architecture (MCA), Plug and play-støtte for PCI-kort, støtte for CD-ROM, DVD, Iomega Zip-drive, irDA, digital penn, og utvidet støtte for de fleste typer av Joystick. Koden for håndtering av lyd, lydkort og periferiutstyr for lyd (høytalere, etc.), var gjort mer modulær og enklere å oppdatere. Støtten for video var kraftig forbedret: Støtten for et voksende antall TV-kort ble utvidet gjennom Video4Linux. Det samme gjaldt støtten for radio og digitalkameraer. Støtten for amatørradiostasjoner ble utvidet ved å tilføye støtte for protokollene NetROM og ROSE (Remote Operations Service Element protocol), og forbedringer i AX.25-laget.
Versjon 2.2 innførte også støtte for internettprotokollen IPv6, med SPX og IPX, og var den første operativsystemkjernen som var fullstendig kompatibel med IPv4.
Filsystemet extended file system (ext) i de tidligere utgavene av Linuxkjernen, ble erstattet av ext2.
I datanett ble det mulig å lese innholdet på datamaskiner med andre operativsystemer og deres filsystemer. Det ble innført slik støtte for NTFS (Windows NT), FAT (MS-DOS), Virtual FAT og FAT32 (Windows 95 og Windows 98), Microsofts filsystem Joliet (med lange filnavn på CD-ROM), Hierarchical File System (Apple Macintosh), Amiga Fast File System (Amiga), Unix File System for blant annet Berkeley Software Distribution (BSD), filsystemer for UNIX System V, Minix file system (MINIX), filsystemet til Acorn RISC OS, samt filsystemer for FreeBSD, SunOS og Solaris (deriblant ZFS). I nettverk ble støtten for NetWare forbedret.
To andre nyheter var støtte for Unicode og en tilpasning til UNIX98 som er en del av Single UNIX Specification.
Versjon 2.4, den stabile utgaven av utviklingsversjonen 2.3, ble lansert den 4. januar 2001. I heterogene nettverk ble støtten til andre operativsystemers filformater utvidet med High Performance File System (OS/2), Extent File System (IRIX) og NeXTSTEP. Linuxkjernen støttet for første gang Sun NFS 3.0.[230] I versjon 2.4 gjorde implementasjonen av IPv4 gjort enda mer skalerbar. I nettverkslaget ble det også tilføyd støtte for DECnet, og innenfor OSI-modellens datalink-lag ble de to lagene for PPP og ISDN i versjon 2.2 slått sammen til ét lag.
Versjon 2.2 satte en grense på 1024 samtidig kjørende prosesser eller tråder. I versjon 2.4 var grensen skalerbar under kjøring, slik at det eneste som begrenser antall prosesser var datamaskinens mengde med RAM.
Versjon 2.4 tilføyde støtte for USB, PCMCIA, PCI-utvidelsen I2O og ISA Plug and Play. IDE-kontrollere støttet maksimalt 4 lagringsenheter i en datamaskin, det være seg harddisker, CD-ROM eller DVD. Versjon 2.2 utvidet grensen til 4 kontrollere og 10 IDE-enheter. I versjon 2.4 ble dette utvidet til 10 kontrollere og 20 enheter. Versjon 2.4 kunne også kjøres i innebygde systemer.
En generisk oppstartslaster gjorde det mulig å kjøre DOS- og Windows-programmer direkte fra kjernen gjennom emulatorer som Wine og DOSEMU. Versjon 2.4 var også mer kompatibel med POSIX, og mer avhengig av formatet ELF enn versjon 2.2, selv om versjon 2.2 var den første Linuxkjernen som bare kunne kompileres som ELF.
Kjerneserien 2.5 ble påbegynt den 23. november 2011 og kulminerte i kjerneserien 2.6 som ble lansert den 17. desember 2003. Serien ble utviklet på grunnlag av den tidligere 2.4-serien og hadde omfattende innovasjoner. For utviklere var den nye kildekoden lettere å oppdatere, mens brukerne kunne dra nytte av en revidert prosess-skedulerer, en revisjon av I/O-funksjoner og en lavere ventetid.[231]
I et operativsystem med fleroppgavekjøring er det et program som tildeler beregningstiden til de ulike prosessene som skal kjøre. Dette programmet er prosess-skedulereren. Siden lanseringen av versjon 2.6 har flere grunnleggende oppgaver blitt utført av skedulereren. Den ungarske utvikleren Ingo Molnár designet og implementerte en ny skedulerer for den første 2.6-kjernen, den såkalte skedulereren. Relevante algoritmer til denne skedulereren har tidskompleksiteten , der er stor O-notasjon.
Skedulereren arbeidet effektivt selv med mange prosesser og krevde svært liten beregningstid. I prinsippet benyttet den to koblede lister med prosesser, en som ønsket å kjøre og en annen som allerede kjørte. Når alle prosessene var i den andre listen, ble tabellene byttet om prosessen startet på nytt. Skedulereren var utformet slik at prosesser som brukte store mengde beregningstid ble straffet i forhold til interaktive prosesser hvis begge ønsket å kjøre samtidig.
Interaktive prosesser krever som regel svært liten beregningstid, men er svært tidskritiske, for eksempel hvis brukeren ventet lenge på svar fra det grafiske brukergrensesnitter. -skedulereren benyttet heuristikk for å avgjøre om en prosess var interaktiv eller om mikroprosessoren benyttet lang tid.
Den interne «klokken» i kjernen ble økt fra 100 til 1000 hertz i versjon 2.6, dvs. den kortest mulige lengde av en timeslice (den periode hvorved en prosess har lov til å kjøre) er satt til et millisekund. Interaktive prosesser drar også fordeler av dette, ettersom de også befinner seg i køen. Men fordi dette gir mer belastning på mikroprosessoren og dermed et høyere strømforbruk, bestemte man å stille klokken til 250 Hz i versjon 2.6.13. Under konfigurasjon av kjernen kan imidlertid også verdiene 100, 300 og 1000 Hz velges.
I versjon 2.6.23 av Linuxkjernen, som ble lansert 9. oktober 2007, ble -skedulereren erstattet av en Completely Fair Scheduler (CFS), som også ble utviklet av Ingo Molnár. CFS er kontroversiell blant utviklere, da den gir skalerbarhet også for tjenere med mange prosessorkjerner. Utviklere som Con Kolivas er av den oppfatning at dette har gitt lavere ytelse på typiske stasjonære systemer.[232]
Fra og med versjon 2.6 er de fleste systemkall preemptive, dvs. selv om systemet utfører oppgaver i kjernemodus, kan systemkall, spesielt de som bruker for lang tid, bli satt på pause for å kjøre andre oppgaver i brukermodus. Systemkallet fortsetter deretter når brukermodusprosessen har brukt opp sin tilmålte tid eller hvis den skulle be om en ny tidsplan. Ett unntak er systemkall som er atomiske, dvs. at de er garantert ikke-avbrytbare.
Automatisk håndtering av enheter som støtter ISA "plug & play". Tidligere var det mulig å benytte slike enheter ved hjelp av dedikert programvare for konfigurasjon (isapnp).
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
