Jak korzystać z polecenia pmap w systemie Linux?

Ustalenie, ile pamięci RAM wykorzystuje proces Linuksa, nie jest prostą sprawą — zwłaszcza, gdy trzeba wziąć pod uwagę pamięć współdzieloną. Na szczęście polecenie pmap pomaga zrozumieć to wszystko.

Mapowanie pamięci

W nowoczesnych systemach operacyjnych każdy proces znajduje się we własnym przydzielonym regionie pamięci lub przestrzeni alokacji . Granice przydzielonego regionu nie są mapowane bezpośrednio na fizyczne adresy sprzętowe. System operacyjny tworzy przestrzeń pamięci wirtualnej dla każdego procesu i działa jako warstwa abstrakcji odwzorowująca pamięć wirtualną na pamięć fizyczną.

Jądro utrzymuje tablicę translacji dla każdego procesu, do której dostęp ma procesor. Kiedy jądro zmienia proces działający na konkretnym rdzeniu procesora, aktualizuje tablicę translacji, która wiąże procesy i rdzenie procesora.

Korzyści z abstrakcji

Ten program ma swoje zalety. Użycie pamięci jest w pewnym stopniu hermetyzowane i piaskowane dla każdego procesu w przestrzeni użytkownika. Proces „widzi” pamięć tylko pod względem adresów pamięci wirtualnej. Oznacza to, że może działać tylko z pamięcią, którą otrzymał od systemu operacyjnego. Chyba że ma dostęp do jakiejś pamięci dzielonej, o której ani nie wie, ani nie ma dostępu do pamięci przydzielonej innym procesom.

POWIĄZANE Co to jest Swappiness w systemie Linux? (i jak to zmienić)

Abstrakcja sprzętowej pamięci fizycznej na adresy pamięci wirtualnej umożliwia jądru zmianę adresu fizycznego, na który mapowana jest część pamięci wirtualnej. Może zamienić pamięć na dysk, zmieniając rzeczywisty adres, na który wskazuje region pamięci wirtualnej. Może również odroczyć udostępnianie pamięci fizycznej, dopóki nie będzie ona faktycznie potrzebna.

Dopóki żądania odczytu lub zapisu pamięci są obsługiwane zgodnie z żądaniem, jądro może dowolnie żonglować tablicą mapowania według własnego uznania.

Pamięć RAM na żądanie

Tabela mapowania i koncepcja „RAM na żądanie” otwierają możliwość współdzielenia pamięci . Jądro spróbuje uniknąć wielokrotnego ładowania tej samej rzeczy do pamięci. Na przykład, załaduje bibliotekę współdzieloną raz do pamięci i zmapuje ją do różnych procesów, które muszą z niej korzystać. Każdy z procesów będzie miał swój własny unikalny adres dla biblioteki współdzielonej, ale wszystkie będą wskazywać na tę samą rzeczywistą lokalizację.

Jeśli współdzielony obszar pamięci jest zapisywalny, jądro używa schematu zwanego kopiowaniem przy zapisie. Jeśli jeden proces zapisuje do pamięci współdzielonej, a inne procesy współdzielące tę pamięć nie mają widzieć zmian, kopia pamięci współdzielonej jest tworzona w miejscu żądania zapisu.

POWIĄZANE Beginner Geek: Jak tworzyć i używać maszyn wirtualnych

Jądro Linuksa 2.6.32 wydane w grudniu 2009 r. dało Linuksowi funkcję o nazwie „Scalanie jądra tej samej strony”. Oznacza to, że Linux może wykrywać identyczne regiony danych w różnych przestrzeniach adresowych. Wyobraź sobie serię maszyn wirtualnych działających na jednym komputerze, a wszystkie maszyny wirtualne korzystają z tego samego systemu operacyjnego. Korzystając z modelu pamięci współdzielonej i funkcji kopiowania przy zapisie, obciążenie komputera hosta może zostać drastycznie zmniejszone.

Wszystko to sprawia, że ​​obsługa pamięci w Linuksie jest wyrafinowana i tak optymalna, jak to tylko możliwe. Ale to wyrafinowanie sprawia, że ​​trudno jest spojrzeć na proces i wiedzieć, jak naprawdę jest jego użycie pamięci.

