.\" -*- coding: UTF-8 -*- .\" Copyright (C) 2015 Serge Hallyn .\" and Copyright (C) 2016, 2017 Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH cgroups 7 "2 maj 2024" "Linux man\-pages 6.8" .SH NAMN cgroups — Linux styrgrupper .SH BESKRIVNING .\" Styrgrupper, vanligen refererade till som cgroups, är en funktion i Linuxkärnan som gör att processer kan organiseras i hierarkiska grupper vars användning av olika typer av resurser sedan kan begränsas och övervakas. Kärnans cgroup\-gränssnitt tillhandahålls via ett pseudofilsystem som kallas cgroupfs. Gruppering implementeras i kärnans centrala cgroup\-kod, medan resursspårning och \-begränsning implementeras i ett antal undersystem per resurstyp (minne, CPU, och så vidare). .SS Terminologi En \fIcgroup\fP är en samling av processer som är bundna av en uppsättning gränser eller parametrar som definieras via cgroup\-filsystemet. .P Ett \fIundersystem\fP är en kärnkomponent som modifierar beteendet hos processerna i en cgroup. Olika undersystem har implementerats, vilket gör det möjligt att göra saker som att begränsa mängden CPU\-tid och minne som är tillgängligt i en cgroup, bokföring av CPU\-tiden som används av en cgroup och frysning och återupptagande av körningen av processerna i en cgroup. Undersystem är också ibland kända som \fIresurshanterare\fP (\fIresource controllers\fP) (eller helt enkelt, hanterare (\fIcontrollers\fP)). .P .\" En hanterares cgroups är arrangerade i en \fIhierarki\fP. Denna hierarki defineras genom att skapa, ta bort och byta namn på underkataloger i cgroup\-filsystemet. På varje nivå av hierarkin kan attribut (t.ex., gränser) definieras. Gränserna, styrningen och bokföringen som erbjuds av cgroups har allmänt sett påverkan genom underhierarkin under den cgroup där attributen definieras. Alltså kan till exempel inte gränserna som placeras på en cgroup på en högre nivå i hierarkin överskridas av avkomme\-cgroups. .SS "Cgroups version 1 och version 2" Den ursprungliga utgåvan av cgroups\-implementationen var i Linux 2.6.24. Med tiden har olika cgroup\-hanterare lagts till för att möjliggöra hanteringen av olika typer av resurser. Dock var utvecklingen av dessa hanterare i stort sett okoordinerad, med resultatet att många inkonsistenser uppstod mellan hanterare och användandet av cgroup\-hierarkier blev ganska komplext. En längre beskrivning av dessa problem finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v2.rst\fP (eller \fIDocumentation/cgroup\-v2.txt\fP i Linux 4.17 och tidigare). .P På grund av problemen med den ursprungliga cgroups\-implementationen (cgroups version 1) inleddes, med början i Linux 3.10, arbete på en ny, ortogonal implementation för att åtgärda dessa problem. Från början markerad experimentell, och dold bakom monteringsflaggan \fI\-o\ __DEVEL__sane_behavior\fP gjordes den nya versionen (cgroups version 2) slutligen officiell i och med utgåvan av Linux 4.5. Skillnader mellan de två versionerna beskrivs i texten nedan. Filen \fIcgroup.sane_behavior\fP, som finns i cgroups v1, är en relik från denna monteringsflagga. Filen rapporterar alltid ”0” och finns bara kvar för bakåtkompatibilitet. .P .\" Även om cgroups v2 är avsett att vara en ersättning för cgroups v1 finns det äldre systemet kvar (och av kompatibilitetsskäl är det osannolikt att det kommer tas bort). För närvarande implementerar cgroups v2 endast en delmängd av hanterarna som är tillgängliga i cgroups v1. De två systemen är implementerade så att både v1\-hanterare och v2\-hanterare kan monteras på samma system. Alltså är det till exempel möjligt att använda de hanterare som stödjs under version 2, men också använda version 1\-hanterare där version 2 ännu inte stödjer dessa hanterare. Den enda begränsningen är att en hanterare inte samtidigt kan användas i både en cgroups v1\-hierarki och i cgroups v2\-hierarkin. .SH "CGROUPS VERSION 1" Under cgroups v1 kan varje hanterare monteras mot ett separat cgroup\-filsystem som ger sin egen hierarkiska organisation av processerna på systemet. Det är också möjligt att sammontera flera (eller alla) cgroups v1\-hanterare mot samma cgroup\-filsystem, vilket betyder att de sammonterade hanterarna använder samma hierarkiska organisation av processer. .P .\" För varje monterad hierarki avspeglar katalogträdet styrgruppshierarkin. Varje styrgrupp representeras av en katalog, där var och en av dess barnstyr\-cgroup representeras av en barnkatalog. Till exempel representerar \fI/user/johan/1.session\fP styrgruppen \fI1.session\fP, vilken är ett barn till \fIjohan\fP, vilken är ett barn till \fI/user\fP. Under varje cgroup\-katalog finns en uppsättning filer vilka kan läsas eller skrivas till, vilket avspeglar resursbegränsningar och några allmänna cgroup\-egenskaper. .SS "Uppgifter (trådar) respektive processer" I cgroups v1 dras en distinktion mellan \fIprocesser\fP och \fIuppgifter\fP. I denna vy kan en process bestå av flera uppgifter (oftare kallade trådar, från ett användarperspektiv, och kallas så i resten av denna manualsida). I cgroups v1 är det möjligt att hantera cgroup\-medlemskapet hos trådarna i en process oberoende av varandra. .P .\" Cgroups v1 möjlighet att dela trådar över olika cgroups orsakade problem i en del fall. Till exempel var det inte meningsfullt för \fIminnes\fPhanteraren eftersom alla trådarna i en process delar en enda adressrymd. På grund av dessa problem togs möjlighetn att oberoende hantera cgroup\-medlemskapet hos trådar i en process bort i den ursprungliga cgroups v2\-implementationen, och återställdes senare i en mer begränsad form (se diskussionen om ”trådläge” nedan). .SS "Montering av v1\-hanterare" Användningen av cgroups förutsätter en kärna byggd med alternativet \fBCONFIG_CGROUP\fP. Dessutom har var och en av v1\-hanterarna ett associerat konfigurationsalternativ som måste vara satt för att använda den hanteraren. .P För att använda en v1\-hanterare måste den monteras mot ett cgroup\-filsystem. Den vanliga platsen för sådana monteringar är under ett \fBtmpfs\fP(5)\-filsystem monterat på \fI/sys/fs/cgroup\fP. Man kan alltså montera \fIcpu\fP\-hanteraren enligt följande: .P .in +4n .EX mount \-t cgroup \-o cpu none /sys/fs/cgroup/cpu .EE .in .P Det är möjligt att sammontera flera hanterare mot samma hierarki. Till exempel sammonteras här hanterarna \fIcpu\fP och \fIcpuacct\fP mot en enda hierarki: .P .in +4n .EX mount \-t cgroup \-o cpu,cpuacct none /sys/fs/cgroup/cpu,cpuacct .EE .in .P Sammontering av hanterare har effekten att en process är i samma cgroup för alla sammonterade hanterare. Separat monterade hanterare gör det möjligt för en process att finnas i en cgroup \fI/apa1\fP för en hanterare medan den finns i \fI/apa2/apa3\fP för en annan. .P Det är möjligt att sammontera alla v1\-hanterare mot samma hierarki: .P .in +4n .EX mount \-t cgroup \-o all cgroup /sys/fs/cgroup .EE .in .P (Man kan åstadkomma samma resultat genom att utelämna \fI\-o all\fP eftersom det är standardbeteendet om inga hanterare uttryckligen anges.) .P Det är inte möjligt att montera samma hanterare mot flera cgroup\-hierarkier. Till exempel är det inte möjligt att montera både hanteraren \fIcpu\fP och \fIcpuacct\fP mot en hierarki, och att montera hanteraren \fIcpu\fP ensam mot en annan hierarki. Det är möjligt att skapa flera monteringar med exakt samma uppsättning av sammonterade hanterare. I det fallet är dock det enda som händer att flera monteringspunkter ger en vy av samma hierarki. .P .\" Observera att på många system är v1\-hanterarna automatiskt monterade under \fI/sys/fs/cgroup\fP; speciellt skapar \fBsystemd\fP(1) automatiskt sådana monteringar. .SS "Avmontering av v1\-hanterare" Ett monterat cgroup\-filsystem kan avmonteras med kommandot \fBumount\fP(8), som i följande exempel: .P .in +4n .EX umount /sys/fs/cgroup/pids .EE .in .P .\" \fIMen observera även\fP: ett cgroup\-filsystem avmonteras bara om det inte är upptaget, det vill säga att det inte har någon barn\-cgroup. Om det inte är fallet är enda effekten av \fBumount\fP(8) att göra monteringen osynlig. Alltså måste man för att säkerställa att en montering verkligen tas bort först ta bort alla barn\-cgroup:er, vilket i sin tur endast kan göras efter att alla medlemsprocesser har flyttats ifrån dessa cgroup:er till root\-cgroup:en. .SS "Cgroup version 1\-hanterare" Varje hanterare i cgroup version 1 styrs av ett kärnkonfigurationsalternativ (uppräknat nedan). Dessutom styrs tillgängligheten av funktionen cgroup av kärnkonfigurationsalternativet \fBCONFIG_CGROUPS\fP. .TP \fIcpu\fP (från Linux 2.6.24; \fBCONFIG_CGROUP_SCHED\fP) Cgroups kan garanteras ett minsta antal ”CPU\-andelar” när ett system är belastat. Detta begränsar inte en cgroup:s CPU\-användning om CPU:erna inte är belastade. För ytterligare information, se \fIDocumentation/scheduler/sched\-design\-CFS.rst\fP (eller \fIDocumentation/scheduler/sched\-design\-CFS.txt\fP i Linux 5.2 och tidigare). .IP I Linux 3.2 utökades denna styrgrupp till att tillandahålla styrning av ”CPU\-bandbredd”. Om kärnan konfigureras med \fBCONFIG_CFS_BANDWIDTH\fP är det, inom varje schemaläggningsperiod (definierad via en fil i cgroup\-katalogen), möjligt att definiera en övre gräns på CPU\-tiden som tilldelas till processer i en cgroup. Denna övre gräns gäller även om det inte finns någon annan konkurrens om CPU:n. Ytterligare information finns i kärnans källfil \fIDocumentation/scheduler/sched\-bwc.rst\fP (eller \fIDocumentation/scheduler/sched\-bwc.txt\fP i Linux 5.2 och tidigare). .TP \fIcpuacct\fP (sedan Linux 2.6.24; \fBCONFIG_CGROUP_CPUACCT\fP) Denna tillhandahåller bokföring av CPU\-användning av grupper av processer. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/cpuacct.rst\fP (eller \fIDocumentation/cgroup\-v1/cpuacct.txt\fP i Linux 5.2 och tidigare). .TP \fIcpuset\fP (sedan Linux 2.6.24; \fBCONFIG_CPUSETS\fP) Denna cgroup kan användas för att binda processerna i en cgroup till en specifik uppsättning av CPU:er och NUMA\-noder. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/cpusets.rst\fP (eller \fIDocumentation/cgroup\-v1/cpusets.txt\fP i Linux 5.2 och tidigare). . .TP \fImemory\fP (sedan Linux 2.6.25; \fBCONFIG_MEMCG\fP) Minneshanteraren stödjer rapportering och begränsning av processminne, kärnminne och växling som används av cgroup:er. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/memory.rst\fP (eller \fIDocumentation/cgroup\-v1/memory.txt\fP i Linux 5.2 och tidigare). .TP \fIdevices\fP (sedan Linux 2.6.26; \fBCONFIG_CGROUP_DEVICE\fP) Detta stödjer styrning av vilka processer som får skapa (mknod) enheter liksom öppna dem för läsning eller skrivning. Policyerna kan anges som tillåtelselistor och nekandelistor. Hierarkin upprätthålls, så att nya regler inte får bryta mot befintliga regler för målet eller anfader\-cgroup:er. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/devices.rst\fP (eller \fIDocumentation/cgroup\-v1/devices.txt\fP i Linux 5.2 och tidigare). .TP \fIfreezer\fP (sedan Linux 2.6.28; \fBCONFIG_CGROUP_FREEZER\fP) Cgroup:en \fIfreezer\fP kan försätta alla processer i en cgroup i vänteläge (suspend) och återuppta (resume) dem. Att frysa en cgroup \fI/A\fP får även dess barn, till exempel processer i \fI/A/B\fP, att frysas. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/freezer\-subsystem.rst\fP (eller \fIDocumentation/cgroup\-v1/freezer\-subsystem.txt\fP i Linux 5.2 och tidigare). .TP \fInet_cls\fP (sedan Linux 2.6.29; \fBCONFIG_CGROUP_NET_CLASSID\fP) Denna lägger ett klass\-id, angivet för cgroup:en, på nätverkspaket som skapas av en cgroup. Dessa klass\-id:n kan sedan användas i brandväggsregler, liksom användas för att forma trafiken med \fBtc\fP(8). Detta gäller endast paket som lämnar cgroup:en, inte trafik som kommer till cgroup:en. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/net_cls.rst\fP (eller \fIDocumentation/cgroup\-v1/net_cls.txt\fP i Linux 5.2 och tidigare). .TP \fIblkio\fP (sedan Linux 2.6.33; \fBCONFIG_BLK_CGROUP\fP) Cgroup:en \fIblkio\fP styr och begränsar åtkomst till angivna blockenheter genom att lägga på IO\-styrning i form av strypning och övre gränser på lövnoder och mellanliggande noder i lagringshierarkin. .IP Två policyer är tillgängliga. Den första är med proportionell vikt tidsbaserad uppdelning av disk implementerad med CFQ. Denna är i kraft för lövnoder som använder CFQ. Den andra är en strypningspolicy som anger övre gränser för I/O\-hastighet för en enhet. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/blkio\-controller.rst\fP (eller \fIDocumentation/cgroup\-v1/blkio\-controller.txt\fP i Linux 5.2 och tidigare). .TP \fIperf_event\fP (sedan Linux 2.6.39; \fBCONFIG_CGROUP_PERF\fP) Denna hanterare medger \fIperf\fP\-övervakning av uppsättningen processer som är grupperade i en cgroup. .IP Ytterligare information finns i kärnans källfiler .TP \fInet_prio\fP (sedan Linux 3.3; \fBCONFIG_CGROUP_NET_PRIO\fP) Denna tillåter att prioriteter anges, per nätverksgränssnitt, för cgroup:er. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/net_prio.rst\fP (eller \fIDocumentation/cgroup\-v1/net_prio.txt\fP i Linux 5.2 och tidigare). .TP \fIhugetlb\fP (sedan Linux 3.5; \fBCONFIG_CGROUP_HUGETLB\fP) Denna stödjer att man begränsar användningen av väldiga sidor med styrgrupper. .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/hugetlb.rst\fP (eller \fIDocumentation/cgroup\-v1/hugetlb.txt\fP i Linux 5.2 och tidigare). .TP \fIpids\fP (sedan Linux 4.3; \fBCONFIG_CGROUP_PIDS\fP) Denna hanterare tillåter att man begränsar antalet processer som kan skapas i en styrgrupp (och dess avkommor). .IP Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/pids.rst\fP (eller \fIDocumentation/cgroup\-v1/pids.txt\fP i Linux 5.2 och senare). .TP \fIrdma\fP (sedan Linux 4.11; \fBCONFIG_CGROUP_RDMA\fP) RDMA\-hanteraren tillåter att man begränsar användningen av RDMA/IB\-specifika resurser per styrgrupp. .IP .\" Ytterligare information finns i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v1/rdma.rst\fP (eller \fIDocumentation/cgroup\-v1/rdma.txt\fP i Linux 5.2 och tidigare). .SS "Att skapa styrgrupper och flytta processer" Ett styrgruppfilsystem innehåller initialt en ensam rotstyrgrupp, ”/”, vilken alla processer hör till. En ny styrgrupp skapas genom att skapa en katalog i styrgruppfilsystemet: .P .in +4n .EX mkdir /sys/fs/cgroup/cpu/sg1 .EE .in .P Detta skapar en ny tom styrgrupp. .P En process kan flyttas till denna styrgrup genom att skriva dess PID in i styrgruppens fil \fIcgroup.procs\fP: .P .in +4n .EX echo $$ > /sys/fs/cgroup/cpu/sg1/cgroup.procs .EE .in .P Endast en PID åt gången får skrivas till denna fil. .P Om man skriver värdet 0 till en fil \fIcgroup.procs\fP flyttas den skrivande processen till motsvarande styrgrupp. .P När man skriver ett PID in i \fIcgroup.procs\fP flyttas alla trådar i processen in i den nya styrgruppen på en gång. .P Inom en hierarki kan en process vara medlem av precis en styrgrupp. När man skriver en process PID till en fil \fIcgroup.procs\fP tas den automatiskt bort från den styrgrupp den var medlem av tidigare. .P Filen \fIcgroup.procs\fP kan läsas för att hämta en lista på processer som är medlemmar av en styrgrupp. Den returnerade listan av PID:er är inte garanterat i ordning. Inte heller är den garanterat fri från upprepningar. (Till exempel kan ett PID ha blivit återanvänt medan listan lästes.) .P .\" I cgroups v1 kan en enskild tråd flyttas till en annan styrgrupp genom att skriva dess tråd\-ID (d.v.s., kärnans tråd\-ID returnerat från \fBclone\fP(2) och \fBgettid\fP(2)) till filen \fItasks\fP i en styrgruppskatalog. Denna fil kan läsas för att se uppsättningen av trådar som är medlemmar av styrgruppen. .SS "Att ta bort styrgrupper" .\" För att ta bort en styrgrupp får den först inte ha några barnstyrgrupper och inte innehålla några processer (andra än zombier). Förutsatt att det är fallet kan man helt enkelt ta bort motsvarande katalogsökväg. Observera att filer i en styrgruppskatalog inte kan och inte behöver tas bort. .SS "Cgroups v1 notifieringar om släpp" Två filer kan användas för att avgöra huruvida kärnan skall tillhandahålla notifieringar när en styrgrupp blir tom. En styrgrupp anses tom när den inte innehåller några barnstyrgrupper och inga medlemsprocesser. .P En speciell fil i rotkatalogen av varje styrgruppshierarki, \fIrelease_agent\fP, kan användas för att registrera sökvägsnamnet till ett program som kan anropas när en styrgrupp i hierarkin blir tom. Sökvägen till den nyss tömda styrgruppen (relativt monteringspunkten för styrgrupper) ges som det enda kommandoradsargumentet när programmet \fIrelease_agent\fP anropas. Programmet \fIrelease_agent\fP kan ta bort styrgruppskatalogen, eller kanske återpopulera den med en process. .P Standardvärdet i filen \fIrelease_agent\fP är tomt, vilket betyder att ingen släppagent anropas. .P Innehållet i filen \fIrelease_agent\fP kan också anges via en monteringsflagga när styrgruppsfilsystemet monteras: .P .in +4n .EX mount \-o release_agent=sökväg … .EE .in .P .\" Huruvida programmet \fIrelease_agent\fP anropas eller inte när en viss styrgrupp blir tom avgörs av värdet i filen \fInotify_on_release\fP i motsvarande styrgruppskatalog. Om denna fil innehåller värdet 0, då anropas inte programmet \fIrelease_agent\fP. Om den innehåller värdet 1 anropas programmet \fIrelease_agent\fP. Standardvärdet i denna fil i rotstyrgruppen är 0. När en ny styrgrupp skapas ärvs värdet i denna fil från motsvarande fil i föräldrastyrgruppen. .SS "Cgroup v1 namngivna hierarkier" I cgroups v1 är det möjligt att montera en styrgruppshierarki som inte har några tillkopplade hanterare: .P .in +4n .EX mount \-t cgroup \-o none,name=ngtnamn none /någon/monterings/punkt .EE .in .P Flera instanser av sådana hierarkier kan monteras; varje hierarki måste ha ett unikt namn. Det enda syftet med sådana hierarkier är att spåra processer. (Se diskussionen om släppnotifieringar nedan.) Ett exempel på detta är styrgruppshierarkin \fIname=systemd\fP som används av \fBsystemd\fP(1) för att spåra tjänster och användarsessioner. .P .\" Sedan Linux 5.0 kan kärnans uppstartsflagga \fIcgroup_no_v1\fP (beskriven nedan) användas till att avaktivera namngivna hierarkier inom cgroup v1, genom att ange \fIcgroup_no_v1=namngiven\fP. .SH "CGROUPS VERSION 2" I cgroups v2 bor alla monterade hanterare i en enda sammanslagen hierarki. Även om (olika) hanterare kan monteras samtidigt under v1\- och v2\-hierarkierna är det inte möjligt att montera samma hanterare samtidigt under både v1\- och v2\-hierarkierna. .P De nya beteendena i cgroups v2 sammanfattas här, och utvecklas i några fall i de följande underavsnitten. .IP \[bu] 3 Cgroups v2 tillhandahåller en sammanslagen hierarki mot vilken alla hanterare monteras. .IP \[bu] ”Interna” processer är inte tillåtna. Med undantag av rotstyrgruppen kan processer endast finnas i lövnoder (styrgrupper som inte själva innehåller barnstyrgrupper). Detaljerna är något mer subtila än detta, och beskrivs nedan. .IP \[bu] Aktiva styrgrupper måste anges via filerna \fIcgroup.controllers\fP och \fIcgroup.subtree_control\fP. .IP \[bu] Filen \fItasks\fP har tagits bort. Dessutom har filen \fIcgroup.clone_children\fP som används i hanteraren \fIcpuset\fP tagits bort. .IP \[bu] En förbättrad mekanism för notifieringar om tomma styrgrupper ges av filen \fIcgroup.events\fP. .P För fler ändringar, se filen \fIDocumentation/admin\-guide/cgroup\-v2.rst\fP i kärnans källa (eller \fIDocumentation/cgroup\-v2.txt\fP i Linux 4.17 och tidigare). . .P .\" Några av de nya beteendena ovan modifierades senare med tillägget i Linux 4.14 av ”trådläge” (beskrivet nedan). .SS "Cgroups v2 sammanslagen hierarki" I cgroups v1 var möjligheten att montera olika hanterare mot olika hierarkier avsedd att ge en stor flexibilitet i designen av program. I praktiken visade sig dock flexibiliteten vara mindre användbar än förväntat, och i många fall lade den till komplexitet. Därför monteras i cgroups v2 alla tillgängliga hanterare mot en enda hierarki. De tillgängliga hanterarna monteras automatiskt, vilket betyder att det inte är nödvändigt (eller möjligt) att ange hanterarna när man monterar filsystemet för cgroups v2 med ett kommando som det följande: .P .in +4n .EX mount \-t cgroup2 none /mnt/cgroup2 .EE .in .P En hanterare i cgroup v2 är tillgänglig endast om den inte för närvarande används via en montering mot en cgroup v1\-hierarki. Eller, för att uttrycka det på ett annat sätt, är det inte möjligt att använda samma hanterare mot både en v1\-hierarki och den sammanslagna v2\-hierarkin. Detta betyder att det kan vara nödvändigt att först avmontera en v1\-hanterare (som beskrivet ovan) före den hanteraren är tillgänglig i v2. Eftersom \fBsystemd\fP(1) normalt använder sig mycket av några v1\-hanterare kan det i några fall vara enklare att starta med de valda v1\-hanterarna avaktiverade. För att göra detta, ange flaggan \fIcgroup_no_v1=lista\fP på kärnans startkommandorad; \fIlista\fP är en kommaseparerad lista av namnen på hanterare att avaktivera, eller ordet \fIall\fP för att avaktivera alla v1\-hanterare. (Denna situation hanteras korrekt av \fBsystemd\fP(1) som faller tillbaka på att arbeta utan de angivna hanterarna.) .P .\" Observera att på många moderna system monterar \fBsystemd\fP(1) automatiskt filsystemet \fIcgroup2\fP på \fI/sys/fs/cgroup/unified\fP under uppstartsprocessen. .SS "Cgroups v2 monteringsflaggor" The following options (\fImount\ \-o\fP) can be specified when mounting the group v2 filesystem: .TP \fInsdelegate\fP (sedan Linux 4.15) Behandla styrgruppsnamnrymder som delegeringsgränser. För detaljer se nedan. .TP \fImemory_localevents\fP (sedan Linux 5.2) .\" commit 9852ae3fe5293264f01c49f2571ef7688f7823ce .\" \fImemory.events\fP skall visa statistik endast för styrgruppen själv, och inte för några avkommestyrgrupper. Detta var beteendet före Linux 5.2. Med början i Linux 5.2 är standardbeteendet att inkludera statistik för avkommestyrgrupper i \fImemory.events\fP, och denna monteringsflagga kan användas för att återgå till det tidigare beteendet. Denna flagga är systemvid och kan anges vid monteringar eller ändras genom ommonteringar endast från den intiala monteringsnamnrymden; den ignoreras tyst i andra namnrymder än den initiala. .SS "Cgroups v2\-hanterare" Följande hanterare, dokumenterade i kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v2.rst\fP (eller \fIDocumentation/cgroup\-v2.txt\fP i Linux 4.17 och tidigare), stödjs i styrgrupper version 2: .TP \fIcpu\fP (sedan Linux 4.15) Detta är efterföljaren till hanterarna \fIcpu\fP och \fIcpuacct\fP i version 1. .TP \fIcpuset\fP (sedan Linux 5.0) Detta är efterföljaren till hanteraren \fIcpuset\fP i version 1. .TP \fIfreezer\fP (sedan Linux 5.2) .\" commit 76f969e8948d82e78e1bc4beb6b9465908e74873 Detta är efterföljaren till hanteraren \fIfreezer\fP i version 1. .TP \fIhugetlb\fP (sedan Linux 5.6) Detta är efterföljaren till hanteraren \fIhugetlb\fP i version 1. .TP \fIio\fP (sedan Linux 4.5) Detta är efterföljaren till hanteraren \fIblkio\fP i version 1. .TP \fImemory\fP (sedan Linux 4.5) Detta är efterföljaren till hanteraren \fImemory\fP i version 1. .TP \fIperf_event\fP (sedan Linux 4.11) Detta är samma som hanteraren \fIperf_event\fP i version 1. .TP \fIpids\fP (sedan Linux 4.5) Detta är samma som hanteraren \fIpids\fP i version 1. .TP \fIrdma\fP (sedan Linux 4.11) Detta är samma som hanteraren \fIrdma\fP i version 1. .P Det finns ingen direkt motsvarighet till hanterarna \fInet_cls\fP och \fInet_prio\fP från styrgrupper version 1. Istället har stöd lagts till i \fBiptables\fP(8) för att tillåta eBPF\-filter att haka på sökvägar i cgroup v2 för att ta beslut om nätverkstrafik baserat på styrgrupp. .P .\" Hanteraren \fIdevices\fP i v2 ger inget gränssnitt till filer; istället begränsas enhetsstyrningen genom att koppla ett eBPF\-program (\fBBPF_CGROUP_DEVICE\fP) till en v2\-styrgrupp. .SS "Cgroups v2 underträdsstyrning" Varje styrgrupp i v2\-hierarkin innehåller följande två filer: .TP \fIcgroup.controllers\fP Denna endast läsbara fil exponerar en lista av hanterarna som finns \fItillgängliga\fP i denna styrgrupp. Innehållet i denna fil motsvarar innehållet i filen \fIcgroup.subtree_control\fP i föräldrastyrgruppen. .TP \fIcgroup.subtree_control\fP Detta är en lista över hanterare som är \fIaktiva\fP (\fIaktiverade\fP) i styrgruppen. Uppsättningen av hanterare i denna fil är en delmängd av mängden i \fIcgroup.controllers\fP för denna styrgrupp. Uppsättningen av aktiva hanterare modifieras genom att till denna fil skriva strängar som innehåller blankavgränsade hanterarnamn, vart och ett föregånget av ”+” (för att aktivera hanteraren) eller ”\-” (för att avaktivera hanteraren), som i följande exempel: .IP .in +4n .EX echo \[aq]+pids \-memory\[aq] > x/y/cgroup.subtree_control .EE .in .IP Ett försök att aktivera en hanterare som inte finns i \fIcgroup.controllers\fP medför ett fel \fBENOENT\fP när man skriver till filen \fIcgroup.subtree_control\fP. .P Eftersom listan av hanterare i \fIcgroup.subtree_control\fP är en delmängd av dem i \fIcgroup.controllers\fP kan en hanterare som har avaktiverats i en styrgrupp i hierarkin aldrig återaktiveras i underträdet nedanför den styrgruppen. .P .\" En styrgrupps fil \fIcgroup.subree_control\fP avgör uppsättningen hanterare som används i \fIbarn\fPstyrgruppen. När en hanterare (t.ex., \fIpids\fP) finns i filen \fIcgroup.subtree_control\fP i en föräldrastyrgrupp, då skapas automatiskt motsvarande hanterargränssnittsfiler (t.ex., \fIpids.max\fP) i barnen till den styrgruppen och kan användas för att utöva resursstyrning i barnstyrgrupperna. .SS "Cgroups v2\-regeln \[dq]inga interna processer\[dq]" Cgroups v2 upprätthåller en så kallad ”inga interna processer”\-regel. Grovt uttryckt betyder denna regel att, med undantag för rotstyrgruppen, processer endast får bo i lövnoder (styrgrupper som inte själva innehåller barnstyrgrupper). Detta undviker behovet av att avgöra hur resurser skall fördelas mellan processer som är medlemmar av en styrgrupp A och processer i barnstyrgrupper till A. .P Till exempel, om styrgruppen \fI/sg1/sg2\fP finns, då kan en process bo i \fI/sg1/sg2\fP, men inte i \fI/sg1\fP. Detta är så för att undvika en tvetydighet i cgroups v1 med avseende på delegationen av resurser mellan processer i \fI/sg1\fP och dess barnstyrgrupper. Det rekommenderade sättet i cgroups v2 är att skapa en underkatalog som heter \fIleaf\fP för alla styrgrupper som inte är löv, vilken skall innehålla processer men inga barnstyrgrupper. Alltså, processer vilka tidigare skulle ha hamnat i \fI/sg1\fP skulle nu hamna i \fI/sg1/leaf\fP. Detta har fördelen att göra relationen mellan processer i \fI/sg1/leaf\fP och \fI/sg1\fPs andra barn explicit. .P Regeln om ”inga interna processer” är i verkligheten mer subtil än den uttrycks ovan. Mer exakt är regeln att en styrgrupp (annan än roten) inte både kan (1) ha medlemsprocesser, och (2) distribuera resurser till barnstyrgrupper \[em] det vill säga, ha en fil \fIcgroup.subtree_control\fP som inte är tom. Alltså \fIär\fP det möjligt för en styrgrupp att både ha medlemsprocesser och barnstyrgrupper, men före några hanterare kan aktiveras för den styrgruppen måste medlemsprocesserna flyttas ut ur styrgruppen (t.ex., kanske in i barnstyrgrupperna). .P .\" Med tillägget i Linux 4.14 av ”trådat läge” (beskrivet nedan) har regeln om ”inga interna processer” blivit friare i några fall. .SS "Cgroups v2 fil cgroup.events" Varje styrgrupp annan än roten i v2\-hierarkin innehåller en fil endast för läsning, \fIcgroup.events\fP, vars innehåll är nyckel\-värde\-par (begränsade med nyradstecken, med nyckeln och värdet separerade med blanktecken) som ger information om styrgruppen. .P .in +4n .EX $ \fBcat mingrp/cgroup.events\fP populated 1 frozen 0 .EE .in .P Följande nycklar kan förekomma i denna fil: .TP \fIpopulated\fP Värdet på denna nyckel är antingen 1, om denna styrgrupp eller någon av dess avkommor har medlemsprocesser, annars 0. .TP \fIfrozen\fP (sedan Linux 5.2) .\" commit 76f969e8948d82e78e1bc4beb6b9465908e7487 Värdet på denna nyckel är 1 om denna styrgrupp för närvarande är frusen, eller 0 om den inte är det. .P .\" Filen \fIcgroup.events\fP kan övervakas för att ta emot notifieringar när värdet på en av dess nycklar ändras. Sådan övervakning kan göras med \fBinotify\fP(7), vilket notifierar om ändringar som \fBIN_MODIFY\fP\-händelser, eller \fBpoll\fP(2), vilket notifierar om ändringar genom att returnera bitarna \fBPOLLPRI\fP och \fBPOLLERR\fP i fältet \fIrevents\fP. .SS "Cgroup v2 släppnotifieringar" Cgroups v2 tillhandahåller en ny mekanism för att få notifieringar när en styrgrupp blir tom. Filerna \fIrelease_agent\fP och \fInotify_on_release\fP är borttagna, och ersatta av nyckeln \fIpopulated\fP i filen \fIcgroup.events\fP. Denna nyckel har antingen värdet 0, vilket betyder att styrgruppen (och dess avkommor) inte innehåller några medlemsprocesser (andra än zombier), eller 1, vilket betyder att styrgruppen (eller en av dess avkommor) innehåller medlemsprocesser. .P Mekanismen för släppnotifieringar i cgroups v2 ger följande fördelar framför mekanismen \fIrelease_agent\fP i cgroups v1: .IP \[bu] 3 Den tillåter billigare notifiering, eftersom en enda process kan övervaka flera \fIcgroup.events\fP\-filer (med teknikerna som beskrivs tidigare). Däremot medför mekanismen i cgroups v1 kostnaden i att skapa en process för varje notifiering. .IP \[bu] .\" Notifieringar för olika underhierarkier av styrgrupper kan delegeras till andra processer. Däremot tillåter mekanismen i cgroups v1 endast en släppagent för en hel hierarki. .SS "Cgroups v2 filen cgroup.stat" .\" commit ec39225cca42c05ac36853d11d28f877fde5c42e Varje styrgrupp i v2\-hierarkin innehåller en fil \fIcgroup.stat\fP endast för läsning (först introducerad i Linux 4.14) som består av rader som innehåller nyckel\-värde\-par. Följande nycklar finns för närvarande i denna fil: .TP \fInr_descendants\fP Detta är det totala antalet synliga (d.v.s., levande) avkommestyrgrupper under denna styrgrupp. .TP \fInr_dying_descendants\fP Detta är det totala antalet döende avkommestyrgrupper under denna styrgrupp. En styrgrupp går in i tillståndet döende efter att ha tagits bort. Den finns kvar i detta tillstånd under en odefinierad period (vilken kommer bero på systemets last) medan resurser frigörs innan styrgruppen förstörs. Observera att förekomsten av några styrgrupper i tillståndet döende är normalt och indikerar inte något problem. .IP .\" En process kan inte göras till medlem av en döende styrgrupp, och en döende styrgrupp kan inte återupplivas. .SS "Begränsning av antalet avkommestyrgrupper" Varje styrgrupp i v2\-hierarkin innehåller följande filer, vilka kan användas för att visa och sätta begränsningar på antalet avkommestyrgrupper under den styrgruppen: .TP \fIcgroup.max.depth\fP (sedan Linux 4.14) .\" commit 1a926e0bbab83bae8207d05a533173425e0496d1 Denna fil definerar en gräns på nästningsdjupet för avkommestyrgrupper. Värdet 0 i denna fil betyder att inga avkommestyrgrupper kan skapas. Ett försök att skapa en avkomma vars nästningsnivå överskrider gränsen misslyckas (\fImkdir\fP(2) misslyckas med felet \fBEAGAIN\fP). .IP Att skriva strängen \fI\[dq]max\[dq]\fP till denna fil betyder att ingen begränsning görs. Standardvärdet i denna fil är \fI\[dq]max\[dq]\fP. .TP \fIcgroup.max.descendants\fP (sedan Linux 4.14) .\" commit 1a926e0bbab83bae8207d05a533173425e0496d1 Denna fil definierar en gräns på antalet levande avkommestyrgrupper som denna styrgrupp får ha. Ett försök att skapa fler avkommor än tillåtet av denna gräns misslyckas (\fImkdir\fP(2) misslyckas med felet \fBEAGAIN\fP). .IP .\" Att skriva strängen \fI\[dq]max\[dq]\fP till denna fil betyder att ingen begränsning görs. Standardvärdet i denna fil är \fI\[dq]max\[dq]\fP. .SH "STYRGRUPPSDELEGERING: ATT DELEGERA EN HIERARKI TILL EN MINDRE PRIVILEGIERAD ANVÄNDARE" I styrgruppssammanhang betyder delegering att man överlåter hanteringen av något underträd av denna styrgruppshierarki till en oprivilegierad användare. Cgroups v1 ger stöd för delegering baserat på filrättigheter i styrgruppshierarkin men med mindre strikta begränsningsregler än v2 (som noteras nedan). Cgroups v2 stödjer delegering med begränsningar genom en explicit design. Fokuset för diskussionen i detta avsnitt är på delegering i cgroups v2, med några avvikelser för cgroups v1 nämnda längs vägen. .P Lite terminologi krävs för att beskriva delegering. En \fIdelegerare\fP är en privilegierad användare (d.v.s., root) som äger en föräldrastyrgrupp. En \fIdelegat\fP är en oprivilegierad användare som kommer få rättigheterna som behövs för att hantera någon underhierarki under föräldrastyrgruppen, känt som det \fIdelegerade underträdet\fP. .P För att utföra en delegering gör delegeraren vissa kataloger och filer skrivbara för delegaten, typiskt genom att ändra ägarskap på objekten till att vara användar\-ID:t för delegaten. Om vi antar att vi vill delegera hierarkin med rot vid (förslagsvis) \fI/dlgt_grp\fP och att det inte ännu finns några barnstyrgrupper under den styrgruppen, då ändras ägandet av följande till användar\-ID:t för delegaten: .TP \fI/dlgt_grp\fP Att ändra ägarskap på roten till underträdet betyder att eventuella nya styrgrupper som skapas under det underträdet (och filerna de innehåller) också kommer ägas av delegaten. .TP \fI/dlgt_grp/cgroup.procs\fP Att ändra ägandet av den här filen betyder att delegaten kan flytta processer in i roten av det delegerade underträdet. .TP \fI/dlgt_grp/cgroup.subtree_control\fP (endast cgroups v2) Att ändra ägandet av den här filen betyder att delegaten kan aktivera hanterare (som finns i \fI/dlgt_grp/cgroup.controllers\fP) för att vidare omfördela resurser till lägre nivåer i underträdet. (Som ett alternativ till att ändra ägandet av denna fil kan delegeraren istället lägga till valda hanterare till denna fil.) .TP \fI/dlgt_grp/cgroup.threads\fP (endast cgroups v2) Att ändra ägandet av den här filen är nödvändigt om ett trådat underträd delegeras (se beskrivningen av ”trådläge”, nedan). Detta tillåter delegaten att skriva tråd\-ID:n till filen. (Ägandet av den här filen kan även ändras när man delegerar ett domänunderträd, men för närvarande fyller det inget syfte eftersom, vilket beskrivs nedan, det inte är möjligt att flytta en tråd mellan domänstyrgrupper genom att skriva dess tråd\-ID till filen \fIcgroups.thread\fP.) .IP I cgroups v1 är istället motsvarande fil som skall delegeras filen \fItasks\fP. .P Delegeraren skall \fIinte\fP ändra ägaren av någon annan av hanterarens gränssnittsfiler (t.ex., \fIpids.max\fP, \fImemory.high\fP) i \fIdlgt_grp\fP. Dessa filer används från nästa nivå ovanför det delegerade underträdet för att fördela resurser in i underträdet, och delegaten skall inte ha rätt att ändra resurserna som fördelas in i det delegerade underträdet. .P Se även diskussionen om filen \fI/sys/kernel/cgroup/delegate\fP i NOTERINGAR för information om ytterligare delegerbara filer i cgroups v2. .P .\" Efter att de tidigare nämnda stegen har utförts kan delegaten skapa barnstyrgrupper inom det delegerade underträdet (styrgruppens underkataloger och filerna de innehåller kommer att ägas av delegaten) och flytta processer mellan styrgrupper i underträdet. Om några hanterare finns i \fIdlgt_grp/cgroup.subtree_control\fP, eller om ägandet av den filen överläts på delegaten, kan delegaten även styra den vidare omfördelningen av motsvarande resurser in i det delegerade underträdet. .SS "Cgroups v2\-delegering: nsdelegate och styrgruppsnamnrymder" .\" commit 5136f6365ce3eace5a926e10f16ed2a233db5ba9 Med start i Linux 4.13 finns det även ett andra sätt att utföra styrgruppsdelegering i cgroups v2\-hierarkin. Detta görs genom att montera eller montera om cgroups v2\-filsystemet med monteringsflaggan \fInsdelegate\fP. Till exempel, om cgroup v2\-filsystemet redan har monterats kan vi montera om det med flaggan \fInsdelegate\fP så här: .P .in +4n .EX mount \-t cgroup2 \-o remount,nsdelegate \e none /sys/fs/cgroup/unified .EE .in .\" .\" Alternatively, we could boot the kernel with the options: .\" .\" cgroup_no_v1=all systemd.legacy_systemd_cgroup_controller .\" .\" The effect of the latter option is to prevent systemd from employing .\" its "hybrid" cgroup mode, where it tries to make use of cgroups v2. .P Effekten av denna monteringsflagga är att den får styrgruppsnamnrymder att automatiskt bli delegeringsgränser. Mer specifikt gäller följande restriktioner för processer inuti styrgruppsnamnrymden: .IP \[bu] 3 Skrivningar till hanterarens gränssnittsfiler i namnrymdens rotkatalog kommer misslyckas med felet \fBEPERM\fP. Processer inuti styrgruppsnamnrymden kan fortfarande skriva till delegerbara filer i styrgruppsnamnrymdens rotkatalog såsom \fIcgroup.procs\fP och \fIcgroup.subtree_control\fP, och kan skapa underhierarkier under rotkatalogen. .IP \[bu] Försök att migrera processer över namnrymdsgränsen förhindras (med felet \fBENOENT\fP). Processer inuti styrgruppsnamnrymden kan fortfarande (med hänsyn tagen till inneslutningsreglerna som beskrivs nedan) flytta processer mellan styrgrupper \fIinom\fP underhierarkin under namnrymdsroten. .P Möjligheten att definiera styrgruppsnamnrymder som delegeringsgränser gör styrgruppsnamnrymder mer användbara. För att förstå varför, anta att vi redan har en styrgruppshierarki som har delegerats till en oprivilegierad användare, \fIcecilia\fP, med den äldre delegeringstekniken som beskrivs ovan. Anta vidare att \fIcecilia\fP vill delegera en underhierarki vidare under den befintliga delegerade hierarkin. (Till exempel kanske den delegerade hierarkin kan vara associerad med en oprivilegierad behållare som körs av \fIcecilia\fP.) Även om en styrgruppsnamnrymd användes skulle, eftersom båda hierarkierna ägs av den oprivilegierade användaren \fIcecilia\fP, följande illegitima åtgärder kunna utföras. .IP \[bu] 3 En process i den underliggande hierarkin skulle kunna ändra resurshanterarens inställningar i hierarkins rotkatalog. (Dessa resurshanterares inställningar är avsedda att möjliggöra utövandet av styrning från \fIföräldra\fPstyrgruppen; en process inuti barngruppen skall inte få ändra dem.) .IP \[bu] En process inuti den underliggande hierarkin skulle kunna flytta processer in i och ut ur den underliggande hierarkin om styrgrupperna i den överliggande hierarkin på något sätt var synliga. .P Genom att använda monteringsflaggan \fInsdelegate\fP förhindras båda dessa möjligheter. .P Monteringsflaggan \fInsdelegate\fP har bara någon effekt när den används i den initiala monteringsnamnrymden; i andra monteringsnamnrymder ignoreras flaggan tyst. .P \fIObservera\fP: på en del system monterar \fBsystemd\fP(1) automatiskt filsystemet cgroup v2. För att experimentera med flaggan \fInsdelegate\fP kan det vara användbart att starta kärnan med följande kommandoradsflaggor: .P .in +4n .EX cgroup_no_v1=all systemd.legacy_systemd_cgroup_controller .EE .in .P .\" Dessa flaggor får kärnan att starta med cgroups v1\-hanterarna avaktiverade (vilket betyder att hanterarna finns tillgängliga i v2\-hierarkin), och säger till \fBsystemd\fP(1) att inte montera och använda cgroup v2\-hierarkin, så att v2\-hierarkin kan monteras manuellt med de önskade flaggorna efter uppstart. .SS "Inneslutningsregler för styrgruppsdelegering" Några \fIinneslutningsregler\fP för delegering säkerställer att delegaten kan flytta processer mellan styrgrupper inom det delegerade underträdet, men inte kan flytta processer utifrån det delegerade underträdet in i underträdet eller vice versa. En oprivilegierad process (d.v.s., delegaten) kan skriva PID:en för en ”mål”\-process in i en fil \fIcgroup.procs\fP endast om alla följande är sanna: .IP \[bu] 3 Skrivaren har skrivrättigheter på filen \fIcgroup.procs\fP i målstyrgruppen. .IP \[bu] Skrivaren har skrivrättigheter till filen \fIcgroup.procs\fP i den närmaste gemensamma anfadern till käll\- och målstyrgrupperna. Observera att i några fall kan den närmaste anfadern vara käll\- eller målstyrgruppen själv. Detta krav vidmakthålls inte för cgroups v1\-hierarkier, med konsekvensen att inneslutningen i v1 är mindre strikt än i v2. (Till exempel kan i cgroups v1 användaren som äger två distinkta delegerade underhierarkier flytta en process mellan hierarkierna.) .IP \[bu] Om cgroup v2\-filsystemet monterades med flaggan \fInsdelegate\fP måste skrivaren kunna se käll\- och målstyrgrupperna från sin egen styrgruppsnamnrymd. .IP \[bu] .\" commit 576dd464505fc53d501bb94569db76f220104d28 I cgroups v1: skrivarens effektiva UID (d.v.s., delegaten) matchar målprocessens verkliga användar\-ID eller sparade set\-user\-ID. Före Linux 4.11 gällde detta krav även i cgroups v2. (Detta var ett historiskt krav ärvt från cgroups v1 som senare bedömdes som onödigt, eftersom de andra reglerna räcker för inneslutning i cgroups v2.) .P .\" \fIObservera\fP: en konsekvens av dessa inneslutningsreger för delegering är att den oprivilegierade delegaten inte kan placera in den första processen i det delegerade underträdet; istället måste delegeraren placera in den första processen (en process som ägs av delegaten) i det delegerade underträdet. .SH "CGROUPS VERSION 2 TRÅDLÄGE" Bland restriktionerna som åläggs av cgroups v2 och som inte fanns med i cgroups v1 är följande: .IP \[bu] 3 \fIIngen styrning på trådnivå\fP: alla trådarna i en process måste finnas i samma styrgrupp. .IP \[bu] \fIInga interna processer\fP: en styrgrupp kan inte både ha medlemsprocesser och utöva styrning av barnstyrgrupper. .P Båda dessa restriktioner lades till för att avsaknaden av dessa restriktioner hade orsakat problem i cgroups v1. Speciellt var möjligheten i cgroups v1 att tillåta upplösning på trådnivå av styrgruppsmedlemskap inte meningsfull för några hanterare. (Ett noterbart exempel var hanteraren \fImemory\fP: eftersom trådar delar en adressrymd är det inte meningsfullt att dela trådar mellan olika \fImemory\fP\-styrgrupper.) .P Oaktat det ursprungliga designbeslutet i cgroups v2 fanns det användningsfall för vissa hanterare, särskilt hanteraren \fIcpu\fP, för vilka upplösning av styrningen på trådnivå var meningsfull och användbar. För att rymma sådana fall lade Linux 4.14 till \fItrådläge\fP till cgroups v2. .P Trådläge tillåter följande: .IP \[bu] 3 Att skapa \fItrådade underträd\fP i vilka en process trådar kan spridas mellan styrgrupper inuti trädet. (Ett trådunderträd kan innehålla flera multitrådade processer.) .IP \[bu] Begreppet \fItrådade hanterare\fP vilka kan fördela resurser mellan styrgrupperna i ett trådat underträd. .IP \[bu] Lättandet av ”regeln inga interna processer”, så att en styrgrupp kan, inom ett trådat underträd, både innehålla medlemstrådar och utöva resurshantering mellan barnstyrgrupper. .P Med tillägget av trådläge innehåller numera varje styrgrupp utom roten en ny fil, \fIcgroup.type\fP, som visar, och under vissa omständigheter kan användas för att ändra, en styrgrupps ”typ”. Denna fil innehåller ett av följande typvärden: .TP \fIdomain\fP Detta är en normal v2\-styrgrupp som tillhandahåller styrning på processnivå. Om en process är medlem av denna styrgrupp, då är alla processens trådar (per definition) i samma styrgrupp. Detta är standardtypen för styrgrupper, och ger samma beteende som gavs för styrgrupper i den ursprungliga implementationen av cgroups v2. .TP \fIthreaded\fP Denna styrgrupp är medlem i ett trådat underträd. Trådar kan läggas till till denna styrgrupp, och hanterare kan aktiveras för styrgruppen. .TP \fIdomain threaded\fP Detta är en domänstyrgrupp som tjänstgör som roten i ett trådat underträd. Denna styrgruppstyp är även känd som ”trådad rot”. .TP \fIdomain invalid\fP Detta är en styrgrupp inuti ett trådat underträd som är i ett ”felaktigt” tillstånd. Processer kan inte läggas till till styrgruppen, och hanterare kan inte aktiveras för styrgruppen. Det enda man kan göra med denna styrgrupp (bortsett från att ta bort den) är att konvertera den till en \fItrådad\fP styrgrupp genom att skriva strängen \fI\[dq]threaded\[dq]\fP till filen \fIcgroup.type\fP. .IP .\" Motiveringen till existensen av denna ”provisoriska” typ under skapandet av ett trådat underträd (istället för att kärnan helt enkelt omedelbart konverterar alla styrgrupper under en trådad rot till typen \fItrådad\fP) är att ge utrymme för möjliga framtida utökningar av modellen för trådat läge. .SS "Trådade hanterare kontra domänhanterare" I och med tillägget av trådat läge särskiljer cgroups v2 nu två typer av resurshanterare: .IP \[bu] 3 .\" In the kernel source, look for ".threaded[ \t]*= true" in .\" initializations of struct cgroup_subsys \fITrådade\fP hanterare: dessa hanterare stödjer resursstyrning på trådnivå och kan aktiveras inuti trådade underträd, med resultatet att motsvarande hanterargränssnittsfiler dyker upp inuti styrgrupperna i det trådade underträdet. Från och med Linux 4.19 är följande hanterare trådade: \fIcpu\fP, \fIperf_event\fP och \fIpids\fP. .IP \[bu] .\" \fIDomän\fPhanterare: dessa hanterare stödjer endast resursstyrning på processnivå. Från en domänhanterares perspektiv är alla trådar i en process alltid i samma styrgrupp. Domänhanterare kan inte aktiveras inuti ett trådat underträd. .SS "Att skapa ett trådat underträd" Det finns två vägar som leder till att ett trådat underträd skapas. Den första vägen är som följer: .IP (1) 5 Vi skriver strängen \fI\[dq]threaded\[dq]\fP till filen \fIcgroup.type\fP i en styrgrupp \fIy/z\fP som just nu har typen \fIdomän\fP. Detta har följande effekter: .RS .IP \[bu] 3 Typen på styrgruppen \fIy/z\fP blir \fItrådad\fP. .IP \[bu] Föräldrastyrgruppens, \fIy\fP, typ blir \fIdomän trådad\fP. Föräldrastyrgruppen är roten i ett trådat underträd (även känt som ”trådad rot”). .IP \[bu] Alla andra styrgrupper under \fIy\fP som inte redan hade typen \fItrådad\fP (för att de befann sig inuti redan befintliga trådade underträd under den nya trådade roten) konverteras till typen \fIdomän felaktig\fP. .RE .IP (2) Vi skriver strängen \fI\[dq]threaded\[dq]\fP till var och en av styrgrupperna med \fIdomän felaktig\fP under \fIy\fP, för att konvertera dem till typen \fItrådad\fP. Som en konsekvens av detta steg har nu alla trådar under den trådade roten typen \fItrådad\fP och det trådade trädet är därmed fullt användbart. Kravet att skriva \fI\[dq]threaded\[dq]\fP till var och en av dessa styrgrupper är något otymplig, men möjliggör tänkbara framtida utvidgningar av modellen trådläge. .P Den andra vägen att skapa ett trådat underträd är som följer: .IP (1) 5 I en befintlig styrgrupp, \fIz\fP, som just nu har typen \fIdomän\fP aktiverar vi (1.1) en eller flera av de trådade hanterarna och (1.2) gör en process till en medlem av \fIz\fP. (Dessa två steg kan göras i godtycklig ordning.) Detta har följande konsekvenser: .RS .IP \[bu] 3 Typen på \fIz\fP blir \fIdomän trådad\fP. .IP \[bu] Alla nedstigande styrgrupper till \fIz\fP som inte redan hade typen \fItrådad\fP konverteras till typen \fIdomän felaktig\fP. .RE .IP (2) Som tidigare gör vi det trådade underträdet användbart genom att skriva strängen \fI\[dq]threaded\[dq]\fP till var och en av styrgrupperna med \fIdomän felaktig\fP under \fIz\fP, för att konvertera dem till typen \fItrådad\fP. .P .\" En av konsekvenserna av de ovanstående sätten för att skapa ett trådat underträd är att den trådade rotstyrgruppen endast kan vara förälder till styrgrupper som är \fItrådade\fP (och \fIdomän felaktiga\fP). Den trådade rotstyrgruppen kan inte vara förälder till \fIdomän\fPstyrgrupper, och en \fItrådad\fP styrgrupp kan inte ha ett syskon som är en \fIdomän\fPstyrgrupp. .SS "Att använda ett trådat underträd" Inom ett trådat underträd kan trådade hanterare aktiveras i varje undergrupp vars typ har ändrats till \fItrådad\fP; när man gör det dyker motsvarande gränssnittsfiler för hanteraren upp i barnen till den styrgruppen. .P En process kan flyttas in i ett trådat underträd genom att skriva dess PID till filen \fIcgroup.procs\fP i en av styrgrupperna inuti trädet. Detta medför att alla trådarna i den processen görs till medlemmar av motsvarande styrgrupp och gör processen till en medlem av det trådade underträdet. Processens trådar kan sedan spridas över det trådade underträdet genom att skriva deras tråd\-ID:n (se \fBgettid\fP(2)) till filerna \fIcgroup.threads\fP i olika styrgrupper inuti underträdet. En process alla trådar måste befinna sig i samma trådade underträd. .P Liksom när man skriver till \fIcgroup.procs\fP gäller vissa inneslutningsregler när man skriver till filen \fIcgroup.threads\fP: .IP \[bu] 3 Skrivaren måste ha skrivrättigheter till filen \fIcgroup.threads\fP i målstyrgruppen. .IP \[bu] Skrivaren måste ha skrivrättigheter till filen \fIcgroup.procs\fP i den gemensamma anfadern till käll\- och målstyrgrupperna. (I några fall kan den gemensamma anfadern vara käll\- eller målstyrgruppen själv.) .IP \[bu] Käll\- och målstyrgrupperna måste finnas i samma trådade underträd. (Utanför ett trådat underträd misslyckas ett försök att flytta en tråd genom att skriva dess tråd\-ID till filen \fIcgroup.threads\fP i en annan \fIdomän\fPstyrgrupp med felet \fBEOPNOTSUPP\fP.) .P Filen \fIcgroup.threads\fP finns i alla styrgrupper (inklusive \fIdomän\fPstyrgrupper) och kan läsas för att upptäcka uppsättningen trådar som finns i styrgruppen. Uppsättningen tråd\-ID:n som fås när man läser denna fil är inte garanterat i ordning eller fri från dubbletter. .P Filen \fIcgroup.procs\fP i den trådade roten visar PID:arna för alla processer som är medlemmar av det trådade underträdet. Filen \fIcgroup.procs\fP i de andra styrgrupperna i underträdet är inte läsbara. .P Domänhanterare kan inte aktiveras i ett trådat underträd; inga gränssnittsfiler till hanteraren dyker upp i styrgrupperna under den trådade roten. Från domänhanterarens synvinkel är trådade underträd osynliga: en multitrådad process i ett trådat underträd ser för domänhanteraren ut som en process som bor i den trådade rotstyrgruppen. .P .\" Inom ett trådat underträd gäller inte regeln ”inga interna processer”: en styrgrupp kan både innehålla medlemsprocesser (eller \-trådar) och utöva styrning över barnstyrgrupper. .SS "Regler för att skriva till cgroup.type och att skapa trådade underträd" Ett antal regler gäller vid skrivning till filen \fIcgroup.type\fP: .IP \[bu] 3 Endast strängen \fI\[dq]threaded\[dq]\fP får skrivas. Med andra ord, den enda uttryckliga övergången som är möjlig är att konvertera en \fIdomän\fPstyrgrupp till typen \fItrådad\fP. .IP \[bu] Resultatet av att skriva \fI\[dq]threaded\[dq]\fP beror på det nuvarande värdet i \fIcgroup.type\fP enligt följande: .RS .IP \[bu] 3 \fIDomän\fP eller \fIdomän trådad\fP: inled skapandet av ett trådat underträd (vars rot är föräldern till denna styrgrupp) via det första av sätten som beskrivs ovan; .IP \[bu] \fIDomän\ felaktig\fP: konvertera denna styrgrupp (vilken finns inuti ett trådat underträd) till ett användbart (d.v.s., \fItrådat\fP) tillstånd; .IP \[bu] \fITrådad\fP: ingen effekt (en ”no\-op”). .RE .IP \[bu] Vi kan inte skriva till en \fIcgroup.type\fP\-fil om förälderns typ är \fIdomän felaktig\fP. Med andra ord, styrgruppen i ett trådat underträd måste konverteras till tillståndet \fItrådad\fP uppifrån och ner. .P Det finns även några begränsningar som måste vara uppfyllda för att skapa ett trådat underträd rotat i styrgruppen \fIx\fP: .IP \[bu] 3 Det får inte finnas någon medlemsprocess i nedstigande styrgrupper från \fIx\fP. (Styrgruppen \fIx\fP själv kan ha medlemsprocesser.) .IP \[bu] Inga domänhanterare får vara aktiverade i \fIx\fPs fil \fIcgroup.subtree_control\fP. .P .\" Vid brott mot någon av ovanstående begränsningar kommer försök att skriva \fI\[dq]threaded\[dq]\fP till en fil \fIcgroup.type\fP att misslyckas med felet \fBENOTSUP\fP. .SS "Styrgruppstypen \[dq]domän trådad\[dq]" Enligt metoderna som beskrivs ovan kan typen på en styrgrupp ändras till \fIdomän trådad\fP i endera av följande fall: .IP \[bu] 3 Strängen \fI\[dq]threaded\[dq]\fP skrivs till en barnstyrgrupp. .IP \[bu] En trådad hanterare aktiveras inuti styrgruppen och en process görs till medlem av styrgruppen. .P En \fIdomän trådad\fP styrgrupp, \fIx\fP, kan återgå till typen \fIdomän\fP om ovanstående villkor inte längre är uppfyllda \[em] det vill säga, om alla \fItrådade\fP barnstyrgrupper till \fIx\fP tas bort och antingen \fIx\fP inte längre har trådade hanterare aktiverade eller inte längre har medlemsprocesser. .P När en styrgrupp \fIx\fP som är \fIdomän trådad\fP återgår till typen \fIdomän\fP: .IP \[bu] 3 Alla avkommor till \fIx\fP som är \fIdomän felaktig\fP och som inte är i underliggande trådade underträd återgår till typen \fIdomän\fP. .IP \[bu] .\" Rotstyrgruppen i eventuella underliggande trådade underträd återgår till typen \fIdomän trådad\fP. .SS "Undantag för rotstyrgruppen" Rotstyrgruppen i v2\-hierarkin hanteras speciellt: den kan vara förälder till både \fIdomän\fP och \fItrådade\fP styrgrupper. Om strängen \fI\[dq]threaded\[dq]\fP skrivs till filen \fIcgroup.type\fP i ett av barnen till rotstyrgruppen, då .IP \[bu] 3 blir typen på den styrgruppen \fItrådad\fP. .IP \[bu] ändras typen på avkommor till den styrgruppen som inte är en del av underliggande trådade underträd till \fIdomän felaktig\fP. .P Observera att i detta fall finns det ingen styrgrupp vars typ blir \fIdomän trådad\fP. (Teoretiskt sett kan rotstyrgruppen betraktas som den trådade roten till styrgruppen vars typ ändrades till \fItrådad\fP.) .P .\" Syftet med denna speciella hantering av rotstyrgruppen är att låta en trådad styrgrupp som använder hanteraren \fIcpu\fP att placeras så högt som möjligt i hierarkin, för att minimera den (lilla) kostnaden i att traversera styrgruppshierarkin. .SS "Hanteraren \[dq]cpu\[dq] i cgroups v2 och realtidstrådar" Per Linux 4.19 stödjer inte hanteraren \fIcpu\fP i cgroups v2 styrning av realtidstrådar (specifikt trådar schemalagda under någon av policyerna \fBSCHED_FIFO\fP, \fBSCHED_RR\fP och \fBSCHED_DEADLINE\fP; se \fBsched\fP(7)). Därför kan hanteraren \fIcpu\fP aktiveras i rotstyrgruppen endast om alla realtidstrådar finns i rotstyrgruppen. (Om det finns realtidstrådar i andra styrgrupper än roten, då misslyckas ett anrop av \fBwrite\fP(2) med strängen \fI\[dq]+cpu\[dq]\fP till filen \fIcgroup.subtree_control\fP med felet \fBEINVAL\fP.) .P .\" På vissa system placerar \fBsystemd\fP(1) vissa realtidstrådar i andra styrgrupper än roten i v2\-hierarkin. På sådana system måste dessa trådar först flyttas till rotstyrgruppen innan \fIcpu\fP\-hanteraren kan aktiveras. .SH FEL Följande fel kan förekomma för \fBmount\fP(2): .TP \fBEBUSY\fP Ett försök att montera ett styrgruppsfilsystem för version 1 som inte specificerade vare sig flaggan \fIname=\fP (för att montera en namngiven hierarki) eller ett hanterarnamn (eller \fIall\fP). .SH NOTERINGAR En barnprocess som skapas via \fBfork\fP(2) ärver sin förälders styrgruppsmedlemskap. En process styrgruppsmedlemskap bevaras över \fBexecve\fP(2). .P .\" Flaggan \fBCLONE_INTO_CGROUP\fP till \fBclone3\fP(2) kan användas för att skapa en barnprocess som inleder sitt liv i en annan version\-2\-styrgrupp än föräldraprocessen. .SS /proc\-filer .TP \fI/proc/cgroups\fP (sedan Linux 2.6.24) Denna fil innehåller information om hanterarna som är inkompilerade i kärnan. Ett exempel på innehållet i denna fil (omformaterat för läsbarhet) är följande: .IP .in +4n .EX #subsys_name hierarchy num_cgroups enabled cpuset 4 1 1 cpu 8 1 1 cpuacct 8 1 1 blkio 6 1 1 memory 3 1 1 devices 10 84 1 freezer 7 1 1 net_cls 9 1 1 perf_event 5 1 1 net_prio 9 1 1 hugetlb 0 1 0 pids 2 1 1 .EE .in .IP Fälten i denna fil är, från vänster till höger: .RS .IP [1] 5 Namnet på hanteraren. .IP [2] Det unika ID:t för styrgruppshierarkin på vilken denna hanterare är monterad. Om flera cgroups v1\-hanterare är bundna till samma hierarki kommer var och en visa samma hierarki\-ID i detta fält. Värdet i detta fält kommer vara 0 om: .RS .IP \[bu] 3 hanteraren inte är monterad på en cgroups v1\-hierarki; .IP \[bu] hanteraren är bunden till cgroups v2s enda unifierade hierarki eller .IP \[bu] hanteraren är avaktiverad (se nedan). .RE .IP [3] Antalet styrgrupper i denna hierarki som använder denna hanterare. .IP [4] Detta fält har värdet 1 om denna hanterare är aktiverad eller 0 om den har avaktiverats (via parametern \fIcgroup_disable\fP på kärnans kommandorad vid uppstart). .RE .TP \fI/proc/\fPpid\fI/cgroup\fP (sedan Linux 2.6.24) Denna fil beskriver styrgrupperna till vilken processen med motsvarande PID hör. Den visade informationen skiljer mellan hierarkierna för styrgrupper version 1 och version 2. .IP För varje styrgruppshierarki i vilken processen är medlem finns det en post som innehåller tre kolonseparerade fält: .IP .in +4n .EX hierarki\-ID:hanterarlista:styrgruppssökväg .EE .in .IP Till exempel: .IP .in +4n .EX 5:cpuacct,cpu,cpuset:/daemons .EE .in .IP De kolonseparerade fälten är, från vänster till höger: .RS .IP [1] 5 För version 1\-hierarkier av styrgrupper innehåller detta fält ett unikt hierarki\-ID\-nummer som kan matchas med ett hierarki\-ID i \fI/proc/cgroups\fP. För version 2\-hierarkin av styrgrupper innehåller detta fält värdet 0. .IP [2] För version 1\-hierarkier av styrgrupper innehåller detta fält en kommaseparerad lista över hanterare bundna till hierarkin. För version 2\-hierarkin av styrgrupper är detta fält tomt. .IP [3] Detta fält innehåller sökvägen till styrgruppen i hierarkin den hör till. Sökvägen är relativ hierarkins monteringspunkt. .RE .\" .SS /sys/kernel/cgroup\-filer .TP \fI/sys/kernel/cgroup/delegate\fP (sedan Linux 4.15) .\" commit 01ee6cfb1483fe57c9cbd8e73817dfbf9bacffd3 Denna fil exporterar en lista över filerna i cgroups v2 (en per rad) som går att delegera (d.v.s., vars ägarskap skall ändras till delegatens användar\-ID). I framtiden kan uppsättningen delegerbara filer ändras eller växa, och denna fil ger en möjlighet för kärnan att informera program i användarrymden om vilka filer som måste delegeras. Per Linux 4.15 syns följande när man inspekterar filen: .IP .in +4n .EX $ \fBcat /sys/kernel/cgroup/delegate\fP cgroup.procs cgroup.subtree_control cgroup.threads .EE .in .TP \fI/sys/kernel/cgroup/features\fP (sedan Linux 4.15) .\" commit 5f2e673405b742be64e7c3604ed4ed3ac14f35ce Med tiden kan samlingen av funktioner i cgroups v2 som kärnan tillhandahåller ändras eller växa, och några funktionerna kanske inte aktiveras som standard. Denna fil ger ett sätt för program i användarrymden att avgöra vilka funktioner den körande kärnan stödjer och har aktiverade. Funktioner listas en per rad: .IP .in +4n .EX $ \fBcat /sys/kernel/cgroup/features\fP nsdelegate memory_localevents .EE .in .IP Posterna som kan förekomma i denna fil är: .RS .TP \fImemory_localevents\fP (sedan Linux 5.2) Kärnan stödjer monteringsflaggan \fImemory_localevents\fP. .TP \fInsdelegate\fP (sedan Linux 4.15) Kärnan stödjer monteringsflaggan \fInsdelegate\fP. .TP \fImemory_recursiveprot\fP (sedan Linux 5.7) .\" commit 8a931f801340c2be10552c7b5622d5f4852f3a36 Kärnan stödjer monteringsflaggan \fImemory_recursiveprot\fP. .RE .SH "SE ÄVEN" \fBprlimit\fP(1), \fBsystemd\fP(1), \fBsystemd\-cgls\fP(1), \fBsystemd\-cgtop\fP(1), \fBclone\fP(2), \fBioprio_set\fP(2), \fBperf_event_open\fP(2), \fBsetrlimit\fP(2), \fBcgroup_namespaces\fP(7), \fBcpuset\fP(7), \fBnamespaces\fP(7), \fBsched\fP(7), \fBuser_namespaces\fP(7) .P Kärnans källfil \fIDocumentation/admin\-guide/cgroup\-v2.rst\fP. .PP .SH ÖVERSÄTTNING Den svenska översättningen av denna manualsida skapades av Göran Uddeborg . .PP Denna översättning är fri dokumentation; läs .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License Version 3 .UE eller senare för upphovsrättsvillkor. Vi tar INGET ANSVAR. .PP Om du hittar fel i översättningen av denna manualsida, skicka ett mail till .MT Tp-sv@listor.tp-sv.se .ME .