SOP322/ćw - temat B

Funkcje systemowe Unixa - powtórka?

Pojęcia Unix-owe, które powinniśmy rozumieć:

• proces macierzysty i potomny, uruchamianie programów:
• tworzenie procesu potomnego, fun. sys. fork()
• oczekiwanie na zakończenie procesu potomnego, fun. sys. wait()
• uruchamianie programów w procesie, fun. sys. exec*()
• deskryptory do plików, przeadresowywanie, fun. sys. dup2()
• łącza nienazwane; deskryptory do końcówek łączy, prawa rządzące łączami
• potoki; jak są zaimplementowane, automatyczne kończenie się procesów w potoku
• parametry i środowisko (zmienne środowiska) procesu/programu

1. Wstęp.

Informacje na temat funcji systemowych znajdują się w rozdziale drugim manuala UNIX-a:

man 2 fork
man 2 read

man 3 printf

gcc prog01.c -o prog01
  // dla jezyka C (programy w C maja rozszerzenie .c)
  // w opcji -o podaje sie nazwe pliku wykonywalnego
g++ prog01.cc -o prog01
  // dla jezyka C++ (programy w C++ maja rozszerzenie .cc)

prog01

PATH=$PATH:.

Jeśli w trakcie działania funkcji systemowej wystąpi błąd to zwraca ona wartość (-1), ponadto globalna zmienna errno jest ustawiana na odpowiednia wartość (opisującą błąd). Słowne opisy możliwych wartości zmiennej errno można zobaczyć w pliku "/usr/include/errno.h". Opis możliwych wartości znajduje się także na stronach manuala, dotyczących konkretnej funkcji systemowej. Słowny opis błędu można wypisać na ekranie funkcją:  perror("tekst pomocniczy").

1.1. Literatura.

2. Tworzenie procesów, uruchamianie programów; 
funkcje systemowe: fork(), wait(), exec*(), exit().

Opis funkcji systemowych:

int fork ( void );

• w procesie potomnym fork() zwraca 0
• w procesie macierzystym fork() zwraca PID procesu potomnego

void exit(int kod_zakończenia)

int wait ( int *status );

niech: status == HHLL (4 cyfry hex)

• potomek zakończył się przez wywołanie "exit(y)"; wtedy HH=y, LL=0
• potomek zakończył się z powodu sygnału; wtedy HH=0, 7-my bit LL zawiera 1 jeśli wygenerowano plik "core", bity 6-0 LL zawierają nr sygnału

Zadanie 35

1. gdy kończy się z powodu wywołania "exit()"
2. gdy kończy się z powodu otrzymania sygnału SIGINT (czyli nr 2)

   ps -O ppid
       PID PPID CMD
       111 222 fork01
       333 111 fork01

   kill -int 333

Teraz pokażemy, jak w procesie potomnym uruchomić inny program ...

int exec*(...)

int execl (
        const char *path,
        const char *arg,
        ...  );
int execv (
        const char *path,
        char * const argv[ ] );
int execle (
        const char *path,
        const char *arg,
        ...
        char * const envp[ ] );
int execve (
        const char *path,
        char * const argv[ ],
        char * const envp[ ] );
int execlp (
        const char *file,
        const char *arg,
        ... );
int execvp (
        const char *file,
        char * const argv[ ] );

   "v" oznacza, ze parametry są przekazywanie przez tablice wskazań
           char *v[]={"ls", "-l", NULL};
           execv("/bin/ls", v);

   "l" oznacza, ze parametry są przekazywanie przez listę
           execl("/bin/ls", "ls", "-l", NULL);

   "p" nie potrzeba podawać pełnej ścieżki do pliku z programem;
       będzie wykorzystywana zmienna PATH
           execlp("ls", "ls", "-l", NULL);

   "e" oznacza, ze podajemy nowe środowisko za pomocą tablicy wskazań
       do napisów "zmienna=wartosc".
           char *v[]={"zmienna1=wart1", "zmienna2=wart2", NULL};
           execle("./prog", "prog", "par1", "par2", NULL, v);
       UWAGA: jeśli nie ma literki "e" to środowisko pozostaje takie
       jakie było przed wykonaniem exec*() !!!

   main(int argc, char *argv[], char *env[]) 
   { 
      int i; char **c;
      for(i=0; i<argc; i++) printf("%s\n", argv[i]);
        // wyswietlanie argumentow

      c=env; while(*c) printf("%s\n", *c++);
        // wyświetlanie środowiska

      c=environ; while(*c) printf("%s\n", *c++);
        // wyświetlanie środowiska innym sposobem
   }

Teraz mały przykład (fork02.cc). W przykładzie tym tworzona jest zmienna środowiska o nazwie QWERTY i wartości 123456; następnie proces tworzy proces potomny który dziedziczy m.in. zmienne środowiska, a więc i zmienną QWERTY. Potem proces potomny uruchamia program "env" wyświetlający zmienne środowiska. Po wywołaniu execl() proces posiada te same zmienne środowiska co przed wywołaniem execl(), dlatego zmienna QWERTY także zostanie wyświetlona.

Zadanie 37

.........................................................................................

Nieco wyprzedzając, podamy teraz opisy funkcji służących do czytania/pisania z/do otwartego deskryptora udostępniającego plik. Przypomnijmy że każdy proces ma zaraz po uruchomieniu otwarte deskryptory 0, 1, 2 (stdin, stdout, stderr) pozwalające czytać/pisać z/do terminala.

int read( int filedes, void *buffer, int nbytes );

 int write( int filedes, void *buffer, int nbytes );

A oto mały przykład, w którym odczytujemy z stdin co najwyżej 100 znaków i przepisujemy je na stdout (przepisujemy dokładnie tyle znaków ile wczytaliśmy):

    char buf[100]; // deklaracja tablicy 100 znaków
    int i,j;
    i=read(0, buf, 100);
    j=write(1, buf, i);
    printf("i=%i, j=%i\n", i, j);

3. Operacje na plikach, przeadresowywanie;
funkcje systemowe: open(), close(), read(), write(), dup(), dup2().

Pamiętajmy, że w UNIX-ie rozmaite urządzenia (np terminale) są dostępne poprzez pliki - są to tzw pliki specjalne, znajdujące się zwyczajowo w katalogu "/dev".  Przykłady:  dostęp do terminala można uzyskać otwierając plik  "/dev/tty??" i pisząc lub czytając z tego pliku;  "surowy" dostęp do dyskietki (traktowanej jako ciąg bajtów) uzyskujemy otwierając plik "/dev/fd0".

Istnieją deskryptory o specjalnym znaczeniu: 0, 1, 2 - standardowe wejście, wyjście i wyjście błędów.  Jeśli uruchomimy program z powłoki poleceniem:

prog01

prog01 >plik.txt

Oto pojęcia niezbędne aby posługiwać się plikami pod Unix-em:
        -> bieżąca pozycja w otwartym pliku
        -> tablica deskryptorów procesu (deskryptory to indeksy elementów tej tablicy)
        -> tablica plików (tu przechowuje się "bieżącą pozycję")
        -> tablica i-węzłów (każdy element tej tablicy identyfikuje plik)

Każdy proces ma własną tablicę deskryptorów.
W danej maszynie istnieje jedna tablica plików i jedna tablica i-węzłów.

Na poniższym rysunku deskryptory 10,11,12 udostępniają ten sam plik "plik.txt".  Jeśli teraz przesuniemy bieżącą pozycję poprzez desk 10 to ma to wpływ na bieżącą pozycje poprzez desk 11 lecz nie poprzez desk 12.  Gdy otwieramy dwukrotnie ten sam plik funkcją open()  - opisaną poniżej - to otrzymamy różne pozycje w tablicy plików.  Gdy duplikujemy deskryptor funkcją dup()/dup2() lub wykonujemy fork() to otrzymamy tę samą pozycję w tablicy plików.
 

Opis funkcji systemowych związanych z plikami:

int open( const char *path, int oflag [ , mode_t mode ] );

- File Acces Flag (tylko jeden bit ustawiony) 
       O_RDONLY - The file is open for reading only. 
       O_WRONLY - The file is open for writing only. 
       O_RDWR - The file is open for reading and writing. 

- File Status Flag 
       --specjalne przetwarzanie przy otwieraniu pliku 
            O_CREAT - jeśli plik nie istniał to zostanie utworzony 
            O_EXCL  - razem z O_CREAT kończy się błędem, jeśli plik istnieje
            O_TRUNC - jeśli plik istnieje to zostanie "skrócony do zera" 
       --początkowy stan otwartego pliku 
            O_APPEND - bieżąca pozycja pliku jest ustawiana na końcu 
                       przed każdym zapisem 
            O_NONBLOCK, O_NDELAY - fun. sys. dotyczące tego pliku 
                                   nie będą blokować

int close( int filedes );

int read( int filedes, void *buffer, int nbytes );

UWAGA:
Jeśli czytamy z terminala i akurat nie ma nic do przeczytania, to wtedy funkcja read() będzie blokować, tak długo aż nie pojawią się jakieś znaki do przeczytania.  Podobnie, funkcja wait() blokuje proces macierzysty, gdy oczekuje on na zakończenie swojego procesu potomnego.
Blokowanie NIE JEST realizowane przez "aktywne czekanie", lecz przez wprowadzenia procesu w "stan uśpienia"; gdy pożądane zdarzenie się zdarzy to proces zostanie "obudzony"; dzięki temu proces zablokowany podczas wykonywania funkcji systemowej nie zużywa czasu procesora; w systemie może istnieć bardzo wiele procesów w stanie uśpienia lecz nie ma to wpływu na szybkość działania pozostałych procesów !.

int write( int filedes, void *buffer, int nbytes );

int dup( int filedes );
int dup2( int filedes, int new );

int desk=open("plik.txt",O_RDWR|O_CREAT|O_TRUNC,0600); 
dup2(desk,1); 
close(desk); 
write(1,"ABC",3); 
    // to jest zapis na "stdout" (czyli deskryptor 1),
    // ale w rzeczywistości wszystko idzie do "plik.txt",
    // czyli "stdout" zostało przeadresowane do pliku "plik.txt"

    offset:
        o ile przesunąć bieżącą pozycję
    whence: 
        SEEK_SET - względem początku pliku 
        SEEK_CUR - względem bieżącej pozycji 
        SEEK_END - względem końca pliku

Zadanie 38

Zadanie 39

4. Sygnały;
funkcja systemowa: signal().

Sygnały docierające do procesu mogą być:

1. przechwytywane
2. ignorowane
3. obsługiwane standardowo

void (*signal( int sig, void (*function) (int) )) (int);

// to jest procedura obsługi sygnału
void procObslugi(int nr_sygnalu) 
{ printf("obsługa sygnału SIGINT !!!\n"); 
} 

// instalacja proc obsługi
signal(SIGINT,procObslugi);

signal(SIGINT,SIG_IGN);

signal(SIGINT,SIG_DFL);

Co się dzieje z obsługą sygnałów po wykonaniu "fork()" ?

• wszystko działa bez zmian

• przechwytywane będą obsługiwane standardowo (bo nie ma "kodu przechwytującego" !)
• ignorowane będą nadal ignorowane
• obsługiwane standardowo będą nadal obsługiwane standardowo

Zadanie 40

1. uruchamianie komend (programów) z parametrami
           ls -l -d kat1
2. uruchamianie procesów drugoplanowych
           sleep 10 &
3. przeadresowywanie
           ls -l kat1 >plik.txt
           cat <plik_we.txt >plik_wy.txt
4. prawidłowe działanie Ctrl+C

Możesz wykorzystać pliki mini01.cc i mini02.cc (+unix.h) w których jest większość kodu (należy go wyciągnąć z komentarza). Powłoka powinna wyświetlać prompt "$" i w ogóle powinna się zachowywać jak typowa powłoka Unixowa ...
Wskazówki:
ad 1: wprowadzając komendę trzeba między wszystkie słowa wstawiać spacje; można zakończyć mini-powłokę klawiszami Ctrl+D;
ad 2: mini-powłoka powinna czekać na zakończenie procesu pierwszoplanowego, a nie drugoplanowego który się wcześniej skończył (ten element mini-)
ad 4: Ctrl-C powoduje wysłanie sygnału SIGINT; standardowa obsługa sygnału SIGINT to zakończenie procesu; Ctrl-C powinno kończyć proces pierwszoplanowy, natomiast nie powinno kończyć procesów drugoplanowych oraz samej mini-powłoki.
Do sprawozdania wstaw funkcję main() oraz wydruki eksperymentów stwierdzające poprawność działania mini-powłoki:

ls >plik1.txt
cat <plik1.txt >plik2.txt
cat <plik2.txt

sleep 100
Ctrl+C
ps

sleep 50 &
sleep 100 &
ps
sleep 5
ps

5. Łącza.

5.1. Łącza nienazwane;
funkcja systemowa: pipe().

int pipe ( int filedes[2] );
--> funkcja ta tworzy łącze i przydziela dwa deskryptory, dające dostęp do jego końcówek, które umieszcza w podanej przez parametr tablicy 2 integer-ów:

• filedes[0] - końcówka do czytania
• filedes[1] - końcówka do pisania

--> jeśli ktoś ma łącze otwarte do zapisu, lecz jest ono PUSTE - to fun. "read()" blokuje, tak długo aż nie pojawią się jakies znaki. Jeśli w pewnym momencie okaże się, ze nie ma procesow, ktore maja to łącze otwarte do zapisu to fun. "read()" przestanie blokować i zwroci 0.

--> jeśli piszemy funkcją "write()" do łącza, ktorego NIKT nie ma otwartego do czytania, to jest wysylany sygnal SIGPIPE do procesu wywołującego write(), a sama funkcja "write()" kończy dzialanie z błędem.

--> jesli ktoś ma łącze otwarte do czytania, lecz uległo ono PRZEPEŁNIENIU, to fun. "write()" bedzie blokować, o ile liczba zapisywanych danych jest <= od stałej PIPE_BUF (jeśli jest większa od PIPE_BUF to write() może zapisać mniej niż zażądaliśmy ! [wg książki Bacha, str 127]).  Jesli w pewnym momencie okaże się, że nie ma procesów, ktore maja to łącze otwarte do czytania to fun. "write()" zakonczy się błędem i do procesu wywołującego write() będzie wyslany SIGPIPE.

Przykład użycia pipe() w programie, w języku C:

  struct {int do_czytania,do_pisania;} L;
    // struktura "L" pozwala na bardziej czytelny dostęp do końcówek łącza
    // niż tablica 2 integer-ów !
  pipe((int *)&L);

  write(L.do_pisania, "ABC", 3);
    // zapis do łącza

  char buf[10]; int i;
  i=read(L.do_czytania, buf, 10);
    // odczyt z łącza

Zadanie 41

5.2. Potoki.

Przyklad "potok.cc". Jest to program tworzący potok z komend podanych jako parametry, w którym NIE MOŻNA podawać parametrów komend. Sposób użycia:

   potok ls cat cat cat cat

   potok2 ls -l \| cat \| cat \| grep txt \| cat

1. jak wygląda "pokrewieństwo" procesów tworzonych przez "potok2.cc" ?
2. jaką własność powinien mieć program uruchamiany "w środku" potoku  przy pomocy jednego z powyższych programów aby wszystko działało tak jak się tego spodziewamy ? (ma to związek z stdin i stdout czyli deskryptorami 0 i 1)
3. jeśli wydamy polecenie "potok cat cat cat cat" to wprowadzane linie tekstu będą przepisywane na terminal; jeśli naciśniemy Ctrl-D to 4 procesy "cat" będą się prawidłowo i po kolei kończyć; dlaczego tak się dzieje ? - wyjaśnij to dokładnie
4. co by się stało i dlaczego gdyby funkcja ZamknijLacza() była "pusta",

po uruchomieniu
     potok2 cat \| cat \| cat
i po wpisaniu kilku linii tekstu oraz naciśnięciu Ctrl-D ?
 

UWAGA: Ctrl-D nie powoduje wysłania sygnału jak to czyni Ctrl-C czy też Ctrl-Z !.

Zadanie 43

    ls -l -a | cat | grep txt | sort | more

    extern char **environ;

   cykl ile_proc prog -par1 -par2

   cykl 20 leaderel

Różne wnioski:

Zadanie 46 (*)

#include <time.h>
timeval czas0, czas1;
gettimeofday(&czas0,0);
//
// operacje których czas mierzymy
//
gettimeofday(&czas1,0);
RoznicaCzasu(czas0, czas1);

void RoznicaCzasu(timeval &c0, timeval &c1)
{
  if( c0.tv_sec==c1.tv_sec)
    printf("czas=%li\n", (long)(c1.tv_usec-c0.tv_usec));
  else
    printf("czas=...\n");
}

cykl 10 testcyklu
cykl 20 testcyklu
cykl 40 testcyklu