Narzędzie pmap

Jądro ujawnia wiele tego, co robi z pamięcią RAM, za pośrednictwem dwóch pseudoplików w pseudosystemie informacji o systemie „/proc”. Istnieją dwa pliki na proces, nazwane na podstawie identyfikatora lub PID każdego procesu: „/proc/maps” i „/proc//smaps”.

Narzędzie pmap odczytuje informacje z tych plików i wyświetla wyniki w oknie terminala. Będzie oczywiste, że za każdym razem, gdy używamy pmap , musimy podać PID procesu, który nas interesuje.

Znajdowanie identyfikatora procesu

Istnieje kilka sposobów na znalezienie PID procesu. Oto kod źródłowy trywialnego programu, którego użyjemy w naszych przykładach. Jest napisany w C. Wszystko, co robi, to drukuje komunikat w oknie terminala i czeka, aż użytkownik naciśnie klawisz „Enter”.

 #włącz <stdio.h>

int main(int argc, char *argv[])
{
  printf("Program testowy How-To Geek.");
  getc(stdin);
} // koniec głównego

Program został skompilowany do pliku wykonywalnego o nazwie pm przy użyciu kompilatora gcc :

 gcc -o pm pm.c 

Ponieważ program będzie czekał, aż użytkownik wciśnie „Enter”, będzie działał tak długo, jak zechcemy.

 ./po południu 

Program uruchamia się, drukuje wiadomość i czeka na naciśnięcie klawisza. Możemy teraz wyszukać jego PID. Polecenie ps wyświetla listę uruchomionych procesów. Opcja -e (pokaż wszystkie procesy) powoduje, że ps wyświetla każdy proces. Prześlemy dane wyjściowe przez grep i odfiltrujemy wpisy, które mają w nazwie „pm”.

 ps -e | grep pm 

Spowoduje to wyświetlenie wszystkich wpisów z „pm” w dowolnym miejscu w ich nazwach.

Możemy być bardziej konkretni za pomocą polecenia pidof . W wierszu poleceń podajemy pidof nazwę procesu, który nas interesuje, a on próbuje znaleźć dopasowanie. Jeśli zostanie znalezione dopasowanie, pidof drukuje PID procesu dopasowania.

 pidof pm 

Metoda pidof jest ładniejsza, gdy znasz nazwę procesu, ale metoda ps będzie działać, nawet jeśli znasz tylko część nazwy procesu.

Korzystanie z pmap

Gdy nasz program testowy jest uruchomiony i gdy zidentyfikujemy jego PID, możemy użyć pmap w następujący sposób:

 mapa 40919 

Mapowania pamięci dla procesu są dla nas wymienione.

Oto pełne dane wyjściowe polecenia:

 40919: ./pm
000056059f06c000 4K r ---- pm
000056059f06d000 4K rx-- pm
000056059f06e000 4K r---- pm
000056059f06f000 4K r---- pm
000056059f070000 4K rw --- pm
000056059fc39000 132K rw--- [ anon ]
00007f97a3edb000 8K rw--- [ anon ]
00007f97a3edd000 160K r---- libc.so.6
00007f97a3f05000 1616K rx-- libc.so.6
00007f97a4099000 352K r---- libc.so.6
00007f97a40f1000 4K ----- libc.so.6
00007f97a40f2000 16K r---- libc.so.6
00007f97a40f6000 8K rw--- libc.so.6
00007f97a40f8000 60K rw--- [ anon ]
00007f97a4116000 4K r---- ld-linux-x86-64.so.2
00007f97a4117000 160K rx-- ld-linux-x86-64.so.2
00007f97a413f000 40K r---- ld-linux-x86-64.so.2
00007f97a4149000 8K r---- ld-linux-x86-64.so.2
00007f97a414b000 8K rw--- ld-linux-x86-64.so.2
00007ffca0e7e000 132K rw--- [ stos ]
00007ffca0fe1000 16K r---- [ anon ]
00007ffca0fe5000 8K rx-- [ anon ]
ffffffffff600000 4K --x-- [ anon ]
łącznie 2756 tys

