Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00483 013815 11056501 na godz. na dobę w sumie
Linux. Niezbędnik programisty - książka
Linux. Niezbędnik programisty - książka
Autor: Liczba stron: 736
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1485-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> systemy operacyjne >> linux
Porównaj ceny (książka, ebook, audiobook).

Wszystko, czego potrzebujesz,
aby tworzyć wydajny, elastyczny i bezbłędny kod!

Programista, jak każdy fachowiec, posiada perfekcyjnie dobrany zestaw narzędzi, pozwalający mu na szybkie, wygodne, elastyczne i - co najważniejsze - optymalne rozwiązywanie postawionych problemów. Wybranie odpowiednich narzędzi i skomponowanie ich zbioru zabiera często wiele dni, miesięcy, a nawet i lat. A przecież my, programiści, nie mamy aż tyle czasu! Koniecznie trzeba znaleźć jakiś szybszy sposób!

Najlepszą odpowiedzią na ten problem jest właśnie niniejsza książka. Dzięki niej opanujesz sposoby pobierania i instalacji różnych narzędzi, a nowo nabyta wiedza na temat sposobów zarządzania pakietami w różnych dystrybucjach na pewno nie pójdzie na marne. W kolejnych rozdziałach poznasz przebieg procesu kompilacji oraz dowiesz się, jak interpretować poszczególne błędy i ostrzeżenia. John Fusco omawia tu także edytory Vim oraz Emacs - ale nie wskazuje, który z nich jest lepszy! Dzięki książce 'Linux. Niezbędnik projektanta' wykorzystanie systemów kontroli wersji nie będzie stanowiło dla Ciebie najmniejszego problemu. Na kolejnych stronach szczegółowo omawiane są zasady funkcjonowania jądra systemu oraz sposób działania procesów i komunikacji między nimi. Lektura kolejnych rozdziałów dostarczy Ci niezbędnych informacji na temat zapewniania wysokiej wydajności tworzonych rozwiązań oraz metod diagnozowania problemów z oprogramowaniem.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Linux. Niezbêdnik programisty Autor: John Fusco ISBN: 978-83-246-1485-1 Tytu³ orygina³u: The Linux Programmer s Toolbox Format: 200x230, stron: 736 Wszystko, czego potrzebujesz, aby tworzyæ wydajny, elastyczny i bezb³êdny kod! • Jaki edytor wybraæ? • Jak dzia³aj¹ systemy kontroli wersji? • Jak zapewniæ wysok¹ wydajnoœæ oraz bezb³êdne dzia³anie tworzonych rozwi¹zañ? Programista, jak ka¿dy fachowiec, posiada perfekcyjnie dobrany zestaw narzêdzi, pozwalaj¹cy mu na szybkie, wygodne, elastyczne i – co najwa¿niejsze – optymalne rozwi¹zywanie postawionych problemów. Wybranie odpowiednich narzêdzi i skomponowanie ich zbioru zabiera czêsto wiele dni, miesiêcy, a nawet i lat. A przecie¿ my, programiœci, nie mamy a¿ tyle czasu! Koniecznie trzeba znaleŸæ jakiœ szybszy sposób! Najlepsz¹ odpowiedzi¹ na ten problem jest w³aœnie niniejsza ksi¹¿ka. Dziêki niej opanujesz sposoby pobierania i instalacji ró¿nych narzêdzi, a nowo nabyta wiedza na temat sposobów zarz¹dzania pakietami w ró¿nych dystrybucjach na pewno nie pójdzie na marne. W kolejnych rozdzia³ach poznasz przebieg procesu kompilacji oraz dowiesz siê, jak interpretowaæ poszczególne b³êdy i ostrze¿enia. John Fusco omawia tu tak¿e edytory Vim oraz Emacs – ale nie wskazuje, który z nich jest lepszy! Dziêki ksi¹¿ce „Linux. Niezbêdnik projektanta” wykorzystanie systemów kontroli wersji nie bêdzie stanowi³o dla Ciebie najmniejszego problemu. Na kolejnych stronach szczegó³owo omawiane s¹ zasady funkcjonowania j¹dra systemu oraz sposób dzia³ania procesów i komunikacji miêdzy nimi. Lektura kolejnych rozdzia³ów dostarczy Ci niezbêdnych informacji na temat zapewniania wysokiej wydajnoœci tworzonych rozwi¹zañ oraz metod diagnozowania problemów z oprogramowaniem. • Zdobywanie i instalacja oprogramowania open source • Proces kompilacji kodu Ÿród³owego • Zarz¹dzanie pakietami w ró¿nych dystrybucjach • Interpretacja komunikatów o b³êdach i ostrze¿eñ • Edytory plików tekstowych • Wykorzystanie systemów kontroli wersji • Wykorzystanie procesów • Komunikacja miêdzy procesami • Diagnozowanie problemów z komunikacj¹ pomiêdzy procesami • Zwiêkszanie wydajnoœci tworzonych rozwi¹zañ • Wykrywanie problemów w napisanym oprogramowaniu Spis treści 5 Spis treści Słowo wstępne ............................................................................................................................................. 17 Przedmowa ................................................................................................................................................... 19 Podziękowania ............................................................................................................................................. 25 O autorze ...................................................................................................................................................... 27 Rozdział 1. Pobieranie i instalacja narzędzi oferowanych w trybie open source ............... 29 1.1. Wprowadzenie ................................................................................................................................... 29 1.2. Czym jest tryb open source? ............................................................................................................ 30 1.3. Co idea otwartego dostępu do kodu źródłowego oznacza dla nas? ............................................... 30 1.3.1. Odnajdywanie właściwych narzędzi ........................................................................................ 31 1.3.2. Formaty dystrybucji oprogramowania .................................................................................... 32 1.4. Wprowadzenie do tematyki plików archiwalnych .......................................................................... 33 1.4.1. Identyfikacja plików archiwalnych .......................................................................................... 35 1.4.2. Przeglądanie zawartości plików archiwalnych ........................................................................ 36 1.4.3. Rozpakowywanie plików z pliku archiwalnego ...................................................................... 40 1.5. Poznajmy wykorzystywany menedżer pakietów ............................................................................ 42 1.5.1. Wybór pomiędzy kodem źródłowym a wersją binarną .......................................................... 43 1.5.2. Praca z pakietami ...................................................................................................................... 46 1.6. Kilka słów o bezpieczeństwie w kontekście pakietów .................................................................... 46 1.6.1. Potrzeba uwierzytelniania ........................................................................................................ 48 1.6.2. Podstawowe uwierzytelnianie pakietów ................................................................................. 49 1.6.3. Uwierzytelnianie pakietów z podpisami cyfrowymi .............................................................. 51 6 Spis treści 1.6.4. Podpisy narzędzia GPG, stosowane dla pakietów RPM ........................................................ 52 1.6.5. Kiedy uwierzytelnienie pakietu jest niemożliwe .................................................................... 56 1.7. Analiza zawartości pakietu ................................................................................................................ 57 1.7.1. Jak analizować pobrane pakiety ................................................................................................ 59 1.7.2. Szczegółowa analiza pakietów RPM ....................................................................................... 61 1.7.3. Szczegółowa analiza pakietów Debiana ................................................................................... 62 1.8. Aktualizowanie pakietów .................................................................................................................. 64 1.8.1. APT ⎯ Advanced Package Tool ............................................................................................. 66 1.8.2. YUM ⎯ Yellowdog Updater Modified .................................................................................. 67 1.8.3. Synaptic ⎯ nakładka narzędzia APT z graficznym interfejsem użytkownika ...................... 67 1.8.4. up2date ⎯ narzędzie aktualizujące pakiety dystrybucji Red Hat .......................................... 69 1.9. Podsumowanie .................................................................................................................................. 71 1.9.1. Narzędzia użyte w tym rozdziale ............................................................................................ 71 1.9.2. Materiały dostępne w internecie .............................................................................................. 72 Rozdział 2. Kompilacja kodu źródłowego .................................................................................... 73 2.1. Wprowadzenie ................................................................................................................................... 73 2.2. Narzędzia kompilujące ..................................................................................................................... 74 2.2.1. Rys historyczny ......................................................................................................................... 74 2.2.2. Zrozumieć program make ....................................................................................................... 77 2.2.3. Jak przebiega proces łączenia programów ............................................................................. 103 2.2.4. Zrozumieć biblioteki .............................................................................................................. 104 2.3. Proces kompilacji ............................................................................................................................ 109 2.3.1. Narzędzia kompilacji GNU .................................................................................................. 110 2.3.2. Etap konfiguracji (skrypt configure) ...................................................................................... 111 2.3.3. Etap kompilacji ⎯ narzędzie make ....................................................................................... 113 2.3.4. Etap instalacji ⎯ polecenie make install ............................................................................... 114 Spis treści 7 2.4. Zrozumieć błędy i ostrzeżenia ....................................................................................................... 115 2.4.1. Typowe błędy w plikach Makefile ......................................................................................... 115 2.4.2. Błędy na etapie konfiguracji ................................................................................................... 119 2.4.3. Błędy na etapie kompilacji ..................................................................................................... 120 2.4.4. Zrozumieć błędy kompilatora ............................................................................................... 124 2.4.5. Zrozumieć ostrzeżenia kompilatora ...................................................................................... 126 2.4.6. Zrozumieć błędy programu łączącego .................................................................................. 138 2.5. Podsumowanie ................................................................................................................................ 140 2.5.1. Narzędzia użyte w tym rozdziale .......................................................................................... 140 2.5.2. Materiały dostępne w internecie ............................................................................................ 141 Rozdział 3. Szukanie pomocy ........................................................................................................ 143 3.1. Wprowadzenie ................................................................................................................................. 143 3.2. Narzędzia pomocy elektronicznej ................................................................................................. 144 3.2.1. Strona man .............................................................................................................................. 144 3.2.2. Organizacja stron man ........................................................................................................... 145 3.2.3. Przeszukiwanie stron man — narzędzie apropos ................................................................. 149 3.2.4. Poszukiwanie właściwych stron man — polecenie whatis .................................................. 151 3.2.5. Czego należy szukać na stronach man .................................................................................. 152 3.2.6. Kilka szczególnie przydatnych stron man ............................................................................. 153 3.2.7. Narzędzie info projektu GNU .............................................................................................. 155 3.2.8. Przeglądanie stron info ........................................................................................................... 156 3.2.9. Przeszukiwanie stron info ...................................................................................................... 159 3.2.10. Zalecane strony info ............................................................................................................... 160 3.2.11. Narzędzia pomocy uruchamiane na pulpicie ....................................................................... 160 3.3. Pozostałe źródła pomocy ................................................................................................................ 162 3.3.1. Katalog /usr/share/doc ............................................................................................................ 162 3.3.2. Odwołania do innych stron oraz mechanizmy indeksowania ............................................. 163 3.3.3. Zapytania kierowane do pakietów ......................................................................................... 164 8 Spis treści 3.4. Formaty dokumentacji ................................................................................................................... 166 3.4.1. Formaty TeX, LaTeX i DVI ................................................................................................... 166 3.4.2. Format Texinfo ....................................................................................................................... 167 3.4.3. Format DocBook .................................................................................................................... 168 Język HTML ........................................................................................................................... 169 3.4.4. 3.4.5. Język PostScript ...................................................................................................................... 171 3.4.6. Format PDF ............................................................................................................................ 173 3.4.7. Język troff ................................................................................................................................ 174 3.5. Źródła informacji w internecie ...................................................................................................... 174 3.5.1. Witryna http://www.gnu.org/ ................................................................................................. 175 3.5.2. Witryna http://SourceForge.net/ ............................................................................................ 175 3.5.3. Witryna projektu The Linux Documentation Project ......................................................... 176 3.5.4. Grupy dyskusyjne Usenet ...................................................................................................... 177 3.5.5. Listy dyskusyjne ...................................................................................................................... 177 3.5.6. Pozostałe fora .......................................................................................................................... 178 3.6. Odnajdywanie informacji o jądrze systemu Linux ....................................................................... 178 3.6.1. Kompilacja jądra ..................................................................................................................... 178 3.6.2. Moduły jądra ........................................................................................................................... 180 3.6.3. Pozostałe źródła dokumentacji .............................................................................................. 182 3.7. Podsumowanie ................................................................................................................................ 182 3.7.1. Narzędzia użyte w tym rozdziale .......................................................................................... 182 3.7.2. Materiały dostępne w internecie ............................................................................................ 183 Rozdział 4. Edycja i konserwacja plików źródłowych ............................................................. 185 4.1. Wprowadzenie ................................................................................................................................. 185 4.2. Edytor tekstu ................................................................................................................................... 186 4.2.1. Edytor domyślny ..................................................................................................................... 188 4.2.2. Jakich funkcji należy szukać w edytorze tekstu .................................................................... 188 4.2.3. Wielka dwójka — vi oraz Emacs ............................................................................................ 190 Spis treści 9 4.2.4. Vim — udoskonalony edytor vi ............................................................................................. 191 4.2.5. Edytor Emacs .......................................................................................................................... 215 4.2.6. Atak klonów ............................................................................................................................ 227 4.2.7. Podstawowe informacje o kilku edytorach tekstu z graficznym interfejsem użytkownika ................................................................................. 230 4.2.8. Wymagania pamięciowe ......................................................................................................... 235 4.2.9. Podsumowanie wiadomości o edytorach .............................................................................. 237 4.3. Kontrola wersji ................................................................................................................................ 238 4.3.1. Podstawy kontroli wersji ........................................................................................................ 238 4.3.2. Terminologia obowiązująca w świecie kontroli wersji ........................................................ 240 4.3.3. Narzędzia pomocnicze ........................................................................................................... 243 4.3.4. Podstawy poleceń diff i patch ................................................................................................ 243 4.3.5. Przeglądanie i scalanie zmian ................................................................................................. 247 4.4. Upiększacze i przeglądarki kodu źródłowego ............................................................................... 254 4.4.1. Upiększacze wcięć w kodzie źródłowym .............................................................................. 255 4.4.2. Artystyczny styl narzędzia astyle ............................................................................................ 258 4.4.3. Analiza kodu za pomocą narzędzia cflow .............................................................................. 259 4.4.4. Analiza kodu za pomocą narzędzia ctags ............................................................................... 262 4.4.5. Przeglądanie kodu za pomocą narzędzia cscope ................................................................... 262 4.4.6. Przeglądanie i dokumentowanie kodu za pomocą narzędzia Doxygen .............................. 264 4.4.7. Analiza kodu źródłowego z wykorzystaniem kompilatora .................................................. 266 4.5. Podsumowanie ................................................................................................................................ 268 4.5.1. Narzędzia użyte w tym rozdziale .......................................................................................... 269 4.5.2. Bibliografia .............................................................................................................................. 270 4.5.3. Materiały dostępne w internecie ............................................................................................ 270 10 Spis treści Rozdział 5. Co każdy programista powinien wiedzieć o jądrze systemu ........................... 273 5.1. Wprowadzenie ................................................................................................................................. 273 5.2. Tryb użytkownika a tryb jądra ....................................................................................................... 274 5.2.1. Wywołania systemowe ........................................................................................................... 276 5.2.2. Przenoszenie danych pomiędzy przestrzenią użytkownika a przestrzenią jądra .................. 278 5.3. Mechanizm szeregowania procesów ............................................................................................. 279 5.3.1. Reguły szeregowania procesów ............................................................................................. 279 5.3.2. Blokowanie, wywłaszczanie i rezygnacje .............................................................................. 282 5.3.3. Priorytety szeregowania i kwestia sprawiedliwości .............................................................. 283 5.3.4. Priorytety i wartość nice ......................................................................................................... 287 5.3.5. Priorytety czasu rzeczywistego .............................................................................................. 289 5.3.6. Tworzenie procesów czasu rzeczywistego ............................................................................ 292 5.3.7. Stany procesów ....................................................................................................................... 294 5.3.8. Jak jest mierzony czas pracy procesów .................................................................................. 301 5.4. Zrozumieć urządzenia i sterowniki urządzeń ............................................................................... 313 5.4.1. Rodzaje sterowników urządzeń ............................................................................................. 314 5.4.2. Słowo o modułach jądra ......................................................................................................... 316 5.4.3. Węzły urządzeń ....................................................................................................................... 317 5.4.4. Urządzenia i operacje wejścia-wyjścia ................................................................................... 330 5.5. Mechanizm szeregowania operacji wejścia-wyjścia ...................................................................... 340 5.5.1. Winda Linusa (znana też jako noop) ..................................................................................... 342 5.5.2. Mechanizm szeregowania operacji wejścia-wyjścia z terminem granicznym .................... 343 5.5.3. Przewidujący mechanizm szeregowania operacji wejścia-wyjścia ...................................... 344 5.5.4. Mechanizm szeregowania operacji wejścia-wyjścia z pełnym kolejkowaniem .................. 344 5.5.5. Wybór mechanizmu szeregowania operacji wejścia-wyjścia ............................................... 344 5.6. Zarządzanie pamięcią w przestrzeni użytkownika ........................................................................ 345 5.6.1. Omówienie pamięci wirtualnej ............................................................................................. 346 5.6.2. Wyczerpanie dostępnej pamięci ............................................................................................. 363 Spis treści 11 5.7. Podsumowanie ................................................................................................................................ 378 5.7.1. Narzędzia użyte w tym rozdziale .......................................................................................... 378 5.7.2. Interfejsy API omówione w tym rozdziale ........................................................................... 379 5.7.3. Materiały dostępne w internecie ............................................................................................ 379 5.7.4. Bibliografia .............................................................................................................................. 379 Rozdział 6. Zrozumieć procesy ..................................................................................................... 381 6.1. Wprowadzenie ................................................................................................................................. 381 6.2. Skąd się biorą procesy ..................................................................................................................... 381 6.2.1. Wywołania systemowe fork i vfork ....................................................................................... 382 6.2.2. Kopiowanie przy zapisie ......................................................................................................... 383 6.2.3. Wywołanie systemowe clone ................................................................................................. 384 6.3. Funkcje z rodziny exec ................................................................................................................... 384 6.3.1. Skrypty wykonywalne ............................................................................................................ 385 6.3.2. Wykonywalne pliki obiektów ................................................................................................. 387 6.3.3. Rozmaite binaria ..................................................................................................................... 389 6.4. Synchronizacja procesów za pomocą funkcji wait ........................................................................ 392 6.5. Wymagania pamięciowe procesu ................................................................................................... 394 6.5.1. Deskryptory plików ................................................................................................................ 397 6.5.2. Stos .......................................................................................................................................... 404 6.5.3. Pamięć rezydentna i pamięć zablokowana ............................................................................ 405 6.6. Ustawianie ograniczeń dla procesów ............................................................................................. 406 6.7. Procesy i system plików procfs ...................................................................................................... 410 6.8. Narzędzia do zarządzania procesami ............................................................................................. 413 6.8.1. Wyświetlanie informacji o procesach za pomocą polecenia ps ............................................ 413 6.8.2. Zaawansowane informacje o procesach, uzyskiwane z wykorzystaniem formatów .......... 416 6.8.3. Odnajdywanie procesów według nazw za pomocą poleceń ps i pgrep ............................... 419 6.8.4. Śledzenie wymagań pamięciowych procesu za pomocą polecenia pmap ........................... 420 6.8.5. Wysyłanie sygnałów do procesów identyfikowanych przez nazwy ..................................... 422 12 Spis treści 6.9. Podsumowanie ................................................................................................................................ 423 6.9.1. Wywołania systemowe i interfejsy API użyte w tym rozdziale ............................................ 423 6.9.2. Narzędzia użyte w tym rozdziale .......................................................................................... 424 6.9.3. Materiały dostępne w internecie ............................................................................................ 424 Rozdział 7. Komunikacja pomiędzy procesami ........................................................................ 425 7.1. Wprowadzenie ................................................................................................................................. 425 7.2. Technika IPC z wykorzystaniem zwykłych plików ..................................................................... 426 7.2.1. Blokowanie plików ................................................................................................................. 431 7.2.2. Wady implementacji techniki IPC z wykorzystaniem plików ............................................. 432 7.3. Pamięć współdzielona .................................................................................................................... 432 7.3.1. Zarządzanie pamięcią współdzieloną za pośrednictwem interfejsu POSIX API ............... 433 7.3.2. Zarządzanie pamięcią współdzieloną za pośrednictwem interfejsu System V API ............ 437 7.4. Sygnały ............................................................................................................................................. 440 7.4.1. Wysyłanie sygnałów do procesu ............................................................................................ 441 7.4.2. Obsługa sygnałów ................................................................................................................... 442 7.4.3. Maska sygnałów i obsługa sygnałów ..................................................................................... 444 7.4.4. Sygnały czasu rzeczywistego .................................................................................................. 447 7.4.5. Zaawansowane operacje na sygnałach z wykorzystaniem funkcji sigqueue i sigaction ..... 450 7.5. Potoki ............................................................................................................................................... 453 7.6. Gniazda ............................................................................................................................................ 454 7.6.1. Tworzenie gniazd ................................................................................................................... 455 7.6.2. Przykład gniazda lokalnego, utworzonego za pomocą funkcji socketpair .......................... 458 7.6.3. Przykład aplikacji klient-serwer, zbudowanej z wykorzystaniem gniazd lokalnych .......... 459 7.6.4. Przykład aplikacji klient-serwer, zbudowanej z wykorzystaniem gniazd sieciowych ........ 465 7.7. Kolejki komunikatów ..................................................................................................................... 466 7.7.1. Kolejka komunikatów standardu System V .......................................................................... 467 7.7.2. Kolejka komunikatów standardu POSIX .............................................................................. 471 7.7.3. Różnice dzielące kolejki komunikatów standardów POSIX i System V ............................. 476 Spis treści 13 7.8.1. 7.8.2. 7.8. Semafory .......................................................................................................................................... 477 Interfejs API semaforów standardu POSIX .......................................................................... 483 Interfejs API semaforów standardu System V ...................................................................... 486 7.9. Podsumowanie ................................................................................................................................ 488 7.9.1. Wywołania systemowe i interfejsy API użyte w tym rozdziale ............................................ 489 7.9.2. Bibliografia .............................................................................................................................. 490 7.9.3. Materiały dostępne w internecie ............................................................................................ 490 Rozdział 8. Diagnozowanie mechanizmów komunikacji międzyprocesowej za pomocą poleceń powłoki ..................................................................................... 491 8.1. Wprowadzenie ................................................................................................................................. 491 8.2. Narzędzia operujące na otwartych plikach .................................................................................... 491 8.2.1. Polecenie lsof .......................................................................................................................... 492 8.2.2. Polecenie fuser ........................................................................................................................ 493 8.2.3. Polecenie ls .............................................................................................................................. 494 8.2.4. Polecenie file ........................................................................................................................... 495 8.2.5. Polecenie stat ........................................................................................................................... 495 8.3. Zrzucanie danych z pliku ............................................................................................................... 496 8.3.1. Polecenie strings ..................................................................................................................... 499 8.3.2. Polecenie xxd .......................................................................................................................... 500 8.3.3. Polecenie hexdump ................................................................................................................ 501 8.3.4. Polecenie od ............................................................................................................................ 502 8.4. Narzędzia powłoki do obsługi komunikacji międzyprocesowej standardu System V ............... 504 8.4.1. Pamięć współdzielona standardu System V .......................................................................... 504 8.4.2. Kolejki komunikatów standardu System V ........................................................................... 507 8.4.3. Semafory standardu System V ............................................................................................... 509 8.5. Narzędzia powłoki do obsługi komunikacji międzyprocesowej standardu POSIX ................... 510 8.5.1. Pamięć współdzielona standardu POSIX ............................................................................. 510 8.5.2. Kolejki komunikatów standardu POSIX .............................................................................. 511 8.5.3. Semafory standardu POSIX ................................................................................................... 512 14 Spis treści 8.6. Narzędzia pomocne w pracy z sygnałami ..................................................................................... 514 8.7. Narzędzia pomocne w pracy z potokami i gniazdami .................................................................. 516 8.7.1. Potoki i struktury FIFO ......................................................................................................... 517 8.7.2. Gniazda .................................................................................................................................... 518 8.8. Identyfikacja plików i obiektów IPC na podstawie i-węzłów ...................................................... 521 8.9. Podsumowanie ................................................................................................................................ 523 8.9.1. Narzędzia wykorzystane w tym rozdziale ............................................................................. 523 8.9.2. Materiały dostępne w internecie ............................................................................................ 523 Rozdział 9. Doskonalenie wydajności .......................................................................................... 525 9.1. Wprowadzenie ................................................................................................................................. 525 9.2. Wydajność systemu ......................................................................................................................... 525 9.2.1. Problemy związane z pamięcią .............................................................................................. 526 9.2.2. Wykorzystanie procesora i rywalizacja o dostęp do magistrali ............................................. 537 9.2.3. Urządzenia i przerwania ........................................................................................................ 541 9.2.4. Narzędzia umożliwiające identyfikację problemów w zakresie wydajności systemu ........ 550 9.3. Wydajność aplikacji ......................................................................................................................... 560 9.3.1. Pierwsze kroki — polecenie time .......................................................................................... 560 9.3.2. Zrozumieć architekturę procesora z wykorzystaniem narzędzia x86info ........................... 561 9.3.3. Stosowanie pakietu Valgrind do analizy efektywności rozkazów ........................................ 565 9.3.4. Wprowadzenie do narzędzia ltrace ........................................................................................ 570 9.3.5. Stosowanie narzędzia strace do monitorowania wydajności programu .............................. 572 9.3.6. Tradycyjne programy do optymalizacji oprogramowania — gcov oraz gprof .................... 574 9.3.7. Podstawowe informacje o narzędziu OProfile ..................................................................... 583 9.4. Wydajność w środowisku wieloprocesorowym ............................................................................ 590 9.4.1. Rodzaje systemów SMP ......................................................................................................... 591 9.4.2. Programowanie dla komputerów SMP ................................................................................. 596 Spis treści 15 9.5. Podsumowanie ................................................................................................................................ 600 9.5.1. Omówione w tym rozdziale problemy związane z wydajnością ......................................... 601 9.5.2. Terminy wprowadzone w tym rozdziale .............................................................................. 601 9.5.3. Narzędzia wykorzystane w tym rozdziale ............................................................................. 601 9.5.4. Materiały dostępne w internecie ............................................................................................ 602 9.5.5. Bibliografia .............................................................................................................................. 602 Rozdział 10. Diagnozowanie oprogramowania ........................................................................... 603 10.1. Wprowadzenie ................................................................................................................................. 603 10.2. Najprostsze narzędzie diagnostyczne — funkcja printf ............................................................... 604 10.2.1. Problemy związane ze stosowaniem funkcji printf w roli narzędzia diagnostycznego ...... 604 10.2.2. Efektywne korzystanie z funkcji printf ................................................................................. 610 10.2.3. Kilka słów podsumowania metod diagnozowania oprogramowania z wykorzystaniem funkcji printf ............................................................................................ 620 10.3. Jak opanować podstawy debugera GNU — gdb .......................................................................... 622 10.3.1. Wykonywanie kodu pod kontrolą debugera gdb .................................................................. 623 10.3.2. Zatrzymywanie i wznawianie wykonywania kodu ............................................................... 624 10.3.3. Analiza i modyfikowanie danych ........................................................................................... 636 10.3.4. Dołączanie debugera gdb do pracującego procesu ............................................................... 649 10.3.5. Diagnozowanie plików rdzenia ............................................................................................. 649 10.3.6. Diagnozowanie programów wielowątkowych za pomocą debugera gdb ............................ 653 10.3.7. Diagnozowanie zoptymalizowanego kodu ........................................................................... 655 10.4. Diagnozowanie obiektów dzielonych ............................................................................................ 659 10.4.1. Kiedy i dlaczego stosujemy obiekty dzielone ........................................................................ 659 10.4.2. Tworzenie obiektów dzielonych ........................................................................................... 660 10.4.3. Lokalizowanie obiektów dzielonych ..................................................................................... 661 10.4.4. Nadpisywanie domyślnych lokalizacji obiektów dzielonych ............................................... 662 10.4.5. Problemy związane z bezpieczeństwem obiektów dzielonych ............................................ 663 10.4.6. Narzędzia wykorzystywane w pracy z obiektami dzielonymi ............................................. 663 16 Spis treści 10.5. Poszukiwanie problemów związanych z pamięcią ....................................................................... 667 10.5.1. Podwójne zwalnianie pamięci ................................................................................................ 668 10.5.2. Wycieki pamięci ...................................................................................................................... 668 10.5.3. Przepełnienia buforów ........................................................................................................... 669 10.5.4. Narzędzia biblioteki standardowej glibc ............................................................................... 671 10.5.5. Diagnozowanie problemów związanych z pamięcią za pomocą pakietu Valgrind ............. 675 10.5.6. Identyfikacja przepełnień za pomocą debugera Electric Fence ........................................... 682 10.6. Techniki niekonwencjonalne ......................................................................................................... 685 10.6.1. Tworzenie własnych czarnych skrzynek ............................................................................... 685 10.6.2. Śledzenie wsteczne w czasie wykonywania .......................................................................... 688 10.6.3. Wymuszanie zrzutów rdzenia ................................................................................................ 691 10.6.4. Stosowanie sygnałów .............................................................................................................. 692 10.6.5. Diagnozowanie oprogramowania z wykorzystaniem systemu pakietu procfs .................... 693 10.7. Podsumowanie ................................................................................................................................ 696 10.7.1. Narzędzia wykorzystane w tym rozdziale ............................................................................. 697 10.7.2. Materiały dostępne w internecie ............................................................................................ 697 10.7.3. Bibliografia .............................................................................................................................. 697 Skorowidz ................................................................................................................................................ 699 Rozdział 1.[SR1] Pobieranie i instalacja narzędzi oferowanych w trybie open source 1.1. Wprowadzenie W tym rozdziale omówię różne formy dystrybuowania darmowego oprogramowania, techniki jego stosowania i miejsca, gdzie należy go szukać. Szczegółowo opiszę pliki archiwalne i pliki pakietów, a także najbardziej popularne narzędzia utworzone z myślą o operowaniu na tych plikach. Stosowanie oprogramowania nieznanych autorów bywa ryzykowne. W związku z tym omówię rozmaite zagadnienia związane z bezpieczeństwem, które warto mieć na uwadze, i techniki, które mogą nas chronić. Wprowadzę zagadnienia uwierzytelniania i zaufania, po czym spróbuję je odnieść do problematyki bezpieczeństwa. Z myślą o sytuacjach, w których uwierzytelnianie jest niemożliwe, zaproponuję techniki przeglądania pakietów i archiwów. I wreszcie wprowadzę kilka narzędzi umożliwiających efektywne zarządzanie pakietami i dystrybucjami opartymi na pakietach oraz sposoby ich uzyskiwania. 29 30 Rozdział 1 • Pobieranie i instalacja narzędzi oferowanych w trybie open source 1.2. Czym jest tryb open source? Nazwa open source jest marketingowym określeniem darmowego oprogramowania tworzo- nego zgodnie z założeniami projektu Open Source Initiative (OSI)1. Organizację OSI założono z myślą o promowaniu darmowego oprogramowania, a faktycznym źródłem tej idei był projekt GNU Richarda Stallmana. Jednym z celów tej organizacji jest zwalczanie negatywnych stereo- typów związanych z darmowym oprogramowaniem i propagowanie darmowego dzielenia się kodem źródłowym aplikacji. Początkowo wiele organizacji biznesowych obawiało się stosowania oprogramowania ofero- wanego w trybie open source. Nie ma wątpliwości, że spory udział w tym stanie rzeczy miały działy marketingu wielkich przedsiębiorstw informatycznych. Jak mówi powiedzenie: „Otrzymujesz to, za co płacisz”. Niektórzy obawiali się, że nowe licencje (np. GNU Public License) będą się roz- przestrzeniały jak wirus, który sprawi, że kod tworzony z wykorzystaniem darmowego oprogra- mowania także będzie musiał być upubliczniony. Zdecydowana większość tych obaw została na szczęście rozwiana. Wiele ogromnych przed- siębiorstw korzysta obecnie z darmowego oprogramowania i promuje ideę otwartego dostępu do kodu źródłowego we własnych projektach. Co więcej, część koncernów korzysta wyłącznie z opro- gramowania open source. Dżin ostatecznie został uwolniony ze swojej lampy. 1.3. Co idea otwartego dostępu do kodu źródłowego oznacza dla nas? Dla większości z nas idea oprogramowania open source oznacza w istocie dostępność darmowych narzędzi wysokiej jakości. Okazuje się, niestety, że oprócz wspomnianego oprogramowania wysokiej jakości istnieje mnóstwo gorszych produktów, co jest nieuniknione. Dobre koncepcje projektowe są stale rozwijane, koncepcje chybione z czasem zanikają. W tej sytuacji wybór opro- gramowania open source przypomina trochę wybór owoców — wskazanie naprawdę dojrzałych wymaga sporego doświadczenia. Właściwie prowadzony proces wyboru musi uwzględniać wiele poziomów. Na poziomie kodu źródłowego dobieramy funkcje i konstrukcje (w tym łatki usuwające usterki), aby dyspo- nować tylko najlepszymi rozwiązaniami. Jako konsumenci wybieramy i pobieramy z internetu te produkty, które w naszej ocenie zwiększają szanse powodzenia realizowanych projektów. Trudno oczekiwać, by ktoś tworzył kod, który nie będzie wykorzystywany w żadnym projekcie. Mniej pobieranego oprogramowania oznacza mniej pracy dla programistów. Więcej pobrań zawsze ozna- cza więcej pracy dla programistów, co z kolei przekłada się na szerszy wybór kodu i — tym 1 Patrz witryna internetowa http://www.opensource.org/. 1.3. Co idea otwartego dostępu do kodu źródłowego oznacza dla nas? 31 samym — lepszy kod. Zdarza się, że wybór właściwego projektu przypomina rozgrywkę hazar- dową, w której o sile naszych kart decyduje wyłącznie ilość poświęcanego czasu i wkładanego wysiłku. Sytuacje, w których będziemy żałować dokonanych wcześniej wyborów, są nieunik- nione — warto więc pamiętać, że podobne zdarzenia są nieodłączną częścią tego procesu. Dla części użytkowników niepełna wiedza o pobieranym oprogramowaniu bywa źródłem pozytywnych emocji. Traktują poznawanie nowych narzędzi jak rozpakowywanie prezentów urodzinowych. Inni użytkownicy uważają, że tego rodzaju eksperymenty są wyjątkowo kłopo- tliwe i czasochłonne. Okazuje się jednak, że także osoby zainteresowane wygodą związaną z goto- wym oprogramowaniem, które wystarczy zainstalować i uruchomić, znajdą w internecie coś dla siebie — problem w tym, że wybór naprawdę dojrzałych projektów jest nieco mniejszy. Internet oferuje wiele zasobów, które ułatwiają wybór pożądanych projektów. 1.3.1. Odnajdywanie właściwych narzędzi Pierwszym miejscem, od którego należy zacząć poszukiwania (zanim przystąpimy do przegląda- nia zasobów dostępnych w internecie), są płyty CD lub DVD naszej dystrybucji systemu Linux. Jeśli zainstalowaliśmy system znajdujący się na wielu nośnikach, najprawdopodobniej pominięto w tym procesie mnóstwo użytecznych narzędzi. Większość dystrybucji zawiera na płytach CD lub DVD dużo więcej oprogramowania, niż instaluje się zgodnie z ustawieniami domyślnymi. Z reguły użytkownik instalujący system operacyjny jest pytany o docelowe przeznaczenie danego kom- putera. Wskutek takiego wyboru na dysku jest instalowany określony podzbiór pakietów, który według twórców programu instalacyjnego najlepiej pasuje do profilu stacji roboczej czy serwera. Zbiór zainstalowanych pakietów zawsze możemy rozszerzyć ręcznie, lokalizując interesujące nas narzędzia na płytach CD lub DVD. Wadą proponowanego podejścia jest brak jednego sche- matu organizowania pakietów i — tym samym — konieczność dysponowania dość precyzyjną wiedzą o poszukiwanych rozwiązaniach. Część dystrybucji oferuje jednak graficzne interfejsy organizujące pakiety w ramach kategorii, które znacznie ułatwiają dobór instalowanego oprogra- mowania. Użytkownicy, którzy nie do końca wiedzą, czego szukają, powinni skorzystać z materiałów dostępnych w internecie. Istnieje wiele witryn internetowych, stworzonych wyłącznie z myślą o użytkownikach poszukujących oprogramowania open source. Jedną z takich witryn jest http:// (cid:180)freshmeat.net/. Można tam znaleźć oprogramowanie uporządkowane według kategorii, co znacznie ułatwia przeszukiwanie oferowanych zasobów. W czasie prac nad tą książką wpisałem w wyszu- kiwarce Freshmeat wyrażenie word processor i znalazłem 71 dostępnych projektów. Aż trudno sobie wyobrazić wybór spomiędzy 71 edytorów tekstu! 32 Rozdział 1 • Pobieranie i instalacja narzędzi oferowanych w trybie open source Witryna Freshmeat umożliwia filtrowanie wyników przeszukiwania, co dodatkowo pozwala zawęzić zbiór dostępnych narzędzi. Początkowe wyniki obejmują oprogramowanie dla różnych systemów operacyjnych (w tym innych niż Linux), a także projekty na różnych etapach reali- zacji. W tej sytuacji podjąłem decyzję o ograniczeniu przeszukiwania do projektów tworzonych z myślą o systemie Linux, projektów dojrzałych i takich, które są oferowane zgodnie z licencją Open Source, zaakceptowaną przez organizację OSI. (Witryna Freshmeat domyślnie odnajduje także oprogramowanie komercyjne). W ten sposób ograniczyłem liczbę projektów do 12 — wybór spośród takiej liczby edytorów jest dużo prostszy. Bliższa analiza wyników ujawniła jednak, że część projektów nie do końca odpowiada moim oczekiwaniom i wynika z dość szerokiej inter- pretacji wyrażenia word processor. Po zastosowaniu kilku dodatkowych filtrów byłem w stanie zidentyfikować kilka znanych mi wcześniej, sprawdzonych projektów wysokiej jakości, np. edytor AbiWord, oraz kilka projektów, o których do tej pory nie słyszałem. Wyniki nie obejmowały jed- nak tak ważnych projektów jak pakiet OpenOffice, w którym pisałem tę książkę. Okazało się, że wspomniany pakiet nie znalazł się w wynikach przeszukiwania, ponieważ należy do kategorii Office/Business — Office Suites, a nie Word Processors. Moje doświadczenia pokazały, że jeśli nie możemy odnaleźć interesującego nas projektu, nie powinniśmy rezygnować, tylko starać się szu- kać do skutku. 1.3.2. Formaty dystrybucji oprogramowania Kiedy już uda nam się odnaleźć potrzebne oprogramowanie, najprawdopodobniej staniemy przed kolejnym ważnym wyborem. Dojrzałe projekty z reguły oferują pakiety w postaci gotowej do zainstalowania, zwykle w co najmniej jednym formacie. Mniej dojrzałe projekty często mają postać kodu źródłowego lub plików binarnych, zawartych w pliku archiwalnym. Okazuje się, że sam for- mat bywa cenną wskazówką sugerującą, z jakim pakietem mamy do czynienia. Pobieranie pliku pakietu dojrzałego oprogramowania można porównać z kupowaniem nowego samochodu — ponieważ nie wiemy, jak to działa, ograniczamy się do przekręcenia kluczyka w stacyjce. Pobie- ranie archiwum z plikami źródłowymi lub binarnymi bardziej przypomina kupowanie używanego samochodu — jeśli niewiele wiemy o samochodach, tak naprawdę nie wiemy, co kupujemy. Jeśli jakiś projekt obejmuje pakiet gotowy do natychmiastowej instalacji, zwykle jest to sygnał o dojrzałości tego projektu. Co więcej, istnienie takiego pakietu sugeruje, że cykl wydań danego projektu jest dość stabilny. Gdyby nowe wydania tego projektu pojawiały się co tydzień, najpraw- dopodobniej nikt nie zawracałby sobie głowy tworzeniem pakietów. Dysponując plikiem pakietu oprogramowania i odrobiną szczęścia najprawdopodobniej będziemy w stanie od razu zainsta- lować i uruchomić nowe narzędzie. Okazuje się jednak, że podobnie jak w przypadku nowych samochodów, szybko możemy się przekonać, iż dokonany wybór nie był najlepszy. 1.4. Wprowadzenie do tematyki plików archiwalnych 33 Alternatywą dla pliku pakietu jest plik archiwum (plik archiwalny). W projektach tworzonych z myślą o systemie operacyjnym Linux archiwa z reguły mają postać skompresowanych plików z rozszerzeniem .tar. Plik archiwalny (ang. archive file) jest kolekcją plików upakowanych w jed- nym pliku za pomocą narzędzia archiwizującego, czyli np. polecenia tar. Tego rodzaju pliki z reguły są dodatkowo kompresowane za pomocą programu gzip, co pozwala oszczędzić cenną przestrzeń na dysku — tak przygotowane pliki określa się mianem plików tar. Pliki tar są preferowanym formatem dystrybucji kodu źródłowego projektów. Ich tworzenie i stosowanie jest bardzo proste, a obsługa programu tar nie stanowi problemu dla żadnego pro- gramisty. Dużo rzadziej mamy do dyspozycji pliki tar obejmujące binarne pliki wykonywalne. Należy tego rozwiązania unikać, chyba że dobrze wiemy, co tak naprawdę robimy. Pliki tar po- winny być przekazywane osobom, które dysponują pewną wiedzą o programowaniu i admini- stracji systemami. 1.4. Wprowadzenie do tematyki plików archiwalnych Podczas pobierania i instalacji oprogramowania open source w pewnym momencie zetkniemy się z plikiem archiwalnym w tej czy innej formie. Mianem pliku archiwalnego określamy każdy plik zawierający kolekcję innych plików. Użytkownicy systemu operacyjnego Windows zapewne znają dominujące na tej platformie narzędzie archiwizujące PKZip. Jego odpowiedniki pracujące w systemach Linux działają podobnie, z tą różnicą, że nie oferują możliwość kompresji. Narzędzia archiwizujące systemu Linux koncentrują się na samej archiwizacji i pozostawiają kompresję innym narzędziom (zwykle gzip lub bzip2). Na tym polega filozofia platformy Unix. Ponieważ pracujemy w systemie Linux, mamy oczywiście szerszy wybór narzędzi archiwi- zujących. Jako konsumenci oprogramowania open source nie powinniśmy się jednak wykazywać przesadną wybrednością. Mimo że w naszej pracy będziemy mieli do czynienia przede wszystkim z plikami tar, warto przynajmniej wiedzieć o istnieniu innych narzędzi. Narzędziom archiwizującym stawiamy większe wymagania niż tylko te związane ze składo- waniem nazw i danych plików. Oprócz ścieżek i danych archiwum musi obejmować metadane właściwe dla poszczególnych plików. Przez określenie metadane (ang. metadata) rozumiemy właściciela pliku, grupę i inne atrybuty (w tym uprawnienia odczytu, zapisu i wykonywania). Narzędzie archiwizujące rejestruje wszystkie te informacje, co oznacza, że stwarza możliwość usunięcia pliku z systemu plików i jego późniejsze przywrócenie z pliku archiwalnego bez utraty jakichkolwiek informacji. Jeśli umieścimy w archiwum jakiś plik wykonywalny, po czym usu- niemy go z systemu plików, odtworzenie tego pliku z archiwum umożliwi nam jego ponowne uruchomienie. W systemie Windows samo rozszerzenie pliku określa, czy mamy do czynienia 34 Rozdział 1 • Pobieranie i instalacja narzędzi oferowanych w trybie open source z plikiem wykonywalnym (tak jest np. w przypadku plików .exe); w systemie Linux o możliwości uruchamiania plików decydują ich metadane, dlatego konieczne jest składowanie tych informacji przez narzędzie archiwizujące. Najbardziej popularne narzędzia archiwizujące, stosowane w systemie Linux, wymieniono i krótko opisano w tabeli 1.1. Zdecydowanie najpopularniejszym formatem archiwizowania pli- ków jest tar. Nazwa tego narzędzia i formatu jest skrótem od angielskiego określenia tape archive, czyli nazwy stosowanych kiedyś systemów archiwizowania danych na taśmach magnetycznych. Narzędzie tar jest obecnie wykorzystywane przede wszystkim w roli uniwersalnego programu do archiwizacji kolekcji plików w ramach pojedynczych plików wynikowych. Mniej popularną alter- natywą dla tego narzędzia jest cpio, czyli program realizujący te same zadania, ale stosujący zupeł- nie odmienną składnię poleceń. Istnieje też narzędzie pax, które jest zgodne ze standardem POSIX i które potrafi prawidłowo interpretować pliki narzędzia tar, pliki archiwalne programu cpio i oczywiście pliki we własnym formacie. Co prawda, nigdy nie spotkałem się z dystrybucją w for- macie narzędzia pax, warto jednak o nim wspomnieć dla kompletności prowadzonych rozważań. TABELA 1.1. Najpopularniejsze narzędzia archiwizujące Narzędzie Uwagi tar cpio ar Najbardziej popularne narzędzie Narzędzie stosowane wewnętrznie przez format RPM, niewykorzystywane nigdzie indziej Narzędzie wykorzystywane wewnętrznie przez mechanizm pakujący Debiana; poza tym systemem stosuje się je wyłącznie dla bibliotek budowanego oprogramowania. Narzędzie ar nie składuje w archiwach informacji o ścieżkach Warto poświęcić trochę uwagi narzędziu ar, które jest wykorzystywane przede wszystkim do tworzenia bibliotek z kodem obiektów stosowanych w procesie wytwarzania oprogramowania, ale także do tworzenia plików pakietów na potrzeby dystrybucji systemu Debian. W internecie można bez trudu odnaleźć zarówno narzędzia przetwarzające pliki .zip, tworzone za pomocą aplikacji PKZip, jak i mniej znane narzędzia generujące skompresowane archiwa, np. lha. Warto jednak pamiętać, że podane formaty niemal nigdy nie są wykorzystywane do dystry- buowania programów open source dla systemu Linux. Oznacza to, że widząc archiwum z roz- szerzeniem .zip, możemy być niemal pewni, że jest przeznaczone dla systemu operacyjnego firmy Microsoft. W większości przypadków musimy dysponować dwiema informacjami na temat poszcze- gólnych formatów: jak sprawdzić zawartość archiwum i jak wyodrębnić pliki z tego archiwum. 1.4. Wprowadzenie do tematyki plików archiwalnych 35 W przeciwieństwie do narzędzi archiwizujących, stosowanych w systemach operacyjnych Win- dows, które oferują rozmaite, często niebezpieczne funkcje dodatkowe, programy archiwizujące przeznaczone dla systemów Linux koncentrują się wyłącznie na podstawowych funkcjach. W tej sytuacji przeglądanie i rozpakowywanie plików archiwalnych jest dość bezpieczne (szczególnie jeśli nie dysponujemy uprawnieniami administratora). Mimo to zawsze warto przyjrzeć się zawartości archiwum przed przystąpieniem do wypakowywania plików, aby przypadkiem nie nadpisać tak samo nazwanych plików już istniejących. Identyfikacja plików archiwalnych 1.4.1. Archiwa pobierane z internetu najczęściej są kompresowane z myślą o oszczędzaniu przepusto- wości łączy. Istnieje szereg konwencji nazewniczych, stosowanych dla plików skompresowanych (część spośród tych konwencji przedstawiono w tabeli 1.2). TABELA 1.2. Konwencje nazewnictwa plików archiwalnych Rozszerzenia .tar .tar.gz, .tgz .tar.bz2 .tar.Z, .taz .ar, .a .cpio Typ Nieskompresowany plik archiwalny narzędzia tar Plik archiwalny narzędzia tar, skompresowany za pomocą narzędzia gzip Plik archiwalny narzędzia tar, skompresowany za pomocą narzędzia bzip2 Plik archiwalny narzędzia tar, skompresowany za pomocą polecenia compress systemu Unix Plik archiwalny narzędzia ar, stosowany przede wszystkim podczas tworzenia oprogramowania Nieskompresowany plik archiwalny narzędzia cpio W razie wątpliwości warto pamiętać o przydatnym poleceniu file. Wspomniane narzędzie wprost doskonale nadaje się do identyfikacji plików, których nazwy niewiele nam mówią o fak- tycznej zawartości. Z tego rodzaju sytuacjami mamy do czynienia np. wtedy, gdy nasza przeglą- darka internetowa lub inne narzędzie tak modyfikuje nazwy plików, że ich rozpoznanie staje się kłopotliwe. Przypuśćmy, że dysponujemy skompresowanym archiwum narzędzia tar, nazwanym foo.x. Nazwa ta nie informuje o zawartości tego pliku. W tej sytuacji można skorzystać z następu- jącego polecenia: $ file foo.x foo.x: gzip compressed data, from UNIX, max compression 36 Rozdział 1 • Pobieranie i instalacja narzędzi oferowanych w trybie open source Teraz możemy być pewni, że nasz plik skompresowano za pomocą narzędzia gzip, nadal jednak nie wiemy, czy mamy do czynienia z plikiem wygenerowanym przez narzędzie tar. Możemy spróbować rozpakować ten plik za pomocą narzędzia gzip i ponownie użyć polecenia file. Lepszym rozwiązaniem będzie jednak zastosowanie opcji polecenia -z: $ file -z foo.x foo.x: tar archive (gzip compressed data, from UNIX, max compression) Tera dokładnie wiemy, czym dysponujemy. Z reguły użytkownicy kierują się intuicyjnymi konwencjami nazewnictwa plików, a same nazwy w zdecydowanej większości przypadków są podstawowym źródłem wiedzy o rodzajach plików archiwalnych i sposobie ich opracowania. 1.4.2. Przeglądanie zawartości plików archiwalnych Pliki archiwalne śledzą informacje o zawieranych plikach w formie swoistego spisu treści, który można uzyskać (co jest dość wygodne), stosując flagę -t. Jest ona obsługiwana przez wszystkie wspomniane do tej pory narzędzia archiwizujące. Poniżej przedstawiono sposób użycia tej flagi na przykładzie instalacji cron systemu Debian: $ tar -tzvf data.tar.gz drwxr-xr-x root/root 0 2001-10-01 07:53:19 ./ drwxr-xr-x root/root 0 2001-10-01 07:53:15 ./usr/ drwxr-xr-x root/root 0 2001-10-01 07:53:18 ./usr/bin/ -rwsr-xr-x root/root 22460 2001-10-01 07:53:18 ./usr/bin/crontab drwxr-xr-x root/root 0 2001-10-01 07:53:18 ./usr/sbin/ -rwxr-xr-x root/root 25116 2001-10-01 07:53:18 ./usr/sbin/cron W powyższym przykładzie dodatkowo użyto opcji -v, wymuszającej dołączanie dodatkowych informacji podobnych do tych znanych z długich list polecenia ls. Dane wyjściowe obejmują uprawnienia właściwe dla poszczególnych plików (w pierwszej kolumnie) i informacje o własności (w drugiej kolumnie). Kolejna, trzecia kolumna zawiera rozmiary plików (wyrażone w bajtach); warto zwrócić uwagę na katalogi, których rozmiar wynosi 0. Analizując zawartość pliku archiwal- nego, należy zwracać szczególną uwagę na własność i uprawnienia właściwe dla poszczególnych plików. Podstawowe
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Linux. Niezbędnik programisty
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: