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.
  int 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.