Pierwsza linia to nazwa procesu i jego PID. Każdy z pozostałych wierszy pokazuje adres zmapowanej pamięci oraz ilość pamięci pod tym adresem wyrażoną w kilobajtach. Następne pięć znaków w każdym wierszu to uprawnienia do pamięci wirtualnej . Prawidłowe uprawnienia to:

• r : Zmapowana pamięć może być odczytana przez proces.
• w : Zmapowana pamięć może być zapisana przez proces.
• x : Proces może wykonać dowolne instrukcje zawarte w mapowanej pamięci.
• s : Zmapowana pamięć jest współdzielona, ​​a zmiany dokonane w pamięci współdzielonej są widoczne dla wszystkich procesów współdzielących pamięć.
• R : Nie ma rezerwacji dla przestrzeni wymiany dla tej mapowanej pamięci.

Ostateczną informacją w każdej linii jest nazwa źródła mapowania. Może to być nazwa procesu, nazwa biblioteki lub nazwa systemu, taka jak stos lub sterta.

Rozszerzony wyświetlacz

Opcja -x (rozszerzona) zapewnia dwie dodatkowe kolumny.

 pmap -x 40919 

Kolumny otrzymują tytuły. Widzieliśmy już kolumny „Adres”, „Kbajty”, „Tryb” i „Mapowanie”. Nowe kolumny noszą nazwy „RSS” i „Dirty”.

Oto pełne dane wyjściowe:

 40919: ./pm
Adres Kbajty RSS Mapowanie trybu brudnego
000056059f06c000 4 4 0 r---- pm
000056059f06d000 4 4 0 rx-- pm
000056059f06e000 4 4 0 r---- pm
000056059f06f000 4 4 4 r---- pm
000056059f070000 4 4 4 rw--- pm
000056059fc39000 132 4 4 rw--- [ anon ]
00007f97a3edb000 8 4 4 rw--- [ anon ]
00007f97a3edd000 160 160 0 r---- libc.so.6
00007f97a3f05000 1616 788 0 rx-- libc.so.6
00007f97a4099000 352 64 0 r---- libc.so.6
00007f97a40f1000 4 0 0 ----- libc.so.6
00007f97a40f2000 16 16 16 r---- libc.so.6
00007f97a40f6000 8 8 8 rw--- libc.so.6
00007f97a40f8000 60 28 28 rw--- [ anon ]
00007f97a4116000 4 4 0 r---- ld-linux-x86-64.so.2
00007f97a4117000 160 160 0 rx-- ld-linux-x86-64.so.2
00007f97a413f000 40 40 0 ​​r---- ld-linux-x86-64.so.2
00007f97a4149000 8 8 8 r---- ld-linux-x86-64.so.2
00007f97a414b000 8 8 8 rw--- ld-linux-x86-64.so.2
00007ffca0e7e000 132 12 12 rw--- [ stos ]
00007ffca0fe1000 16 0 0 r---- [ anon ]
00007ffca0fe5000 8 4 0 rx-- [ anon ]
ffffffffff600000 4 0 0 --x-- [ anon ]
----- ------- ------- ------- 
łącznie kB 2756 1328 96

• RSS : To jest rozmiar zestawu rezydentnego . Oznacza to ilość pamięci, która jest obecnie w pamięci RAM i nie została zamieniona.
• Dirty : „Brudna” pamięć została zmieniona od czasu rozpoczęcia procesu — i mapowania.

Pokaż mi wszystko

-X (nawet bardziej niż rozszerzony) dodaje dodatkowe kolumny do danych wyjściowych. Zwróć uwagę na wielkie litery „X”. Inna opcja o nazwie -XX (nawet bardziej niż -X ) pokazuje wszystko, co pmap może uzyskać z jądra. Ponieważ -X jest podzbiorem -XX , opiszemy wyjście z -XX .

 pmap - XX 40919 

