Figura 84.80. Interdipendenza tra la funzione dev_io() e le altre. I collegamenti con le funzioni major() e minor() sono omesse.
arp.h 93.1
ata.h 93.2
blk.h 93.3
blk_ata() 93.3.1
blk_cache_check() 93.3.2
blk_cache_init() 93.3.3
blk_cache_read() 93.3.4
blk_cache_save() 93.3.4
dev.h 93.4
dev_ata() 93.4.3
dev_dm() 93.4.2
dev_io() 93.4.1
dev_kmem() 93.4.4
dev_mem() 93.4.5
dev_tty() 93.4.6
dm.h 93.5
fd_dup() 93.6.1
fd_reference() 93.6.2
file_pipe_make() 93.6.4
file_reference() 93.6.5
file_stdio_dev_make() 93.6.6
fs.h 93.6
fs_init() 93.6.3
ibm_i386.h 93.7
icmp.h 93.8
inode_alloc() 93.6.7
inode_check() 93.6.8
inode_dir_empty() 93.6.9
inode_file_read() 93.6.10
inode_file_write() 93.6.11
inode_free() 93.6.12
inode_fzones_read() 93.6.13
inode_fzones_write() 93.6.13
inode_get() 93.6.15
inode_pipe_make() 93.6.16
inode_pipe_read() 93.6.17
inode_pipe_write() 93.6.18
inode_print() 93.6.19
inode_put() 93.6.20
inode_reference() 93.6.21
inode_save() 93.6.22
inode_stdio_dev_make() 93.6.23
inode_truncate() 93.6.24
inode_zone() 93.6.25
ip.h 93.9
kbd.h 93.10
lib_k.h 93.11
lib_s.h 93.12
main.h 93.13
memory.h 93.14
multiboot.h 93.15
ne2k.h 93.16
net.h 93.17
part.h 93.18
path_device() 93.6.38
path_fix() 93.6.39
path_full() 93.6.40
path_inode() 93.6.41
path_inode_link() 93.6.42
pci.h 93.19
proc.h 93.20
proc_available() 93.20.1
proc_dump_memory() 93.20.2
proc_init() 93.20.3
proc_print() 93.20.4
proc_reference() 93.20.5
proc_scheduler() 93.20.10
proc_sch_net() 93.20.6
proc_sch_signals() 93.20.7
proc_sch_terminals() 93.20.8
proc_sch_timers() 93.20.9
proc_sig_chld() 93.20.11
proc_sig_cont() 93.20.12
proc_sig_core() 93.20.13
proc_sig_handler() 93.20.14
proc_sig_ignore() 93.20.15
proc_sig_off() 93.20.17
proc_sig_on() 93.20.17
proc_sig_status() 93.20.18
proc_sig_stop() 93.20.19
proc_sig_term() 93.20.20
proc_sys_exec() 93.20.21
proc_timer_init() 93.20.22
proc_wakeup_pipe_read() 93.20.23
proc_wakeup_pipe_write() 93.20.23
proc_wakeup_terminal() 93.20.23
ptr() 93.20.27
route.h 93.21
sb_inode_status() 93.6.26
sb_mount() 93.6.27
sb_print() 93.6.28
sb_reference() 93.6.29
sb_save() 93.6.30
sb_zone_status() 93.6.26
screen.h 93.22
sock_free_port() 93.6.32
sock_reference() 93.6.33
sysroutine() 93.20.28
s_brk() 93.12
s_chdir() 93.12
s_chmod() 93.12
s_chown() 93.12
s_clock() 93.12
s_close() 93.12
s_dup() 93.12
s_dup2() 93.12
s_fchmod() 93.12
s_fchown() 93.12
s_fcntl() 93.12
s_fork() 93.12
s_fstat() 93.12
s_kill() 93.12
s_link() 93.12
s_longjmp() 93.12
s_lseek() 93.12
s_mkdir() 93.12
s_mknod() 93.12
s_mount() 93.12
s_open() 93.12
s_pipe() 93.12
s_read() 93.12
s_sbrk() 93.12
s_setegid() 93.12
s_seteuid() 93.12
s_setgid() 93.12
s_setjmp() 93.12
s_setuid() 93.12
s_signal() 93.12
s_stat() 93.12
s_stime() 93.12
s_tcgetattr() 93.12
s_tcsetattr() 93.12
s_time() 93.12
s_umount() 93.12
s_unlink() 93.12
s_wait() 93.12
s_write() 93.12
s__exit() 93.12
tcp.h 93.23
tty.h 93.24
zone_alloc() 93.6.34
zone_free() 93.6.34
zone_print() 93.6.36
zone_read() 93.6.37
zone_write() 93.6.37
Il file kernel/net/arp.h [94.12.1] descrive le funzioni per la gestione della tabella ARP, per la trasformazione degli indirizzi IPv4 in indirizzi Ethernet.
Per la descrizione sulla gestione della tabella ARP da parte di os32, si rimanda alla sezione 84.9.3. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.123. Funzioni per la gestione della tabella ARP, contenute nella directory
|
Il file kernel/driver/ata.h [94.4.3] descrive le funzioni per la gestione delle unità a disco PATA.
Per la descrizione dell'organizzazione della gestione delle unità PATA di os32, si rimanda alla sezione 84.7.7. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.94. Funzioni per la gestione delle unità PATA, dichiarate nel file di intestazione
|
Il file kernel/blk.h [94.2] descrive ciò che serve per la gestione dei blocchi di dati, in relazione ai dispositivi di memorizzazione a blocchi.
blk_ata - interfaccia di accesso ai dispositivi di memorizzazione PATA
<kernel/blk.h>
void *blk_ata (dev_t device, int rw, unsigned int n,
void *buffer);
|
|
La funzione blk_ata() è un'interfaccia per l'accesso alle unità PATA, un blocco alla volta, che si avvale di una memoria cache per ridurre gli accessi fisici ripetuti agli stessi blocchi.
La funzione restituisce il puntatore a un'area di memoria contenente il blocco di dati letto o scritto. In caso di errore restituisce il puntatore nullo e aggiorna la variabile errno del kernel. Il blocco in questione si riferisce all'unità complessiva, pertanto, se originariamente si faceva riferimento a un dispositivo di una partizione, prima di arrivare a questa funzione il blocco relativo della partizione deve essere stato convertito in un blocco assoluto dell'unità complessiva.
|
kernel/blk.h [94.2]
kernel/blk/blk_ata.c [94.2.1]
dev_dm(9) [93.4.2], dev_ata(9) [93.4.3], blk_cache_read(9) [93.3.4], blk_cache_save(9) [93.3.4].
blk_cache_check - verifica della validità del contenuto della tabella dei blocchi conservati in memoria
<kernel/blk.h> void blk_cache_check (void); |
La funzione blk_cache_check() serve a verificare che la tabella dei blocchi conservati in memoria (blk_table[]) contenga dati validi, per ciò che riguarda le età degli stessi. In pratica, il valore dell'età dei blocchi deve essere sequenziale, iniziando da zero e terminando con il valore massimo consentito: non ci devono essere valori mancanti e non ci devono essere valori doppi. Questa funzione serve solo a titolo diagnostico e in pratica non viene usata.
La funzione non restituisce alcunché; se viene usata e se individua errori, questi vengono visualizzati attraverso la funzione k_printf().
kernel/blk.h [94.2]
kernel/blk/blk_cache_check.c [94.2.2]
blk_cache_init(9) [93.3.3], blk_cache_read(9) [93.3.4], blk_cache_save(9) [93.3.4].
blk_cache_init - inizializzazione della tabella dei blocchi conservati in memoria
<kernel/blk.h> void blk_cache_init (void); |
La funzione blk_cache_init() serve a inizializzare la tabella dei blocchi conservati in memoria (blk_table[]), assegnando anche il valore dell'età in modo progressivo, da zero fino al valore massimo consentito. Questa funzione viene usata una volta sola, prima che i dispositivi di memorizzazione a blocchi possano avvalersi della tabella stessa.
La funzione non restituisce alcunché.
kernel/blk.h [94.2]
kernel/blk/blk_cache_init.c [94.2.3]
blk_cache_check(9) [93.3.2], blk_cache_read(9) [93.3.4], blk_cache_save(9) [93.3.4].
blk_cache_read, blk_cache_save, - lettura e scrittura nella tabella dei blocchi
<kernel/blk.h>
void *blk_cache_read (dev_t device, unsigned int n);
void *blk_cache_save (dev_t device, unsigned int n,
void *block);
|
|
Le funzioni blk_cache_read() e blk_cache_save() si occupano di trovare un blocco già salvato in precedenza nella tabella dei blocchi, o di salvarne uno nuovo o di aggiornarne il contenuto. Le funzioni restituiscono il puntatore al blocco trovato o memorizzato, oppure il puntatore nullo in caso di fallimento dell'operazione.
Quando si legge un blocco, lo si ottiene solo se viene trovata la corrispondenza con il numero di dispositivo (riferito all'unità complessiva) e al numero del blocco stesso. Quando si salva un blocco, viene prima cercato lo stesso blocco nella tabella, per aggiornarlo, ma se non c'è, viene riutilizzata una cella corrispondente a un vecchio blocco che non risulta usato da più tempo.
Una lettura con successo o il salvataggio di un blocco, implica l'attribuzione allo stesso di un'età pari a zero, modificando di conseguenza quella degli altri blocchi in modo coerente.
La funzione restituisce il puntatore all'area di memoria contenente il blocco di dati letto o scritto. Mentre il salvataggio avviene sempre con successo, la lettura può fallire e in tal caso si ottiene il puntatore nullo.
kernel/blk.h [94.2]
kernel/blk/blk_cache_read.c [94.2.4]
kernel/blk/blk_cache_save.c [94.2.5]
Vedere blk_cache_read(9) [93.3.4].
Il file kernel/dev.h [94.3] descrive ciò che serve per la gestione dei dispositivi. Tuttavia, la definizione dei numeri di dispositivo è contenuta nel file lib/sys/os32.h [95.21], il quale viene incluso da dev.h.
|
Tabella 84.82. Classificazione dei dispositivi di os32.
|
|
Figura 84.80. 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/dev.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 os32.
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/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
dev_dm(9) [93.4.2], dev_kmem(9) [93.4.4], dev_mem(9) [93.4.5], dev_tty(9) [93.4.6].
dev_dm - interfaccia di accesso alle unità di memorizzazione di massa
<kernel/dev.h>
ssize_t dev_dm (pid_t pid, dev_t device, int rw, off_t offset,
void *buffer, size_t size, int *eof);
|
La funzione dev_dm() consente di accedere alle unità di memorizzazione di massa, che per os32 si riducono alle sole unità PATA.
Per il significato degli argomenti, il valore restituito e gli eventuali errori, si veda dev_io(9) [93.4.1].
kernel/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
kernel/dev/dev_dm.c [94.3.2]
dev_ata - interfaccia di accesso alle unità di memorizzazione di massa PATA
<kernel/dev.h>
ssize_t dev_ata (pid_t pid, dev_t device, int rw, off_t offset,
void *buffer, size_t size, int *eof);
|
La funzione dev_ata() consente di accedere alle unità di memorizzazione di massa PATA, traducendo le operazioni da flusso di byte a blocchi. Questa funzione viene usata da dev_dm() e si avvale a sua volta di blk_ata().
Per il significato degli argomenti, il valore restituito e gli eventuali errori, si veda dev_io(9) [93.4.1].
kernel/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
kernel/dev/dev_dm.c [94.3.2]
kernel/dev/dev_ata.c [94.3.1]
dev_kmem - interfaccia di accesso alle tabelle di dati del kernel, rappresentate in memoria
<kernel/dev.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) [93.4.1].
kernel/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
kernel/dev/dev_kmem.c [94.3.4]
dev_mem - interfaccia di accesso alla memoria, in modo indiscriminato
<kernel/fs.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) [93.4.1].
kernel/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
kernel/dev/dev_mem.c [94.3.5]
dev_tty - interfaccia di accesso alla console
<kernel/dev.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 os32, in quanto il terminale può funzionare soltanto in modalità canonica; in altri termini, si può interagire soltanto come se si trattasse della telescrivente tradizionale.
Per quanto non viene descritto qui, si veda dev_io(9) [93.4.1].
kernel/dev.h [94.3]
kernel/dev/dev_io.c [94.3.3]
kernel/dev/dev_tty.c [94.3.6]
Il file kernel/dm.h [94.4] descrive ciò che serve per la gestione delle unità di memorizzazione, in generale. È disponibile soltanto la funzione dm_init() per la predisposizione iniziale della tabella dm_table[].
Il file kernel/fs.h [94.5] descrive ciò che serve per la gestione del file system, che per os32 corrisponde al tipo Minix 1, assieme ai socket, essendo questi assimilati ai descrittori di file.
La gestione del file system e dei socket, a livello complessivo di sistema, è suddivisa in quattro aspetti principali: super blocco, inode, file e socket. Per ognuno di questi è prevista una tabella (di super blocchi, di inode, di file e di socket). Seguono delle figure e i listati che descrivono l'organizzazione di queste tabelle.
|
Figura 84.95. Struttura del tipo sb_t, corrispondente agli elementi dell'array sb_table[]. |
|
Listato 84.96. Struttura del tipo sb_t, corrispondente agli elementi dell'array sb_table[].
|
|
Figura 84.100. Struttura del tipo inode_t, corrispondente agli elementi dell'array inode_table[]. |
|
Listato 84.101. Struttura del tipo inode_t, corrispondente agli elementi dell'array inode_table[].
|
|
Figura 84.108. Struttura del tipo file_t, corrispondente agli elementi dell'array file_table[].
|
|
Figura 84.111. Struttura del tipo fd_t, con cui si costituiscono gli elementi delle tabelle dei descrittori di file, una per ogni processo.
|
|
Listato 84.131. Struttura di ogni elemento della tabella dei socket.
|
fd_dup - duplicazione di un descrittore di file
<kernel/fs.h> int fd_dup (pid_t pid, int fdn_old, int fdn_min); |
|
La funzione fd_dup() duplica un descrittore, nel senso che sdoppia l'accesso a un file in due descrittori, cercando un descrittore libero a cominciare da fdn_min e continuando progressivamente, fino al primo disponibile. Il descrittore ottenuto dalla copia, viene privato dell'indicatore FD_CLOEXEC, ammesso che nel descrittore originale ci fosse.
Questa funzione viene usata da s_dup(9) [93.12] e da s_fcntl(9) [93.12], per la duplicazione di un descrittore.
La funzione restituisce il numero del descrittore prodotto dalla duplicazione. In caso di errore, invece, restituisce il valore -1, aggiornando la variabile errno del kernel.
|
kernel/fs.h [94.5]
kernel/fs/fd_dup.c [94.5.1]
dup(2) [87.12], dup2(2) [87.12], sysroutine(9) [93.20.28], proc_reference(9) [93.20.5].
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 [94.5]
kernel/fs/fd_reference.c [94.5.2]
file_reference(9) [93.6.5], inode_reference(9) [93.6.21], sb_reference(9) [93.6.29], proc_reference(9) [93.20.5].
fs_init - inizializzazione delle tabelle relative alla gestione del file system
<kernel/fs.h> void fs_init (void); |
La funzione fs_init() azzera il contenuto delle tabelle dei super blocchi, degli inode e dei file. Questa funzione viene usata esclusivamente da kmain(9) [93.13], per predisporre le tabelle di gestione del file system.
kernel/fs.h [94.5]
kernel/fs/fs_init.c [94.5.6]
fd_reference(9) [93.6.2], inode_reference(9) [93.6.21], sb_reference(9) [93.6.29].
file_pipe_make - creazione di una voce relativa a un condotto, nella tabella dei file di sistema
<kernel/fs.h> file_t *file_pipe_make (void); |
La funzione file_pipe_make() produce una voce nella tabella dei file di sistema, relativa a un condotto (pipe).
Per ottenere questo risultato occorre coinvolgere anche la funzione inode_pipe_make(9) [93.6.16], 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 s_pipe(9) [93.12], per la realizzazione della chiamata di sistema pipe(2) [87.38].
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 [94.5]
kernel/fs/file_pipe_make.c [94.5.3]
inode_pipe_make(9) [93.6.16], file_reference(9) [93.6.5], inode_put(9) [93.6.20].
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 [94.5]
kernel/fs/fs_public.c [94.5.7]
kernel/fs/file_reference.c [94.5.4]
fd_reference(9) [93.6.2], inode_reference(9) [93.6.21], sb_reference(9) [93.6.29], proc_reference(9) [93.20.5].
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) [93.6.23], 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) [93.20.21], 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 [94.5]
kernel/fs/file_stdio_dev_make.c [94.5.5]
proc_sys_exec(9) [93.20.21], inode_stdio_dev_make(9) [93.6.23], file_reference(9) [93.6.5], inode_put(9) [93.6.20].
inode_alloc - allocazione di un inode
<kernel/fs.h>
inode_t *inode_alloc (dev_t device, mode_t mode, uid_t uid,
gid_t gid);
|
|
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) [93.6.42], 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 [94.5]
kernel/fs/inode_alloc.c [94.5.8]
path_inode_link(9) [93.6.42], sb_reference(9) [93.6.29], inode_get(9) [93.6.15], inode_put(9) [93.6.20], inode_truncate(9) [93.6.24], inode_save(9) [93.6.22].
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, gid_t gid);
|
|
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 e gruppo. 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 e del gruppo gid, tenendo conto del complesso dei permessi che li 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 [94.5]
kernel/fs/inode_check.c [94.5.9]
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 [94.5]
kernel/fs/inode_dir_empty.c [94.5.10]
inode_file_read(9) [93.6.10].
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) [93.6.13], 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 [94.5]
kernel/fs/inode_file_read.c [94.5.11]
inode_fzones_read(9) [93.6.13].
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) [93.6.13], per accedere ai contenuti del file, suddivisi in zone, secondo l'organizzazione del file system Minix 1, e di zone_write(9) [93.6.37], per la riscrittura delle zone relative.
Per os32, 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 [94.5]
kernel/fs/inode_file_write.c [94.5.12]
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) [93.6.20], per completare la cancellazione di un inode che non ha più collegamenti nel file system, quando non vi si fa più riferimento nel sistema in funzione.
|
|
kernel/fs.h [94.5]
kernel/fs/inode_free.c [94.5.13]
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) [93.6.10] e inode_file_write(9) [93.6.11], 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 [94.5]
kernel/fs/inode_fzones_read.c [94.5.14]
kernel/fs/inode_fzones_write.c [94.5.15]
inode_file_read(9) [93.6.10], inode_file_write(9) [93.6.11], zone_read(9) [93.6.37], zone_write(9) [93.6.37].
Vedere inode_fzones_read(9) [93.6.13].
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 [94.5]
kernel/fs/inode_get.c [94.5.16]
offsetof(3) [88.88], inode_put(9) [93.6.20], inode_reference(9) [93.6.21], sb_reference(9) [93.6.29], sb_inode_status(9) [93.6.26], dev_io(9) [93.4.1].
inode_pipe_make - creazione di una voce relativa a un condotto, nella tabella degli inode
<kernel/fs.h> inode_t *inode_pipe_make (void); |
La funzione inode_pipe_make() produce una voce nella tabella degli inode, relativa a un condotto (pipe).
Questa funzione viene usata esclusivamente da file_pipe_make(9) [93.6.4], per creare una voce da usare condotto, 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 [94.5]
kernel/fs/inode_pipe_make.c [94.5.17]
inode_pipe_read - lettura di un condotto rappresentato da un inode
<kernel/fs.h>
ssize_t inode_file_read (inode_t *inode, void *buffer,
size_t count, int *eof);
|
|
La funzione inode_pipe_read() legge il contenuto del file a cui si riferisce l'inode inode e se il puntatore eof è valido, aggiorna anche la variabile *eof.
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, impostandolo a uno quando la lettura avviene mentre non ci sono più riferimenti in scrittura per il condotto.
|
kernel/fs.h [94.5]
kernel/fs/inode_pipe_read.c [94.5.18]
inode_file_read(9) [93.6.10].
inode_pipe_write - scrittura di un condotto rappresentato da un inode
<kernel/fs.h>
ssize_t inode_pipe_write (inode_t *inode, void *buffer,
size_t count);
|
|
La funzione inode_pipe_write() scrive nel condotto rappresentato da inode, la quantità massima di byte indicati con count, ciò che si trova in memoria a partire da buffer.
La funzione restituisce la quantità di byte scritti.
|
kernel/fs.h [94.5]
kernel/fs/inode_pipe_write.c [94.5.19]
inode_file_write(9) [93.6.11].
inode_print - visualizzazione diagnostica della tabella degli inode
<kernel/fs.h> void inode_print (void); |
La funzione inode_print() visualizza sinteticamente i contenuti della tabella degli inode, per fini diagnostici.
kernel/fs.h [94.5]
kernel/fs/inode_print.c [94.5.20]
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 [94.5]
kernel/fs/inode_put.c [94.5.21]
inode_truncate(9) [93.6.24], inode_free(9) [93.6.12], inode_save(9) [93.6.22].
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 [94.5]
kernel/fs/inode_reference.c [94.5.22]
sb_reference(9) [93.6.29], file_reference(9) [93.6.5], proc_reference(9) [93.20.5].
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 [94.5]
kernel/fs/inode_save.c [94.5.23]
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) [93.6.6], 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 [94.5]
kernel/fs/inode_stdio_dev_make.c [94.5.24]
file_stdio_dev_make(9) [93.6.6], inode_reference(9) [93.6.21].
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 [94.5]
kernel/fs/inode_truncate.c [94.5.25]
zone_free(9) [93.6.34], sb_save(9) [93.6.30], inode_save(9) [93.6.22].
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 [94.5]
kernel/fs/inode_zone.c [94.5.26]
memset(3) [88.82], zone_alloc(9) [93.6.34], zone_read(9) [93.6.37], zone_write(9) [93.6.37].
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) [93.6.15]; la funzione sb_zone_status() non viene usata affatto.
|
|
kernel/fs.h [94.5]
kernel/fs/sb_inode_status.c [94.5.32]
kernel/fs/sb_zone_status.c [94.5.37]
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) [93.20.3] per innestare il file system principale, e da s_mount(9) [93.12] 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 [94.5]
kernel/fs/sb_mount.c [94.5.33]
sb_reference(9) [93.6.29], dev_io(9) [93.4.1], inode_get(9) [93.6.15].
sb_print - visualizzazione diagnostica della tabella dei super blocchi
<kernel/fs.h> void sb_print (void); |
La funzione sb_print() visualizza sinteticamente i contenuti della tabella dei super blocchi, per fini diagnostici.
kernel/fs.h [94.5]
kernel/fs/sb_print.c [94.5.34]
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 [94.5]
kernel/fs/fs_public.c [94.5.7]
kernel/fs/sb_reference.c [94.5.35]
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 [94.5]
kernel/fs/sb_save.c [94.5.36]
Vedere sb_inode_status(9) [93.6.26].
sock_free_port - scansione della tabella dei socket alla ricerca di una porta libera, da 1 024 in su
<kernel/fs.h> h_port_t sock_free_port (void); |
La funzione sock_free_port() restituisce il numero di una porta libera, dopo avere scandito la tabella dei socket. La ricerca riguarda esclusivamente le porte da 1 024 in su, ovvero di quelle che possono essere utilizzate da processi non privilegiati. Nel caso le porte siano tutte impegnate, la funzione restituisce il valore zero.
Il tipo h_port_t a cui si riferisce il valore restituito dalla funzione è un valore scalare, adatto a contenere il numero di una porta, rappresentato secondo l'ordinamento dei byte del sistema (host byte order).
La funzione restituisce il numero della porta libera trovata, oppure zero in mancanza di questo.
kernel/fs.h [94.5]
kernel/fs/sock_free_port.c [94.5.38]
sock_reference(9) [93.6.33].
sock_reference - riferimento a un elemento della tabella dei socket
<kernel/fs.h> sock_t *sock_reference (int skn); |
|
La funzione sock_reference() serve a produrre il puntatore a una voce della tabella dei super blocchi. Se si fornisce un indice positivo (maggiore o uguale a zero), si ottiene &sock_table[skn]; altrimenti, con un valore negativo qualunque, viene scandita la tabella alla ricerca della prima voce libera, di cui si restituisce il puntatore allo stesso modo.
La funzione restituisce il puntatore all'elemento della tabella dei super blocchi che soddisfa la richiesta. Non si manifestano errori e se viene richiesto un indice positivo troppo grande, si ottiene un puntatore al di fuori della tabella.
kernel/fs.h [94.5]
kernel/fs/fs_public.c [94.5.7]
kernel/fs/sock_reference.c [94.5.39]
sock_free_port(9) [93.6.32].
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 [94.5]
kernel/fs/zone_alloc.c [94.5.40]
kernel/fs/zone_free.c [94.5.41]
Vedere zone_alloc(9) [93.6.34].
zone_print - visualizzazione diagnostica del contenuto della prima parte di una zona dati
<kernel/fs.h> void zone_print (sb_t *sb, zno_t zone); |
La funzione zone_print() visualizza la prima parte del contenuto di una zona dati, riferita a un certo super blocco, in esadecimale, per fini diagnostici.
kernel/fs.h [94.5]
kernel/fs/zone_print.c [94.5.42]
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 [94.5]
kernel/fs/zone_read.c [94.5.43]
kernel/fs/zone_write.c [94.5.44]
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 s_mount(9) [93.12].
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 [94.5]
kernel/fs/path_device.c [94.5.27]
proc_reference(9) [93.20.5], path_inode(9) [93.6.41], inode_put(9) [93.6.20].
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 [94.5]
kernel/fs/path_fix.c [94.5.28]
strtok(3) [88.129], strcmp(3) [88.115], strcat(3) [88.113], strncat(3) [88.113], strncpy(3) [88.117].
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 [94.5]
kernel/fs/path_full.c [94.5.29]
strtok(3) [88.129], strcmp(3) [88.115], strcat(3) [88.113], strncat(3) [88.113], strncpy(3) [88.117], path_fix(9) [93.6.39].
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 [94.5]
kernel/fs/path_inode.c [94.5.30]
proc_reference(9) [93.20.5], path_full(9) [93.6.40], inode_get(9) [93.6.15], inode_put(9) [93.6.20], inode_check(9) [93.6.8], inode_file_read(9) [93.6.10].
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 [94.5]
kernel/fs/path_inode_link.c [94.5.31]
proc_reference(9) [93.20.5], path_inode(9) [93.6.41], inode_get(9) [93.6.15], inode_put(9) [93.6.20], inode_save(9) [93.6.22], inode_check(9) [93.6.8], inode_alloc(9) [93.6.7], inode_file_read(9) [93.6.10], inode_file_write(9) [93.6.11].
Il file kernel/ibm_i386.h [94.6] descrive le funzioni e le macroistruzioni per la gestione dell'hardware e delle interruzioni, secondo l'architettura IBM i386.
La sezione 84.3 descrive complessivamente queste funzioni e le tabelle successive sono tratte da lì.
|
Tabella 84.28. Funzioni e macroistruzioni per l'input e l'output con le porte interne x86.
|
|
Tabella 84.29. Funzioni accessorie per il controllo delle interruzioni hardware.
|
|
Tabella 84.32. Funzioni per la gestione della tabella GDT.
|
|
Tabella 84.35. Funzioni per la gestione della tabella IDT.
|
|
Tabella 84.37. Funzioni per la gestione delle interruzioni.
|
Il file kernel/net/icmp.h [94.12.10] descrive le funzioni per la gestione del protocollo ICMP.
Per la descrizione sulla gestione del protocollo ICMP da parte di os32, si rimanda alla sezione 84.11. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
Il file kernel/net/ip.h [94.12.15] descrive le funzioni per la gestione del protocollo IPv4, esclusa però la questione degli instradamenti.
Per la descrizione sulla gestione del protocollo IPv4 eseguita da os32, si rimanda alla sezione 84.10. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.124. Funzioni per la gestione dei pacchetti a livello IP.
|
Il file kernel/driver/kbd.h [94.4.15] descrive le funzioni per la gestione della tastiera, in relazione alla gestione complessiva dei terminali virtuali.
Per la descrizione dell'organizzazione della gestione della tastiera di os32, si rimanda alla sezione 84.7.5.1. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.87. Funzioni per la gestione della tastiera, dichiarate nel file di intestazione
|
Il file kernel/lib_k.h [94.7] 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/lib_s.h [94.8] descrive alcune funzioni con nomi che iniziano per s_... (dove la lettera «s» sta per sistema) e servono a realizzare le chiamate di sistema, all'interno del kernel. Per esempio, la funzione s__exit() realizza la funzione _exit(). Il prototipo delle funzioni s_...() è lo stesso di quelle a cui si riferiscono, con l'aggiunta iniziale del numero del processo da cui ha origine la chiamata di sistema.
sysroutine(9) [93.20.28], brk(2) [87.5], chdir(2) [87.6], chmod(2) [87.7], chown(2) [87.8], clock(2) [87.9], close(2) [87.10], dup2(2) [87.12], dup(2) [87.12], _exit(2) [87.2], fchmod(2) [87.7], fchown(2) [87.8], fcntl(2) [87.18], fork(2) [87.19], fstat(2) [87.55], kill(2) [87.29], link(2) [87.30], longjmp(2) [87.49], lseek(2) [87.33], mkdir(2) [87.34], mknod(2) [87.35], mount(2) [87.36], open(2) [87.37], pipe(2) [87.38], read(2) [87.39], sbrk(2) [87.5], setegid(2) [87.48], seteuid(2) [87.51], setgid(2) [87.48], setjmp(2) [87.49], setuid(2) [87.51], signal(2) [87.52], stat(2) [87.55], stime(2) [87.59], tcgetattr(2) [87.58], tcsetattr(2) [87.58], time(2) [87.59], umount(2) [87.36], unlink(2) [87.62], wait(2) [87.63], write(2) [87.64].
Il file kernel/main.h [94.9] descrive la funzione kmain() del kernel e altre funzioni accessorie, assieme al codice iniziale necessario per mettere in funzione il kernel stesso.
Si rimanda alla sezione 84.2 che descrive dettagliatamente il codice iniziale del kernel.
Il file kernel/memory.h [94.10] 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 84.6. Le tabelle successive che sintetizzano l'uso delle funzioni di questo gruppo, sono tratte da quel capitolo.
|
Tabella 84.77. Funzioni per la gestione della mappa della memoria, dichiarate nel file di intestazione
|
Il file kernel/multiboot.h [94.11] descrive delle funzioni e un tipo derivato per il trattamento delle informazioni multiboot.
Per la descrizione della gestione delle informazioni multiboot da parte di os32, si rimanda alla sezione 84.2.1; la tabella successiva descrive brevemente le due funzioni disponibili per questa gestione.
|
Tabella 84.14. Funzioni per la gestione delle specifiche multiboot all'interno di os32.
|
Il file kernel/driver/nic/ne2k.h [94.4.19] descrive le funzioni per la gestione delle interfacce di rete NE2K.
Per la descrizione della gestione dei dispositivi NE2K si rimanda alla sezione 84.9.1. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, sono tratte da quella sezione.
|
Tabella 84.118. Funzioni per la gestione dell'interfaccia di rete NE2000.
|
Il file kernel/net.h [94.12] descrive le funzioni per la gestione della tabella delle interfacce, assieme ad altre funzioni accessorie relative alla trasmissione di trame Ethernet.
Per la descrizione sulla gestione della tabella delle interfacce, si rimanda alla sezione 84.9.2. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.121. Funzioni per la gestione della tabella delle interfacce, contenute nella directory
|
Il file kernel/part.h [94.13] descrive la struttura part_t e delle macro-variabili per la gestione delle partizioni. Solo la funzione dm_init() si avvale di questo file di intestazione.
Il file kernel/driver/pci.h [94.4.27] descrive le funzioni per la gestione del bus PCI; ma in pratica è disponibile solo pci_init() che ha lo scopo di scandire il bus per trovare i dispositivi presenti e annotarli nella tabella PCI, funzione che viene usata una volta sola, all'avvio del sistema. A tale proposito va osservato che os32 è in grado di leggere solo il bus principale e non può aggiornare la tabella dei dispositivi.
Per una descrizione ulteriore del funzionamento del bus PCI, nell'ottica semplificata di os32, si veda la sezione 83.10.
Il file kernel/proc.h [94.14] 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.
Si veda in particolare la spiegazione contenuta nella sezione 84.4 al riguardo della gestione dei processi.
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) [93.20.3], proc_sig_chld(9) [93.20.11], s_wait(9) [93.12].
kernel/proc.h [94.14]
kernel/proc/proc_public.c [94.14.5]
kernel/proc/proc_available.c [94.14.1]
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) [93.20.3], 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 [94.14]
kernel/proc/proc_sig_core.c [94.14.14]
proc_init - inizializzazione della gestione complessiva dei processi elaborativi
<kernel/proc.h> extern uint32_t _k_start; extern uint32_t _k_end; extern uint32_t _k_text_end; extern uint32_t _k_data_end; extern uint32_t _k_bss_end; extern uint32_t _k_stack_top; extern uint32_t _k_stack_bottom; void proc_init (void); |
|
|
La funzione proc_init() viene usata una volta sola, dalla funzione kmain(9) [93.13], per predisporre la gestione dei processi. Per la precisione si occupa di:
predisporre la tabella GDT, attraverso la chiamata della funzione gdt();
impostare il temporizzatore in modo da fornire impulsi alla frequenza dichiarata nella macro-variabile CLOCKS_PER_SEC, pari a 100 Hz;
predisporre la tabella IDT, attraverso la chiamata della funzione idt();
azzerare la tabella dei processi, inserendovi però i dati relativi al kernel (il processo zero);
allocare la memoria già utilizzata dal kernel;
attivare selettivamente le interruzioni hardware desiderate;
attivare la gestione delle unità PATA;
innestare il file system principale.
kernel/proc.h [94.14]
kernel/proc/proc_public.c [94.14.5]
kernel/proc/proc_init.c [94.14.3]
proc_print - visualizzazione diagnostica dei in corso
<kernel/proc.h> void proc_print (void); |
La funzione proc_print() visualizza sinteticamente i processi in corso, per fini diagnostici. Viene usata nella funzione kmain(), quando il kernel è in modalità di funzionamento interattivo.
kernel/proc.h [94.14]
kernel/proc/proc_print.c [94.14.4]
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 [94.14]
kernel/proc/proc_public.c [94.14.5]
kernel/proc/proc_reference.c [94.14.6]
proc_sch_net - operazioni di routine relative alla gestione della rete
<kernel/proc.h> void proc_sch_net (void); |
La funzione proc_sch_net() ha il compito di scandire le interfacce di rete alla ricerca di operazioni da concludere e di pacchetti da acquisire; inoltre si occupa di aggiornare lo stato della gestione TCP e di risvegliare i processi in attesa di eventi relativi alla rete, se se ne presenta il motivo.
Questa funzione viene usata soltanto da proc_scheduler(9) [93.20.10], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [94.14]
kernel/proc/proc_scheduler.c [94.14.11]
kernel/proc/proc_sch_net.c [94.14.7]
proc_scheduler(9) [93.20.10], proc_sch_signals(9) [93.20.7], proc_sch_terminals(9) [93.20.8], proc_sch_timers(9) [93.20.9].
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.
Questa funzione viene usata soltanto da proc_scheduler(9) [93.20.10], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [94.14]
kernel/proc/proc_scheduler.c [94.14.11]
kernel/proc/proc_sch_signals.c [94.14.8]
proc_sig_term(9) [93.20.20], proc_sig_core(9) [93.20.13], proc_sig_chld(9) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_stop(9) [93.20.19].
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 c'è effettivamente un carattere digitato, dopo aver determinato a quale terminale virtuale si riferisce, lo accumula nella sua riga di inserimento.
Successivamente verifica se quel terminale virtuale è associato a un gruppo di processi; se è così e se il carattere corrisponde a VINTR (di norma si tratta di ciò che viene prodotto dalla combinazione di tasti [Ctrl c]), invia il segnale SIGINT al processo più interno del gruppo, il quale dovrebbe corrispondere presumibilmente a quello in primo piano.
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.
Se il carattere ricevuto è tale da fare intendere la conclusione di un inserimento (per esempio il carattere <NL>, prodotto dalla pressione di [Invio]), la funzione scandisce tutti i processi sospesi in attesa di input dal terminale, risvegliandoli (ogni processo deve poi verificare se effettivamente c'è qualcosa da trarre dal terminale per sé oppure no, e se non c'è dovrebbe rimettersi in attesa).
Questa funzione viene usata soltanto da proc_scheduler(9) [93.20.10], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [94.14]
kernel/proc/proc_scheduler.c [94.14.11]
kernel/proc/proc_sch_terminals.c [94.14.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 os32 è 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) [93.20.10], ogni volta che ci si prepara allo scambio con un altro processo.
kernel/proc.h [94.14]
kernel/proc/proc_scheduler.c [94.14.11]
kernel/proc/proc_sch_timers.c [94.14.10]
proc_scheduler - schedulatore
<kernel/proc.h> extern uint32_t _ksp; extern uint32_t proc_stack_pointer; extern uint16_t proc_stack_segment_selector; extern pid_t proc_current; void proc_scheduler (void); |
|
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 prima cosa che fa la funzione consiste nel verificare che il valore dell'indice della pila del processo interrotto non superi lo spazio disponibile per la pila stessa. Diversamente il processo viene eliminato forzatamente, con una segnalazione adeguata sul terminale attivo. Si ottiene comunque una segnalazione se l'indice si avvicina pericolosamente al limite.
Successivamente la funzione svolge delle operazioni che riguardano tutti i processi: aggiorna i contatori dei processi che attendono lo scadere di un certo tempo; verifica la presenza di segnali e predispone le azioni relative; raccoglie l'input dai terminali. Quindi aggiorna il tempo di utilizzo della CPU del processo appena interrotto.
Poi inizia la ricerca di un altro processo, candidato a essere ripreso al posto di quello interrotto. La ricerca inizia dal processo successivo a quello interrotto, senza considerare alcun criterio di precedenza. Il ciclo termina se la ricerca incontra di nuovo il processo di partenza. All'interno di questo ciclo di ricerca, se si incontra un processo pronto per essere messo in funzione, lo si scambia con quello interrotto: in pratica si salva il valore attuale dell'indice della pila, si scambiano gli stati e si aggiornano i valori di proc_current, proc_stack_segment_selector e proc_stack_pointer, in modo da ottenere effettivamente lo scambio all'uscita dalla funzione. Alla fine del ciclo, occorre verificare se esiste effettivamente un processo successivo attivato, perché in caso contrario, si lascia il controllo direttamente al kernel. In fine, si salva il valore accumulato in precedenza dell'indice della pila del kernel, nella variabile _ksp.
Questa funzione viene usata dalla routine irq_timer del file kernel/ibm_i386/isr.s e dalla funzione sysroutine(9) [93.20.28].
kernel/proc.h [94.14]
kernel/ibm_i386/isr.s [94.6.21]
kernel/proc/sysroutine.c [94.14.28]
kernel/proc/proc_scheduler.c [94.14.11]
proc_sch_timers(9) [93.20.9], proc_sch_signals(9) [93.20.7], proc_sch_terminals(9) [93.20.8].
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) [93.20.7].
kernel/proc.h [94.14]
kernel/proc/proc_sig_chld.c [94.14.12]
proc_sig_status(9) [93.20.18], proc_sig_ignore(9) [93.20.15], proc_sig_off(9) [93.20.17].
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) [93.20.7].
kernel/proc.h [94.14]
kernel/proc/proc_sig_cont.c [94.14.13]
proc_sig_status(9) [93.20.18], proc_sig_ignore(9) [93.20.15], proc_sig_off(9) [93.20.17].
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) [93.20.2].
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 os32 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) [93.20.7].
kernel/proc.h [94.14]
kernel/proc/proc_sig_core.c [94.14.14]
proc_sig_status(9) [93.20.18], proc_sig_ignore(9) [93.20.15], proc_sig_off(9) [93.20.17], proc_dump_memory(9) [93.20.2].
proc_sig_handler - attivazione di una funzione a seguito del recepimento di un segnale
<kernel/proc.h> void proc_sig_handler (pid_t pid, int sig); |
|
La funzione proc_sig_handler() verifica se, per un certo processo pid, il segnale sig risulti associato a una funzione. Se è così, modifica la pila dei dati del processo in modo da far si che alla sua ripresa, venga azionata la funzione programmata, prima di riprendere con l'attività precedente. Contestualmente, il segnale sig viene liberato dall'associazione a una funzione.
Questa funzione viene usata da proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19] e proc_sig_term(9) [93.20.20], per verificare se un segnale sia stato associato a una funzione; prima di decidere di eseguire l'azione predefinita, in mancanza di tale associazione.
kernel/proc.h [94.14]
kernel/proc/proc_sig_handler.c [94.14.15]
proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19]m proc_sig_term(9) [93.20.20].
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) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19] e proc_sig_term(9) [93.20.20], per verificare se un segnale sia stato inibito, prima di applicarne le conseguenze, nel caso fosse stato ricevuto.
|
kernel/proc.h [94.14]
kernel/proc/proc_sig_ignore.c [94.14.16]
proc_sig_chld(9) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19]m proc_sig_term(9) [93.20.20].
Vedere proc_sig_on(9) [93.20.17].
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) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19] e proc_sig_term(9) [93.20.20].
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 s__exit(9) [93.12] e s_kill(9) [93.12].
kernel/proc.h [94.14]
kernel/proc/proc_sig_on.c [94.14.18]
kernel/proc/proc_sig_off.c [94.14.17]
proc_sig_chld(9) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19], proc_sig_term(9) [93.20.20].
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) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19] e proc_sig_term(9) [93.20.20], per verificare se un segnale è stato ricevuto effettivamente, prima di applicarne eventualmente le conseguenze.
|
kernel/proc.h [94.14]
kernel/proc/proc_sig_status.c [94.14.19]
proc_sig_chld(9) [93.20.11], proc_sig_cont(9) [93.20.12], proc_sig_core(9) [93.20.13], proc_sig_stop(9) [93.20.19], proc_sig_term(9) [93.20.20].
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) [93.20.7].
kernel/proc.h [94.14]
kernel/proc/proc_sig_stop.c [94.14.20]
proc_sig_status(9) [93.20.18], proc_sig_ignore(9) [93.20.15], proc_sig_off(9) [93.20.17].
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) [93.20.7].
kernel/proc.h [94.14]
kernel/proc/proc_sig_term.c [94.14.21]
proc_sig_status(9) [93.20.18], proc_sig_ignore(9) [93.20.15], proc_sig_off(9) [93.20.17].
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 (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) [87.14], 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, 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 84.69. 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.
|
Figura 84.70. Completamento della pila con i valori dei registri. |
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) [93.20.28], in occasione del ricevimento di una chiamata di sistema di tipo SYS_EXEC.
lib/unistd/execve.c [95.30.14]
lib/sys/os32/sys.s [95.21.7]
kernel/proc.h [94.14]
kernel/ibm_i386/isr.s [94.6.21]
kernel/proc/sysroutine.c [94.14.28]
kernel/proc/proc_sys_exec.c [94.14.22]
execve(2) [87.14], sys(2) [87.56], sysroutine(9) [93.20.28], proc_scheduler(9) [93.20.10], path_inode(9) [93.6.41], inode_check(9) [93.6.8], inode_put(9) [93.6.20], inode_file_read(9) [93.6.10], dev_io(9) [93.4.1].
proc_timer_init - inizializzazione del generatore di impulsi (temporizzatore)
<kernel/proc.h> void proc_timer_init (clock_t freq); |
|
La funzione proc_timer_init() viene chiamata esclusivamente dalla funzione proc_init(9) [93.20.3], per inizializzare il generatore di impulsi alla frequenza di CLOCKS_PER_SEC Hz, pari a 100 Hz.
kernel/proc.h [94.14]
kernel/proc/proc_timer_init.c [94.14.23]
proc_wakeup_pipe_read, proc_wakeup_pipe_write, proc_wakeup_terminal - risveglio dei processi in attesa di un condotto o di un terminale.
<kernel/proc.h> void proc_wakeup_pipe_read (inode_t *inode); void proc_wakeup_pipe_write (inode_t *inode); void proc_wakeup_terminal (void); |
|
Le funzioni proc_wakeup_...() hanno lo scopo di scandire la tabella dei processi, alla ricerca di quelli da risvegliare, a seguito di un evento che richiede o può richiedere la loro attenzione. Le funzioni proc_wakeup_pipe_...() risvegliano esclusivamente i processi che sono in attesa di accedere a un condotto identificato attraverso un inode, mentre proc_wakeup_terminal() va a risvegliare tutti i processi in attesa del terminale, anche quelli che probabilmente non sono interessati direttamente da un input disponibile da tastiera.
kernel/proc.h [94.14]
kernel/proc/proc_wakeup_pipe_read.c [94.14.24]
kernel/proc/proc_wakeup_pipe_write.c [94.14.25]
kernel/proc/proc_wakeup_terminal.c [94.14.26]
proc_sch_terminals(9) [93.20.8].
Vedere proc_wakeup(9) [93.20.23].
Vedere proc_wakeup(9) [93.20.23].
Vedere proc_wakeup(9) [93.20.23].
ptr - conversione di un puntatore relativo all'area dati di un processo in un puntatore valido per il kernel
<kernel/proc.h> void *ptr (pid_t pid, void *p); |
La funzione ptr() ha il compito di convertire un puntatore proveniente dall'area dati di un processo in un puntatore valido dal punto di vista del kernel. In pratica, il puntatore corrispondente al parametro p va inteso come riferito a un certo processo pid; la funzione restituisce un puntatore equivalente, ma valido per il kernel.
kernel/proc.h [94.14]
kernel/proc/ptr.c [94.14.27]
sysroutine(9) [93.20.28].
s_sysroutine - attuazione delle chiamate di sistema
<kernel/proc.h>
extern pid_t proc_current;
void sysroutine (uint32_t syscallnr, uint32_t msg_off,
uint32_t msg_size);
|
|
La funzione sysroutine() viene chiamata esclusivamente dalla routine isr_128, contenuta nel file kernel/ibm_i386/isr.s [94.6.21], a seguito di una chiamata di sistema.
Inizialmente, la funzione individua l'indirizzo corrispondente alla posizione del messaggio proveniente dal processo, dal punto di vista del kernel; in pratica traduce msg_off in qualcosa di adatto al kernel.
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 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 originale 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 riscritto a partire dall'indirizzo 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) [93.20.10], 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/os32/sys.s [95.21.7]
kernel/proc.h [94.14]
kernel/ibm_i386/isr.s [94.6.21]
kernel/proc/sysroutine.c [94.14.28]
sys(2) [87.56], proc_scheduler(9) [93.20.10], dev_io(9) [93.4.1], lib_s(9) [93.12].
Il file kernel/net/route.h [94.12.33] descrive le funzioni per la gestione degli instradamenti IPv4 secondo os32.
Per la descrizione sulla gestione degli instradamenti IPv4 secondo il sistema os32, si rimanda alla sezione 84.10.3. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.128. Funzioni per la gestione della tabella degli instradamenti.
|
Il file kernel/driver/screen.h [94.4.30] descrive le funzioni per la gestione dello schermo, in relazione alla gestione complessiva dei terminali virtuali.
Per la descrizione dell'organizzazione della gestione dello schermo di os32, si rimanda alla sezione 84.7.5.2. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.89. Funzioni per la gestione dello schermo, dichiarate nel file di intestazione
|
I file kernel/net/tcp.h [94.12.40] e kernel/net/udp.h [94.12.53] descrivono le funzioni per la gestione dei protocolli TCP e UDP, secondo os32.
Per la descrizione sulla gestione dei protocolli TCP e UDP da parte di os32, si rimanda alla sezione 84.12. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.132. Funzioni per la gestione dei protocolli TCP e UDP.
|
Il file kernel/driver/tty.h [94.4.42] descrive le funzioni per la gestione dei terminali virtuali.
Per la descrizione dell'organizzazione della gestione dei terminali virtuali di os32, si rimanda alla sezione 84.7.5. La tabella successiva che sintetizza l'uso delle funzioni di questo gruppo, è tratta da lì.
|
Tabella 84.85. Funzioni per l'accesso al terminale, dichiarate nel file di intestazione
|
«a2» 2013.11.11 --- Copyright © Daniele Giacomini -- appunti2@gmail.com http://informaticalibera.net
