e degli errori.
-\section{La gestione di catteristiche e parametri del sistema}
+\section{La gestione di caratteristiche e parametri del sistema}
\label{sec:sys_characteristics}
In questa sezione tratteremo le varie modalità con cui un programma può
\fhead{pwd.h}
\fhead{sys/types.h}
\fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
- char *buffer, size\_t buflen, struct passwd **result)}
+ char *buffer,\\
+\phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
\fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
- *password, char *buffer, size\_t buflen, struct passwd **result)}
+ *password, char *buffer,\\
+\phantom{struct passwd *getpwnam\_r(}size\_t buflen, struct passwd **result)}
\fdesc{Restituiscono le informazioni relative all'utente specificato.}
}
\fhead{grp.h}
\fhead{sys/types.h}
\fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
- size\_t buflen, struct group **result)}
+ size\_t buflen,\\
+\phantom{int getgrgid\_r(}struct group **result)}
\fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
- size\_t buflen, struct group **result)}
+ size\_t buflen,\\
+\phantom{int getgrnam\_r(}struct group **result)}
\fdesc{Restituiscono le informazioni relative al gruppo specificato.}
}
sono completamente generiche. Si noti però che non c'è una funzione che
permetta di impostare direttamente una password.\footnote{in realtà questo può
essere fatto ricorrendo alle funzioni della libreria PAM, ma questo non è un
- argomento che trattremo qui.} Dato che POSIX non prevede questa possibilità
+ argomento che tratteremo qui.} Dato che POSIX non prevede questa possibilità
esiste un'altra interfaccia che lo fa, derivata da SVID le cui funzioni sono
riportate in tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona
soltanto quando le informazioni sono mantenute su un apposito file di
voce dal registro: \func{getutent} legge semplicemente la prima voce
disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
-queste funzioni eseguirà la lettura sulle voci seguenti, portanto la posizione
+queste funzioni eseguirà la lettura sulle voci seguenti, pertanto la posizione
sulla voce appena letta, in modo da consentire una scansione del file. Questo
vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
l'erogazione della potenza.
-Ia funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
+La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
basso livello della \textit{system call} la quale richiede attualmente tre
kernel che è stato opportunamente caricato in memoria da una
\func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
- corrente è stato compilato inlcudendo il relativo supporto.\footnote{deve
+ corrente è stato compilato includendo il relativo supporto.\footnote{deve
essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
immediatamente la procedura di riavvio usando il comando fornito
nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}
- (veniva usato per lanciare un altro programma al posto di \cmd{init}. Nelle
+ (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
versioni recenti questo argomento viene ignorato ed il riavvio può essere
controllato dall'argomento di avvio del kernel \texttt{reboot=...} Se non
si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
-verrà eseguita direttettamente. Questo meccanismo consente di evitare la
+verrà eseguita direttamente. Questo meccanismo consente di evitare la
reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
macchina e della memoria, per cui viene usato spesso per installare un kernel
\begin{funcproto}{
\fhead{linux/kexec.h}
\fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
-struct kexec\_segment \phantom{long kexec\_load(}*segments, unsigned long
-flags)}
+struct kexec\_segment\\
+\phantom{long kexec\_load(}*segments, unsigned long flags)}
\fdesc{Carica un kernel per un riavvio immediato.}
}
\label{fig:kexec_segment}
\end{figure}
-L'argomento \param{flags} è una maschera binaria che contiene i flag che
-consentono di indicare alcune specifiche relative alle modalità con cui dovrà
-essere eseguito il nuovo kernel. La parte meno significativa viene usata per
-impostare l'architettura di esecuzione, il valore \const{KEXEC\_ARCH\_DEFAULT}
-indica l'architettura corrente, ma se ne può specificare anche una diversa,
-con i valori della seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa
-verrà usato posto che sia effettivamente eseguibile sul proprio processore.
+L'argomento \param{flags} è una maschera binaria contenente i flag che
+consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
+kernel. La parte meno significativa viene usata per impostare l'architettura
+di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
+corrente, ma se ne può specificare anche una diversa, con i valori della
+seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
+che sia effettivamente eseguibile sul proprio processore.
\begin{table}[htb]
\footnotesize
\end{table}
I due valori più importanti sono però quelli della parte più significativa
-di \param{flags} (riportati nella prima sezione di
-tab.~\ref{tab:kexec_load_flags}). Il primo, \const{KEXEC\_ON\_CRASH}, consente
-di impostare l'esecuzione automatica del nuovo kernel caricato in caso di
-crollo del sistema, e viene usato quando si carica un kernel di emergenza da
-utilizzare per poter raccogliere informazioni diagnostiche che altrimenti
-verrebbero perdute non essendo il kernel ordinario più in grado di essere
-eseguito in maniera coerente. Il secondo valore,
+(riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
+\const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
+nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
+carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
+diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
+più in grado di essere eseguito in maniera coerente. Il secondo valore,
\const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
programmi e dei dispositivi, e viene in genere usato per realizzare la
cosiddetta ibernazione in RAM.
processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
-\var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. Con i kernel della
-serie 2.6 si aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, e a partire
-dal 2.6.22 anche \var{ru\_inblock} e \var{ru\_oublock}.
-
-I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
-indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
-istruzioni in user space, e quello impiegato dal kernel nelle \textit{system
- call} eseguite per conto del processo. I campi \var{ru\_minflt} e
-\var{ru\_majflt} servono a quantificare l'uso della memoria
-virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
-\itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
-avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
- fault}), a quelli che invece han richiesto I/O su disco (detti invece
-\textit{major page fault}), mentre \var{ru\_nswap} ed al numero di volte che
-il processo è stato completamente tolto dalla memoria per essere inserito
-nello swap.
-
-% TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti
+\var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
+aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
+anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
+\var{ru\_maxrss}.
In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
necessario, ma aumenta la portabilità, e serve comunque quando, come nella
\begin{errlist}
\item[\errcode{EINVAL}] l'argomento \param{who} non è valido
\end{errlist}
- ed inoltre \errval{EFAULT} nel suo significato generico.
+ ed inoltre \errval{EFAULT} nel suo significato generico.
}
\end{funcproto}
\caption{Valori per l'argomento \param{who} di \func{getrusage}.}
\label{tab:getrusage_who}
\end{table}
+
+I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
+indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
+istruzioni in user space, e quello impiegato dal kernel nelle \textit{system
+ call} eseguite per conto del processo. I campi \var{ru\_minflt} e
+\var{ru\_majflt} servono a quantificare l'uso della memoria
+virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
+\itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
+avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
+ fault}), a quelli che invece han richiesto I/O su disco (detti invece
+\textit{major page fault}).% mentre \var{ru\_nswap} ed al numero di volte che
+% il processo è stato completamente tolto dalla memoria per essere inserito
+% nello swap.
+% TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
+% dato per non utilizzato.
+
+I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
+processo ha subito un \textit{context switch} da parte dello
+\textit{scheduler} rispettivamente nel caso un cui questo avviene prima
+dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
+\textit{system call} bloccante), o per averla esaurita o essere stato
+interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
+\var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
+attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
+infine \var{ru\_maxrss} indica il valore più alto della
+\itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size} raggiunto dal
+processo stesso o, nel caso sia stato usato \const{RUSAGE\_CHILDREN}, da uno
+dei suoi figli.
Si tenga conto che per un errore di implementazione nei i kernel precedenti il
2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
delle risorse usate dai processi figli anche quando si era impostata una
-azione di \const{SIG\_ING} per il segnale \const{SIGCHLD} (per i segnali si
+azione di \const{SIG\_IGN} per il segnale \const{SIGCHLD} (per i segnali si
veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
allo standard a partire dal kernel 2.6.9.
specifico segnale o il fallimento della \textit{system call} che lo ha
provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
in cui si ha in comportamento diverso per il superamento dei due limiti e
-\const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
-creazione) dei file di \itindex{core~dump} \textit{core dump}.
+\const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
+creazione dei file di \itindex{core~dump} \textit{core dump} (vedi
+sez.~\ref{sec:sig_standard}).
Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
\fhead{sys/resource.h}
\fhead{unistd.h}
\fdecl{int getrlimit(int resource, struct rlimit *rlim)}
-\fdesc{Legge il limite corrente di una risorsa.}
+\fdesc{Legge i limiti di una risorsa.}
\fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
-\fdesc{Imposta il limite di una risorsa.}
+\fdesc{Imposta i limiti di una risorsa.}
}
{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
+ \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
+ nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
+ \var{rlim->rlim\_max}.
\item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
cercato di innalzare i propri limiti.
\end{errlist}
al valore del limite massimo, può anche ridurre, irreversibilmente, il valore
di quest'ultimo. Nello specificare un limite, oltre a fornire dei valori
specifici, si può anche usare la costante \const{RLIM\_INFINITY} che permette
-di sbloccare completamente l'uso di una risorsa; ma si ricordi che solo un
+di sbloccare completamente l'uso di una risorsa. Si ricordi però che solo un
processo con i privilegi di amministratore\footnote{per essere precisi in
questo caso quello che serve è la \itindex{capabilities} \textit{capability}
\const{CAP\_SYS\_RESOURCE} (vedi sez.~\ref{sec:proc_capabilities}).} può
innalzare un limite al di sopra del valore corrente del limite massimo ed
usare un valore qualsiasi per entrambi i limiti.
-Come accennato ciascuna risorsa è identificata da uno specifico valore
-dell'argomento \param{resource}, i valori possibili per questo argomento, ed
-il significato della risorsa corrispondente, dei rispettivi limiti e gli
-effetti causati dal superamento degli stessi sono riportati nel seguente
-elenco:
+Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
+specifico valore dell'argomento \param{resource}, i valori possibili per
+questo argomento, ed il significato della risorsa corrispondente, dei
+rispettivi limiti e gli effetti causati dal superamento degli stessi sono
+riportati nel seguente elenco:
\begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
\item[\const{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
\item[\const{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
dimensione per un file di \itindex{core~dump} \textit{core dump} (vedi
- sez.~\ref{sec:sig_prog_error}) creato nella terminazione di un
- processo. File di dimensioni maggiori verranno troncati a questo valore,
- mentre con un valore nullo si bloccherà la creazione dei \itindex{core~dump}
- \textit{core dump}.
+ sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
+ di dimensioni maggiori verranno troncati a questo valore, mentre con un
+ valore nullo si bloccherà la creazione dei \itindex{core~dump} \textit{core
+ dump}.
\item[\const{RLIMIT\_CPU}] Questa risorsa indica, in secondi, il massimo tempo
di CPU (vedi sez.~\ref{sec:sys_cpu_times}) che il processo può usare. Il
\errcode{EAGAIN}.
\item[\const{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
- dimensione massima della memoria residente (il codiddetto RSS
+ dimensione massima della memoria residente (il cosiddetto RSS
\itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
l'ammontare della memoria associata al processo che risiede effettivamente
- in RAM (e non a quella eventualmente portata sulla \textit{swap} o non
- ancora caricata dal filesystem (per il \index{segmento!testo} segmento testo
- del programma). Ha effetto solo sulle chiamate a \func{madvise} con
+ in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
+ caricata dal filesystem per il \index{segmento!testo} segmento testo del
+ programma. Ha effetto solo sulle chiamate a \func{madvise} con
\const{MADV\_WILLNEED} (vedi sez.~\ref{sec:file_memory_map}). Presente solo
sui i kernel precedenti il 2.4.30.
-\item[\const{RLIMIT\_RTPRIO}] Questa risorsa indica il
+\item[\const{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
+ priorità statica che un processo può assegnarsi o assegnare con
+ \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
+ sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
+ kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
+ precedenza solo i processi con privilegi amministrativi potevano avere una
+ priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
+ \textit{real-time}.
+
+\item[\const{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
+ massimo di CPU che un processo eseguito con una priorità statica può
+ consumare. Il superamento del limite corrente comporta l'emissione di un
+ segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
+ con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
+ intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
+ superamento del limite massimo. Questo limite è stato introdotto con il
+ kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
+ il sistema.
% TODO trattare i seguenti...
-% \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
% aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
% vedi file include/asm-generic/resource.h
-\item[\const{RLIMIT\_SIGPENDING}] Il numero massimo di segnali che possono
- essere mantenuti in coda per ciascun utente, considerando sia i segnali
- normali che real-time (vedi sez.~\ref{sec:sig_real_time}). Il limite è
+\item[\const{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
+ segnali che possono essere mantenuti in coda per ciascun utente,
+ identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
+ che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
- segnale che non sia già presente su una coda.\footnote{il limite su questa
- risorsa è stato introdotto con il kernel 2.6.8.}
-
+ segnale che non sia già presente su una coda. Questo limite è stato
+ introdotto con il kernel 2.6.8.
+
+\item[\const{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
+ dimensione dello \itindex{stack} \textit{stack} del processo. Se il processo
+ esegue operazioni che estendano lo \textit{stack} oltre questa dimensione
+ riceverà un segnale di \signal{SIGSEGV}.
+
+ A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
+ parte delle architetture anche ai dati che possono essere passati come
+ argomenti e variabili di ambiente ad un programma posto in esecuzione con
+ \func{execve}, nella misura di un quarto del valore indicato per lo
+ \textit{stack}. Questo valore in precedenza era fisso e pari a 32 pagine di
+ memoria, corrispondenti per la gran parte delle architetture a 128kb di
+ dati, dal 2.6.25, per evitare problemi di compatibilità quando
+ \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
+ base di 32 pagine qualunque sia l'architettura.
-\item[\const{RLIMIT\_RSS}] L'ammontare massimo di pagine di memoria dato al
- \index{segmento!testo} testo del processo. Il limite è solo una indicazione
- per il kernel, qualora ci fosse un surplus di memoria questa verrebbe
- assegnata.
+\end{basedescript}
-\item[\const{RLIMIT\_STACK}] La massima dimensione dello \itindex{stack}
- \textit{stack} del processo. Se il processo esegue operazioni che estendano
- lo \textit{stack} oltre questa dimensione riceverà un segnale di
- \signal{SIGSEGV}.
+Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
+vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
+sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
+esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
-% TODO dal 2.6.23 il significato è cambiato, vedi anche man execve
+Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
+operare solo sul processo corrente. Per questo motivo a partire dal kernel
+2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
+sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
+precedenti. Il suo prototipo è:
-% TODO: aggiungere a \const{RLIMIT\_STACK} i dati di execve:
-% Questi fino al kernel 2.6.23 erano fissi e costituiti da
-% 32 pagine di memoria (corrispondenti per la gran parte delle architetture a
-% 128kb di dati). Dal 2.6.23 su molte architettire il limite viene stabilito in
-% base al valore della risorsa \const{RLIMIT\_STACK} (vedi
-% sez.~\ref{sec:sys_resource_limit}), ad un quarto dello spazio da essa
-% indicato). Dal 2.6.25 viene comunque garantito uno spazio base di 32 pagine.
+\begin{funcproto}{
+\fhead{sys/resource.h}
+\fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
+\phantom{int prlimit(}struct rlimit *old\_limit}
+\fdesc{Legge e imposta i limiti di una risorsa.}
+}
-% TODO integrare con la roba di madvise
-% TODO integrare con le ultime aggiunte, vedi pagina di manuale
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
+ nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
+ \var{rlim->rlim\_max}.
+ \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
+ cercato di innalzare i propri limiti o si è cercato di modificare i limiti
+ di un processo di un altro utente.
+ \item [\errcode{ESRCH}] il process \param{pid} non esiste.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.
+}
+\end{funcproto}
-% TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
-% setrlimit
+La funzione è specifica di Linux e non portabile; per essere usata richiede
+che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
+indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
+usare un valore nullo per indicare il processo chiamante. Per modificare i
+limiti di un altro processo, a meno di non avere privilegi
+amministrativi,\footnote{anche in questo caso la \itindex{capabilities}
+ \textit{capability} necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
+ sez.~\ref{sec:proc_capabilities}).} l'\ids{UID} ed il \ids{GID} reale del
+chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
+per i tre gruppi reale, effettivo e salvato.
-\end{basedescript}
+Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
+struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
+mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
+del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
+possibile sia leggere che scrivere, anche in contemporanea, i valori dei
+limiti. Il significato dell'argomento \param{resource} resta identico rispetto
+a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti.
-Si tenga conto infine che tutti i limiti vengono ereditati dal
-processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork}) e
-mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
-sez.~\ref{sec:proc_exec}).
-\subsection{Le risorse di memoria e processore}
+\subsection{Le informazioni sulle risorse di memoria e processore}
\label{sec:sys_memory_res}
La gestione della memoria è già stata affrontata in dettaglio in
sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
-divisione della memoria fisica in pagine.
-
-In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
-casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
-che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
-dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
-gestire in maniera ottimale l'interazione della memoria che si sta allocando
-con il meccanismo della \index{paginazione} paginazione.
-
-Di solito la dimensione delle pagine di memoria è fissata dall'architettura
-hardware, per cui il suo valore di norma veniva mantenuto in una costante che
-bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
-architetture (ad esempio Sun Sparc) che permettono di variare questa
-dimensione, per non dover ricompilare i programmi per ogni possibile modello e
-scelta di dimensioni, è necessario poter utilizzare una funzione.
-
-Dato che si tratta di una caratteristica generale del sistema, questa
-dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
-\func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
- parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
-apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
-pagine di memoria; il suo prototipo è:
-\begin{prototype}{unistd.h}{int getpagesize(void)}
- Legge le dimensioni delle pagine di memoria.
-
- \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
- sono previsti errori.}
-\end{prototype}
+divisione della memoria fisica in pagine. In genere tutto ciò è del tutto
+trasparente al singolo processo, ma in certi casi, come per l'I/O mappato in
+memoria (vedi sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per
+accedere ai file, è necessario conoscere le dimensioni delle pagine usate dal
+kernel. Lo stesso vale quando si vuole gestire in maniera ottimale
+l'interazione della memoria che si sta allocando con il meccanismo della
+\index{paginazione} paginazione.
+
+Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
+dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
+costante che bastava utilizzare in fase di compilazione. Oggi invece molte
+architetture permettono di variare questa dimensione (ad esempio sui PC
+recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
+ricompilare i programmi per ogni possibile caso e relativa scelta di
+dimensioni, è necessario poter utilizzare una funzione che restituisca questi
+valori quando il programma viene eseguito.
+
+Dato che si tratta di una caratteristica general del sistemae come abbiamo
+visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
+ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
+caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
+in BSD 4.2 è stata introdotta una apposita funzione di sistema
+\funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
+funzione è disponibile anche su Linux (ma richiede che sia definita la macro
+\macro{\_BSD\_SOURCE}) ed il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int getpagesize(void)}
+\fdesc{Legge la dimensione delle pagine di memoria.}
+}
+
+{La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
+ errori.}
+\end{funcproto}
La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
-ha eliminata. In Linux è implementata come una \textit{system call} nelle
-architetture in cui essa è necessaria, ed in genere restituisce il valore del
-simbolo \const{PAGE\_SIZE} del kernel, che dipende dalla architettura
-hardware, anche se le versioni delle librerie del C precedenti le \acr{glibc}
-2.1 implementavano questa funzione restituendo sempre un valore statico.
+ha eliminata, ed i programmi che intendono essere portabili devono ricorrere
+alla chiamata a \func{sysconf}.
+
+In Linux è implementata come una \textit{system call} nelle architetture in
+cui essa è necessaria, ed in genere restituisce il valore del simbolo
+\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
+se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
+implementavano questa funzione restituendo sempre un valore statico.
% TODO verificare meglio la faccenda di const{PAGE\_SIZE}
Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
-di ottenere informazioni riguardo la memoria; i loro prototipi sono:
-\begin{functions}
- \headdecl{sys/sysinfo.h}
-
- \funcdecl{long int get\_phys\_pages(void)}
+di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
- Legge il numero totale di pagine di memoria disponibili per il sistema.
-
- \funcdecl{long int get\_avphys\_pages(void)}
-
- Legge il numero di pagine di memoria disponibili nel sistema.
-
- \bodydesc{Le funzioni restituiscono un numero di pagine.}
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/sysinfo.h}
+\fdecl{long int get\_phys\_pages(void)}
+\fdesc{Legge il numero totale di pagine di memoria.}
+\fdecl{long int get\_avphys\_pages(void)}
+\fdesc{Legge il numero di pagine di memoria disponibili nel sistema.}
+}
+
+{La funzioni ritornano il numero di pagine, e non sono previsti
+ errori.}
+\end{funcproto}
Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
permette di ottenere il carico di processore della macchina, in questo modo è
possibile prendere decisioni su quando far partire eventuali nuovi processi.
Il suo prototipo è:
-\begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
- Legge il carico medio della macchina.
-
- \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
- errore.}
-\end{prototype}
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{int getloadavg(double loadavg[], int nelem)}
+\fdesc{Legge il carico medio della macchina.}
+}
+
+{La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
+ riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
+\end{funcproto}
La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
Linux consente di salvare la contabilità delle informazioni relative alle
risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
prototipo è:
-\begin{prototype}{unistd.h}{int acct(const char *filename)}
- Abilita il \textit{BSD accounting}.
-
- \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
- \begin{errlist}
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int acct(const char *filename)}
+\fdesc{Abilita il \textit{BSD accounting}.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
\item[\errcode{EACCES}] non si hanno i permessi per accedere a
\param{pathname}.
\item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
\end{errlist}
ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
\errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
- \errval{ENOTDIR}, \errval{EROFS}.}
-\end{prototype}
+ \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
+\end{funcproto}
La funzione attiva il salvataggio dei dati sul file indicato dal
\textit{pathname} contenuti nella stringa puntata da \param{filename}; la
\texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
Quando si attiva la contabilità, il file che si indica deve esistere; esso
-verrà aperto in sola scrittura; le informazioni verranno registrate in
+verrà aperto in sola scrittura e le informazioni verranno registrate in
\itindex{append~mode} \textit{append} in coda al file tutte le volte che un
processo termina. Le informazioni vengono salvate in formato binario, e
corrispondono al contenuto della apposita struttura dati definita all'interno
del kernel.
Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
-parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct}
-(o tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi,
-il primo indica la percentuale di spazio disco libero sopra il quale viene
+parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct} (o
+tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
+primo indica la percentuale di spazio disco libero sopra il quale viene
ripresa una registrazione che era stata sospesa per essere scesi sotto il
minimo indicato dal secondo valore (sempre in percentuale di spazio disco
libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
essere controllata detta percentuale.
+% TODO: bassa priorità, trattare la lettura del file di accounting, da
+% programma, vedi man 5 acct
+
\section{La gestione dei tempi del sistema}
\label{sec:sys_time}
La funzione più semplice per leggere il \textit{process time} di un processo è
\funcd{clock}, che da una valutazione approssimativa del tempo di CPU
utilizzato dallo stesso; il suo prototipo è:
-\begin{prototype}{time.h}{clock\_t clock(void)}
- Legge il valore corrente del tempo di CPU.
-
- \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
- caso di errore.}
-\end{prototype}
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{clock\_t clock(void)}
+\fdesc{Legge il valore corrente del tempo di CPU.}
+}
+
+{La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
+ è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
+ \var{errno} non viene usata.}
+\end{funcproto}
La funzione restituisce il tempo in \itindex{clock~tick} \texttt{clock tick},
quindi se si vuole il tempo in secondi occorre dividere il risultato per la
altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
-\begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
- Legge in \param{buf} il valore corrente dei tempi di processore.
-
- \bodydesc{La funzione ritorna il numero di \itindex{clock~tick}
- \textit{clock tick} dall'avvio del sistema in caso di successo e -1 in
- caso di errore.}
-\end{prototype}
+
+\begin{funcproto}{
+\fhead{sys/times.h
+\fdecl{clock\_t times(struct tms *buf)}
+\fdesc{Legge il valore corrente dei tempi di processore.}
+}
+
+{La funzione ritorna il numero di \textit{clock ticks} in caso di successo e
+ $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \end{errlist}
+ ed inoltre
+nel loro significato generico.}
+\end{funcproto}
La funzione restituisce i valori di \textit{process time} del processo
corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
valere per qualunque funzione che vada a modificare l'orologio di sistema,
quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
da un processo coi privilegi di amministratore.\footnote{più precisamente la
- capabitity \const{CAP\_SYS\_TIME}.}
+ capability \const{CAP\_SYS\_TIME}.}
Il secondo argomento di entrambe le funzioni è una struttura
\struct{timezone}, che storicamente veniva utilizzata per specificare appunto
% LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
% LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
% LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
-% LocalWords: dall'header posix lim nell'header glibc run unistd name errno
+% LocalWords: dall'header posix lim nell'header glibc run unistd name errno SC
% LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
% LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
% LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
% LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
% LocalWords: TCP shell Documentation ostype hostname osrelease version mount
% LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
-% LocalWords: device EBUSY only EACCES NODEV ENXIO major
+% LocalWords: device EBUSY only EACCES NODEV ENXIO major RTSIG syscall PID NSS
% LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
% LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
% LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
% LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
% LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
% LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
-% LocalWords: capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
+% LocalWords: capability CAP Sun Sparc PAGESIZE getpagesize SVr SUSv get IGN
% LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
-% LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER
+% LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER sizeof
% LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
% LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
-% LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex
-% LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp
+% LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex NetBSD
+% LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp cmd
% LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
% LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
% LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
% LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
% LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
-% LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
+% LocalWords: perror string errnum MESSAGES error message strtol log
% LocalWords: program invocation argv printf print progname exit count fname
-% LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM
-% LocalWords: CEST
-
+% LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM CAD
+% LocalWords: CEST utmpxname Solaris updwtmpx reboot RESTART Ctrl OFF SIGINT
+% LocalWords: HALT halted sync KEXEC kexec load bootloader POWER Power with nr
+% LocalWords: Restarting command arg entry segments segment ARCH CRASH CONTEXT
+% LocalWords: PRESERVE PPC IA ARM SH MIPS nvcsw nivcsw inblock oublock maxrss
+% LocalWords: context switch slice Resident SIG SIGCHLD cur Gb lease mlock
+% LocalWords: memory mlockall MAP LOCKED shmctl MSGQUEUE attr NICE nice MADV
+% LocalWords: madvise WILLNEED RTPRIO sched setscheduler setparam scheduling
+% LocalWords: RTTIME execve kb prlimit pid new old ESRCH EUSERS
%%% Local Variables:
projects / gapil.git / blobdiff