Dane wyjściowe strasznie zawijają się w oknie terminala i są praktycznie nieczytelne. Oto pełne dane wyjściowe:

 40919: ./pm
         Adres Perm Przesunięcie Rozmiar węzła urządzenia KernelPageSize MMUPageSize Rss Pss Shared_Clean Shared_Dirty Private_Clean Private_Dirty Referenced Anonimowy LazyFree AnonHugePages ShmemPmdMapped FilePmdMapped Shared_Hugetlb Private_Hugetlb Swap SwapFlagpssLig Zablokowany
    56059f06c000 r--p 00000000 08:03 393304 4 4 4 4 4 0 0 4 0 4 0 0 0 0 0 0 0 0 0 0 0 rd mr mw me dw sd pm
    56059f06d000 r-xp 00001000 08:03 393304 4 4 4 4 4 0 0 4 0 4 0 0 0 0 0 0 0 0 0 0 0 rd ex pan mw me dw sd pm
    56059f06e000 r--p 00002000 08:03 393304 4 4 4 4 4 0 0 4 0 4 0 0 0 0 0 0 0 0 0 0 0 rd pan mw me dw sd pm
    56059f06f000 r--p 00002000 08:03 393304 4 4 4 4 4 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0 rd pan mw me dw ac sd pm
    56059f070000 rw-p 00003000 08:03 393304 4 4 4 4 4 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0 rd wr mw mw me dw ac sd pm
    56059fc39000 rw-p 00000000 00:00 0 132 4 4 4 4 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0 rd wr mw me ac sd [sterta]
    7f97a3edb000 rw-p 00000000 00:00 0 8 4 4 4 4 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0 rd wr mr mw me ac sd 
    7f97a3edd000 r--p 00000000 08:03 264328 160 4 4 160 4 160 0 0 0 160 0 0 0 0 0 0 0 0 0 0 0 rd mr mw me sd libc.so.6
    7f97a3f05000 r-xp 00028000 08:03 264328 1616 4 4 788 32 788 0 0 0 788 0 0 0 0 0 0 0 0 0 0 0 rd ex mr mw me sd libc.so.6
    7f97a4099000 r--p 001bc000 08:03 264328 352 4 4 64 1 64 0 0 0 64 0 0 0 0 0 0 0 0 0 0 0 rd mr mw me sd libc.so.6
    7f97a40f1000 ---p 00214000 08:03 264328 4 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 mr mw me sd libc.so.6
    7f97a40f2000 r--p 00214000 08:03 264328 16 4 4 16 16 0 0 0 16 16 16 0 0 0 0 0 0 0 0 0 0 rd mr mw me ac sd libc.so.6
    7f97a40f6000 rw-p 00218000 08:03 264328 8 4 4 8 8 0 0 0 8 8 8 0 0 0 0 0 0 0 0 0 0 rd wr mr mw me ac sd libc.so.6
    7f97a40f8000 rw-p 00000000 00:00 0 60 4 4 28 28 0 0 0 28 28 28 0 0 0 0 0 0 0 0 0 0 rd wr mw me ac sd 
    7f97a4116000 r--p 00000000 08:03 264305 4 4 4 4 0 4 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 rd mr mw me dw sd ld-linux-x86-64.so.2
    7f97a4117000 r-xp 00001000 08:03 264305 160 4 4 160 11 160 0 0 0 160 0 0 0 0 0 0 0 0 0 0 0 rd ex mr mw me dw sd ld-linux-x86-64.so.2
    7f97a413f000 r--p 00029000 08:03 264305 40 4 4 40 1 40 0 ​​0 0 40 0 ​​0 0 0 0 0 0 0 0 0 0 rd mr mw me dw sd ld-linux-x86-64.so.2
    7f97a4149000 r--p 00032000 08:03 264305 8 4 4 8 8 0 0 0 8 8 8 0 0 0 0 0 0 0 0 0 0 rd mr mw me dw ac sd ld-linux-x86-64.so.2
    7f97a414b000 rw-p 00034000 08:03 264305 8 4 4 8 8 0 0 0 8 8 8 0 0 0 0 0 0 0 0 0 0 rd wr mr mw me dw ac sd ld-linux-x86-64.so.2
    7ffca0e7e000 rw-p 00000000 00:00 0 132 4 4 12 12 0 0 0 12 12 12 0 0 0 0 0 0 0 0 0 0 rd wr mw me gd ac [stos]
    7ffca0fe1000 r--p 00000000 00:00 0 16 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 rd mr pf io de dd sd [vvar]
    7ffca0fe5000 r-xp 00000000 00:00 0 8 4 4 4 0 4 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 rd ex pan mw me de sd [vdso]
ffffffffff600000 --xp 00000000 00:00 0 4 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ex [vsyscall]
                                             ==== =============== === ======= === ============= ================ ==== ============ ======== ============= ============== =========== === ==================== ======= ====== = ==== 
                                             2756 92 92 1328 157 1220 0 12 96 1328 96 0 0 0 0 0 0 0 0 0 0 0 KB 

Jest tu dużo informacji. Oto, co zawierają kolumny:

• Adres : adres początkowy tego mapowania. Wykorzystuje adresowanie pamięci wirtualnej.
• Perm : uprawnienia pamięci.
• Przesunięcie : Jeśli pamięć jest oparta na pliku, przesunięcie tego mapowania wewnątrz pliku.
• Urządzenie : Numer urządzenia Linux, podany w liczbach głównych i pobocznych. Możesz zobaczyć numery urządzeń na swoim komputerze, uruchamiając polecenie lsblk .
• I- węzeł : i-węzeł pliku, z którym powiązane jest mapowanie. Na przykład w naszym przykładzie może to być i-węzeł przechowujący informacje o programie pm.
• Rozmiar : rozmiar regionu mapowanego w pamięci.
• KernelPageSize : rozmiar strony używany przez jądro.
• MMUPageSize : rozmiar strony używany przez jednostkę zarządzania pamięcią.
• Rss : To jest rozmiar zestawu rezydentnego . Oznacza to ilość pamięci, która jest obecnie w pamięci RAM i nie została zamieniona.
• Pss : Jest to proporcjonalny rozmiar udziału . Jest to prywatny rozmiar współdzielony dodany do (współdzielony rozmiar podzielony przez liczbę udziałów).
• Shared_Clean : ilość pamięci współdzielonej z innymi procesami, która nie została zmieniona od czasu utworzenia mapowania. Zauważ, że nawet jeśli pamięć jest udostępniana, jeśli nie została faktycznie udostępniona, nadal jest uważana za pamięć prywatną.
• Shared_Dirty : ilość pamięci współdzielonej z innymi procesami, która została zmieniona od czasu utworzenia mapowania.
• Private_Clean : ilość pamięci prywatnej — nie współdzielonej z innymi procesami — która nie została zmieniona od czasu utworzenia mapowania.
• Private_Dirty : Ilość pamięci prywatnej, która została zmieniona od czasu utworzenia mapowania.
• Odwołanie : ilość pamięci aktualnie oznaczona jako przywoływana lub dostępna.
• Anonimowy : Pamięć, która nie ma urządzenia, na które można by się zamienić. Oznacza to, że nie jest oparty na plikach.
• LazyFree : Strony oznaczone jako MADV_FREE . Te strony zostały oznaczone jako dostępne do uwolnienia i odzyskania, mimo że mogą zawierać niepisane zmiany. Jeśli jednak kolejne zmiany wystąpią po ustawieniu MADV_FREE w mapowaniu pamięci, flaga MADV_FREE zostanie usunięta i strony nie zostaną odzyskane, dopóki zmiany nie zostaną zapisane.
• AnonHugePages : są to „ogromne” strony pamięci bez kopii zapasowych (większe niż 4 KB).
• ShmemPmdMapped : Pamięć współdzielona powiązana z dużymi stronami. Mogą być również używane przez systemy plików, które znajdują się w całości w pamięci.
• FilePmdMapped : Katalog pośredni strony jest jednym ze schematów stronicowania dostępnych dla jądra. Jest to liczba stron opartych na plikach wskazywanych przez wpisy PMD.
• Shared_Hugetlb : Translation Lookaside Tables (TLB) to pamięci podręczne używane do optymalizacji czasu potrzebnego na dostęp do lokalizacji pamięci w przestrzeni użytkownika. Ta liczba to ilość pamięci RAM używanej w TLB, która jest powiązana ze współdzielonymi stronami dużej pamięci.
• Private_Hugetlb : Ta liczba to ilość pamięci RAM używanej w TLB, która jest skojarzona z prywatnymi stronami o dużej pamięci.
• Swap : Kwota używanej wymiany.
• SwapPss : proporcjonalny rozmiar udziału wymiany . Jest to ilość wymiany składająca się z zamienionych stron pamięci prywatnej dodanych do (rozmiar współdzielony podzielony przez liczbę udziałów).
• Zablokowane : mapowania pamięci można zablokować, aby uniemożliwić systemowi operacyjnemu stronicowanie sterty lub pamięci poza stertą.
• THPeligible : Jest to flaga wskazująca, czy mapowanie kwalifikuje się do przydzielania przezroczystych dużych stron . 1 oznacza prawdę, 0 oznacza fałsz. Przezroczyste ogromne strony to system zarządzania pamięcią, który zmniejsza obciążenie wyszukiwania stron TLB na komputerach z dużą ilością pamięci RAM.
• VmFlags : Zobacz listę flag poniżej.
• Mapowanie : nazwa źródła mapowania. Może to być nazwa procesu, nazwa biblioteki lub nazwy systemu, takie jak stos lub sterta.

