Figura u175.1. Interdipendenza tra la funzione dev_io() e le altre. I collegamenti con le funzioni major() e minor() sono omesse.
devices.h u0.1
dev_dsk() i187.1.2
dev_io() i187.1.1
dev_kmem() i187.1.3
dev_mem() i187.1.4
dev_tty() i187.1.5
diag.h u0.2
fd_chmod() i187.3.1
fd_chown() i187.3.2
fd_close() i187.3.3
fd_dup() i187.3.4
fd_dup2() i187.3.4
fd_fcntl() i187.3.6
fd_lseek() i187.3.7
fd_open() i187.3.8
fd_read() i187.3.9
fd_reference() i187.3.10
fd_stat() i187.3.50
fd_write() i187.3.12
file_reference() i187.3.13
file_stdio_dev_make() i187.3.14
fs.h u0.3
ibm_i86.h u0.4
inode_alloc() i187.3.15
inode_check() i187.3.16
inode_dir_empty() i187.3.17
inode_file_read() i187.3.18
inode_file_write() i187.3.19
inode_free() i187.3.20
inode_fzones_read() i187.3.21
inode_fzones_write() i187.3.21
inode_get() i187.3.23
inode_put() i187.3.24
inode_reference() i187.3.25
inode_save() i187.3.26
inode_stdio_dev_make() i187.3.27
inode_truncate() i187.3.28
inode_zone() i187.3.29
isr_1C i187.8.1
isr_80 i187.8.1
ivt_load() i187.8.2
k_libc.h u0.5
main.h u0.6
memory.h u0.7
path_chdir() i187.3.30
path_chmod() i187.3.31
path_chown() i187.3.32
path_device() i187.3.33
path_fix() i187.3.34
path_full() i187.3.35
path_inode() i187.3.36
path_inode_link() i187.3.37
path_link() i187.3.38
path_mkdir() i187.3.39
path_mknod() i187.3.40
path_mount() i187.3.41
path_stat() i187.3.50
path_umount() i187.3.41
path_unlink() i187.3.44
proc.h u0.8
proc_available() i187.8.3
proc_dump_memory() i187.8.4
proc_find() i187.8.5
proc_init() i187.8.6
proc_reference() i187.8.7
proc_scheduler() i187.8.11
proc_sch_signals() i187.8.8
proc_sch_terminals() i187.8.9
proc_sch_timers() i187.8.10
proc_sig_chld() i187.8.12
proc_sig_cont() i187.8.13
proc_sig_core() i187.8.14
proc_sig_ignore() i187.8.15
proc_sig_off() i187.8.16
proc_sig_on() i187.8.16
proc_sig_status() i187.8.17
proc_sig_stop() i187.8.18
proc_sig_term() i187.8.19
proc_sys_exec() i187.8.20
proc_sys_exit() i187.8.21
proc_sys_fork() i187.8.22
proc_sys_kill() i187.8.23
proc_sys_seteuid() i187.8.24
proc_sys_setuid() i187.8.25
proc_sys_signal() i187.8.26
proc_sys_wait() i187.8.27
sb_inode_status() i187.3.45
sb_mount() i187.3.46
sb_reference() i187.3.47
sb_save() i187.3.48
sb_zone_status() i187.3.45
sysroutine() i187.8.28
tty.h u0.9
zone_alloc() i187.3.51
zone_free() i187.3.51
zone_read() i187.3.53
zone_write() i187.3.53
_ivt_load() i187.8.2
Il file kernel/devices.h [u0.2] descrive ciò che serve per la gestione dei dispositivi. Tuttavia, la definizione dei numeri di dispositivo è contenuta nel file lib/sys/os16.h [u0.12], il quale viene incluso da devices.h.
|
Tabella u175.4. Classificazione dei dispositivi di os16.
|
|
Figura u175.1. Interdipendenza tra la funzione dev_io() e le altre. I collegamenti con le funzioni major() e minor() sono omesse. |
dev_io - interfaccia di accesso ai dispositivi
<kernel/devices.h>
ssize_t dev_io (pid_t pid, dev_t device, int rw, off_t offset,
void *buffer, size_t size, int *eof);
|
|
La funzione dev_io() è un'interfaccia generale per l'accesso ai dispositivi gestiti da os16.
La funzione restituisce la quantità di byte letti o scritti effettivamente. In caso di errore restituisce il valore -1 e aggiorna la variabile errno del kernel.
|
kernel/devices.h [u0.2]
kernel/devices/dev_io.c [i188.2.2]
dev_dsk(9) [i187.1.2], dev_kmem(9) [i187.1.3], dev_mem(9) [i187.1.4], dev_tty(9) [i187.1.5].
dev_dsk - interfaccia di accesso alle unità di memorizzazione di massa
<kernel/devices.h>
ssize_t dev_dsk (pid_t pid, dev_t device, int rw,
off_t offset, void *buffer,
size_t size, int *eof);
|
La funzione dev_dsk() consente di accedere alle unità di memorizzazione di massa, che per os16 si riducono ai soli dischetti da 1 440 Kibyte.
Per il significato degli argomenti, il valore restituito e gli eventuali errori, si veda dev_io(9) [i187.1.1].
kernel/devices.h [u0.2]
kernel/devices/dev_io.c [i188.2.2]
kernel/devices/dev_dsk.c [i188.2.1]
dev_kmem - interfaccia di accesso alle tabelle di dati del kernel, rappresentate in memoria
<kernel/devices.h>
ssize_t dev_kmem (pid_t pid, dev_t device, int rw,
off_t offset,
void *buffer, size_t size, int *eof);
|
La funzione dev_kmem() consente di accedere, solo in lettura, alle porzioni di memoria che il kernel utilizza per rappresentare alcune tabelle importanti. Per poter interpretare ciò che si ottiene occorre riprodurre la struttura di un elemento della tabella a cui si è interessati, pertanto occorre incorporare il file di intestazione del kernel che la descrive.
|
Per il significato degli argomenti della chiamata, per interpretare il valore restituito e gli eventuali errori, si veda dev_io(9) [i187.1.1].
kernel/devices.h [u0.2]
kernel/devices/dev_io.c [i188.2.2]
kernel/devices/dev_kmem.c [i188.2.3]
dev_mem - interfaccia di accesso alla memoria, in modo indiscriminato
<kernel/devices.h>
ssize_t dev_mem (pid_t pid, dev_t device, int rw,
off_t offset, void *buffer,
size_t size, int *eof);
|
La funzione dev_mem() consente di accedere, in lettura e in scrittura alla memoria e alle porte di input-output.
|
Per quanto non viene descritto qui, si veda dev_io(9) [i187.1.1].
kernel/devices.h [u0.2]
kernel/devices/dev_io.c [i188.2.2]
kernel/devices/dev_mem.c [i188.2.4]
dev_tty - interfaccia di accesso alla console
<kernel/devices.h>
ssize_t dev_tty (pid_t pid, dev_t device, int rw, off_t offset,
void *buffer, size_t size, int *eof);
|
La funzione dev_tty() consente di accedere, in lettura e in scrittura, a una console virtuale, scelta in base al numero del dispositivo.
Quando la lettura richiede l'attesa per l'inserimento da tastiera, se il processo elaborativo pid non è il kernel, allora viene messo in pausa, in attesa di un evento legato al terminale.
Il sistema di gestione del terminale è molto povero con os16. Va osservato che il testo letto viene anche visualizzato automaticamente. Quando un processo non vuole mostrare il testo sullo schermo, deve provvedere a sovrascriverlo immediatamente, facendo arretrare il cursore preventivamente.
Per quanto non viene descritto qui, si veda dev_io(9) [i187.1.1].
kernel/devices.h [u0.2]
kernel/devices/dev_io.c [i188.2.2]
kernel/devices/dev_tty.c [i188.2.5]
Il file kernel/diag.h [u0.3] descrive alcune funzioni e macroistruzioni, per uso diagnostico. Lo scopo di queste è di mostrare o di rendere visualizzabile alcune informazioni interne alla gestione del kernel.
Alcune di queste funzioni sono usate, altre no. Per esempio durante il funzionamento interattivo del kernel vengono usate print_proc_list(), print_segments(), print_kmem(), print_time() e print_mb_map().
Il file kernel/fs.h [u0.4] descrive ciò che serve per la gestione del file system, che per os16 corrisponde al tipo Minix 1.
La gestione del file system, a livello complessivo di sistema, è suddivisa in tre aspetti principali: super blocco, inode e file. Per ognuno di questi è prevista una tabella (di super blocchi, di inode e di file). Seguono delle figure che descrivono l'organizzazione di queste tabelle.
|
Figura u176.1. Struttura del tipo sb_t, corrispondente agli elementi dell'array sb_table[]. |
|
Listato u176.2. Struttura del tipo sb_t, corrispondente agli elementi dell'array sb_table[].
|
|
Figura u176.6. Struttura del tipo inode_t, corrispondente agli elementi dell'array inode_table[]. |
|
Listato u176.7. Struttura del tipo inode_t, corrispondente agli elementi dell'array inode_table[].
|
|
Figura u176.13. Struttura del tipo file_t, corrispondente agli elementi dell'array file_table[].
|
|
Figura u176.16. Struttura del tipo fd_t, con cui si costituiscono gli elementi delle tabelle dei descrittori di file, una per ogni processo.
|
fd_chmod - cambiamento della modalità dei permessi di un descrittore di file
<kernel/fs.h> int fd_chmod (pid_t pid, int fdn, mode_t mode); |
|
La funzione fs_chmod() cambia la modalità dei permessi del file aperto con il descrittore numero fdn, secondo il valore contenuto nel parametro mode, di cui però si considerano solo gli ultimi 12 bit. L'operazione viene svolta per conto del processo pid, il quale deve avere i privilegi necessari per poter intervenire così. La modifica della modalità dei permessi raggiunge l'inode del file a cui fa capo il descrittore in questione; pertanto l'inode viene necessariamente salvato dopo la modifica. Il fatto che il descrittore di file possa essere stato aperto in sola lettura, non impedisce la modifica dell'inode attuata da questa funzione.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_FCHMOD. Nella libreria standard, si avvale di questa funzionalità fchmod(2) [u0.4].
|
|
lib/sys/stat/fchmod.c [i189.13.2]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_chmod.c [i188.4.1]
fchmod(2) [u0.4], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7].
fd_chown - cambiamento della proprietà di un descrittore di file
<kernel/fs.h> int fd_chown (pid_t pid, int fdn, uid_t uid, gid_t gid); |
|
La funzione fs_chown() cambia la proprietà del file già aperto, individuato attraverso il suo descrittore. L'operazione viene svolta per conto del processo pid, il quale deve avere i privilegi necessari per poter intervenire così: in pratica deve trattarsi di un processo con identità efficace pari a zero, perché os16 non considera la gestione dei gruppi. La modifica della proprietà raggiunge l'inode del file a cui fa capo il descrittore in questione; pertanto l'inode viene necessariamente salvato dopo la modifica. Il fatto che il descrittore di file possa essere stato aperto in sola lettura, non impedisce la modifica dell'inode attuata da questa funzione.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_FCHOWN. Nella libreria standard, si avvale di questa funzionalità fchown(2) [u0.4].
|
|
lib/unistd/fchown.c [i189.17.16]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_chown.c [i188.4.2]
fchown(2) [u0.5], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7].
fd_close - chiusura di un descrittore di file
<kernel/fs.h> int fd_close (pid_t pid, int fdn); |
|
La funzione fd_close() chiude il descrittore di file specificato come argomento. Per ottenere questo risultato, oltre che intervenire nella tabella dei descrittori associata al processo elaborativo specificato come argomento, riduce il contatore dei riferimenti nella voce corrispondente della tabella dei file; se però questo contatore raggiunge lo zero, anche l'inode viene liberato, attraverso inode_put(9) [i187.3.24].
Questa funzione viene usata in modo particolare da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_CLOSE. Nella libreria standard, si avvale di questa funzionalità close(2) [u0.7]. La funzione fd_close è comunque usata internamente al kernel, in tutte le occasioni in cui la chiusura di un descrittore deve avvenire in modo implicito.
|
|
lib/unistd/close.c [i189.17.5]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_close.c [i188.4.3]
close(2) [u0.7], sysroutine(9) [i187.8.28], inode_put(9) [i187.3.24].
fd_dup, fd_dup2 - duplicazione di un descrittore di file
<kernel/fs.h> int fd_dup (pid_t pid, int fdn_old, int fdn_min); int fd_dup2 (pid_t pid, int fdn_old, int fdn_new); |
|
Le funzioni fd_dup() e fd_dup2() duplicano un descrittore, nel senso che sdoppiano l'accesso a un file in due descrittori. La funzione fd_dup(), per il duplicato da realizzare, cerca un descrittore libero, cominciando da fdn_min e continuando progressivamente, fino al primo disponibile. La funzione fd_dup2(), invece, richiede di specificare esattamente il descrittore da usare per il duplicato, con la differenza che, se fdn_new è già utilizzato, prima della duplicazione viene chiuso.
In entrambi i casi, il descrittore ottenuto dalla copia, viene privato dell'indicatore FD_CLOEXEC, ammesso che nel descrittore originale ci fosse.
Queste funzioni vengono usate da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_DUP e SYS_DUP2. Inoltre, la funzione fd_fcntl(9) [i187.3.6] si avvale di fd_dup() per la duplicazione di un descrittore. Le funzioni della libreria standard che si avvalgono delle chiamate di sistema che poi raggiungono fd_dup() e fd_dup2() sono dup(2) [u0.8] e dup2(2) [u0.8].
Le due funzioni restituiscono il numero del descrittore prodotto dalla duplicazione. In caso di errore, invece, restituiscono il valore -1, aggiornando la variabile errno del kernel.
|
lib/unistd/dup.c [i189.17.6]
lib/unistd/dup2.c [i189.17.7]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_dup.c [i188.4.4]
kernel/fs/fd_dup2.c [i188.4.5]
dup(2) [u0.8], dup2(2) [u0.8], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7].
Vedere fd_dup(9) [i187.3.4].
fd_fcntl - configurazione e intervento sui descrittori di file
<kernel/fs.h> int fd_fcntl (pid_t pid, int fdn, int cmd, int arg); |
|
La funzione fd_fcntl() esegue un'operazione, definita dal parametro cmd, sul descrittore fdn. A seconda del tipo di operazione richiesta, può essere preso in considerazione anche l'argomento corrispondente al parametro arg. Il valore del parametro cmd che rappresenta l'operazione richiesta, va fornito in forma di costante simbolica, come descritto nell'elenco seguente. Tali macro-variabili derivano dalle dichiarazioni contenute nel file lib/sys/fcntl.h.
|
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_FCNTL. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge fd_fcntl() è fcntl(2) [u0.13].
Il significato del valore restituito dalla funzione dipende dal tipo di operazione richiesta, come sintetizzato dalla tabella successiva.
|
|
lib/fcntl/fcntl.c [i189.4.2]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_fcntl.c [i188.4.6]
fcntl(2) [u0.13], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], fd_dup(9) [i187.3.4].
fd_lseek - riposizionamento dell'indice di accesso a un descrittore di file
<kernel/fs.h> off_t fd_lseek (pid_t pid, int fdn, off_t offset, int whence); |
|
La funzione fd_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 lib/unistd.h. Può trattarsi dei casi seguenti.
|
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.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_LSEEK. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge fd_lseek() è lseek(2) [u0.24].
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 del kernel.
|
lib/unistd/lseek.c [i189.17.27]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_lseek.c [i188.4.7]
lseek(2) [u0.24], sysroutine(9) [i187.8.28], fd_reference(9) [i187.3.10].
fd_open - apertura di un file puro e semplice oppure di un file di dispositivo
<kernel/fs.h>
int fd_open (pid_t pid, const char *path, int oflags,
mode_t mode);
|
|
La funzione fd_open() apre un file, indicato attraverso il percorso path, in base alle opzioni rappresentate dagli indicatori oflags. A seconda del tipo di indicatori specificati, il parametro mode potrebbe essere preso in considerazione.
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 a cui ci si riferisce.
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.
|
Quando si utilizza l'opzione O_CREAT, è necessario stabilire la modalità dei permessi, attraverso la combinazione di macro-variabili 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.
|
|
|
Questa funzione viene usata principalmente da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_OPEN. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge fd_open() è open(2) [u0.28].
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 del kernel.
|
lib/fcntl/open.c [i189.4.3]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_open.c [i188.4.8]
open(2) [u0.28], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], path_full(9) [i187.3.35], path_inode_link(9) [i187.3.37], inode_truncate(9) [i187.3.28], inode_check(9) [i187.3.16], file_reference(9) [i187.3.13], fd_reference(9) [i187.3.10].
fd_read - lettura di descrittore di file
<kernel/fs.h>
ssize_t fd_read (pid_t pid, int fdn, void *buffer,
size_t count,
int *eof);
|
|
La funzione fd_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 aggiornata la variabile *eof.
La funzione può leggere file normali, file di dispositivo e directory, trattandole però come se fossero dei file puri e semplici. Gli altri tipi di file non sono gestiti da os16.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_READ. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge fd_read() è read(2) [u0.29].
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 eventualmente con successive operazioni di lettura. In caso di errore, la funzione restituisce il valore -1, aggiornando contestualmente la variabile errno del kernel.
|
lib/unistd/read.c [i189.17.28]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_read.c [i188.4.9]
read(2) [u0.29], sysroutine(9) [i187.8.28], fd_reference(9) [i187.3.10], dev_io(9) [i187.1.1], inode_file_read(9) [i187.3.18].
fd_reference - riferimento a un elemento della tabella dei descrittori
<kernel/fs.h> fd_t *fd_reference (pid_t pid, int *fdn); |
|
La funzione fd_reference() restituisce il puntatore all'elemento della tabella dei descrittori, corrispondente al processo e al numero di descrittore specificati. Se però viene fornito un numero di descrittore negativo, si ottiene il puntatore al primo elemento che risulta libero nella tabella.
La funzione restituisce il puntatore a un elemento della tabella dei descrittori, oppure il puntatore nullo in caso di errore, ma senza aggiornare la variabile errno del kernel. Infatti, l'unico errore che può verificarsi consiste nel non poter trovare il descrittore richiesto.
kernel/fs.h [u0.4]
kernel/fs/fd_reference.c [i188.4.10]
file_reference(9) [i187.3.13], inode_reference(9) [i187.3.25], sb_reference(9) [i187.3.47], proc_reference(9) [i187.8.7].
Vedere stat(9) [i187.3.50].
fd_write - scrittura di un descrittore di file
<kernel/fs.h>
ssize_t fd_write (pid_t pid, int fdn, const void *buffer,
size_t count);
|
|
La funzione fd_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, del processo pid. La scrittura avviene a partire dalla posizione in cui si trova l'indice interno.
Questa funzione viene usata principalmente da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_WRITE. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge fd_write() è write(2) [u0.44].
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 del kernel.
|
lib/unistd/write.c [i189.17.36]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_write.c [i188.4.12]
write(2) [u0.44], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], dev_io(9) [i187.1.1], inode_file_write(9) [i187.3.19].
file_reference - riferimento a un elemento della tabella dei file di sistema
<kernel/fs.h> file_t *file_reference (int fno); |
|
La funzione file_reference() restituisce il puntatore all'elemento della tabella dei file di sistema, corrispondente al numero indicato come argomento. Se però tale numero fosse negativo, viene restituito il puntatore al primo elemento libero.
La funzione restituisce il puntatore a un elemento della tabella dei file di sistema, oppure il puntatore nullo in caso di errore, ma senza aggiornare la variabile errno del kernel. Infatti, l'unico errore che può verificarsi consiste nel non poter trovare la voce richiesta.
kernel/fs.h [u0.4]
kernel/fs/file_table.c [i188.4.15]
kernel/fs/file_reference.c [i188.4.13]
fd_reference(9) [i187.3.10], inode_reference(9) [i187.3.25], sb_reference(9) [i187.3.47], proc_reference(9) [i187.8.7].
file_stdio_dev_make - creazione di una voce relativa a un dispositivo di input-output standard, nella tabella dei file di sistema
<kernel/fs.h>
file_t *file_stdio_dev_make (dev_t device, mode_t mode,
int oflags);
|
|
La funzione file_stdio_dev_make() produce una voce nella tabella dei file di sistema, relativa a un dispositivo di input-output, da usare come flusso standard. In altri termini, serve per creare le voci della tabella dei file, relative a standard input, standard output e standard error.
Per ottenere questo risultato occorre coinvolgere anche la funzione inode_stdio_dev_make(9) [i187.3.27], la quale si occupa di predisporre un inode, privo però di un collegamento a un file vero e proprio.
Questa funzione viene usata esclusivamente da proc_sys_exec(9) [i187.8.20], per attribuire standard input, standard output e standard error, che non fossero già disponibili.
La funzione restituisce il puntatore a un elemento della tabella dei file di sistema, oppure il puntatore nullo in caso di errore, aggiornando la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/file_stdio_dev_make.c [i188.4.14]
proc_sys_exec(9) [i187.8.20], inode_stdio_dev_make(9) [i187.3.27], file_reference(9) [i187.3.13], inode_put(9) [i187.3.24].
inode_alloc - allocazione di un inode
<kernel/fs.h> inode_t *inode_alloc (dev_t device, mode_t mode, uid_t uid); |
|
La funzione inode_alloc() cerca un inode libero nel file system del dispositivo indicato, quindi lo alloca (lo segna come utilizzato) e lo modifica aggiornando il tipo e la modalità dei permessi, oltre al proprietario del file. Se la funzione riesce nel suo intento, restituisce il puntatore all'inode in memoria, il quale rimane così aperto e disponibile per ulteriori elaborazioni.
Questa funzione viene usata esclusivamente da path_inode_link(9) [i187.3.37], per la creazione di un nuovo file.
La funzione restituisce il puntatore a un elemento della tabella degli inode di sistema, oppure il puntatore nullo in caso di errore, aggiornando la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/inode_alloc.c [i188.4.16]
path_inode_link(9) [i187.3.37], sb_reference(9) [i187.3.47], inode_get(9) [i187.3.23], inode_put(9) [i187.3.24], inode_truncate(9) [i187.3.28], inode_save(9) [i187.3.26].
inode_check - verifica delle caratteristiche di un inode
<kernel/fs.h>
int inode_check (inode_t *inode, mode_t type, int perm,
uid_t uid);
|
|
La funzione inode_check() verifica che l'inode indicato sia di un certo tipo e abbia i permessi di accesso necessari a un certo utente. Tali permessi vanno rappresentati utilizzando solo gli ultimi tre bit (4 = lettura, 2 = scrittura, 1 = esecuzione o attraversamento) e si riferiscono alla richiesta di accesso all'inode, da parte dell'utente uid, tenendo conto del complesso dei permessi che lo riguardano.
Nel parametro type è ammessa la sovrapposizione di più tipi validi.
Questa funzione viene usata in varie situazioni, internamente al kernel, per verificare il tipo o l'accessibilità di un file.
|
|
kernel/fs.h [u0.4]
kernel/fs/inode_check.c [i188.4.17]
inode_dir_empty - verifica della presenza di contenuti in una directory
<kernel/fs.h> int inode_dir_empty (inode_t *inode); |
|
La funzione inode_dir_empty() verifica che la directory, a cui si riferisce l'inode a cui punta inode, sia vuota.
|
Dal momento che un risultato Falso non rappresenta necessariamente un errore, per verificare il contenuto della variabile errno, prima dell'uso della funzione occorre azzerarla.
|
kernel/fs.h [u0.4]
kernel/fs/inode_dir_empty.c [i188.4.18]
inode_file_read(9) [i187.3.18].
inode_file_read - lettura di un file rappresentato da un inode
<kernel/fs.h>
ssize_t inode_file_read (inode_t *inode, off_t offset,
void *buffer, size_t count,
int *eof);
|
|
La funzione inode_file_read() legge il contenuto del file a cui si riferisce l'inode inode e se il puntatore eof è valido, aggiorna anche la variabile *eof.
Questa funzione si avvale a sua volta di inode_fzones_read(9) [i187.3.21], per accedere ai contenuti del file, suddivisi in zone, secondo l'organizzazione del file system Minix 1.
La funzione restituisce la quantità di byte letti e resi effettivamente disponibili a partire da ciò a cui punta buffer. Se la variabile var è un puntatore valido, aggiorna anche il suo valore, azzerandolo se la lettura avviene in una posizione interna al file, oppure impostandolo a uno se la lettura richiesta è oltre la fine del file. Se invece si tenta una lettura con un valore di offset negativo, o specificando il puntatore nullo al posto dell'inode, la funzione restituisce -1 e aggiorna la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/inode_file_read.c [i188.4.19]
inode_fzones_read(9) [i187.3.21].
inode_file_write - scrittura di un file rappresentato da un inode
<kernel/fs.h>
ssize_t inode_file_write (inode_t *inode, off_t offset,
void *buffer, size_t count);
|
|
La funzione inode_file_write() scrive nel file rappresentato da inode, a partire dalla posizione offset (purché non sia un valore negativo), la quantità massima di byte indicati con count, ciò che si trova in memoria a partire da buffer.
Questa funzione si avvale a sua volta di inode_fzones_read(9) [i187.3.21], per accedere ai contenuti del file, suddivisi in zone, secondo l'organizzazione del file system Minix 1, e di zone_write(9) [i187.3.53], per la riscrittura delle zone relative.
Per os16, le operazioni di scrittura nel file system sono sincrone, senza alcun trattenimento in memoria (ovvero senza cache).
La funzione restituisce la quantità di byte scritti. La scrittura può avvenire oltre la fine del file, anche in modo discontinuo; tuttavia, non è ammissibile un valore di offset negativo.
|
kernel/fs.h [u0.4]
kernel/fs/inode_file_write.c [i188.4.20]
inode_fzones_read(9) [i187.3.21], zone_write(9) [i187.3.53].
inode_free - deallocazione di un inode
<kernel/fs.h> int inode_free (inode_t *inode); |
|
La funzione inode_free() libera l'inode specificato attraverso il puntatore inode, rispetto al proprio super blocco. L'operazione comporta semplicemente il fatto di indicare questo inode come libero, senza controlli per verificare se effettivamente non esistono più collegamenti nel file system che lo riguardano.
Questa funzione viene usata esclusivamente da inode_put(9) [i187.3.24], per completare la cancellazione di un inode che non ha più collegamenti nel file system, nel momento in cui non vi si fa più riferimento nel sistema in funzione.
|
|
kernel/fs.h [u0.4]
kernel/fs/inode_free.c [i188.4.21]
inode_fzones_read, inode_fzones_write - lettura e scrittura di zone relative al contenuto di un file
<kernel/fs.h>
blkcnt_t inode_fzones_read (inode_t *inode, zno_t zone_start,
void *buffer, blkcnt_t blkcnt);
blkcnt_t inode_fzones_write (inode_t *inode, zno_t zone_start,
void *buffer, blkcnt_t blkcnt);
|
|
Le funzioni inode_fzones_read() e inode_fzones_write(), consentono di leggere e di scrivere un file, a zone intere (la zona è un multiplo del blocco, secondo la filosofia del file system Minix 1).
Questa funzione vengono usate soltanto da inode_file_read(9) [i187.3.18] e inode_file_write(9) [i187.3.19], con le quali l'accesso ai file si semplifica a livello di byte.
Le due funzioni restituiscono la quantità di zone lette o scritte effettivamente. Una quantità pari a zero potrebbe eventualmente rappresentare un errore, ma solo in alcuni casi. Per poterlo verificare, occorre azzerare la variabile errno prima di chiamare le funzioni, riservandosi di verificarne successivamente il valore.
|
kernel/fs.h [u0.4]
kernel/fs/inode_fzones_read.c [i188.4.22]
kernel/fs/inode_fzones_write.c [i188.4.23]
inode_file_read(9) [i187.3.18], inode_file_write(9) [i187.3.19], zone_read(9) [i187.3.53], zone_write(9) [i187.3.53].
Vedere inode_fzones_read(9) [i187.3.21].
inode_get - caricamento di un inode
<kernel/fs.h> inode_t *inode_get (dev_t device, ino_t ino); |
|
La funzione inode_get() consente di «aprire» un inode, fornendo il numero del dispositivo corrispondente all'unità di memorizzazione e il numero dell'inode del file system in essa contenuto. L'inode in questione potrebbe essere già stato aperto e quindi già disponibile in memoria nella tabella degli inode; in tal caso, la funzione si limita a incrementare il contatore dei riferimenti a tale inode, da parte del sistema in funzione, restituendo il puntatore all'elemento della tabella che lo contiene gia. Se invece l'inode non è ancora presente nella tabella rispettiva, la funzione deve provvedere a caricarlo.
Se si richiede un inode non ancora disponibile, contenuto in un'unità di cui non è ancora stato caricato il super blocco nella tabella rispettiva, la funzione deve provvedere anche a questo procedimento.
La funzione restituisce il puntatore all'elemento della tabella degli inode che rappresenta l'inode aperto. Se però si presenta un problema, restituisce il puntatore nullo e aggiorna la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/inode_get.c [i188.4.24]
offsetof(3) [u0.75], inode_put(9) [i187.3.24], inode_reference(9) [i187.3.25], sb_reference(9) [i187.3.47], sb_inode_status(9) [i187.3.45], dev_io(9) [i187.1.1].
inode_put - rilascio di un inode
<kernel/fs.h> int inode_put (inode_t *inode); |
|
La funzione inode_put() «chiude» un inode, riducendo il contatore degli accessi allo stesso. Tuttavia, se questo contatore, dopo il decremento, raggiunge lo zero, è necessario verificare se nel frattempo anche i collegamenti del file system si sono azzerati, perché in tal caso occorre anche rimuovere l'inode, nel senso di segnalarlo come libero per la creazione di un nuovo file. In ogni caso, le informazioni aggiornate dell'inode, ancora allocato o liberato, vengono memorizzate nel file system.
|
|
kernel/fs.h [u0.4]
kernel/fs/inode_put.c [i188.4.25]
inode_truncate(9) [i187.3.28], inode_free(9) [i187.3.20], inode_save(9) [i187.3.26].
inode_reference - riferimento a un elemento della tabella di inode
<kernel/fs.h> inode_t *inode_reference (dev_t device, ino_t ino); |
|
La funzione inode_reference() cerca nella tabella degli inode la voce corrispondente ai dati forniti come argomenti, ovvero quella dell'inode numero ino del file system contenuto nel dispositivo device, restituendo il puntatore alla voce corrispondente. Tuttavia ci sono dei casi particolari:
se il numero del dispositivo e quello dell'inode sono entrambi zero, viene restituito il puntatore all'inizio della tabella, ovvero al primo elemento della stessa;
se il numero del dispositivo e quello dell'inode sono pari a un numero negativo (rispettivamente (dev_t) -1 e (ino_t) -1), viene restituito il puntatore alla prima voce libera;
se il numero del dispositivo è pari a zero e il numero dell'inode è pari a uno, si intende ricercare la voce dell'inode della directory radice del file system principale.
La funzione restituisce il puntatore a un elemento della tabella degli inode, se la ricerca si compie con successo. In caso di problemi, invece, la funzione restituisce il puntatore nullo e aggiorna la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/inode_reference.c [i188.4.26]
sb_reference(9) [i187.3.47], file_reference(9) [i187.3.13], proc_reference(9) [i187.8.7].
inode_save - memorizzazione dei dati di un inode
<kernel/fs.h> int inode_save (inode_t *inode); |
|
La funzione inode_save() memorizza l'inode a cui si riferisce la voce *inode, nel file system, ammesso che si tratti effettivamente di un inode relativo a un file system e che sia stato modificato dopo l'ultima memorizzazione precedente. In questo caso, la funzione, a sua volta, richiede la memorizzazione del super blocco.
|
|
kernel/fs.h [u0.4]
kernel/fs/inode_save.c [i188.4.27]
inode_stdio_dev_make - creazione di una voce relativa a un dispositivo di input-output standard, nella tabella degli inode
<kernel/fs.h> inode_t *inode_stdio_dev_make (dev_t device, mode_t mode); |
|
La funzione inode_stdio_dev_make() produce una voce nella tabella degli inode, relativa a un dispositivo di input-output, da usare come flusso standard. In altri termini, serve per creare le voci della tabella degli inode, relative a standard input, standard output e standard error.
Questa funzione viene usata esclusivamente da file_stdio_dev_make(9) [i187.3.14], per creare una voce da usare come flusso standard di input o di output, nella tabella dei file.
La funzione restituisce il puntatore a un elemento della tabella degli inode, oppure il puntatore nullo in caso di errore, aggiornando la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/inode_stdio_dev_make.c [i188.4.28]
file_stdio_dev_make(9) [i187.3.14], inode_reference(9) [i187.3.25].
inode_truncate - troncamento del file a cui si riferisce un inode
<kernel/fs.h> int inode_truncate (inode_t *inode); |
|
La funzione inode_truncate() richiede che il puntatore inode si riferisca a una voce della tabella degli inode, relativa a un file contenuto in un file system. Lo scopo della funzione è annullare il contenuto di tale file, trasformandolo in un file vuoto.
|
Allo stato attuale dello sviluppo della funzione, non ci sono controlli e non sono previsti errori.
kernel/fs.h [u0.4]
kernel/fs/inode_truncate.c [i188.4.30]
zone_free(9) [i187.3.51], sb_save(9) [i187.3.48], inode_save(9) [i187.3.26].
inode_zone - traduzione del numero di zona relativo in un numero di zona assoluto
<kernel/fs.h> zno_t inode_zone (inode_t *inode, zno_t fzone, int write); |
|
La funzione inode_zone() serve a tradurre il numero di una zona, inteso relativamente a un file, nel numero assoluto relativamente al file system in cui si trova. Tuttavia, un file può essere memorizzato effettivamente in modo discontinuo, ovvero con zone inesistenti nella sua parte centrale. Il contenuto di un file che non dispone effettivamente di zone allocate, corrisponde a un contenuto nullo dal punto di vista binario (zero binario), ma per la funzione, una zona assente comporta la restituzione di un valore nullo, perché nel file system non c'è. Pertanto, se l'argomento corrispondente al parametro write contiene un valore diverso da zero, la funzione che non trova una zona, la alloca e quindi ne restituisce il numero.
La funzione restituisce il numero della zona che nel file system corrisponde a quella relativa richiesta per un certo file. Nel caso la zona non esista, perché non allocata, restituisce zero. Tuttavia, la zona zero di un file system Minix 1 esiste, ma contiene sostanzialmente le informazioni amministrative del super blocco, pertanto non può essere una traduzione valida di una zona di un file.
La funzione non prevede il verificarsi di errori.
kernel/fs.h [u0.4]
kernel/fs/inode_zone.c [i188.4.31]
memset(3) [u0.72], zone_alloc(9) [i187.3.51], zone_read(9) [i187.3.53], zone_write(9) [i187.3.53].
path_chdir - cambiamento della directory corrente
<kernel/fs.h> int path_chdir (pid_t pid, const char *path); |
|
La funzione path_chdir() cambia la directory corrente del processo pid, in modo che quella nuova corrisponda al percorso annotato nella stringa path.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_CHDIR. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_chdir() è chdir(2) [u0.3].
|
|
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]
chdir(2) [u0.3], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_full(9) [i187.3.35], path_inode(9) [i187.3.36], inode_put(9) [i187.3.24].
path_chmod - cambiamento della modalità dei permessi di un file
<kernel/fs.h> int path_chmod (pid_t pid, const char *path, mode_t mode); |
|
La funzione path_chmod() modifica la modalità dei permessi di accesso del file indicato, tramite il suo percorso, relativo eventualmente alla directory corrente del processo pid.
Tradizionalmente, i permessi si scrivono attraverso un numero in base otto; in alternativa, si possono usare convenientemente della macro-variabili, dichiarate nel file lib/sys/stat.h, combinate assieme con l'operatore binario OR.
|
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, perché non tiene traccia dei gruppi.
|
|
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_CHMOD. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_chmod() è chmod(2) [u0.4].
lib/sys/stat/chmod.c [i189.13.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/path_chmod.c [i188.4.33]
chmod(2) [u0.4], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36].
path_chown - cambiamento della proprietà di un file
<kernel/fs.h>
int path_chown (pid_t pid, const char *path, uid_t uid,
gid_t gid);
|
|
La funzione path_chown() modifica la proprietà di un file, fornendo il numero UID e il numero GID. Il file viene indicato attraverso il percorso scritto in una stringa, relativo alla directory corrente del processo pid.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_CHOWN. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_chown() è chown(2) [u0.5].
|
|
Benché sia consentito di attribuire il numero del gruppo, os16 non valuta i permessi di accesso ai file, relativi a questi.
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.h [u0.4]
kernel/fs/path_chown.c [i188.4.34]
chown(2) [u0.5], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_save(9) [i187.3.26], inode_put(9) [i187.3.24].
path_device - conversione di un file di dispositivo nel numero corrispondente
<kernel/fs.h> dev_t path_device (pid_t pid, const char *path); |
|
La funzione path_device() consente di trarre il numero complessivo di un dispositivo, a partire da un file di dispositivo.
Questa funzione viene usata soltanto da path_mount(9) [i187.8.28].
La funzione restituisce il numero del dispositivo corrispondente al file indicato, oppure il valore -1, in caso di errore, aggiornando la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/path_device.c [i188.4.35]
proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_put(9) [i187.3.24].
path_fix - semplificazione di un percorso
<kernel/fs.h> int path_fix (char *path); |
|
La funzione path_fix() legge la stringa del percorso path e la rielabora, semplificandolo. La semplificazione riguarda l'eliminazione di riferimenti inutili alla directory corrente e di indietreggiamenti. Il percorso può essere assoluto o relativo: la funzione non ne cambia l'origine.
La funzione restituisce sempre zero e non è prevista la manifestazione di errori.
kernel/fs.h [u0.4]
kernel/fs/path_fix.c [i188.4.36]
strtok(3) [u0.120], strcmp(3) [u0.106], strcat(3) [u0.104], strncat(3) [u0.104], strncpy(3) [u0.108].
path_full - traduzione di un percorso relativo in un percorso assoluto
<kernel/fs.h>
int path_full (const char *path, const char *path_cwd,
char *full_path);
|
|
La funzione path_full() ricostruisce un percorso assoluto, mettendolo in memoria a partire da ciò a cui punta full_path.
|
|
kernel/fs.h [u0.4]
kernel/fs/path_full.c [i188.4.37]
strtok(3) [u0.120], strcmp(3) [u0.106], strcat(3) [u0.104], strncat(3) [u0.104], strncpy(3) [u0.108], path_fix(9) [i187.3.34].
path_inode - caricamento di un inode, partendo dal percorso del file
<kernel/fs.h> inode_t *path_inode (pid_t pid, const char *path); |
|
La funzione path_inode() carica un inode nella tabella degli inode, oppure lo localizza se questo è già caricato, partendo dal percorso di un file. L'operazione è subordinata all'accessibilità del percorso che conduce al file, nel senso che il processo pid deve avere il permesso di accesso («x») in tutti gli stadi dello stesso.
La funzione restituisce il puntatore all'elemento della tabella degli inode che contiene le informazioni caricate in memoria sull'inode. Se qualcosa non va, restituisce invece il puntatore nullo, aggiornando di conseguenza il contenuto della variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/path_inode.c [i188.4.38]
proc_reference(9) [i187.8.7], path_full(9) [i187.3.35], inode_get(9) [i187.3.23], inode_put(9) [i187.3.24], inode_check(9) [i187.3.16], inode_file_read(9) [i187.3.18].
path_inode_link - creazione di un collegamento fisico o di un nuovo file
<kernel/fs.h>
inode_t *path_inode_link (pid_t pid, const char *path,
inode_t *inode, mode_t mode);
|
|
La funzione path_inode_link() crea un collegamento fisico con il nome fornito in path, riferito all'inode a cui punta inode. Tuttavia, l'argomento corrispondente al parametro inode può essere un puntatore nullo, e in tal caso viene creato un file vuoto, allocando contestualmente un nuovo inode, usando l'argomento corrispondente al parametro mode per il tipo e la modalità dei permessi del nuovo file.
Il processo pid deve avere i permessi di accesso per tutte le directory che portano al file da collegare o da creare; inoltre, nell'ultima directory ci deve essere anche il permesso di scrittura, dovendo intervenire sulla stessa modificandola.
La funzione restituisce il puntatore all'elemento della tabella degli inode che descrive l'inode collegato o creato. In caso di problemi, restituisce invece il puntatore nullo, aggiornando di conseguenza il contenuto della variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/path_inode_link.c [i188.4.39]
proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_get(9) [i187.3.23], inode_put(9) [i187.3.24], inode_save(9) [i187.3.26], inode_check(9) [i187.3.16], inode_alloc(9) [i187.3.15], inode_file_read(9) [i187.3.18], inode_file_write(9) [i187.3.19].
path_link - creazione di un collegamento fisico
<kernel/fs.h>
int path_link (pid_t pid, const char *path_old,
const char *path_new);
|
|
La funzione path_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 per il processo pid. Dopo l'operazione di collegamento, fatta in questo modo, non è possibile distinguere quale sia stato il file originale e quale sia invece il nome aggiunto.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_LINK. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_link() è link(2) [u0.23].
|
|
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]
kernel/fs.h [u0.4]
link(2) [u0.23], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], path_inode_link(9) [i187.3.37], inode_put(9) [i187.3.24].
path_mkdir - creazione di una directory
<kernel/fs.h> int path_mkdir (pid_t pid, const char *path, mode_t mode); |
|
La funzione path_mkdir() crea una directory, indicata attraverso un percorso (parametro path()) e specificando la modalità dei permessi (parametro mode). Va osservato che 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.
La directory che viene creata in questo modo, appartiene all'identità efficace del processo, ovvero all'utente per conto del quale questo sta funzionando.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_MKDIR. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_mkdir() è mkdir(2) [u0.25].
|
|
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.h [u0.4]
kernel/fs/path_mkdir.c [i188.4.41]
mkdir(2) [u0.25], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_file_write(9) [i187.3.19], inode_put(9) [i187.3.24].
path_mknod - creazione di un file vuoto di qualunque tipo
<kernel/fs.h>
int path_mknod (pid_t pid, const char *path, mode_t mode,
dev_t device);
|
|
La funzione path_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 lib/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]).
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_MKNOD. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_mknod() è mknod(2) [u0.26].
|
|
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.h [u0.4]
kernel/fs/path_mknod.c [i188.4.42]
mknod(2) [u0.26], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_put(9) [i187.3.24].
path_mount, path_umount - innesto e distacco di un file system
<kernel/fs.h>
int path_mount (pid_t pid, const char *path_dev,
const char *path_mnt, int options);
int path_umount (pid_t pid, const char *path_mnt);
|
|
La funzione path_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:
|
La funzione path_umount() consente di staccare un innesto fatto precedentemente, specificando il percorso della directory in cui questo è avvenuto.
Queste funzioni vengono usate soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento delle chiamate di sistema di tipo SYS_MOUNT e SYS_UMOUNT. Le funzioni della libreria standard che si avvalgono delle chiamate di sistema che poi raggiungono path_mount() e path_umount(), sono mount(2) [u0.27] e umount(2) [u0.27].
|
|
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.h [u0.4]
kernel/fs/path_mount.c [i188.4.43]
kernel/fs/path_umount.c [i188.4.45]
mount(2) [u0.27], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_device(9) [i187.3.33], path_inode(9) [i187.3.36], inode_put(9) [i187.3.24], sb_mount(9) [i187.3.46].
Vedere stat(9) [i187.3.50].
Vedere path_mount(9) [i187.3.41].
path_unlink - cancellazione di un nome
<kernel/fs.h> int path_unlink (pid_t pid, const char *path); |
|
La funzione path_unlink() cancella un nome da una directory, ma se si tratta dell'ultimo collegamento che ha quel file, allora libera anche l'inode corrispondente.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_UNLINK. La funzione della libreria standard che si avvale della chiamata di sistema che poi raggiunge path_unlink() è unlink(2) [u0.42].
|
|
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.h [u0.4]
kernel/fs/path_unlink.c [i188.4.46]
unlink(2) [u0.42], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_check(9) [i187.3.16], inode_file_read(9) [i187.3.18], inode_file_write(9) [i187.3.19], inode_put(9) [i187.3.24].
sb_inode_status, sb_zone_status - verifica di utilizzazione attraverso il controllo delle mappe di inode e di zone
<kernel/fs.h> int sb_inode_status (sb_t *sb, ino_t ino); int sb_zone_status (sb_t *sb, zno_t zone); |
|
La funzione sb_inode_status() verifica che un certo inode, individuato per numero, risulti utilizzato nel file system a cui si riferisce il super blocco a cui punta il primo argomento.
La funzione sb_zone_status() verifica che una certa zona, individuato per numero, risulti utilizzata nel file system a cui si riferisce il super blocco a cui punta il primo argomento.
La funzione sb_inode_status() viene usata soltanto da inode_get(9) [i187.3.23]; la funzione sb_zone_status() non viene usata affatto.
|
|
kernel/fs.h [u0.4]
kernel/fs/sb_inode_status.c [i188.4.47]
kernel/fs/sb_zone_status.c [i188.4.52]
sb_mount - innesto di un dispositivo di memorizzazione
<kernel/fs.h>
sb_t *sb_mount (dev_t device, inode_t **inode_mnt,
int options);
|
|
La funzione sb_mount() innesta il dispositivo rappresentato numericamente dal primo parametro, sulla directory corrispondente all'inode a cui punta, indirettamente, il secondo parametro, con le opzioni del terzo parametro.
Il secondo parametro è un puntatore di puntatore al tipo inode_t, in quanto il valore rappresentato da *inode_mnt deve poter essere modificato dalla funzione. Infatti, quando si vuole innestare il file system principale, si crea una situazione particolare, perché la directory di innesto è la radice dello stesso file system da innestare; pertanto, *inode_mnt deve essere un puntatore nullo ed è compito della funzione far sì che diventi il puntatore alla voce corretta nella tabella degli inode.
Questa funzione viene usata da proc_init(9) [i187.8.6] per innestare il file system principale, e da path_mount(9) [i187.3.41] per innestare un file system in condizioni diverse.
La funzione restituisce il puntatore all'elemento della tabella dei super blocchi che rappresenta il dispositivo innestato. In caso si insuccesso, restituisce invece il puntatore nullo e aggiorna la variabile errno del kernel.
|
kernel/fs.h [u0.4]
kernel/fs/sb_mount.c [i188.4.48]
sb_reference(9) [i187.3.47], dev_io(9) [i187.1.1], inode_get(9) [i187.3.23].
sb_reference - riferimento a un elemento della tabella dei super blocchi
<kernel/fs.h> sb_t *sb_reference (dev_t device); |
|
La funzione sb_reference() serve a produrre il puntatore a una voce della tabella dei super blocchi. Se si fornisce il numero di un dispositivo già innestato nella tabella, si intende ottenere il puntatore alla voce relativa; se si fornisce il valore zero, si intende semplicemente avere un puntatore alla prima voce (ovvero all'inizio della tabella); se invece si fornisce il valore -1, si vuole ottenere il riferimento alla prima voce libera.
La funzione restituisce il puntatore all'elemento della tabella dei super blocchi che soddisfa la richiesta. In caso di errore, restituisce invece un puntatore nullo, ma senza dare informazioni aggiuntive con la variabile errno, perché il motivo è implicito nel tipo di richiesta.
In caso di errore la variabile errno non viene aggiornata. Tuttavia, se l'errore deriva dalla richiesta di un dispositivo di memorizzazione, significa che non è presente nella tabella; se è stato richiesta una voce libera, significa che la tabella dei super blocchi è occupata completamente.
kernel/fs.h [u0.4]
kernel/fs/sb_table.c [i188.4.51]
kernel/fs/sb_reference.c [i188.4.49]
inode_reference(9) [i187.3.25], file_reference(9) [i187.3.13].
sb_save - memorizzazione di un super blocco nel proprio file system
<kernel/fs.h> int sb_save (sb_t *sb); |
|
La funzione sb_save() verifica se il super blocco conservato in memoria e rappresentato dal puntatore sb risulta modificato; in tal caso provvede ad aggiornarlo nell'unità di memorizzazione di origine, assieme alle mappe di utilizzo degli inode e delle zone di dati.
|
|
kernel/fs.h [u0.4]
kernel/fs/sb_save.c [i188.4.50]
Vedere sb_inode_status(9) [i187.3.45].
fd_stat, path_stat - interrogazione dello stato di un file
<kernel/fs.h>
int fd_stat (pid_t pid, int fdn, struct stat *buffer);
int path_stat (pid_t pid, const char *path,
struct stat *buffer);
|
|
Le funzioni fd_stat() e path_stat() raccolgono le informazioni disponibili sul file corrispondente al descrittore fdn del processo pid o al percorso path, in una variabile strutturata di tipo struct stat, a cui punta buffer. La struttura struct stat è definita nel file lib/sys/stat.h nel modo seguente:
|
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 fd_chmod(9) [i187.3.1], serve ad annotare anche il tipo di file. Nel file lib/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:
|
|
|
|
|
os16 non considera i permessi SUID (Set user id), SGID (Set group id) e Sticky; inoltre, non considera i permessi legati al gruppo, perché non tiene traccia dei gruppi.
Queste funzioni vengono usate soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento delle chiamate di sistema di tipo SYS_STAT e SYS_FSTAT. Le funzioni della libreria standard che si avvalgono delle chiamate di sistema che poi raggiungono fd_stat() e path_stat(), sono fstat(2) [u0.36] e stat(2) [u0.36].
|
|
lib/sys/stat/fstat.c [i189.13.3]
lib/sys/stat/stat.c [i189.13.6]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/fs.h [u0.4]
kernel/fs/fd_stat.c [i188.4.11]
kernel/fs/path_stat.c [i188.4.44]
fstat(2) [u0.36], stat(2) [u0.36], sysroutine(9) [i187.8.28], proc_reference(9) [i187.8.7], path_inode(9) [i187.3.36], inode_put(9) [i187.3.24].
zone_alloc, zone_free - allocazione di zone di dati
<kernel/fs.h> zno_t zone_alloc (sb_t *sb); int zone_free (sb_t *sb, zno_t zone); |
|
La funzione zone_alloc() occupa una zona nella mappa associata al super blocco a cui si riferisce sb, restituendone il numero. La funzione zone_free() libera una zona che precedentemente risultava occupata nella mappa relativa.
La funzione zone_alloc() restituisce il numero della zona allocata. Se questo numero è zero, si tratta di un errore, e va considerato il contenuto della variabile errno.
La funzione zone_free() restituisce zero in caso di successo, oppure -1 in caso di errore, aggiornando di conseguenza la variabile errno.
|
kernel/fs.h [u0.4]
kernel/fs/zone_alloc.c [i188.4.53]
kernel/fs/zone_free.c [i188.4.54]
Vedere zone_alloc(9) [i187.3.51].
zone_read, zone_write - lettura o scrittura di una zona di dati
<kernel/fs.h> int zone_read (sb_t *sb, zno_t zone, void *buffer); int zone_write (sb_t *sb, zno_t zone, void *buffer); |
|
La funzione zone_read() legge una zona e ne trascrive il contenuto a partire da buffer. La funzione zone_write() scrive una zona copiandovi al suo interno quanto si trova in memoria a partire da buffer. La zona è individuata dal numero zone e riguarda il file system a cui si riferisce il super blocco sb.
La lettura o la scrittura riguarda una zona soltanto, ma nella sua interezza.
|
|
kernel/fs.h [u0.4]
kernel/fs/zone_read.c [i188.4.55]
kernel/fs/zone_write.c [i188.4.56]
Il file kernel/ibm_i86.h [u0.5] descrive le funzioni e le macroistruzioni per la gestione dell'hardware.
La sezione u172 descrive complessivamente queste funzioni e le tabelle successive sono tratte da lì.
|
Tabella u172.2. Funzioni e macroistruzioni di basso livello, dichiarate nel file di intestazione
|
|
Tabella u172.3. Funzioni per l'accesso alla console, dichiarate nel file di intestazione
|
|
Tabella u172.6. Funzioni per l'accesso ai dischi, dichiarate nel file di intestazione
|
Il file kernel/k_libc.h [u0.6] descrive alcune funzioni con nomi che iniziano per k_... (dove la lettera «k» sta per kernel) e riproducono il comportamento di funzioni standard, della libreria C. Per esempio, k_printf() è l'equivalente di printf(), ma per la gestione interna del kernel.
|
Teoricamente, quando una funzione interna al kernel può ricondursi allo standard, dovrebbe avere il nome previsto. Tuttavia, per evitare di dover qualificare ogni volta l'ambito di una funzione, sono stati usati nomi differenti, ciò anche al fine di non creare complicazioni in fase di compilazione di tutto il sistema. |
Il file kernel/main.h [u0.7] descrive la funzione main() del kernel e altre funzioni accessorie, assieme al codice iniziale necessario per mettere in funzione il kernel stesso.
Si rimanda alla sezione u171 che descrive dettagliatamente il codice iniziale del kernel.
Il file kernel/memory.h [u0.8] descrive le funzioni per la gestione della memoria, a livello di sistema.
Per la descrizione dell'organizzazione della gestione della memoria si rimanda alla sezione u173. Le tabelle successive che sintetizzano l'uso delle funzioni di questo gruppo, sono tratte da quel capitolo.
|
Tabella u173.2. Funzioni per la gestione della mappa della memoria, dichiarate nel file di intestazione
|
|
Tabella u173.3. Funzioni per le operazioni di lettura e scrittura in memoria, dichiarate nel file di intestazione
|
Il file kernel/proc.h [u0.9] descrive ciò che serve per la gestione dei processi. In modo particolare, in questo file si definisce il tipo derivato proc_t, con cui si realizza la tabella dei processi.
|
Figura u177.19. Struttura del tipo proc_t, corrispondente agli elementi dell'array proc_table[]. |
|
Listato u177.20. Struttura del tipo proc_t, corrispondente agli elementi dell'array proc_table[].
|
|
Tabella u177.21. Membri del tipo proc_t.
|
isr_1C, isr_80 - routine di gestione delle interruzioni
La routine isr_1C del file kernel/proc/_isr.s viene eseguita a ogni impulso del temporizzatore, proveniente dal sistema delle interruzioni hardware; la routine isr_80, in modo analogo, viene eseguita in corrispondenza dell'interruzione software 8016 Perché ciò avvenga, nella tabella IVT, nelle voci che riguardano l'interruzione 1C16 e 8016, si trova l'indirizzo corrispondente alle routine in questione. La configurazione della tabella IVT avviene per mezzo della funzione ivt_load(9) [i187.8.2].
La routine isr_1C prevede il salvataggio dei registri principali nella pila dei dati in funzione al momento dell'interruzione. Quindi vengono modificati i registri che definiscono l'area dati (ES e DS) e successivamente ciò permette di intervenire su delle variabili locali: viene incrementato il contatore degli impulsi del temporizzatore; viene incrementato il contatore dei secondi, se il contatore degli impulsi è divisibile per 18 senza dare resto; vengono salvati l'indice e il segmento della pila dei dati, in due variabili locali.
Dalla verifica del valore del segmento in cui si colloca la pila dei dati del processo interrotto, la routine verifica se si tratta di un processo comune o del kernel. Se si tratta di un processo comune, si scambia la pila con quella del kernel. Per questo la routine si avvale della variabile _ksp (kernel stack pointer), usata anche dalla funzione proc_scheduler(9) [i187.8.11]. Sempre se si tratta dell'interruzione di un processo diverso dal kernel, viene chiamata la funzione proc_scheduler(), già citata, fornendo come argomenti il puntatore alla variabile che contiene l'indice della pila e il puntatore alla variabile che contiene il segmento di memoria che ospita la pila dei dati. Al termine viene scambiata nuovamente la pila dei dati, usando come valori quanto contenuto nelle variabili che prima sono servite per salvare l'indice e il segmento della pila.
Poi, indipendentemente dal tipo di processo, vengono ripristinati i registri accumulati in precedenza nella pila e viene restituito il controllo, concludendo il lavoro dell'interruzione.
Va osservato che la funzione proc_scheduler() riceve l'indice e il segmento della pila dei dati attraverso dei puntatori a variabili scalari. Pertanto, tale funzione è perfettamente in grado di sostituire questi valori, con quelli della pila di un altro processo. Per questo, quando al ritorno della funzione viene ripristinata la pila sulla base di tali variabili, si ha uno scambio di processi. Il ripristino successivo dalla pila dei registri, completa il procedimento di sostituzione dei processi.
La routine isr_80 viene attivata da un'interruzione software, dovuta a una chiamata di sistema. Questa routine si distingue leggermente da isr_1C, in quanto non si occupa di tenere conto del tempo trascorso, ma ha la necessità di recuperare dalla pila del processo interrotto, i valori che hanno origine dalla chiamata di sistema. Si tratta sempre del numero della chiamata di sistema, del puntatore al messaggio trasmesso con la chiamata e della sua lunghezza.
Si può osservare anche un'altra differenza importante, per cui, se l'interruzione riguarda il processo del kernel, l'indice della pila dello stesso viene conservato nella variabile _ksp. Questo fatto è importante, perché prima di abilitare la gestione delle interruzioni, è necessario che il kernel stesso ne provochi una, in modo da poter salvare la prima volta l'indice della propria pila.
Successivamente, indipendentemente dal processo interrotto, si chiama la funzione sysroutine(9) [i187.8.28], alla quale si passano come argomenti, oltre che i puntatori all'indice e al segmento della pila dei dati del processo interrotto, anche gli argomenti della chiamata di sistema.
La funzione sysroutine() si avvale a sua volta della funzione proc_scheduler(), pertanto anche in questo caso la pila dei dati che viene ripristinata successivamente può risultare differente da quella del processo interrotto originariamente, comportando anche in questo caso lo scambio del processo con un altro.
kernel/proc.h [u0.9]
kernel/proc/proc_table.c [i188.9.29]
kernel/proc/_isr.s [i188.9.1]
ivt_load(9) [i187.8.2], sys(2) [u0.37], proc_scheduler(9) [i187.8.11], sysroutine(9) [i187.8.28].
ivt_load - caricamento della tabella IVT
<kernel/proc.h> void _ivt_load (void); |
<kernel/proc.h> void ivt_load (void); |
La funzione _ivt_load(), ovvero la macroistruzione corrispondente ivt_load(), modifica la tabella IVT del BIOS, in modo che nella posizione corrispondente all'interruzione 1C16 ci sia il puntatore alla routine isr_1C(9) [i187.8.1], e che in corrispondenza dell'interruzione 8016 ci sia il puntatore alla routine isr_80(9) [i187.8.1].
Questa funzione viene usata una volta sola, all'interno di main(9) [u0.6].
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/_ivt_load.s [i188.9.2]
sys(2) [u0.37], isr_80(9) [i187.8.1], proc_scheduler(9) [i187.8.11], sysroutine(9) [i187.8.28].
proc_available - inizializzazione di un processo libero
<kernel/proc.h> void proc_available (pid_t pid); |
|
La funzione proc_available() si limita a inizializzare, con valori appropriati, i dati di un processo nella tabella relativa, in modo che risulti correttamente uno spazio libero per le allocazioni successive.
Questa funzione viene usata da proc_init(9) [i187.8.6], proc_sig_chld(9) [i187.8.12], proc_sys_wait(9) [i187.8.27].
kernel/proc.h [u0.9]
kernel/proc/proc_table.c [i188.9.29]
kernel/proc/proc_available.c [i188.9.3]
proc_dump_memory - copia di una porzione di memoria in un file
<kernel/proc.h>
void proc_dump_memory (pid_t pid, addr_t address, size_t size,
char *name);
|
|
La funzione proc_dump_memory() salva in un file una porzione di memoria, secondo le coordinate fornita dagli argomenti.
Viene usata esclusivamente da proc_sig_core(9) [i187.8.6], quando si riceve un segnale per cui è necessario scaricare la memoria di un processo. In quel caso, se il processo eliminato ha i permessi per scrivere nella directory radice, vengono creati due file: uno con l'immagine del segmento codice (/core.i) e l'altro con l'immagine del segmento dati (/core.d).
kernel/proc.h [u0.9]
kernel/proc/proc_sig_core.c [i188.9.14]
fd_open(9) [i187.3.8], fd_write(9) [i187.3.12], fd_close(9) [i187.3.3].
proc_find - localizzazione di un processo sulla base dell'indirizzo del segmento dati
<kernel/proc.h> pid_t proc_find (segment_t segment_d); |
|
La funzione proc_find() scandisce la tabella dei processi, alla ricerca di quel processo il cui segmento dati corrisponde al valore fornito come argomento. Ciò serve per sapere chi sia il processo interrotto, del quale si conosce il valore che, prima dell'interruzione, aveva il registro DS (data segment).
Questa funzione viene usata da proc_scheduler(9) [i187.8.11] e da sysroutine(9) [i187.8.28].
La funzione restituisce il numero del processo trovato e non è ammissibile che la ricerca possa fallire. Infatti, se così fosse, si produrrebbe un errore fatale, con avvertimento a video, tale da arrestare il funzionamento del kernel.
kernel/proc.h [u0.9]
kernel/proc/proc_table.c [i188.9.29]
kernel/proc/proc_find.c [i188.9.5]
proc_init - inizializzazione della gestione complessiva dei processi elaborativi
<kernel/proc.h> extern uint16_t _etext; void proc_init (void); |
|
La funzione proc_init() viene usata una volta sola, dalla funzione main(9) [u0.6], per predisporre la gestione dei processi. Per la precisione svolge le operazioni seguenti:
carica la tabella IVT, in modo che le interruzioni software 1C16 e 8016 siano dirette correttamente al codice che deve gestirle;
programma il temporizzatore interno, in modo da produrre una frequenza di circa 18,2 Hz;
inizializza la tabella dei processi in modo che tutti gli alloggiamenti previsti risultino liberi;
innesta il file system principale, presupponendo che possa trattarsi soltanto della prima unità a dischetti;
inizializza correttamente le voci del processo zero, ovvero quelle del kernel, segnando anche come allocata la porzione di memoria utilizzata dal kernel e lo spazio iniziale usato dal BIOS (tabella IVT e BDA);
abilita le interruzioni hardware del temporizzatore, della tastiera e dell'unità a dischetti: le altre interruzioni hardware rimangono disabilitate.
kernel/proc.h [u0.9]
kernel/proc/proc_table.c [i188.9.29]
kernel/proc/proc_init.c [i188.9.6]
ivt_load(9) [i187.8.2], proc_available(9) [i187.8.3], sb_mount(9) [i187.3.46].
proc_reference - puntatore alla voce che rappresenta un certo processo
<kernel/proc.h> proc_t *proc_reference (pid_t pid); |
|
La funzione proc_reference() serve a produrre il puntatore all'elemento dell'array proc_table[] che contiene i dati del processo indicato per numero come argomento.
Viene usata dalle funzioni che non fanno parte del gruppo di kernel/proc.h.
Restituisce il puntatore all'elemento della tabella proc_table[] che rappresenta il processo richiesto. Se il numero del processo richiesto non può esistere, la funzione restituisce il puntatore nullo NULL.
kernel/proc.h [u0.9]
kernel/proc/proc_table.c [i188.9.29]
kernel/proc/proc_reference.c [i188.9.7]
proc_sch_signals - verifica dei segnali dei processi
<kernel/proc.h> void proc_sch_signals (void); |
La funzione proc_sch_signals() ha il compito di scandire tutti i processi della tabella proc_table[], per verificare lo stato di attivazione dei segnali e procedere di conseguenza.
Dal punto di vista pratico, la funzione si limita a scandire i numeri PID possibili, demandando ad altre funzioni il compito di fare qualcosa nel caso fosse attivato l'indicatore di un segnale. Va comunque osservato che os16 si limita a gestire le azioni predefinite, pertanto si può soltanto attivare o inibire i segnali, salvo i casi in cui questi non possono essere mascherati.
Questa funzione viene usata soltanto da proc_scheduler(9) [i187.8.11], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [u0.9]
kernel/proc/proc_scheduler.c [i188.9.11]
kernel/proc/proc_sch_signals.c [i188.9.8]
proc_sig_term(9) [i187.8.19], proc_sig_core(9) [i187.8.14], proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_stop(9) [i187.8.18].
proc_sch_terminals - acquisizione di un carattere dal terminale attivo
<kernel/proc.h> void proc_sch_terminals (void); |
La funzione proc_sch_terminals() ha il compito di verificare la presenza di un carattere digitato dalla console. Se verifica che effettivamente è stato digitato un carattere, dopo aver determinato a quale terminale virtuale si riferisce, determina se per quel terminale era già stato accumulato un carattere, e se è effettivamente così, sovrascrive quel carattere ma annota anche che l'inserimento precedente è stato perduto.
Successivamente verifica se quel terminale virtuale è associato a un gruppo di processi; se è così e se il carattere corrisponde alla combinazione [Ctrl c], invia il segnale SIGINT a tutti i processi di quel gruppo, ma senza poi accumulare il carattere.
Indipendentemente dal fatto che il terminale appartenga a un gruppo di processi, controlla che il carattere inserito sia stato ottenuto, rispettivamente, con le combinazioni di tasti [Ctrl q], [Ctrl r], [Ctrl s] e [Ctrl t], nel qual caso attiva la console virtuale relativa (dalla prima alla quarta), evitando di accumulare il carattere.
Alla fine, scandisce tutti i processi sospesi in attesa di input dal terminale, risvegliandoli (ogni processo deve poi verificare se effettivamente c'è un carattere per sé oppure no, e se non c'è dovrebbe rimettersi in attesa).
Questa funzione viene usata soltanto da proc_scheduler(9) [i187.8.11], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [u0.9]
kernel/proc/proc_scheduler.c [i188.9.11]
kernel/proc/proc_sch_terminals.c [i188.9.9]
proc_sch_timers - verifica dell'incremento del contatore del tempo
<kernel/proc.h> void proc_sch_timers (void); |
La funzione proc_sch_timers() verifica che il calendario si sia incrementato di almeno una unità temporale (per os16 è un secondo soltanto) e se è così, va a risvegliare tutti i processi sospesi in attesa del passaggio di un certo tempo. Tali processi, una volta messi effettivamente in funzione, devono verificare che sia trascorsa effettivamente la quantità di tempo desiderata, altrimenti devono rimettersi a riposo in attesa del tempo rimanente.
Questa funzione viene usata soltanto da proc_scheduler(9) [i187.8.11], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [u0.9]
kernel/proc/proc_scheduler.c [i188.9.11]
kernel/proc/proc_sch_timers.c [i188.9.10]
proc_scheduler - schedulatore
<kernel/proc.h> void proc_scheduler (uint16_t *sp, segment_t *segment_d); |
|
La funzione proc_scheduler() viene avviata a seguito di un'interruzione hardware, dovuta al temporizzatore, oppure a seguito di un'interruzione software, dovuta a una chiamata di sistema.
La funzione determina qual è il processo interrotto, scandendo la tabella dei processi alla ricerca di quello il cui segmento dati corrisponde al valore segment_d. Per questo si avvale di proc_find(9) [i187.8.5].
Successivamente verifica se ci sono processi in attesa di un evento del temporizzatore o del terminale, inoltre verifica se ci sono processi con segnali in attesa di essere presi in considerazione. per fare questo si avvale di proc_sch_timers(9) [i187.8.10], proc_sch_terminals(9) [i187.8.9] e proc_sch_signals(9) [i187.8.8], che provvedono a fare ciò che serve in presenza degli eventi di propria competenza.
Si occupa quindi di annotare il tempo di CPU utilizzato dal processo appena sospeso, misurato in unità di tempo a cui si riferisce il tipo clock_t.
Successivamente scandisce la tabella dei processi alla ricerca di un altro processo da mettere in funzione, al posto di quello sospeso. Se trova un processo pronto per questo lo elegge a processo attivo, declassando quello sospeso a processo pronto ma in attesa, inoltre aggiorna i valori per le variabili *sp e *segment_d.
Al termine salva nella variabile globale _ksp il valore dell'indice della pila del kernel, come appare nelle informazioni della tabella dei processi e poi manda il messaggio «EOI» (end of interrupt al «PIC 1» (programmable interrupt controller).
Questa funzione viene usata dalla routine isr_1C(9) [i187.8.1] del file kernel/proc/_isr.s e dalla funzione sysroutine(9) [i187.8.28].
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_scheduler.c [i188.9.11]
proc_find(9) [i187.8.5], proc_sch_timers(9) [i187.8.10], proc_sch_signals(9) [i187.8.8], proc_sch_terminals(9) [i187.8.9].
proc_sig_chld - procedura associata alla ricezione di un segnale SIGCHLD
<kernel/proc.h> void proc_sig_chld (pid_t parent, int sig); |
|
La funzione proc_sig_chld() si occupa di verificare che il processo specificato con il parametro parent abbia ricevuto precedentemente un segnale SIGCHLD. Se risulta effettivamente così, allora va a verificare se tale segnale risulta ignorato per quel processo: se è preso in considerazione verifica ancora se quel processo è sospeso proprio in attesa di un segnale SIGCHLD. Se si tratta di un processo che sta attendendo tale segnale, allora viene risvegliato, altrimenti, sempre ammesso che comunque il segnale non sia ignorato, la funzione elimina tutti i processi figli di parent, i quali risultano già defunti, ma non ancora rimossi dalla tabella dei processi (pertanto processi «zombie»).
In pratica, se il processo parent sta attendendo un segnale SIGCHLD, significa che al risveglio si aspetta di verificare la morte di uno dei suoi processi figli, in modo da poter ottenere il valore di uscita con cui questo si è concluso. Diversamente, non c'è modo di informare il processo parent di tali conclusioni, per cui a nulla servirebbe continuare a mantenerne le tracce nella tabella dei processi.
Questa funzione viene usata soltanto da proc_sch_signals(9) [i187.8.8].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_chld.c [i188.9.12]
proc_sig_status(9) [i187.8.17], proc_sig_ignore(9) [i187.8.15], proc_sig_off(9) [i187.8.16].
proc_sig_cont - ripresa di un processo sospeso in attesa di qualcosa
<kernel/proc.h> void proc_sig_cont (pid_t pid, int sig); |
|
La funzione proc_sig_cont() si occupa di verificare che il processo specificato con il parametro pid abbia ricevuto precedentemente un segnale SIGCONT e che questo non sia stato disabilitato. In tal caso, assegna al processo lo status di «pronto» (PROC_READY), ammesso che non si trovasse già in questa situazione.
Lo scopo del segnale SIGCONT è quindi quello di far riprendere un processo che in precedenza fosse stato sospeso attraverso un segnale SIGSTOP, SIGTSTP, SIGTTIN oppure SIGTTOU.
Questa funzione viene usata soltanto da proc_sch_signals(9) [i187.8.8].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_cont.c [i188.9.13]
proc_sig_status(9) [i187.8.17], proc_sig_ignore(9) [i187.8.15], proc_sig_off(9) [i187.8.16].
proc_sig_core - chiusura di un processo e scarico della memoria su file
<kernel/proc.h> void proc_sig_core (pid_t pid, int sig); |
|
La funzione proc_sig_core() si occupa di verificare che il processo specificato con il parametro pid abbia ricevuto precedentemente un segnale tale da richiedere la conclusione e lo scarico della memoria del processo stesso, e che il segnale in questione non sia stato disabilitato. In tal caso, la funzione chiude il processo, ma prima ne scarica la memoria su uno o due file, avvalendosi per questo della funzione proc_dump_memory(9) [i187.8.4].
Un segnale atto a produrre lo scarico della memoria, potrebbe essere prodotto anche a seguito di un errore rilevato dalla CPU, come una divisione per zero. Tuttavia, il kernel di os16 non riesce a intrappolare errori di questo tipo, dato che dalla tabella IVT vengono presi in considerazione soltanto l'impulso del temporizzatore e le chiamate di sistema. In altri termini, se un programma produce effettivamente un errore così grave da essere rilevato dalla CPU, al sistema operativo non arriva alcuna comunicazione. Pertanto, tali segnali possono essere soltanto provocati deliberatamente.
Lo scarico della memoria, nell'eventualità di un errore così grave, dovrebbe servire per consentire un'analisi dello stato del processo nel momento del verificarsi di un errore fatale. Sotto questo aspetto, va anche considerato che l'area dati dei processi è priva di etichette che possano agevolare l'interpretazione dei contenuti e, di conseguenza, non ci sono strumenti che consentano tale attività.
Questa funzione viene usata soltanto da proc_sch_signals(9) [i187.8.8].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_core.c [i188.9.14]
proc_sig_status(9) [i187.8.17], proc_sig_ignore(9) [i187.8.15], proc_sig_off(9) [i187.8.16], proc_dump_memory(9) [i187.8.4].
proc_sig_ignore - verifica dello stato di inibizione di un segnale
<kernel/proc.h> int proc_sig_ignore (pid_t pid, int sig); |
|
La funzione proc_sig_ignore() verifica se, per un certo processo pid, il segnale sig risulti inibito.
Questa funzione viene usata da proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18] e proc_sig_term(9) [i187.8.19], per verificare se un segnale sia stato inibito, prima di applicarne le conseguenze, nel caso fosse stato ricevuto.
|
kernel/proc.h [u0.9]
kernel/proc/proc_sig_ignore.c [i188.9.15]
proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18]m proc_sig_term(9) [i187.8.19].
proc_sig_on, proc_sig_off - registrazione o cancellazione di un segnale per un processo
<kernel/proc.h> void proc_sig_on (pid_t pid, int sig); void proc_sig_off (pid_t pid, int sig); |
|
La funzione proc_sig_on() annota per il processo pid la ricezione del segnale sig; la funzione proc_sig_off() procede invece in senso opposto, cancellando quel segnale.
La funzione proc_sig_off() viene usata quando l'azione prevista per un segnale che risulta ricevuto è stata eseguita, allo scopo di riportare l'indicatore di quel segnale in una condizione di riposo. Si tratta delle funzioni proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18] e proc_sig_term(9) [i187.8.19].
La funzione proc_sig_on() viene usata quando risulta acquisito un segnale o quando il contesto lo deve produrre, per annotarlo. Si tratta delle funzioni proc_sys_exit(9) [i187.8.21] e proc_sys_kill(9) [i187.8.23].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_on.c [i188.9.17]
kernel/proc/proc_sig_off.c [i188.9.16]
proc_sys_exit(9) [i187.8.21], proc_sys_kill(9) [i187.8.23], proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18], proc_sig_term(9) [i187.8.19].
proc_sig_status - verifica dello stato di ricezione di un segnale
<kernel/proc.h> int proc_sig_status (pid_t pid, int sig); |
|
La funzione proc_sig_status() verifica se, per un certo processo pid, il segnale sig risulti essere stato ricevuto (registrato).
Questa funzione viene usata da proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18] e proc_sig_term(9) [i187.8.19], per verificare se un segnale è stato ricevuto effettivamente, prima di applicarne eventualmente le conseguenze.
|
kernel/proc.h [u0.9]
kernel/proc/proc_sig_status.c [i188.9.18]
proc_sig_chld(9) [i187.8.12], proc_sig_cont(9) [i187.8.13], proc_sig_core(9) [i187.8.14], proc_sig_stop(9) [i187.8.18], proc_sig_term(9) [i187.8.19].
proc_sig_stop - sospensione di un processo
<kernel/proc.h> void proc_sig_stop (pid_t pid, int sig); |
|
La funzione proc_sig_stop() si occupa di verificare che il processo specificato con il parametro pid abbia ricevuto precedentemente un segnale SIGSTOP, SIGTSTP, SIGTTIN o SIGTTOU, e che questo non sia stato disabilitato. In tal caso, sospende il processo, lasciandolo in attesa di un segnale (SIGCONT).
Questa funzione viene usata soltanto da proc_sch_signals(9) [i187.8.8].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_stop.c [i188.9.19]
proc_sig_status(9) [i187.8.17], proc_sig_ignore(9) [i187.8.15], proc_sig_off(9) [i187.8.16].
proc_sig_term - conclusione di un processo
<kernel/proc.h> void proc_sig_term (pid_t pid, int sig); |
|
La funzione proc_sig_term() si occupa di verificare che il processo specificato con il parametro pid abbia ricevuto precedentemente un segnale per cui si prevede generalmente la conclusione del processo. Inoltre, la funzione verifica che il segnale non sia stato inibito, con l'eccezione che per il segnale SIGKILL un'eventuale inibizione non viene considerata (in quanto segnale non mascherabile). Se il segnale risulta ricevuto e valido, procede con la conclusione del processo.
Questa funzione viene usata soltanto da proc_sch_signals(9) [i187.8.8].
kernel/proc.h [u0.9]
kernel/proc/proc_sig_term.c [i188.9.20]
proc_sig_status(9) [i187.8.17], proc_sig_ignore(9) [i187.8.15], proc_sig_off(9) [i187.8.16], proc_sys_exit(9) [i187.8.21].
proc_sys_exec - sostituzione di un processo esistente con un altro, ottenuto dal caricamento di un file eseguibile
<kernel/proc.h>
int proc_sys_exec (uint16_t *sp, segment_t *segment_d,
pid_t pid, const char *path,
unsigned int argc, char *arg_data,
unsigned int envc, char *env_data);
|
|
I parametri arg_data e env_data sono stringhe multiple, nel senso che sono separate le une dalle altre dal codice nullo di terminazione. Per sapere quante sono effettivamente le stringhe da cercare a partire dai puntatori che costituiscono effettivamente questi due parametri, si usano argc e envc.
La funzione proc_sys_exec() serve a mettere in pratica la chiamata di sistema execve(2) [u0.10], destinata a rimpiazzare il processo in corso con un nuovo processo, caricato da un file eseguibile.
La funzione proc_sys_exec(), dopo aver verificato che si tratti effettivamente di un file eseguibile valido e che ci siano i permessi per metterlo in funzione, procede all'allocazione della memoria, dividendo se necessario l'area codice da quella dei dati, quindi legge il file e copia opportunamente le componenti di questo nelle aree di memoria allocate.
Terminato il caricamento del file, viene ricostruita in memoria la pila dei dati del nuovo processo. Prima si mettono sul fondo le stringhe delle variabili di ambiente e quelle degli argomenti della chiamata, quindi si aggiungono i puntatori alle stringhe delle variabili di ambiente, ricostruendo così l'array noto convenzionalmente come envp[], continuando con l'aggiunta dei puntatori alle stringhe degli argomenti della chiamata, per riprodurre l'array argv[]. Per ricostruire gli argomenti della chiamata della funzione main() dell'applicazione, vanno però aggiunti ancora: il puntatore all'inizio dell'array delle stringhe che descrivono le variabili di ambiente, il puntatore all'array delle stringhe che descrivono gli argomenti della chiamata e il valore che rappresenta la quantità di argomenti della chiamata.
|
Figura u187.145. Caricamento degli argomenti della chiamata della funzione main(). |
Fatto ciò, vanno aggiunti tutti i valori necessari allo scambio dei processi, costituiti dai vari registri da rimpiazzare.
Superato il problema della ricostruzione della pila dei dati, la funzione proc_sys_exec() predispone i descrittori di standard input, standard output e standard error, quindi libera la memoria usata dal processo chiamante e ne rimpiazza i dati nella tabella dei processi con quelli del nuovo processo caricato.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_EXEC.
lib/unistd/execve.c [i189.17.13]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_exec.c [i188.9.21]
execve(2) [u0.10], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], path_inode(9) [i187.3.36], inode_check(9) [i187.3.16], inode_put(9) [i187.3.24], inode_file_read(9) [i187.3.18], dev_io(9) [i187.1.1], fd_close(9) [i187.3.3].
proc_sys_exit - chiusura di un processo elaborativo
<kernel/proc.h> void proc_sys_exit (pid_t pid, int status); |
|
La funzione proc_sys_exit() conclude il processo indicato come argomento, chiudendo tutti i descrittori di file che risultano ancora aperti e liberando la memoria. Precisamente compie i passaggi seguenti:
aggiorna la tabella dei processi indicando per questo lo stato di «zombie» e annotando il valore di uscita;
chiude i descrittori di file che risultano aperti;
chiude l'inode della directory corrente;
se si tratta del processo principale di un gruppo di processi, allora chiude anche il terminale di controllo;
libera la memoria utilizzata dal processo, verificando comunque che l'area usata per il codice non sia abbinata anche a un altro processo, nel qual caso l'area del codice verrebbe preservata;
se ci sono dei processi figli di quello che si va a chiudere, questi vengono abbandonati e affidati al processo numero uno (init);
se sono stati abbandonati dei processi, invia il segnale SIGCHLD al processo numero uno (init);
invia al processo genitore il segnale, in modo che possa valutare, eventualmente, il valore di uscita del processo ormai defunto.
Questa funzione viene usata principalmente da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_EXIT, e anche dalle funzioni proc_sig_core(9) [i187.8.14] e proc_sig_term(9) [i187.8.19].
lib/unistd/_exit.c [i189.17.1]
lib/stdlib/_Exit.c [i189.10.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_exit.c [i188.9.22]
_exit(2) [u0.2], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], proc_sig_core(9) [i187.8.14], proc_sig_term(9) [i187.8.19], fd_close(9) [i187.3.3], inode_put(9) [i187.3.24], proc_sig_on(9) [i187.8.16].
proc_sys_fork - sdoppiamento di un processo elaborativo
<kernel/proc.h> pid_t proc_sys_fork (pid_t ppid, uint16_t sp); |
|
La funzione proc_sys_fork() crea un duplicato del processo chiamante, il quale diventa figlio dello stesso. Precisamente, la funzione compie i passaggi seguenti:
cerca un alloggiamento libero nella tabella dei processi e procede solo se questo risulta disponibile effettivamente;
per sicurezza, analizza i processi che risultano essere defunti (zombie) e ne inizializza i valori delle allocazioni in memoria;
alloca la memoria necessaria a ottenere la copia del processo, tenendo conto che se il processo originario divide l'area codice da quella dei dati, è necessario allocare soltanto lo spazio per l'area dati, in quanto quella del codice può essere condivisa (essendo usata soltanto in lettura);
compila le informazioni necessarie nella tabella dei processi, relative al nuovo processo da produrre, dichiarandolo come figlio di quello chiamante;
incrementa il contatore di utilizzo dell'inode che rappresenta la directory corrente, in quanto un nuovo processo la va a utilizzare;
duplica i descrittori di file già aperti per il processo da duplicare, incrementando di conseguenza il contatore dei riferimenti nella tabella dei file;
modifica i valori dei registri di segmento nella pila dei dati riferita al processo nuovo, per renderli coerenti con la nuova collocazione in memoria;
mette il nuovo processo nello stato di pronto, annotandolo così nella tabella dei processi;
restituisce il numero del nuovo processo: nel processo figlio, invece, non restituisce alcunché.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_FORK.
La funzione restituisce al processo chiamante il numero del processo figlio, mentre il risultato che si ottiene nel processo figlio che si trova a riprendere il funzionamento dallo stesso punto, è semplicemente zero. Ciò consente di distinguere quale sia il processo genitore e quale è invece il figlio. Se la funzione non è in grado di portare a termine il lavoro di duplicazione dei processi, restituisce il valore -1, aggiornando di conseguenza la variabile errno del kernel.
|
lib/unistd/fork.c [i189.17.17]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_fork.c [i188.9.23]
fork(2) [u0.14], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], dev_io(9) [i187.1.1].
proc_sys_kill - invio di un segnale a uno o più processi elaborativi
<kernel/proc.h> int proc_sys_kill (pid_t pid_killer, pid_t pid_target, int sig); |
|
La funzione proc_sys_kill() invia il segnale sig al processo numero pid_target, ammesso che il processo pid_killer abbia i privilegi necessari a farlo. Tuttavia, se il numero pid_target è zero o -1, si richiede alla funzione l'invio del segnale a un insieme di processi. La tabella successiva descrive i vari casi.
|
Si osservi che il preteso invio di un segnale pari a zero, ovvero di un segnale nullo, non produce alcun effetto, ma la funzione segnala comunque di avere completato l'operazione con successo.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_KILL.
|
|
lib/signal/kill.c [i189.8.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_kill.c [i188.9.24]
kill(2) [u0.22], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], proc_sig_on(9) [i187.8.16].
proc_sys_seteuid - modifica dell'identità efficace
<kernel/proc.h> int proc_sys_seteuid (pid_t pid, uid_t euid); |
|
La funzione proc_sys_seteuid() modifica l'identità efficace del processo pid, purché si verifichino certe condizioni:
se il processo pid è zero, l'identità efficace viene modificata senza altre verifiche;
se l'identità efficace che ha già il processo coincide con quella nuova richiesta, non viene apportata alcuna modifica (per ovvi motivi);
se la nuova identità efficace corrisponde all'identità reale del processo, oppure se corrisponde alla sua identità salvata, allora la modifica di quella efficace ha luogo come richiesto;
in tutti gli altri casi si ottiene un errore.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_SETEUID.
|
|
lib/unistd/seteuid.c [i189.17.30]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_seteuid.c [i188.9.25]
seteuid(2) [u0.33], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], proc_sys_setuid(9) [i187.8.25].
proc_sys_setuid - modifica dell'identità
<kernel/proc.h> int proc_sys_setuid (pid_t pid, uid_t uid); |
|
La funzione proc_sys_setuid() modifica l'identità del processo pid, oppure tutti i tipi di identità, a seconda di certe condizioni:
se l'identità efficace del processo pid è zero, viene modificata l'identità reale, quella salvata e quella efficace, utilizzando il nuovo valore uid;
se l'identità efficace del processo coincide già con quella del valore richiesto uid, non viene apportata alcuna modifica e la funzione si conclude con successo;
se l'identità reale o quella salvato del processo pid coincide con l'identità richiesta uid, allora viene modificata l'identità efficace del processo con il valore uid;
in tutti gli altri casi si ottiene un errore.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_SETUID.
|
|
lib/unistd/setuid.c [i189.17.32]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_setuid.c [i188.9.26]
setuid(2) [u0.33], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], proc_sys_seteuid(9) [i187.8.24].
proc_sys_signal - modifica della configurazione dei segnali
<kernel/proc.h>
sighandler_t proc_sys_signal (pid_t pid, int sig,
sighandler_t handler);
|
|
La funzione proc_sys_signal() ha il compito di modificare il comportamento del processo nel caso fosse ricevuto il segnale specificato. Teoricamente, il parametro handler potrebbe riferirsi a una funzione da eseguire allo scattare del segnale; tuttavia, os16 non è in grado di gestire questa evenienza e per handler si può specificare soltanto il valore corrispondente all'azione predefinita o a quella di inibizione del segnale.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_SIGNAL.
La funzione restituisce il valore di handler abbinato precedentemente al processo. Se si verifica un errore, restituisce SIG_ERR e aggiorna la variabile errno del kernel.
|
lib/signal/signal.c [i189.8.2]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_signal.c [i188.9.27]
signal(2) [u0.34], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_scheduler(9) [i187.8.11], proc_sys_kill(9) [i187.8.23].
proc_sys_wait - attesa per la morte di un processo figlio
<kernel/proc.h> pid_t proc_sys_wait (pid_t pid, int *status); |
|
La funzione proc_sys_wait() ha il compito di mettere il processo pid in pausa, fino alla morte di uno dei propri processi figli.
Per realizzare questo compito, la funzione scandisce inizialmente la tabella dei processi alla ricerca di figli di pid. Se tra questi ne esiste già uno defunto, allora aggiorna *status con il valore di uscita di quello, liberando definitivamente la tabella dei processi dalle tracce di questo figlio. Se invece, pur avendo trovato dei figli, questi risultano ancora tutti in funzione, mette il processo pid in pausa, in attesa di un segnale SIGCHLD.
Questa funzione viene usata soltanto da sysroutine(9) [i187.8.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_WAIT.
La funzione restituisce il numero PID del processo defunto, se c'è, aggiornando anche *status con il valore di uscita dello stesso processo. Se invece il processo pid è stato messo in attesa, allora restituisce zero, mentre se non ci sono proprio figli di pid, restituisce -1 e aggiorna la variabile errno del kernel.
|
lib/sys/wait/wait.c [i189.15.1]
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
kernel/proc/proc_sys_wait.c [i188.9.28]
wait(2) [u0.43], sys(2) [u0.37], isr_80(9) [i187.8.1], sysroutine(9) [i187.8.28], proc_available(9) [i187.8.3], proc_scheduler(9) [i187.8.11], proc_sys_fork(9) [i187.8.22], proc_sys_kill(9) [i187.8.23].
sysroutine - attuazione delle chiamate di sistema
<kernel/proc.h>
void sysroutine (uint16_t *sp, segment_t *segment_d,
uint16_t syscallnr,
uint16_t msg_off, uint16_t msg_size);
|
|
La funzione sysroutine() viene chiamata esclusivamente dalla routine isr_80(9) [i187.8.1], a seguito di una chiamata di sistema.
Inizialmente, la funzione individua il processo elaborativo corrispondente a quello che utilizza il segmento dati *segment_d e l'indirizzo efficace dell'area di memoria contenente il messaggio della chiamata di sistema, traducendo le informazioni contenute in msg_off e *segment_d.
Attraverso un'unione di variabili strutturate, tutti i tipi di messaggi gestibili per le chiamate di sistema vengono dichiarati assieme in un'unica area di memoria. Successivamente, la funzione deve trasferire il messaggio, dall'indirizzo efficace calcolato precedentemente all'inizio dell'unione in questione.
Quando la funzione è in grado di accedere ai dati del messaggio, procede con una grande struttura di selezione, sulla base del tipo di messaggio, quindi esegue ciò che è richiesto, avvalendosi prevalentemente di altre funzioni, interpretando il messaggio in modo diverso a seconda del tipo di chiamata.
Il messaggio viene poi sovrascritto con le informazioni prodotte dall'azione richiesta, in particolare viene trasferito anche il valore della variabile errno del kernel, in modo che possa essere recepita anche dal processo che ha eseguito la chiamata, in caso di esito erroneo. Pertanto, il messaggio viene anche riscritto a partire dall'indirizzo efficace da cui era stato copiato precedentemente, in modo da renderlo disponibile effettivamente al processo chiamante.
Quando la funzione sysroutine() ha finito il suo lavoro, chiama a sua volta proc_scheduler(9) [i187.8.11], perché con l'occasione provveda eventualmente alla sostituzione del processo attivo con un altro che si trovi nello stato di pronto.
La funzione non restituisce alcun valore, in quanto tutto ciò che c'è da restituire viene trasmesso con la riscrittura del messaggio, nell'area di memoria originale.
lib/sys/os16/sys.s [i189.12.15]
kernel/proc.h [u0.9]
kernel/proc/_isr.s [i188.9.1]
kernel/proc/sysroutine.c [i188.9.30]
sys(2) [u0.37], isr_80(9) [i187.8.1], proc_scheduler(9) [i187.8.11], dev_io(9) [i187.1.1], path_chdir(9) [i187.3.30], path_chmod(9) [i187.3.31], path_chown(9) [i187.3.32], fd_close(9) [i187.3.3], fd_dup(9) [i187.3.4], fd_dup2(9) [i187.3.4], proc_sys_exec(9) [i187.8.20], proc_sys_exit(9) [i187.8.21], fd_chmod(9) [i187.3.1], fd_chown(9) [i187.3.2], fd_fcntl(9) [i187.3.6], proc_sys_fork(9) [i187.8.22], fd_stat(9) [i187.3.50], proc_sys_kill(9) [i187.8.23], path_link(9) [i187.3.38], fd_lseek(9) [i187.3.7], path_mkdir(9) [i187.3.39], path_mknod(9) [i187.3.40], path_mount(9) [i187.3.41], fd_open(9) [i187.3.8], fd_read(9) [i187.3.9], proc_sys_seteuid(9) [i187.8.24], proc_sys_setuid(9) [i187.8.25], proc_sys_signal(9) [i187.8.26], path_stat(9) [i187.3.50], path_umount(9) [i187.3.41], path_unlink(9) [i187.3.44], proc_sys_wait(9) [i187.8.27], fd_write(9) [i187.3.12].
Il file kernel/tty.h [u0.10] descrive le funzioni per la gestione dei terminali virtuali.
Per la descrizione dell'organizzazione della gestione dei terminali virtuali di os16, si rimanda alla sezione u174. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da quel capitolo.
|
Tabella u174.1. Funzioni per la gestione dei terminali, dichiarate nel file di intestazione
|
«a2» 2013.11.11 --- Copyright © Daniele Giacomini -- appunti2@gmail.com http://informaticalibera.net
