Sisteme de Operare (pe scurt)

Fișiere

Deschidere

  int open(const char *pathname, int flags);

• Deschide fișierul aflat la calea pathname cu opțiunile date în flags.
• Returnează un descriptor la fișierul respectiv sau -1 în caz de eroare.
• Câteva flag-uri importante:
  • O_RDONLY, O_WRONLY, O_RDWR - deschide fișierul în modul Read-Only, Write-Only, respectiv Read-Write.
  • O_APPEND - deschide fișierul în apendare, adică înainte de fiecare write() cursorul de scriere se va muta la sfârșitul fișierului.
  • O_EXCL - în cazul în care fișierul nu există, open() va returna -1 (eroare)
  • O_CREAT - creează fișierul în cazul în care acesta nu există. De menționat că dacă se folosește acest flag, trebuie menționate și drepturile pe care le va avea fișierul, deci trebuie folosit apelul de mai jos cu 3 parametrii.

  int open(const char *pathname, int flags, mode_t mode);

• La fel ca mai sus, numai că mai ai un parametru suplimentar pentru specificat drepturile fișierului în cazul în care acesta este creat. (ai folosit O_CREAT în lista de flags).

Citire

  ssize_t read(int fd, void *buf, size_t count);

• Citește din fișierul având descriptorul fd un număr de count bytes și îi pune în locul din memorie rezervat la adresa buf. (ssize_t e echivalent cu int)
• Returnează numărul de bytes citiți sau -1 în caz de eroare.

Scriere

  ssize_t write(int fd, const void *buf, size_t count);

• Scrie în fișierul având descriptorul fd un număr de count bytes care încep la adresa specificată de buf.
• Returnează numărul de bytes scriși sau -1 în caz de eroare.

Închidere

  int close(int fd);

• Închide fișierul având descriptorul fd.
• Returnează 0 dacă apelul se termină cu succes, -1 altfel. (NOTĂ: Nu e cazul să verifici dacă apelul a eșuat sau nu).

Directoare

Deschidere

  DIR *opendir(const char *name);

• Deschide directorul dat la calea name.
• Returnează un fel de structură ajutătoare ce va fi folosită ulterior la alte funcții cu directoare. (spre exemplu în readdir() mai jos). În caz de eroare, returnează NULL.

Citire

  struct dirent *readdir(DIR *dirp);

• Citește conținutul directorului deschis mai înainte.
• Structura dirent este definită astfel:

  struct dirent
  {
      ino_t d_ino;      // Numărul i-nodului.
      char d_name[256]; // Numele fișierului.
      ...               // Alte date neimportante.
  };

• Returnează o structură ce conține date despre un fișier din acest director. La următoarea apelare a lui readdir() se va obține o altă structură a altui fișier din director, și tot așa până cand nu mai sunt fișiere, caz în care se returnează NULL.

Închidere

  int closedir(DIR *dirp);

• Închide directorul reprezentat de dirp.
• Returnează 0 dacă apelul s-a executat cu succes, -1 altfel. La fel ca la close(), nu e cazul să verifici dacă apelul s-a executat sau nu cu succes.

Pipes (aka "Tuburi")

Crearea

  int pipe(int pipefd[2]);

• Primește ca parametru un vector de doi întregi în care se pun doi descriptori:
  • Unul pentru citire (pipefd[0])
  • Unul pentru scriere (pipefd[1])
• Se folosesc aceleași apeluri de I/O ca la fișiere, adică read() pentru citire din pipe și write() pentru scriere în pipe.
• Returnează 0 în caz de succes, -1 în caz de eroare.

Închiderea

Se face asemănător fișierelor, numai că se închid ambele capete:

  close(pipefd[0]);
  close(pipefd[1]);

Shared Memory (Memorie Partajată)

Crearea

  int shmget(key_t key, size_t size, int shmflg);

• Ia id-ul unui segment de memorie partajată dat de cheia key, având mărimea size. În shmflg trebuie specificată cel puțin masca de drepturi (de obicei se folosește 0666, adică citire și scriere pentru toți).
• Dacă se vrea creearea unui nou segment de memorie partajată, trebuie menționat IPC_CREAT în lista de flaguri. Totodată, dacă se vrea ca memoria partajată să nu poată fi accesată decât de procesele fiu, valoarea parametrului key trebuie să fie IPC_PRIVATE.
• Returnează un fel de descriptor ce poate fi folosit de apelurile de mai jos sau -1 în caz de eroare.

Atașarea

  void *shmat(int shmid, const void *shmaddr, int shmflg);

• Atașează segmentul de memorie în procesul curent. shmid este identificatorul segmentului de memorie obținut anterior cu shmget(), shmaddr este adresa unde va fi atașat segmentul (e recomandat să fie NULL; astfel va aloca sistemul de operare automat memoria), iar în shmflg ar trebui să fie niște flag-uri, dar nu observ niciunul important, deci îl lași 0.
• Returnează un pointer la începutul segmentului de memorie în caz de succes, (void *) -1 în caz de eroare.
• După apel, pointer-ul returnat va putea fi folosit ca orice vector în C.

Detașarea

  int shmdt(const void *shmaddr);

• Detașează segmentul de memorie care a fost atașat la adresa shmaddr.
• A nu se confunda cu distrugerea completă a segmentului de memorie. El încă mai există în sistem, dar nu în proces. Se poate, desigur, reatașa folosind același shmid returnat la început de shmget().
• Returnează 0 în caz de succes, -1 în caz de eroare.

Distrugerea

  // Funcția pentru controlul memoriei partajate.
  int shmctl(int shmid, int cmd, struct shmid_ds *buf);

  // Apelul pentru distrugerea segmentului de memorie.
  shmctl(shmid, IPC_RMID, NULL);

• Sterge din sistem segmentul și toate datele acestuia.
• Returnează 0 în caz de succes, -1 în caz de eroare. shmctl() poate returna și alte valori, dar în acest cazul de stergere, nu.

Procese

Crearea unui proces fiu

  pid_t fork(void);

• Crează un proces fiu din punctul apelării.
• Returnează PID-ul procesului fiu în tată, 0 în procesul fiu sau -1 în caz de eroare.

Așteptarea terminării unui proces fiu

  pid_t wait(int *status);

• Așteaptă terminarea unui proces fiu și îi setează în status date despre terminarea sa. Se poate obține direct codul de retur, apelând macroinstrucțiunea (= un fel de funcție) WIFEXITED(status);.
• Returnează PID-ul primului proces fiu care și-a terminat execuția, -1 în caz de eroare.

Substituirea unui proces curent cu altul

  int execve(const char *filename, char *const argv[], char *const envp[]);

• Execută fișierul aflat la calea filename, punându-i argumentele și environment-ul terminate printr-un NULL în vectorul argv, respectiv envp.
• Returnează -1 în caz de eroare.

Semnale

Transmiterea unui semnal

  int kill(pid_t pid, int sig);

• Transmite procesului identificat prin pid semnalul sig.
• Returnează 0 dacă apelul s-a executat cu succes, -1 în caz de eroare.

"Mulțimea" de semnale

  // Tipul:
  sigset_t set;

  // Funcțiile ce execută operații peste mulțimea respectivă:
  int sigemptyset(sigset_t *set);
  int sigfillset(sigset_t *set);
  int sigaddset(sigset_t *set, int signum);
  int sigdelset(sigset_t *set, int signum);
  int sigismember(const sigset_t *set, int signum);

Mascarea semnalelor

  int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

Montarea unui handler pentru un anumit semnal

  int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);