Wywołania systemowe Uniksa: Różnice pomiędzy wersjami

== Otwieranie i zamykanie plików - <tt>open</tt>, <tt>create</tt> i <tt>close</tt> ==

Pliki otwiera się za pomocą trzyargumentowego <tt>open</tt>, którego definicja znajduje się w <tt>fcntl.h</tt>[http://lxr.linux.no/linux/include/asm-generic/fcntl.h]:

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

 

Pierwszy argument <tt>pathname</tt> oznacza ścieżkę do pliku.

'''Opcjonalny''' trzeci - uprawnienia dla nowo utworzonych plików.

<tt>open</tt> należy do nielicznych wywołań systemowych dopuszczających pomijanie argumentu:

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

 

Istnieje też specjalna postać <tt>open</tt>:

int creat(const char *pathname, mode_t mode);

równoważna <tt>open(pathname, O_CREAT|O_WRONLY|O_TRUNC, mode)</tt>

 

W przypadku błędu zwracają <tt>-1</tt> a <tt>[[errno]]</tt> jest ustawiana na kod błędu.

 

int close(int fd);

zamyka otwarty deskryptor pliku. W dawnych czasach <tt>close</tt> nie zwracało kodu błędu,

więc nikt go nie sprawdzał. Współcześnie zwraca kod błędu, co z punktu widzenia architektury systemu

 

Katalogi tworzy się za pomocą:

int mkdir(const char *pathname, mode_t mode);

gdzie <tt>pathname</tt> i <tt>mode</tt> mają znaczenie podobne jak w <tt>creat</tt>.

 

Pliki urządzeń tworzy się za pomocą:

int mknod(const char *pathname, mode_t mode, dev_t dev);

gdzie <tt>pathname</tt> i <tt>mode</tt> mają to samo znaczenie a <tt>dev</tt> to informacje o typie urządzenia.

 

== Zakończenie pracy - <tt>_exit</tt> ==

void _exit(int status);

służy do zakończenia pracy programu.

<tt>status</tt> zostanie zwrócony jako kod wyjścia.

 

== Zarządzanie pamięcią - <tt>brk</tt> ==

int brk(void *end_data_segment);

 

Wywołanie <tt>brk</tt> jest bardzo ważne i widać je często w wynikach <tt>strace</tt>,

=== <tt>read</tt> ===

<tt>read</tt> jest zdefiniowany w <tt>unistd.h</tt>[] jako:

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

 

Pierwszym argumentem jest otwarty deskryptor piku, drugim bufor, do którego mają się dostać zapisywane dane,

=== <tt>write</tt> ===

<tt>write</tt> jest zdefiniowany w <tt>unistd.h</tt> jako:

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

 

Argumenty mają takie samo znaczenie jak w <tt>read</tt> - <tt>write</tt> pisze do deskryptora <tt>fd</tt> co najwyżej <tt>count</tt> bajtów z bufora <tt>buf</tt> i zwraca liczbę zapisanych bajtów. W przypadku <tt>write</tt> liczba <tt>0</tt> jest jednak równie poprawna jak pozostałe i można próbować dalej.

 

Nic nie stoi jednak na przeszkodzie, żeby kernel sam zajął się tą operacją - służą temu zdefiniowane w <tt>sys/uio.h</tt> wywołania:

int readv(int filedes, const struct iovec *vector, size_t count);

int writev(int filedes, const struct iovec *vector, size_t count);

 

Pierwszy argument to tradycyjnie otwarty deskryptor pliku, drugi to wskaźnik na tablicę wektorów,

trzeci zaś to ilość elementów tej tablicy. Element ma postać:

 

struct iovec {

void *iov_base;

size_t iov_len;

};

 

gdzie <tt>iov_base</tt> to adres a <tt>iov_len</tt> rozmiar bufora.

 

Procedura naszego serwera miałaby wówczas postać:

struct iovec io[2];

io[0].iov_base = http_headers;

io[1].iov_len = file_headers_size;

writev (fd, io, 2);

 

<tt>readv</tt> i <tt>writev</tt> pojawiły się po raz pierwszy w systemie [[4.2BSD]].

=== <tt>sendfile</tt> ===

Kolejny często występujący problem wydajności przedstawia następujący fragment kodu:

bytes_read = read (fd1, buf, buf_size);

write (fd2, buf, bytes_read);

 

Często występuje konieczność przerzucenia ogromnej ilości danych z jednego deskryptora do drugiego.

Jednym problemem jest podwojona liczba wywołań systemowych, ale jeszcze poważniejse jest zupełnie

bezużyteczne kopiowanie danych. Przeciwdziałać temu ma zdefiniowany w nagłówku <tt>sys/sendfile.h</tt>:

ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

 

<tt>out_fd</tt> to deskryptor wyjściowy, <tt>in_fd</tt> - wejściowy, <tt>offset</tt> to wskaźnik na

 

Przykład działania:

#include <sys/sendfile.h>

#include <unistd.h>

return 0;

}

 

Ponieważ dane nie wędrują przez pamięć procesu, można podawać "absurdalne" wartości typu (jak wyżej) 64 megabajty

== Sprawdzanie uprawnień ==

Zdefiniowane w <tt>unistd.h</tt> wywołanie:

int access(const char *pathname, int mode);

służy do sprawdzenia praw do pliku <tt>pathname</tt>.

 

 

Przykład działania:

#include <unistd.h>

#include <stdio.h>

return 0;

}

 

== Przechwytywanie sygnałów ==

Kontroler sygnałów instaluje się za pomocą zdefiniowanej w <tt>signal.h</tt> funkcji:

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

 

Na przykład jeśli nie chcemy pozwolić na Control-C (SIGINT, 2) w trakcie wpisywania danych,

możemy przechwycić sygnał:

#include <stdio.h>

#include <signal.h>

return 0;

}

 

== Zobacz też ==