wartość zwracana

Spis treści
execl, execlp, execle, execv, execvp − uruchomienie pliku ................................................................. 2
SKŁADNIA .................................................................................................................................... 2
OPIS ................................................................................................................................................ 2
WARTOŚĆ ZWRACANA .............................................................................................................. 3
fork - utworzenie procesu potomnego ................................................................................................. 3
SKŁADNIA .................................................................................................................................... 3
OPIS ................................................................................................................................................ 3
WARTOŚĆ ZWRACANA .............................................................................................................. 3
calloc, malloc, free, realloc - przydziela i zwalnia pamięć dynamiczną .............................................. 3
SKŁADNIA .................................................................................................................................... 3
OPIS ................................................................................................................................................ 4
WARTOŚĆ ZWRACANA .............................................................................................................. 4
wait, waitpid - oczekiwanie na zakończenie procesu .......................................................................... 4
SKŁADNIA .................................................................................................................................... 4
OPIS ................................................................................................................................................ 4
WARTOŚĆ ZWRACANA .............................................................................................................. 6
strcmp, strncmp – porównuje dwa ciągi znaków ................................................................................. 6
SKŁADNIA .................................................................................................................................... 6
OPIS ................................................................................................................................................ 6
WARTOŚĆ ZWRACANA .............................................................................................................. 6
_exit, _Exit - zakończenie bieżącego procesu ..................................................................................... 6
SKŁADNIA .................................................................................................................................... 6
OPIS ................................................................................................................................................ 7
atoi, atol, atoll, atoq - przekształcenie łańcucha na wartość całkowitą ................................................ 7
SKŁADNIA .................................................................................................................................... 7
OPIS ................................................................................................................................................ 7
WARTOŚĆ ZWRACANA .............................................................................................................. 7
getrlimit, getrusage, setrlimit - pobranie/ustawienie limitów i zużycia zasobów ................................ 7
SKŁADNIA .................................................................................................................................... 7
OPIS ................................................................................................................................................ 8
Dodatkowe zalecenia ........................................................................................................................... 8
execl, execlp, execle, execv, execvp − uruchomienie pliku
SKŁADNIA
#include <unistd.h>
extern char **environ;
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg , ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
OPIS
Rodzina funkcji exec zastępuje w pamięci obraz aktualnego procesu obrazem nowego procesu.
Funkcje opisane na tej stronie man są tylko nakładkami dla funkcji execve(2). (Dodatkowych
informacji na temat nadpisywania aktualnego procesu szukaj na stronie man tej funkcji.)
Pierwszym argumentem tych funkcji jest ścieżka do pliku, który ma być uruchomiony.
Kolejne wyrażenia const char *arg w funkcjach execl, execlp, i execle można traktować jako arg0,
arg1, ..., argn. Razem opisują one listę jednego lub więcej wskaźników do zakończonych znakiem
NUL łańcuchów, reprezentujących listę argumentów udostępnoianych wykonywanemu programowi.
Pierwszy argument, zgodnie z konwencją, powinien wskazywać na nazwę pliku powiązaną z
wykonywanym plikiem. Lista argumentów musi być zakończona wskaźnikiem NULL.
Funkcje execv oraz execvp udostępniają tablicę wskaźników do zakończonych znakami NUL
łańcuchów, które reprezentują listę argumentów dostępnych dla wykonywanego programu. Pierwszy
argument, zgodnie z konwencją, powinien wskazywać na nazwę pliku powiązaną z wykonywanym
plikiem. Tablica wskaźników musi być zakończona wskaźnikiem NULL.
Funkcja execle dodatkowo określa środowisko wykonywanego procesu poprzez dodanie po
wskaźniku NULL, kończącym listę argumentów w liście parametrów lub po tablicy argv
dodatkowego argumentu. Tym dodatkowym argumentem jest tablica wskaźników do zakończonych
znakami NUL łańcuchów, która to tablica musi być zakończona wskaźnikiem NULL. Pozostałe
funkcje pobierają środowisko dla nowego procesu z zewnętrznej zmiennej environ aktualnego
procesu.
Niektóre z tych funkcji mają specyficzną semantykę.
Funkcje execlp oraz execvp wykonują zadania powłoki szukając pliku wykonywalnego, jeśli nazwa
pliku nie zawiera znaku ukośnika (/). Ścieżka przeszukiwania to ścieżka podana w zmiennej
środowiskowej PATH. Jeśli zmienna ta nie istnieje, przyjmowana jest domyślna ścieżka
‘‘:/bin:/usr/bin’’. Dodatkowo pewne błędy traktowane są odmiennie.
Jeśli dostęp do pliku został zabroniony (wywołanie execve zwróciło EACCES), funkcje te będą
przeszukiwać resztę ścieżki. Jeśli jednak nie odnajdą innego pliku, powrócą i zmienią wartość
zmiennej globalnej errno na EACCES.
Jeśli nagłówek nie zostanie rozpoznany (wywołanie execve zwróci ENOEXEC), funkcje te spróbują
uruchomić powłokę ze ścieżką do pliku jako pierwszym argumentem. (Jeśli i ta próba się nie
powiedzie, przeszukiwanie jest zakończone.)
WARTOŚĆ ZWRACANA
Jeśli dowolna z funkcji exec powróci, oznacza to że nastąpił błąd. Zwracana jest wartość −1 i
ustawiana jest zmienna globalna errno aby wskazać błąd.
fork - utworzenie procesu potomnego
SKŁADNIA
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
OPIS
fork tworzy proces potomny, który różni się od procesu macierzystego jedynie swoimi numerami
PID i PPID oraz tym, że w rzeczywistości użycie przez niego zasobów jest ustawione na 0. Blokady
plików i oczekujące sygnały nie są dziedziczone.
Pod Linuksem fork funkcja jest zaimplementowana za pomocą kopiowania stron pamięci przy
zapisie, więc jedynymi mankamentami fork są czas i pamięć wymagane do powielenia tablic stron
rodzica i utworzenia unikalnej struktury zadania dla potomka.
WARTOŚĆ ZWRACANA
Po pomyślnym zakończeniu, w procesie macierzystym zwracany jest PID procesu potomnego, a w
procesie potomnym zwracane jest 0. Po błędzie zwracane jest -1 w kontekście rodzica, nie jest
tworzony procesie potomny i odpowiednio ustawiane jest errno.
calloc, malloc, free, realloc - przydziela i zwalnia pamięć dynamiczną
SKŁADNIA
#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
OPIS
calloc() przydziela pamięć dla tablicy zawierającej nmemb elementów, każdy o rozmiarze size
bajtów i zwraca wskaźnik do przydzielonej pamięci. Pamięć jest zerowana.
malloc() przydziela size bajtów i zwraca wskaźnik do przydzielonej pamięci.
Pamięć nie jest
czyszczona.
free() zwalnia obszar pamięci wskazywany przez ptr, który został wcześniej przydzielony za pomocą
wywołania malloc(), calloc() lub realloc(). W przeciwnym przypadku, lub gdy free(ptr) zostało
już wcześniej wywołane, funkcja zachowa się w sposób nieokreślony. Jeśli ptr jest równe NULL,
nie zostanie wykonana żadna operacja.
realloc() zmienia rozmiar bloku pamięci wskazywanego przez ptr na size bajtów. Zawartość nie
zostanie zmieniona w zakresie poniżej minimum ze starego i nowego rozmiaru; nowo przydzielona
pamięć nie zostanie zainicjalizowana. Jeśli ptr jest równe NULL, to wywołanie jest
równoważne malloc(size); jeśli size jest równe zeru, to wywołanie jest równoważne free(ptr). O
ile ptr nie jest równe NULL, musi ono być zwrócone przez wcześniejsze wywołanie malloc(),
calloc() lub realloc().
WARTOŚĆ ZWRACANA
Dla calloc() i malloc(), zwracana wartość jest wskaźnikiem do przydzielonej pamięci, który jest
właściwie wyrównany dla dowolnego rodzaju zmiennej, lub NULL gdy żądanie zakończyło się
niepowodzeniem.
free() nie zwraca żadnej wartości.
realloc() zwraca wskaźnik do nowoprzydzielonej pamięci, który jest właściwie wyrównany dla
dowolnego rodzaju zmiennej i może być różny od ptr, lub NULL gdy żądanie zakończy się
niepowodzeniem. Jeśli rozmiar był równy 0, zwracane jest NULL lub wskaźnik odpowiedni do
przekazania go funkcji free(). Gdy realloc() zakończy się niepowodzeniem, pierwotny blok zostaje
nienaruszony - nie jest on ani zwalniany ani przesuwany.
wait, waitpid - oczekiwanie na zakończenie procesu
SKŁADNIA
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
OPIS
Funkcja wait zatrzymuje wykonywanie bieżącego procesu aż do zakończenia procesu potomka lub
aż do dostarczenia sygnału kończącego bieżący proces lub innego, dla którego wywoływana jest
funkcja obsługi sygnału. Jeśli potomek zakończył działanie przed wywołaniem tej funkcji (tak
zwany proces-duch - "zombie"), to funkcja kończy się natychmiast. Wszelkie zasoby potomka są
zwalniane.
Funkcja waitpid zawiesza wykonywanie bieżącego procesu dopóki potomek określony przez pid
nie zakończy działania lub dopóki nie zostanie dostarczony sygnał, którego akcją jest zakończenie
procesu lub wywołanie funkcji obsługującej sygnały. Jeśli potomek, podany jako pid, zakończył
swoje działanie przed wywołaniem tej funkcji (tak zwany proces "zombie"), funkcja kończy się
natychmiast. Wszelkie zasoby potomka są zwalnianie.
Wartość pid może być:
< -1 co oznacza oczekiwanie na dowolny proces potomny, którego ID grupy procesów jest równy
wartości bezwzględnej pid.
-1 co oznacza oczekiwanie na dowolny proces potomny; jest to takie samo zachowanie, jakie
wykazuje wait.
0
co oznacza oczekiwanie na każdy proces potomny, którego ID grupy procesu jest równe ID
grupy procesu wywołującego funkcję.
>0
oznacza oczekiwanie na potomka, którego ID procesu jest równy wartości pid.
Wartość options jest sumą OR zera lub więcej spośród następujących stałych:
WNOHANG
pracy.
oznacza natychmiastowy powrót z funkcji, jeśli potomek nie zakończył
WUNTRACED
oznacza zakończenie także dla zatrzymanych (ale nie śledzonych)
procesów potomnych, których stan jeszcze nie został zgłoszony. Stan śledzonych procesów
potomnych, które zostały zatrzymane, jest udostępniany również bez tej opcji.
(Poniższe opcje dotyczą wyłącznie Linuksa.)
Jeśli status nie jest równe NULL, wait lub waitpid zapisuje dane o stanie w buforze wskazywanym
przez status.
Stan ten można zanalizować następującymi makrami (makra te pobierają jako argument bufor stat
(typu int), -- nie wskaźnik do bufora!):
WIFEXITED(status)
jest niezerowe, jeśli potomek normalnie zakończył pracę.
WEXITSTATUS(status)
analizuje
osiem
najmniej znaczących bitów kodu powrotu
zakończonego potomka, które mogły być ustawione jako argument wywołania exit() lub jako
argument instrukcji return w programie głównym. Makro to może być przetworzone, tylko jeśli
WIFEXITED zwróciło wartość niezerową.
WIFSIGNALED(status)
zwraca prawdę, jeśli proces potomny zakończył pracę z powodu
nieprzechwyconego sygnału.
WTERMSIG(status)
zwraca numer sygnału, który spowodował zakończenie procesu
potomnego. Makro to może być przetworzone, tylko jeśli WIFSIGNALED zwróciło wartość
niezerową.
WIFSTOPPED(status)
zwraca prawdę, jeśli proces potomny jest obecnie zatrzymany; jest to
możliwe tylko gdy w wywołaniu użyto WUNTRACED oraz gdy proces potomny jest śledzony
(zobacz ptrace(2)).
WSTOPSIG(status)
zwraca numer sygnału, który spowodował zatrzymanie potomka.
Makro to może być przetworzone, tylko jeśli WIFSTOPPED zwróciło wartość niezerową.
Niektóre wersje Uniksa (np. Linux, Solaris, ale nie AIX, SunOS) definiują także makro
WCOREDUMP(status)
sprawdzające, czy proces potomny dokonał zrzutu pamięci. Należy go
używać tylko pomiędzy dyrektywami kompilatora #ifdef WCOREDUMP ... #endif.
WARTOŚĆ ZWRACANA
PID zakończonego potomka lub zero, jeśli użyto WNOHANG, a nie było dostępnego żadnego
potomka, albo -1 w przypadku błędu (w tym ostatnim wypadku odpowiednia wartość jest nadawana
errno).
strcmp, strncmp – porównuje dwa ciągi znaków
SKŁADNIA
#include <string.h>
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
OPIS
Funkcja strcmp() porównuje dwa stringi, s1 i s2. Zwraca integer mniejszy niż, równy lub większy od
zera jeśli s1 jest odpowiednio mniejszy, równy lub większy od s2.
Funkcja strncmp() działa podobnie, lecz porównuje tylko pierwsze n bajtów s1 i s2
WARTOŚĆ ZWRACANA
Funkcje strcmp() oraz strncmp() zwracają liczbę całkowitą mniejszą, równą lub większą od zera jeśli
s1 (lub pierwsze n jego bajtów) jest odpowiednio: mniejsze, równe lub większe od s2.
_exit, _Exit - zakończenie bieżącego procesu
SKŁADNIA
#include <unistd.h>
void _exit(int status);
#include <stdlib.h>
void _Exit(int status);
OPIS
Funkcja _exit "natychmiast" kończy proces, z którego została wywołana. Wszystkie przynależące
do procesu otwarte deskryptory plików są zamykane; wszystkie jego procesy potomne są
przejmowane przez proces 1, init, a jego proces macierzysty otrzymuje sygnał SIGCHLD.
Wartość status jest zwracana procesowi macierzystemu jako kod zakończenia procesu wywołującego
tę funkcję i może zostać odczytana za pomocą jednej z funkcji z rodziny wait.
Funkcja _Exit jest równoważna _exit.
atoi, atol, atoll, atoq - przekształcenie łańcucha na wartość całkowitą
SKŁADNIA
#include <stdlib.h>
int atoi(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);
long long atoq(const char *nptr);
OPIS
Funkcja atoi() przekształca początkową część łańcucha wskazywanego przez nptr na int. Działa tak
samo, jak
strtol(nptr, (char **)NULL, 10);
z wyjątkiem tego, że atoi() nie wykrywa błędów.
Funkcje atol() i atoll() zachowują się tak samo, jak atoi, z tym wyjątkiem, że przekształcają
początkową część przekazanego im łańcucha na - w zależności od typu zwracanego przez te funkcje
- odpowiednio long oraz long long. atoq() jest przestarzałą nazwą dla atoll().
WARTOŚĆ ZWRACANA
Zwracany jest wynik przekształcenia.
getrlimit, getrusage, setrlimit - pobranie/ustawienie limitów i zużycia
zasobów
SKŁADNIA
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
int getrlimit(int resource, struct rlimit *rlim);
int getrusage(int who, struct rusage *usage);
int setrlimit(int resource, const struct rlimit *rlim);
OPIS
getrlimit i setrlimit odpowiednio pobierają i ustawiają limity zasobów.Z każdym z zasobów
stowarzyszone jest miękkie i sztywne ograniczenie zdefiniowane w strukturze rlimit (argument rlim
w getrlimit() i setrlimit()):
struct rlimit {
rlim_t rlim_cur;
rlim_t rlim_max;
/* ograniczenie miękkie */
/* ograniczenie sztywne (górna
granica dla rlim_cur) */
};
Ograniczenie miękkie jest wartością odpowiedniego zasoby wymuszną przez jądro. Ograniczenie
sztywne działa jak wartość
maksymalna
dla ograniczenia miękkiego: proces
nieuprzywilejowany może sobie ustawić ograniczenie miękkie tylko w zakresie od 0 do ograniczenia
sztywnego oraz (nieodwracalnie) obniżyć swoje ograniczenie sztywne. Proces uprzywilejowany
może dowolnie zmieniać każdą z wartości ograniczenia.
Dodatkowe zalecenia
Zapoznajcie się dodatkowo z argumentami programów w C, zmiennymi argc i argv.