SOP121/ćw - temat D.

Unix: funkcje systemowe.

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.cc -o prog01

prog01

PATH=$PATH:.

Tworzenie procesow, uruchamianie programow; 
fork(), wait(), exec*(), exit()

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

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

    mumia - początek
    mumia - koniec

Zadanie 52 (**)

Teraz pokażemy, jak w procesie potomnym uruchomić inny program;
służą do tego celu funkcje z rodziny exec*() ...

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 wykonaneim 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 2 (patrz niżej)
   }

Zadanie 53

 
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 );

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);

Zadanie 55

ls -l kat1
ps -O ppid,user

Operacje na plikach, przeadresowywanie;
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 );

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",
    // 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 57

Zadanie 58

      ls -l kat1 >plik.txt
      cat <plik_we.txt >plik_wy.txt

Sygnały;
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

Łącza.

Łącza nienazwane.

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 60

Zadanie 61 (*)

Poniżej przedstawiam programy pozwalające uruchamiać potoki ...

--> co to jest potok ?
Przez potok rozumiemy kilka procesów, np p1, p2, p3, p4, komunikujących się przez łącza
miedzy parami procesow: p1->-p2, p2->-p3, p3->-p4. Informacja płynie więc w jedną
stronę jak woda w potoku.
 

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 "potok.cc" ?
2. jaką własność powinien mieć program uruchamiany "w środku" potoku  przy pomocy jednego z powyższych programów aby dane "przepływały" przez potok ? (ma to związek z stdin i stdout)
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 zdefiniowana jako {},

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

Zadanie 63 (**)

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