successivo precedente inizio fine indice generale aiuto indice analitico volume parte TXT HTML PDF pdf gdoc P4
chdir() u0.3
chmod() u0.4
chown() u0.5
clock() u0.6
close() u0.7
dup() u0.8
dup2() u0.8
execve() u0.10
fchmod() u0.4
fchown() u0.5
fcntl() u0.13
fork() u0.14
fstat() u0.36
getcwd() u0.16
geteuid() u0.18
getpgrp() u0.20
getpid() u0.20
getppid() u0.20
getuid() u0.18
kill() u0.22
link() u0.23
lseek() u0.24
mkdir() u0.25
mknod() u0.26
mount() u0.27
open() u0.28
read() u0.29
rmdir() u0.30
seteuid() u0.33
setpgrp() u0.32
setuid() u0.33
signal() u0.34
sleep() u0.35
stat() u0.36
stime() u0.39
sys() u0.37
time() u0.39
umask() u0.40
umount() u0.27
unlink() u0.42
wait() u0.43
write() u0.44
z_perror() u0.45
z_printf() u0.45
z_putchar() u0.45
z_puts() u0.45
z_vprintf() u0.45
_exit() u0.2
_Exit() u0.2
Vedere _exit(2) [u0.2].
_exit, _Exit - conclusione del processo chiamante
#include <unistd.h> void _exit (int status);
#include <stdlib.h> void _Exit (int status);
Le funzioni _exit() e _Exit() sono equivalenti e servono per concludere il processo chiamante, con un valore pari a quello indicato come argomento (status), purché inferiore o uguale 255 (FF16).
La conclusione del processo implica anche la chiusura dei suoi file aperti, e l'affidamento di eventuali processi figli al processo numero uno (init); inoltre, si ottiene l'invio di un segnale SIGCHLD al processo genitore di quello che viene concluso.
La funzione non può restituire alcunché, dal momento che la sua esecuzione comporta la morte del processo.
lib/unistd.h [u0.17]
lib/unistd/_exit.c [i189.17.1]
lib/stdlib.h [u0.10]
lib/stdlib/_Exit.c [i189.10.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_exit.c [i188.9.22]
execve(2) [u0.10], fork(2) [u0.14], kill(2) [u0.22], wait(2) [u0.43], atexit(3) [u0.4], exit(3) [u0.4].
chdir - modifica della directory corrente
#include <unistd.h> int chdir (const char *path);
La funzione chdir() cambia la directory corrente, in modo che quella nuova corrisponda al percorso annotato nella stringa path.
EINVALArgomento non valido.
EACCESAccesso negato.
ENOTDIRUno dei componenti del percorso non è una directory.
ENOENTUno dei componenti del percorso non esiste.
lib/unistd.h [u0.17]
lib/unistd/chdir.c [i189.17.3]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_chdir.c [i188.4.32]
chmod, fchmod - cambiamento della modalità dei permessi di un file
#include <sys/stat.h> int chmod (const char *path, mode_t mode); int fchmod (int fdn, mode_t mode);
Le funzioni chmod() e fchmod() consentono di modificare la modalità dei permessi di accesso di un file. La funzione chmod() individua il file su cui intervenire attraverso un percorso, ovvero la stringa path; la funzione fchmod(), invece, richiede l'indicazione del numero di un descrittore di file, già aperto. In entrambi i casi, l'ultimo argomento serve a specificare la nuova modalità dei permessi.
Tradizionalmente, i permessi si scrivono attraverso un numero in base otto; in alternativa, si possono usare convenientemente della macro-variabili, dichiarate nel file sys/stat.h, combinate assieme con l'operatore binario OR.
S_IRWXU007008 Lettura, scrittura ed esecuzione per l'utente proprietario.
S_IRUSR004008 Lettura per l'utente proprietario.
S_IWUSR002008 Scrittura per l'utente proprietario.
S_IXUSR001008 Esecuzione per l'utente proprietario.
S_IRWXG000708 Lettura, scrittura ed esecuzione per il gruppo.
S_IRGRP000408 Lettura per il gruppo.
S_IWGRP000208 Scrittura per il gruppo.
S_IXGRP000108 Esecuzione per il gruppo.
S_IRWXO000078 Lettura, scrittura ed esecuzione per gli altri utenti.
S_IROTH000048 Lettura per gli altri utenti.
S_IWOTH000028 Scrittura per gli altri utenti.
S_IXOTH000018 Esecuzione per gli altri utenti.
os16 non considera i permessi SUID (Set user id), SGID (Set group id) e Sticky, che nella tabella non sono stati nemmeno annotati; inoltre, non tiene in considerazione i permessi legati al gruppo.
EACCESPermesso negato.
EBADFIl descrittore del file richiesto non è valido.
lib/sys/stat.h [u0.13]
lib/sys/stat/chmod.c [i189.13.1]
lib/sys/stat/fchmod.c [i189.13.2]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_chmod.c [i188.4.33]
chmod(1) [u0.5], chown(2) [u0.5], open(2) [u0.28], stat(2) [u0.36].
chown, fchown - modifica della proprietà dei file
#include <unistd.h> int chown (const char *path, uid_t uid, gid_t gid); int fchown (int fdn, uid_t uid, gid_t gid);
Le funzioni chown() e fchown(), modificano la proprietà di un file, fornendo il numero UID e il numero GID. Il file viene indicato, rispettivamente, attraverso il percorso scritto in una stringa, oppure come numero di descrittore già aperto.
EINVALArgomento non valido.
EPERMPermessi insufficienti per eseguire l'operazione.
ENOTDIRUno dei componenti del percorso non è una directory.
ENOENTUno dei componenti del percorso non esiste.
EBADFIl descrittore del file non è valido.
Le funzioni consentono di attribuire il numero del gruppo, ma os16 non valuta i permessi di accesso ai file, relativi ai gruppi.
lib/unistd.h [u0.17]
lib/unistd/chown.c [i189.17.4]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_chown.c [i188.4.34]
kernel/fs/fd_chown.c [i188.4.2]
chmod(2) [u0.4].
clock - tempo della CPU espresso in unità clock_t
#include <time.h> clock_t clock (void);
La funzione clock() restituisce il tempo di utilizzo della CPU, espresso in unità clock_t, corrispondenti a secondi diviso il valore della macro-variabile CLOCKS_PER_SEC. Per os16, come dichiarato nel file time.h, il valore di CLOCKS_PER_SEC è 18, essendo la frequenza di CPU poco più di 18 Hz.
La funzione restituisce il tempo di CPU, espresso in multipli di 1/18 di secondo.
lib/time.h [u0.16]
lib/time/clock.c [i189.16.2]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/k_libc/k_clock.c [i188.6.1]
time(2) [u0.39].
close - chiusura di un descrittore di file
#include <unistd.h> int close (int fdn);
Le funzioni close() chiude un descrittore di file.
EBADFIl descrittore del file non è valido.
lib/unistd.h [u0.17]
lib/unistd/close.c [i189.17.5]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/fd_close.c [i188.4.3]
dup, dup2 - duplicazione di descrittori di file
#include <unistd.h> int dup (int fdn_old); int dup2 (int fdn_old, int fdn_new);
Le funzioni dup() e dup2() servono a duplicare un descrittore di file. La funzione dup() duplica il descrittore fdn_old, utilizzando il numero di descrittore libero più basso che sia disponibile; dup2(), invece, richiede che il nuovo numero di descrittore sia specificato, attraverso il parametro fdn_new. Tuttavia, se il numero di descrittore fdn_new risulta utilizzato, questo viene chiuso prima di diventare la copia di fdn_old.
EBADFUno dei descrittori specificati non è valido.
EMFILETroppi file aperti per il processo.
lib/unistd.h [u0.17]
lib/unistd/dup.c [i189.17.6]
lib/unistd/dup2.c [i189.17.7]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/fd_dup.c [i188.4.4]
kernel/fs/fd_dup2.c [i188.4.5]
Vedere dup(2) [u0.8].
execve - esecuzione di un file
#include <unistd.h> int execve (const char *path, char *const argv[], char *const envp[]);
La funzione execve() è quella che avvia effettivamente un programma, mentre le altre funzioni exec...() offrono semplicemente un'interfaccia differente per l'avvio, ma poi si avvalgono di execve() per svolgere effettivamente quanto loro richiesto.
La funzione execve() avvia il file il cui percorso è specificato come stringa, nel primo argomento.
Il secondo argomento deve essere un array di stringhe, dove la prima deve rappresentare il nome del programma avviato e le successive sono gli argomenti da passare al programma. L'ultimo elemento di tale array deve essere un puntatore nullo, per poter essere riconosciuto.
Il terzo argomento deve essere un array di stringhe, rappresentanti l'ambiente da passare al nuovo processo. Per ambiente si intende l'insieme delle variabili di ambiente, pertanto queste stringhe devono avere la forma nome=valore, per essere riconoscibili. Anche in questo caso, per poter individuare l'ultimo elemento dell'array, questo deve essere un puntatore nullo.
Se execve() riesce nel suo compito, non può restituire alcunché, dato che in quel momento, il processo chiamante viene rimpiazzato da quello del file che viene eseguito. Pertanto, se viene restituito qualcosa, può trattarsi solo di un valore che rappresenta un errore, ovvero -1, aggiornando anche la variabile errno di conseguenza.
E2BIGCi sono troppi argomenti.
ENOMEMMemoria insufficiente.
ENOENTIl file richiesto non esiste.
EACCESIl file non può essere avviato per la mancanza dei permessi di acceso necessari.
ENOEXECIl file non può essere un file eseguibile, perché non ne ha le caratteristiche.
EIOErrore di input-output.
os16 non prevede l'interpretazione di script, perché non esiste alcun programma in grado di farlo. Anche la shell di os16 si limita a eseguire i comandi inseriti, ma non può interpretare un file.
lib/unistd.h [u0.17]
lib/unistd/execle.c [i189.17.10]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_exec.c [i188.9.21]
fork(2) [u0.14], exec(3) [u0.20], getopt(3) [u0.52], environ(7) [u0.1].
Vedere chmod(2) [u0.4].
Vedere chown(2) [u0.5].
fcntl - configurazione e intervento sui descrittori di file
#include <fcntl.h> int fcntl (int fdn, int cmd, ...);
La funzione fcntl() esegue un'operazione, definita dal parametro cmd, sul descrittore richiesto come primo parametro (fdn). A seconda del tipo di operazione richiesta, potrebbero essere necessari degli argomenti ulteriori, i quali però non possono essere formalizzati in modo esatto nel prototipo della funzione. Il valore del secondo parametro che rappresenta l'operazione richiesta, va fornito in forma di costante simbolica, come descritto nell'elenco seguente.
fcntl (fdn, F_DUPFD,Richiede la duplicazione del descrittore di file fdn, in modo tale che la copia abbia il numero di descrittore minore possibile, ma maggiore o uguale a quello indicato come argomento fdn_min.
(int) fdn_min)
fcntl (fdn, F_GETFD)
fcntl (fdn, F_SETFD,Rispettivamente, legge o imposta, gli indicatori del descrittore di file fdn (eventualmente noti come file descriptor flags o solo fd flags). Per il momento, è possibile impostare un solo indicatore, FD_CLOEXEC, pertanto, al posto di fd_flags si può mettere solo la costante FD_CLOEXEC.
(int) fd_flags)
fcntl (fdn, F_GETFL)
fcntl (fdn, F_SETFL,Rispettivamente, legge o imposta, gli indicatori dello stato del file, relativi al descrittore fdn (eventualmente noti come file flaga o solo fl flags). Per impostare questi indicatori, vanno combinate delle costanti simboliche: O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC.
(int) fl_flags)
Il significato del valore restituito dalla funzione dipende dal tipo di operazione richiesta, come sintetizzato dalla tabella successiva.
F_DUPFDSi ottiene il numero del descrittore prodotto dalla copia, oppure -1 in caso di errore.
F_GETFDSi ottiene il valore degli indicatori del descrittore (fd flags), oppure -1 in caso di errore.
F_GETFLSi ottiene il valore degli indicatori del file (fl flags), oppure -1 in caso di errore.
F_GETOWN
F_SETOWN
F_GETLK
F_SETLK
F_SETLKWSi ottiene -1, in quanto si tratta di operazioni non realizzate in questa versione della funzione, per os16.
E_NOT_IMPLEMENTEDÈ stato richiesto un tipo di operazione che non è disponibile nel caso particolare di os16.
EINVALÈ stato richiesto un tipo di operazione non valido.
lib/fcntl.h [u0.4]
lib/fcntl/fcntl.c [i189.4.2]
fork - sdoppiamento di un processo, ovvero creazione di un processo figlio
#include <unistd.h> pid_t fork (void);
La funzione fork() crea una copia del processo in corso, la quale copia diventa un processo figlio del primo. Il processo figlio eredita una copia dei descrittori di file aperti e di conseguenza dei flussi di file e directory.
Il processo genitore riceve dalla funzione il valore del numero PID del processo figlio avviato; il processo figlio si mette a funzionare dal punto in cui si trova la funzione fork(), restituendo però un valore nullo: in questo modo tale processo figlio può riconoscersi come tale.
La funzione restituisce al processo genitore il numero PID del processo figlio; al processo figlio restituisce zero. In caso di problemi, invece, il valore restituito è -1 e la variabile errno risulta aggiornata di conseguenza.
ENOMEMMemoria insufficiente per avviare un altro processo.
lib/unistd.h [u0.17]
lib/unistd/fork.c [i189.17.17]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_fork.c [i188.9.23]
Vedere stat(2) [u0.36].
getcwd - determinazione della directory corrente
#include <unistd.h> char *getcwd (char *buffer, size_t size);
La funzione getcwd() modifica il contenuto dell'area di memoria a cui punta buffer, copiandovi al suo interno la stringa che rappresenta il percorso della directory corrente. La scrittura all'interno di buffer può prolungarsi al massimo per size byte, incluso il codice nullo di terminazione delle stringhe.
La funzione restituisce il puntatore alla stringa che rappresenta il percorso della directory corrente, il quale deve coincidere con buffer. In caso di errore, invece, la funzione restituisce il puntatore nullo NULL.
EINVALIl puntatore buffer non è valido.
E_LIMITIl percorso della directory corrente è troppo lungo, rispetto ai limiti realizzativi di os16.
La funzione getcwd() di os16 deve comunicare con il kernel per ottenere l'informazione che le serve, perché la «u-area» (User area) è trattenuta all'interno del kernel stesso.
lib/unistd.h [u0.17]
lib/unistd/getcwd.c [i189.17.18]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
chdir(2) [u0.3].
Vedere getuid(2) [u0.18].
getuid, geteuid - determinazione dell'identità reale ed efficace
#include <unistd.h> uid_t getuid (void); uid_t geteuid (void);
La funzione getuid() restituisce il numero corrispondente all'identità reale del processo; la funzione geteuid() restituisce il numero dell'identità efficace del processo.
Il numero UID, reale o efficace del processo chiamante. Non sono previsti casi di errore.
Le funzioni getuid() e geteuid() di os16 devono comunicare con il kernel per ottenere l'informazione che a loro serve, perché la «u-area» (User area) è trattenuta all'interno del kernel stesso.
lib/unistd.h [u0.17]
lib/unistd/getuid.c [i189.17.24]
lib/unistd/geteuid.c [i189.17.19]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
setuid(2) [u0.33].
Vedere getpid(2) [u0.20].
getpid, getppid, getpgrp - determinazione del numero del processo o del gruppo di processi
#include <unistd.h> pid_t getpid (void); pid_t getppid (void); pid_t getpgrp (void);
La funzione getpid() restituisce il numero del processo chiamante; la funzione getppid() restituisce il numero del processo genitore rispetto a quello chiamante; la funzione getpgrp() restituisce il numero attribuito al gruppo di processi a cui appartiene quello chiamante.
Il numero di processo o di gruppo di processi, relativo al contesto della funzione. Non sono previsti casi di errore.
Le funzioni getpid(), getppid() e getpgrp() di os16 devono comunicare con il kernel per ottenere l'informazione che a loro serve, perché la «u-area» (User area) è trattenuta all'interno del kernel stesso.
lib/unistd.h [u0.17]
lib/unistd/getpid.c [i189.17.22]
lib/unistd/getppid.c [i189.17.23]
lib/unistd/getpgrp.c [i189.17.21]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
Vedere getpid(2) [u0.20].
kill - invio di un segnale a un processo
#include <sys/types.h> #include <signal.h> int kill (pid_t pid, int sig)
La funzione kill() invia il segnale sig al processo numero pid, oppure a un gruppo di processi. Questa realizzazione particolare di os16 comporta come segue:
se il valore pid è maggiore di zero, il segnale viene inviato al processo con il numero pid, ammesso di averne il permesso;
se il valore pid è pari a zero, il segnale viene inviato a tutti i processi appartenenti allo stesso utente (quelli che hanno la stessa identità efficace, ovvero il valore euid), ma se il processo che chiama la funzione lavora con un valore di euid pari a zero, il segnale viene inviato a tutti i processi, a partire dal numero due (si salta init);
valori negativi di pid non vengono presi in considerazione.
EPERMIl processo non ha i permessi per inviare il segnale alla destinazione richiesta.
ESRCHLa ricerca del processo pid è fallita. Nel caso di os16, si ottiene questo errore anche per valori negativi di pid.
lib/sys/types.h [u0.14]
lib/signal.h [u0.8]
lib/signal/kill.c [i189.8.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_kill.c [i188.9.24]
signal(2) [u0.34].
link - creazione di un collegamento fisico tra un file esistente e un altro nome
#include <unistd.h> int link (const char *path_old, const char *path_new);
La funzione link() produce un nuovo collegamento a un file già esistente. Va fornito il percorso del file già esistente, path_old e quello del file da creare, in qualità di collegamento, path_new. L'operazione può avvenire soltanto se i due percorsi si trovano sulla stessa unità di memorizzazione e se ci sono i permessi di scrittura necessari nella directory di destinazione. Dopo l'operazione di collegamento, fatta in questo modo, non è possibile distinguere quale sia il file originale e quale sia invece il nome aggiunto.
EINVALGli argomenti forniti alla chiamata non sono validi per qualche ragione.
EPERMOperazione non consentita.
EEXISTIl nome da creare esiste già.
EACCESAccesso non consentito.
ENOENTIl file non esiste, oppure non esiste il percorso che porta al file da creare.
EROFSIl file system consente soltanto un accesso in lettura.
ENOTDIRUno dei due percorsi non è valido, in quanto ciò che dovrebbe essere una directory, non lo è.
lib/unistd.h [u0.17]
lib/unistd/link.c [i189.17.26]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_link.c [i188.4.40]
ln(1) [u0.11] open(2) [u0.28], stat(2) [u0.36], unlink(2) [u0.42].
lseek - riposizionamento dell'indice di accesso a un descrittore di file
#include <unistd.h> off_t lseek (int fdn, off_t offset, int whence);
La funzione lseek() consente di riposizionare l'indice di accesso interno al descrittore di file fdn. Per fare questo occorre prima determinare un punto di riferimento, rappresentato dal parametro whence, dove va usata una macro-variabile definita nel file unistd.h. Può trattarsi dei casi seguenti.
SEEK_SETLo scostamento si riferisce all'inizio del file.
SEEK_CURLo scostamento si riferisce alla posizione che ha già l'indice interno al file.
SEEK_ENDLo scostamento si riferisce alla fine del file.
Lo scostamento indicato dal parametro offset si applica a partire dalla posizione a cui si riferisce whence, pertanto può avere segno positivo o negativo, ma in ogni caso non è possibile collocare l'indice prima dell'inizio del file.
Se l'operazione avviene con successo, la funzione restituisce il valore dell'indice riposizionato, preso come scostamento a partire dall'inizio del file. In caso di errore, restituisce invece il valore -1, aggiornando di conseguenza anche la variabile errno.
EBADFIl numero del descrittore di file non è valido.
EINVALIl valore di whence non è contemplato, oppure la combinazione tra whence e offset non è valida.
lib/unistd.h [u0.17]
lib/unistd/lseek.c [i189.17.27]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/fd_lseek.c [i188.4.7]
dup(2) [u0.8] fork(2) [u0.14], open(2) [u0.28], fseek(3) [u0.43].
mkdir - creazione di una directory
#include <sys/stat.h> int mkdir (const char *path, mode_t mode);
La funzione mkdir() crea una directory, indicata attraverso un percorso, nel parametro path, specificando la modalità dei permessi, con il parametro mode.
Tuttavia, il valore del parametro mode non viene preso in considerazione integralmente: di questo si considerano solo gli ultimi nove bit, ovvero quelli dei permessi di utenti, gruppi e altri utenti; inoltre, vengono tolti i bit presenti nella maschera dei permessi associata al processo (si veda anche umask(2) [u0.40]).
La directory che viene creata in questo modo, appartiene all'identità efficace del processo, ovvero all'utente per conto del quale questo sta funzionando.
EINVALIl percorso indicato non è valido.
EEXISTEsiste già un file o una directory con lo stesso nome.
ENOTDIRUna porzione del percorso della directory da creare, non è una directory.
ENOENTUna porzione del percorso della directory da creare non esiste.
EACCESPermesso negato.
lib/sys/stat.h [u0.13]
lib/sys/stat/mkdir.c [i189.13.4]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_mkdir.c [i188.4.41]
mkdir(1) [u0.15], chmod(2) [u0.4], chown(2) [u0.5], mknod(2) [u0.26], mount(2) [u0.27], stat(2) [u0.36], umask(2) [u0.40], unlink(2) [u0.42].
mknod - creazione di un file vuoto di qualunque tipo
#include <sys/stat.h> int mknod (const char *path, mode_t mode, dev_t device);
La funzione mknod() crea un file vuoto, di qualunque tipo. Potenzialmente può creare anche una directory, ma priva di qualunque voce, rendendola così non adeguata al suo scopo (una directory richiede almeno le voci . e .., per potersi considerare tale).
Il parametro path specifica il percorso del file da creare; il parametro mode serve a indicare il tipo di file da creare, oltre ai permessi comuni.
Il parametro device, con il quale va indicato il numero di un dispositivo (completo di numero primario e secondario), viene preso in considerazione soltanto se nel parametro mode si richiede la creazione di un file di dispositivo a caratteri o a blocchi.
Il valore del parametro mode va costruito combinando assieme delle macro-variabili definite nel file sys/stat.h, come descritto nella pagina di manuale stat(2) [u0.36], tenendo conto che os16 non può gestire file FIFO, collegamenti simbolici e socket di dominio Unix.
Il valore del parametro mode, per la porzione che riguarda i permessi di accesso al file, viene comunque filtrato con la maschera dei permessi (umask(2) [u0.36]).
EINVALIl percorso indicato non è valido.
EEXISTEsiste già un file o una directory con lo stesso nome.
ENOTDIRUna porzione del percorso del file da creare, non è una directory.
ENOENTUna porzione del percorso del file da creare non esiste.
EACCESPermesso negato.
lib/sys/stat.h [u0.13]
lib/sys/stat/mknod.c [i189.13.5]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_mknod.c [i188.4.42]
mkdir(2) [u0.25], chmod(2) [u0.4], chown(2) [u0.5], fcntl(2) [u0.13], stat(2) [u0.36], umask(2) [u0.40], unlink(2) [u0.42].
mount, umount - innesto e distacco di unità di memorizzazione
#include <sys/os16.h> int mount (const char *path_dev, const char *path_mnt, int options); int umount (const char *path_mnt);
La funzione mount() permette l'innesto di un'unità di memorizzazione individuata attraverso il percorso del file di dispositivo nel parametro path_dev, nella directory corrispondente al percorso path_mnt, con le opzioni indicate numericamente nell'ultimo argomento options. Le opzioni di innesto, rappresentate attraverso delle macro-variabili, sono solo due:
MOUNT_DEFAULTInnesto normale, in lettura e scrittura.
MOUNT_ROInnesto in sola lettura.
La funzione umount() consente di staccare un innesto fatto precedentemente, specificando il percorso della directory in cui questo è avvenuto.
EPERMProblema di accesso dovuto alla mancanza dei permessi necessari.
ENOTDIRCiò che dovrebbe essere una directory, non lo è.
EBUSYLa directory innesta già un file system e non può innestarne un altro.
ENOENTLa directory non esiste.
E_NOT_MOUNTEDLa directory non innesta un file system da staccare.
EUNKNOWNSi è verificato un problema non previsto e sconosciuto.
lib/sys/os16.h [u0.12]
lib/sys/os16/mount.c [i189.12.12]
lib/sys/os16/umount.c [i189.12.16]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_mount.c [i188.4.43]
kernel/fs/path_umount.c [i188.4.45]
open - apertura di un file puro e semplice oppure di un file di dispositivo
#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open (const char *path, int oflags); int open (const char *path, int oflags, mode_t mode);
La funzione open() apre un file, indicato attraverso il percorso path, in base alle opzioni rappresentate dagli indicatori oflags. A seconda del tipo di indicatori specificati, potrebbe essere richiesto il parametro mode.
Quando la funzione porta a termine correttamente il proprio compito, restituisce il numero del descrittore del file associato, il quale è sempre quello di valore più basso disponibile per il processo elaborativo in corso.
Il descrittore di file ottenuto inizialmente con la funzione open(), è legato al processo elaborativo in corso; tuttavia, se successivamente il processo si sdoppia attraverso la funzione fork(), tale descrittore, se ancora aperto, viene duplicato nella nuova copia del processo. Inoltre, se per il descrittore aperto non viene impostato l'indicatore FD_CLOEXEC (con l'ausilio della funzione fcntl()), se il processo viene rimpiazzato con la funzione execve(), il descrittore aperto viene ereditato dal nuovo processo.
Il parametro oflags richiede necessariamente la specificazione della modalità di accesso, attraverso la combinazione appropriata dei valori: O_RDONLY, O_WRONLY, O_RDWR. Inoltre, si possono combinare altri indicatori: O_CREAT, O_TRUNC, O_APPEND.
O_RDONLYRichiede un accesso in lettura.
O_WRONLYRichiede un accesso in scrittura.
O_RDWR
O_RDONLY|O_WRONLYRichiede un accesso in lettura e scrittura (la combinazione di R_RDONLY e di O_WRONLY è equivalente all'uso di O_RDWR).
O_CREATRichiede di creare contestualmente il file, ma in tal caso va usato anche il parametro mode.
O_TRUNCSe file da aprire esiste già, richiede che questo sia ridotto preventivamente a un file vuoto.
O_APPENDFa in modo che le operazioni di scrittura avvengano sempre partendo dalla fine del file.
Quando si utilizza l'opzione O_CREAT, è necessario stabilire la modalità dei permessi, cosa che va fatta preferibilmente attraverso la combinazione di costanti simboliche appropriate, come elencato nella tabella successiva. Tale combinazione va fatta con l'uso dell'operatore OR binario; per esempio: S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH. Va osservato che os16 non gestisce i gruppi di utenti, pertanto, la definizione dei permessi relativi agli utenti appartenenti al gruppo proprietario di un file, non ha poi effetti pratici nel controllo degli accessi per tale tipo di contesto.
S_IRWXU007008 Lettura, scrittura ed esecuzione per l'utente proprietario.
S_IRUSR004008 Lettura per l'utente proprietario.
S_IWUSR002008 Scrittura per l'utente proprietario.
S_IXUSR001008 Esecuzione per l'utente proprietario.
S_IRWXG000708 Lettura, scrittura ed esecuzione per il gruppo.
S_IRGRP000408 Lettura per il gruppo.
S_IWGRP000208 Scrittura per il gruppo.
S_IXGRP000108 Esecuzione per il gruppo.
S_IRWXO000078 Lettura, scrittura ed esecuzione per gli altri utenti.
S_IROTH000048 Lettura per gli altri utenti.
S_IWOTH000028 Scrittura per gli altri utenti.
S_IXOTH000018 Esecuzione per gli altri utenti.
La funzione restituisce il numero del descrittore del file aperto, se l'operazione ha avuto successo, altrimenti dà semplicemente -1, impostando di conseguenza il valore della variabile errno.
EINVALGli argomenti forniti alla chiamata non sono validi per qualche ragione.
EPERMOperazione non consentita.
EEXISTIl file da creare esiste già.
EACCESAccesso non consentito.
ENOENTIl file non esiste, oppure non esiste il percorso che porta al file da creare.
EROFSAvendo richiesto un accesso in scrittura, si ottiene che il file system che lo contiene consente soltanto un accesso in lettura.
ENOTDIRIl percorso che porta al file da aprire non è valido, in quanto ciò che dovrebbe essere una directory, non lo è.
ENFILENon si possono aprire altri file nell'ambito del sistema operativo (il sistema ha raggiunto il limite).
EMFILENon si possono aprire altri file nell'ambito del processo in corso.
lib/sys/types.h [u0.14]
lib/sys/stat.h [u0.13]
lib/fcntl.h [u0.4]
lib/fcntl/open.c [i189.4.3]
chmod(2) [u0.4], chown(2) [u0.5], close(2) [u0.7], dup(2) [u0.8], fcntl(2) [u0.13], link(2) [u0.24], mknod(2) [u0.26], mount(2) [u0.27], read(2) [u0.29], stat(2) [u0.36], umask(2) [u0.40], unlink(2) [u0.42], write(2) [u0.44], fopen(3) [u0.35].
read - lettura di descrittore di file
#include <unistd.h> ssize_t read (int fdn, void *buffer, size_t count);
La funzione read() cerca di leggere il file rappresentato dal descrittore fdn, partendo dalla posizione in cui si trova l'indice interno di accesso, per un massimo di count byte, collocando i dati letti in memoria a partire dal puntatore buffer. L'indice interno al file viene fatto avanzare della quantità di byte letti effettivamente, se invece si incontra la fine del file, viene aggiornato l'indicatore interno per segnalare tale fatto.
La funzione restituisce la quantità di byte letti effettivamente, oppure zero se è stata raggiunta la fine del file e non si può proseguire oltre. Va osservato che la lettura effettiva di una quantità inferiore di byte rispetto a quanto richiesto non costituisce un errore: in quel caso i byte mancanti vanno richiesti con successive operazioni di lettura. In caso di errore, la funzione restituisce il valore -1, aggiornando contestualmente la variabile errno.
EBADFIl numero del descrittore di file non è valido.
EINVALIl file non è aperto in lettura.
E_FILE_TYPE_UNSUPPORTEDIl file è di tipo non gestibile con os16.
lib/unistd.h [u0.17]
lib/unistd/read.c [i189.17.28]
lib/sys/os16/sys.s [i189.12.15]
kernel/fs/fd_read.c [i188.4.9]
rmdir - eliminazione di una directory vuota
#include <unistd.h> int rmdir (const char *path);
La funzione rmdir() cancella la directory indicata come percorso, nella stringa path, purché sia vuota.
EINVALIl percorso path non è valido o è semplicemente un puntatore nullo.
ENOTDIRIl nome indicato o le posizioni intermedie del percorso si riferiscono a qualcosa che non è una directory.
ENOTEMPTYLa directory che si vorrebbe cancellare non è vuota.
EROFSLa directory si trova in un'unità innestata in sola lettura.
EPERMMancano i permessi necessari per eseguire l'operazione.
EUNKNOWNSi è verificato un errore imprevisto e sconosciuto.
lib/unistd.h [u0.17]
lib/unistd/rmdir.c [i189.17.29]
lib/sys/os16/sys.s [i189.12.15]
kernel/fs/path_unlink.c [i188.4.46]
Vedere setuid(2) [u0.33].
setpgrp - impostazione del gruppo a cui appartiene il processo
#include <unistd.h> int setpgrp (void);
La funzione setpgrp() fa sì che il processo in corso costituisca un proprio gruppo autonomo, corrispondente al proprio numero PID. In altri termini, la funzione serve per iniziare un nuovo gruppo di processi, a cui i processi figli creati successivamente vengano associati in modo predefinito.
La funzione termina sempre con successo e restituisce sempre zero.
lib/unistd.h [u0.17]
lib/unistd/setpgrp.c [i189.17.31]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
setuid, seteuid - impostazione dell'identità dell'utente
#include <unistd.h> int setuid (uid_t uid); int seteuid (uid_t uid);
A ogni processo viene attribuita l'identità di un utente, rappresentata da un numero, noto come UID, ovvero user identity. Tuttavia si distinguono tre tipi di numeri UID: l'identità reale, l'identità efficace e un'identità salvata in precedenza. L'identità efficace (EUID) è quella con cui opera sostanzialmente il processo; l'identità salvata è quella che ha avuto il processo in un altro momento in qualità di identità efficace e che per qualche motivo non ha più.
La funzione setuid() riceve come argomento un numero UID e si comporta diversamente a seconda della personalità del processo, come descritto nell'elenco successivo:
se l'identità efficace del processo corrisponde a zero, trattandosi di un caso particolarmente privilegiato, tutte le identità del processo (reale, efficace e salvata) vengono inizializzate con il valore fornito alla funzione setuid();
se l'identità efficace del processo corrisponde a quella fornita come argomento a setuid(), nulla cambia nella gestione delle identità del processo;
se l'identità reale o quella salvata in precedenza corrispondono a quella fornita come argomento di setuid(), viene aggiornato il valore dell'identità efficace, senza cambiare le altre;
in tutti gli altri casi, l'operazione non è consentita e si ottiene un errore.
La funzione seteuid() riceve come argomento un numero UID e imposta con tale valore l'identità efficace del processo, purché si verifichi almeno una delle condizioni seguenti:
l'identità efficace del processo è zero;
l'identità reale o quella salvata del processo corrisponde all'identità efficace che si vuole impostare;
l'identità efficace del processo corrisponde già all'identità efficace che si vuole impostare.
EPERMNon si dispone dei permessi necessari a eseguire il cambiamento di identità.
lib/unistd.h [u0.17]
lib/unistd/setuid.c [i189.17.32]
lib/unistd/seteuid.c [i189.17.30]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
getuid(2) [u0.33].
signal - abilitazione e disabilitazione dei segnali
#include <signal.h> sighandler_t signal (int sig, sighandler_t handler);
La funzione signal() di os16 consente soltanto di abilitare o disabilitare un segnale, il quale, se abilitato, può essere gestito solo in modo predefinito dal sistema. Pertanto, il valore che può assumere handler sono solo: SIG_DFL (gestione predefinita) e SIG_IGN (ignora il segnale). Il primo parametro, sig, rappresenta il segnale a cui applicare handler.
Il tipo sighandler_t è definito nel file signal.h, nel modo seguente:
typedef void (*sighandler_t) (int);
Rappresenta il puntatore a una funzione avente un solo parametro di tipo int, la quale non restituisce alcunché.
La funzione restituisce il tipo di «gestione» impostata precedentemente per il segnale richiesto, ovvero SIG_ERR in caso di errore.
EINVALIl numero sig o il valore di handler non sono validi.
Lo scopo della funzione signal() dovrebbe essere quello di consentire l'associazione di un evento, manifestato da un segnale, all'esecuzione di un'altra funzione, avente una forma del tipo nome (int). os16 non consente tale gestione, pertanto lascia soltanto la possibilità di attribuire un comportamento predefinito al segnale scelto, oppure di disabilitarlo, ammesso che ciò sia consentito. Sotto questo aspetto, il fatto di dover gestire i valori SIG_ERR, SIG_DFL e SIG_IGN, come se fossero puntatori a una funzione, diventa superfluo, ma rimane utile soltanto per mantenere un minimo di conformità con quello che è lo standard della funzione signal().
lib/signal.h [u0.8]
lib/signal/signal.c [i189.8.2]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_signal.c [i188.9.27]
kill(2) [u0.22].
sleep - pausa volontaria del processo chiamante
#include <unistd.h> unsigned int sleep (unsigned int seconds);
La funzione sleep() chiede di mettere a riposo il processo chiamante per la quantità di secondi indicata come argomento. Il processo può però essere risvegliato prima della conclusione di tale durata, ma in tal caso la funzione restituisce la quantità di secondi che non sono stati usati per il «riposo» del processo.
La funzione restituisce zero se la pausa richiesta è trascorsa completamente; altrimenti, restituisce quanti secondi mancano ancora per completare il tempo di riposo chiesto originariamente. Non si prevede il manifestarsi di errori.
lib/unistd.h [u0.17]
lib/unistd/sleep.c [i189.17.33]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
signal(2) [u0.34].
stat, fstat - interrogazione dello stato di un file
#include <sys/stat.h> int stat (const char *path, struct stat *buffer); int fstat (int fdn, struct stat *buffer);
Le funzioni stat() e fstat() interrogano il sistema su di un file, per ottenerne le caratteristiche in forma di variabile strutturata di tipo struct stat.
La funzione stat() individua il file attraverso una stringa contenente il suo percorso (path); la funzione fstat si riferisce a un file aperto di cui si conosce il numero del descrittore (fdn). In entrambi i casi, la struttura che deve accogliere l'esito dell'interrogazione, viene indicata attraverso un puntatore, come ultimo argomento (buffer).
La struttura struct stat è definita nel file sys/stat.h nel modo seguente:
struct stat {
dev_t st_dev; // Device containing the file.
ino_t st_ino; // File serial number (inode
// number).
mode_t st_mode; // File type and permissions.
nlink_t st_nlink; // Links to the file.
uid_t st_uid; // Owner user id.
gid_t st_gid; // Owner group id.
dev_t st_rdev; // Device number if it is a
// device file.
off_t st_size; // File size.
time_t st_atime; // Last access time.
time_t st_mtime; // Last modification time.
time_t st_ctime; // Last inode modification.
blksize_t st_blksize; // Block size for I/O operations.
blkcnt_t st_blocks; // File size / block size.
};
Va osservato che il file system Minix 1, usato da os16, riporta esclusivamente la data e l'ora di modifica, pertanto le altre due date previste sono sempre uguali a quella di modifica.
Il membro st_mode, oltre alla modalità dei permessi che si cambiano con chmod(2) [u0.4], serve ad annotare altre informazioni. Nel file sys/stat.h sono definite delle macroistruzioni, utili per individuare il tipo di file. Queste macroistruzioni si risolvono in un valore numerico diverso da zero, solo se la condizione che rappresentano è vera:
S_ISBLK (m)È un file di dispositivo a blocchi?
S_ISCHR (m)È un file di dispositivo a caratteri?
S_ISFIFO (m)È un file FIFO?
S_ISREG (m)È un file puro e semplice?
S_ISDIR (m)È una directory?
S_ISLNK (m)È un collegamento simbolico?
S_ISSOCK (m)È un socket di dominio Unix?
Naturalmente, anche se nel file system possono esistere file di ogni tipo, poi os16 non è in grado di gestire i file FIFO, i collegamenti simbolici e nemmeno i socket di dominio Unix.
Nel file sys/stat.h sono definite anche delle macro-variabili per individuare e facilitare la selezione dei bit che compongono le informazioni del membro st_mode:
S_IFMT01700008 Maschera che raccoglie tutti i bit che individuano il tipo di file.
S_IFBLK00600008 File di dispositivo a blocchi.
S_IFCHR00200008 File di dispositivo a caratteri.
S_IFIFO00100008 File FIFO.
S_IFREG01000008 File puro e semplice.
S_IFDIR00400008 Directory.
S_IFLNK01200008 Collegamento simbolico.
S_IFSOCK01400008 Socket di dominio Unix.
S_ISUID00040008 SUID.
S_ISGID00020008 SGID.
S_ISVTX00010008 Sticky.
S_IRWXU00007008 Lettura, scrittura ed esecuzione per l'utente proprietario.
S_IRUSR00004008 Lettura per l'utente proprietario.
S_IWUSR00002008 Scrittura per l'utente proprietario.
S_IXUSR00001008 Esecuzione per l'utente proprietario.
S_IRWXG00000708 Lettura, scrittura ed esecuzione per il gruppo.
S_IRGRP00000408 Lettura per il gruppo.
S_IWGRP00000208 Scrittura per il gruppo.
S_IXGRP00000108 Esecuzione per il gruppo.
S_IRWXO00000078 Lettura, scrittura ed esecuzione per gli altri utenti.
S_IROTH00000048 Lettura per gli altri utenti.
S_IWOTH00000028 Scrittura per gli altri utenti.
S_IXOTH00000018 Esecuzione per gli altri utenti.
os16 non considera i permessi SUID (Set user id), SGID (Set group id) e Sticky; inoltre, non tiene in considerazione i permessi legati al gruppo, perché non ne tiene traccia.
ENFILETroppi file aperti nel sistema.
ENOENTFile non trovato.
EACCESPermesso negato.
EBADFIl descrittore del file richiesto non è valido.
lib/sys/stat.h [u0.13]
lib/sys/stat/stat.c [i189.13.6]
lib/sys/stat/fstat.c [i189.13.3]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_stat.c [i188.4.44]
kernel/fs/fd_stat.c [i188.4.11]
sys - chiamata di sistema
#include <sys/os16.h> void sys (int syscallnr, void *message, size_t size);
Attraverso la funzione sys() si effettuano tutte le chiamate di sistema, passando al kernel un messaggio, a cui punta message, lungo size byte. A seconda dei casi, il messaggio può essere modificato dal kernel, come risposta alla chiamata.
Il messaggio è in pratica una variabile strutturata, la cui articolazione cambia a seconda del tipo di chiamata, pertanto si rende necessario specificarne ogni volta la dimensione.
Le strutture usate per comporre i messaggi hanno alcuni membri ricorrenti frequentemente:
char path[PATH_MAX];Un percorso di file o directory.
... ret;Serve a contenere il valore restituito dalla funzione che nel kernel compie effettivamente il lavoro. Il tipo del membro varia caso per caso.
int errno;Serve a contenere il numero dell'errore prodotto dalla funzione che nel kernel compie effettivamente il lavoro.
int errln;Serve a contenere il numero della riga di codice in cui si è prodotto un errore.
char errfn[PATH_MAX];Serve a contenere il nome del file in cui si è prodotto un errore.
Le funzioni che si avvalgono di sys(), prima della chiamata devono provvedere a compilare il messaggio con i dati necessari, dopo la chiamata devono acquisire i dati di ritorno, contenuti nel messaggio aggiornato dal kernel, e in particolare devono aggiornare le variabili errno, errln e errfl, utilizzando i membri con lo stesso nome presenti nel messaggio.
lib/sys/os16.h [u0.12]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
Vedere time(2) [u0.39].
time, stime - lettura o impostazione della data e dell'ora del sistema
#include <time.h> time_t time (time_t *timer); int stime (time_t *timer);
La funzioni time() legge la data e l'ora attuale del sistema, espressa in secondi; se il puntatore timer è valido (non è NULL), il risultato dell'interrogazione viene salvato anche in ciò a cui questo punta.
La funzione stime() consente di modificare la data e l'ora attuale del sistema, fornendo il puntatore alla variabile contenente la quantità di secondi trascorsi a partire dall'ora zero del 1 gennaio 1970.
La funzione time() restituisce la data e l'ora attuale del sistema, espressa in secondi trascorsi a partire dall'ora zero del 1 gennaio 1970.
La funzione stime() restituisce zero in caso di successo e, teoricamente, -1 in caso di errore, ma attualmente nessun tipo di errore è previsto.
La funzione stime() dovrebbe essere riservata a un utente privilegiato, mentre attualmente qualunque utente può servirsene per cambiare la data di sistema.
lib/time.h [u0.16]
lib/time/time.c [i189.16.6]
lib/time/stime.c [i189.16.5]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/k_libc.h [u0.6]
kernel/k_libc/k_time.c [i188.6.11]
kernel/k_libc/k_stime.c [i188.6.10]
umask - maschera dei permessi
#include <sys/stat.h> mode_t umask (mode_t mask);
La funzione umask() modifica la maschera dei permessi associata al processo in corso. Nel contenuto del parametro mask vengono presi in considerazione soltanto i nove bit meno significativi, i quali rappresentano i premessi di accesso di utente proprietario, gruppo e altri utenti.
La maschera dei permessi viene usata dalle funzioni che creano dei file, per limitare i permessi in modo automatico: ciò che appare attivo nella maschera è quello che non viene consentito nella creazione del file.
La funzione restituisce il valore che aveva la maschera dei permessi prima della chiamata.
lib/sys/stat.h [u0.13]
lib/sys/stat/umask.c [i189.13.7]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
mkdir(2) [u0.25], chmod(2) [u0.4], open(2) [u0.28], stat(2) [u0.36].
Vedere mount(2) [u0.27].
unlink - cancellazione di un nome
#include <unistd.h> int unlink (const char *path);
La funzione unlink() cancella un nome da una directory, ma se si tratta dell'ultimo collegamento che ha quel file, allora libera anche l'inode corrispondente.
ENOTEMPTYÈ stata tentata la cancellazione di una directory, ma questa non è vuota.
ENOTDIRUna delle directory del percorso, non è una directory.
ENOENTIl nome richiesto non esiste.
EROFSIl file system è in sola lettura.
EPERMMancano i permessi necessari.
EUNKNOWNSi è verificato un errore imprevisto e sconosciuto.
lib/unistd.h [u0.17]
lib/unistd/unlink.c [i189.17.35]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/path_unlink.c [i188.4.46]
wait - attesa della morte di un processo figlio
#include <sys/wait.h> pid_t wait (int *status);
La funzione wait() mette il processo in pausa, in attesa della morte di un processo figlio; quando ciò dovesse accadere, il valore di *status verrebbe aggiornato con quanto restituito dal processo defunto e il processo sospeso riprenderebbe l'esecuzione.
La funzione restituisce il numero del processo defunto, oppure -1 se non ci sono processi figli.
ECHILDNon ci sono processi figli da attendere.
lib/sys/wait.h [u0.15]
lib/sys/wait/wait.c [i189.15.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_wait.c [i188.9.28]
_exit(2) [u0.2], fork(2) [u0.14], kill(2) [u0.22], signal(2) [u0.34].
write - scrittura di un descrittore di file
#include <unistd.h> ssize_t write (int fdn, const void *buffer, size_t count);
La funzione write() consente di scrivere fino a un massimo di count byte, tratti dall'area di memoria che inizia all'indirizzo buffer, presso il file rappresentato dal descrittore fdn. La scrittura avviene a partire dalla posizione in cui si trova l'indice interno.
La funzione restituisce la quantità di byte scritti effettivamente e in tal caso è possibile anche ottenere una quantità pari a zero. Se si verifica invece un errore, la funzione restituisce -1 e aggiorna la variabile errno.
EBADFIl numero del descrittore di file non è valido.
EINVALIl file non è aperto in scrittura.
EISDIRIl file è una directory.
E_FILE_TYPE_UNSUPPORTEDIl file è di tipo non gestibile con os16.
EIOErrore di input-output.
lib/unistd.h [u0.17]
lib/unistd/write.c [i189.17.36]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs/fd_write.c [i188.4.12]
close(2) [u0.7], lseek(2) [u0.24], open(2) [u0.28], read(2) [u0.29], fwrite(3) [u0.48].
z_... - funzioni provvisorie
#include <sys/os16.h> void z_perror (const char *string); int z_printf (char *format, ...); int z_putchar (int c); int z_puts (char *string); int z_vprintf (char *format, va_list arg);
Le funzioni del gruppo z_...() eseguono compiti equivalenti a quelli delle funzioni di libreria con lo stesso nome, ma prive del prefisso z_. Queste funzioni z_...() si avvalgono, per il loro lavoro, di chiamate di sistema particolari; la loro realizzazione si è resa necessaria durante lo sviluppo di os16, prima che potesse essere disponibile un sistema di gestione centralizzato dei dispositivi.
Queste funzioni non sono più utili, ma rimangono per documentare le fasi realizzative iniziali di os16 e, d'altro canto, possono servire se si rende necessario raggirare la gestione dei dispositivi per visualizzare dei messaggi sullo schermo.
lib/sys/os16.h [u0.12]
lib/sys/os16/z_perror.c [i189.12.17]
lib/sys/os16/z_printf.c [i189.12.18]
lib/sys/os16/z_putchar.c [i189.12.19]
lib/sys/os16/z_puts.c [i189.12.20]
lib/sys/os16/z_vprintf.c [i189.12.21]
perror(3) [u0.77], printf(3) [u0.78], putchar(3) [u0.37], puts(3) [u0.38], vprintf(3) [u0.128], vsprintf(3) [u0.128].
Vedere z(2) [u0.45].
Vedere z(2) [u0.45].
Vedere z(2) [u0.45].
Vedere z(2) [u0.45].
Vedere z(2) [u0.45].
«a2» 2013年11月11日 --- Copyright © Daniele Giacomini -- appunti2@gmail.com http://informaticalibera.net