VmFlags — flagi pamięci wirtualnej — będą podzbiorem poniższej listy.

• rd : Czytelny.
• wr : zapisywalny.
• ex : plik wykonywalny.
• sh : wspólne.
• pan : Może czytać.
• mw : Może napisać.
• ja : Może wykonać.
• ms : Może się podzielić.
• gd : Segment stosu rośnie.
• pf : czysty zakres numerów ramek strony. Numery ramek stron to lista stron pamięci fizycznej.
• dw : Wyłączono zapis do mapowanego pliku.
• lo : Strony są zablokowane w pamięci.
• io : Obszar we/wy mapowany w pamięci.
• sr : Dostarczona informacja dotycząca odczytu sekwencyjnego (przez funkcję madvise() .)
• rr : Dostarczono losową wskazówkę dotyczącą odczytu.
• dc : Nie kopiuj tego obszaru pamięci, jeśli proces jest rozwidlony.
• de : Nie rozszerzaj tego obszaru pamięci przy ponownym mapowaniu.
• ac : Obszar jest odpowiedzialny.
• nr : Przestrzeń wymiany nie jest zarezerwowana dla obszaru.
• ht : Obszar używa ogromnych stron TLB.
• sf : Błąd strony synchronicznej.
• ar : flaga charakterystyczna dla architektury.
• wf : Wyczyść ten obszar pamięci, jeśli proces jest rozwidlony.
• dd : Nie dołączaj tego regionu pamięci do zrzutów pamięci.
• sd : Miękka, brudna flaga.
• mm : Mieszany obszar mapy.
• hg : Flaga z informacją o dużej stronie.
• nh : Brak flagi z informacją o dużej stronie.
• mg : Flaga doradzająca, którą można łączyć.
• bt : ARM64 strona chroniona niestabilnością temperatury.
• mt : ARM64 Tagi rozszerzenia tagowania pamięci są włączone.
• um : Brak śledzenia błędu użytkownika.
• uw : śledzenie Userfaultfd wr-protect.

Zarządzanie pamięcią jest skomplikowane

A praca wstecz od tabel danych, aby zrozumieć, co się naprawdę dzieje, jest trudna. Ale przynajmniej pmap daje pełny obraz, więc masz największą szansę dowiedzieć się, co musisz wiedzieć.

Warto zauważyć, że nasz przykładowy program skompilował się do pliku wykonywalnego o rozmiarze 16 KB, a mimo to używa (lub współdzieli) około 2756 KB pamięci, prawie całkowicie dzięki bibliotekom wykonawczym.

Ostatnią fajną sztuczką jest to, że możesz używać razem poleceń pmap i pidof , łącząc działania polegające na znalezieniu PID procesu i przekazaniu go do pmap w jednym poleceniu:

 pmap $(pidof pm)