Il sistema operativo LINUX Il file system Indice Blocchi logici Indice

Sistemi operativi – Modulo II
Il File System
Il sistema operativo LINUX
Il file system
Giorgio Di Natale <[email protected]>
Stefano Di Carlo <[email protected]>
Politecnico di Torino
Dip. Automatica e Informatica
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
Blocchi logici
• Il file system è organizzato in blocchi logici
contigui
– dimensione fissa di 1024, 2048 o 4096 byte
– indipendente dalla dimensione del blocco fisico
(generalmente 512 byte)
• Un blocco speciale, detto super block, in
posizione fissa all’inizio del FS ne descrive le
caratteristiche
Super block
• Caratteristiche del FS
– dimensioni, struttura, …
• Parametri modificabili del FS
– max mount count, ...
• Stato del FS
– state, free blocks, mount count, …
• Non contiene informazioni sulla struttura fisica e sul
tipo di device utilizzato (perché ne costituisce una
astrazione)
G. Di Natale, S. Di Carlo
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
struct ext2_super_block {
__u32 s_inodes_count;
__u32 s_blocks_count;
__u32 s_r_blocks_count;
__u32 s_free_blocks_count;
__u32 s_free_inodes_count;
__u32 s_first_data_block;
…
__u32 s_blocks_per_group;
__u32 s_inodes_per_group;
…
__u32 s_mount_count;
__u32 s_max_mount_count;
__u32 s_state;
…
};
•1
Sistemi operativi – Modulo II
Il File System
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
Cylinder group
• Compartimentano il FS
– impediscono che un errore sulle bitmap e/o inode table
corrompa tutto il FS
• Replicano il super block e la group descriptor table
• Consentono di allocare i file nei pressi della directory
che li contiene
• dumpe2fs <device> mostra i gruppi di una
partizione ext2
Cylinder group
struct ext2_group_desc {
__u32 bg_block_bitmap;
__u32 bg_inode_bitmap;
__u32 bg_inode_table;
__u32 bg_free_blocks_count;
__u32 bg_free_inodes_count;
__u32 bg_used_dirs_count;
__u32 bg_pad;
__u32 bg_reserved[3];
};
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
G. Di Natale, S. Di Carlo
Inode
• Ogni file o directory è associato ad un inode
– descrive le caratteristiche del file
– identifica i blocchi di cui è composto il file
• Numerati a partire da 1
• Alcuni sono riservati al sistema
– bad block inode, root inode, boot loader inode
•2
Sistemi operativi – Modulo II
Il File System
Inode
struct ext2_inode {
__u32 i_mode;
__u32 i_uid;
__u32 i_size; /* Size in bytes (major/minor device) */
__u32 i_atime; /* Access time */
__u32 i_ctime; /* Creation time */
__u32 i_mtime; /* modification time */
__u32 i_gid;
__u32 i_links_count;
__u32 i_blocks; /* Blocks count */
__u32 i_flags;
…
__u32 i_block[EXT2_N_BLOCKS];
…
};
0
1
Data
0
1
Data
0
11
13
14
0
11
255
indirect block
double
indirect block
15
triple
indirect block
12
Data
13
0
0
...
...
255
255
Data
15
0
0
0
...
...
255
255
255
triple
indirect block
Data
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
14
indirect block
double
indirect block
Data
...
G. Di Natale, S. Di Carlo
13
Data
Data
...
12
Data
Data
...
256
255
Data
0
0
Data
...
...
65536
255
255
Data
0
0
0
...
...
...
255
255
255
3
256
Data
Directory
• E’ un file che contiene record di tipo directory
entry
• Una directory entry associa un nome file al suo
inode
•3
Sistemi operativi – Modulo II
Il File System
Directory
Directory entry
#define EXT2_NAME_LEN 255
struct ext2_dir_entry {
__u32 inode;
__u32 rec_len; /* Directory entry length */
__u32 name_len;
__u32 name[EXT2_NAME_LEN];
};
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
link
• Hard link (fisico)
– directory entry che punta ad un inode puntato da un
altra directory entry
– no cross-file system
• Soft link (simbolico)
– directory entry che punta ad un inode che punta ad un
blocco contenente il path name del file corrispondente
• Fast soft link
– il path name (<60 byte) è memorizzato nell’inode (nei
15 byte dell’i_block)
Fast Symbolic Link
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
G. Di Natale, S. Di Carlo
•4
Sistemi operativi – Modulo II
Il File System
Virtual File System
• Linux supporta diversi FS:
– ext2, minix, msdos, vfat, iso9660, hpfs, …
• VFS astrae il particolare FS fisico occupandosi di
mappare le system call orientate ai file sulle funzioni
supportate dal FS
• Al mount VFS individua (attraverso una tabella di
configurazione del kernel) la specifica funzione da
utilizzare che:
– legge il super blocco e ne inizializza le variabili
– restituisce a VFS un descrittore di file con cui verranno
mappate le successive system call
Indice
• Struttura
– super block
– cylinder group
– inode
– directory
– link
• VFS: Virtual File System
• System calls
File descriptor
• Individua univocamente un file aperto
• Ciascun processo può utilizzare fino a
OPEN_MAX (<limits.h>) file descriptor
• File descriptor di default:
– 0 standard input
– 1 standard output
– 2 standard error
open( )
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *path, int flags);
int open(const char *path, int flags,
mode_t mode);
int fd;
fd=open(“file.txt”,O_WRONLY|O_CREAT,
S_IRUSR|S_IWRUSR);
open( )
#include <sys/types.h>
#include <sys/stat.h>
Setta i permessi
#include <fcntl.h>
quando si crea un
nuovo file
int open(const char *path, int flags);
int open(const char *path, int flags,
mode_t mode);
int fd;
fd=open(“file.txt”,O_WRONLY|O_CREAT,
S_IRUSR|S_IWUSR);
G. Di Natale, S. Di Carlo
flags
• Di base:
– O_RDONLY
– O_WRONLY
– O_RDWR
• In bitwise-or:
– O_CREATE
– O_EXCL
– O_TRUNC
– O_APPEND
open for read-only access
open for write-only access
open for read/write access
crea il file se non esiste
errore se O_CREAT è settato e il
file esiste
rimuove il ceontenuto del file
appende al file
•5
Sistemi operativi – Modulo II
Il File System
modi
• S_I[RWX]USR
• S_I[RWX]GRP
• S_I[RWX]OTH
rwx --- ----- rwx ----- --- rwx
open( ): mode
• I permessi con cui viene effetivamente creato
un file sono modificati dall’umask dell’utente
proprietario del processo
– mode & (~umask)
access( )
access( )
#include <unistd.h>
int access(char *pathname, int mode);
if ( access(“f1.txt”, F_OK) ) {
/* file exists */
}
• Return value:
– 0 KO
– 1 OK
• Mode:
– R_OK read access
– W_OK write access
– X_OK execute access
– F_OK file exists
read( )
#include <sys/types.h>
#include <unistd.h>
int read(int fd, void *buf, size_t nbytes);
Return values:
-1
error
0
EOF
n
numero di byte letti
G. Di Natale, S. Di Carlo
write( )
#include <sys/types.h>
#include <unistd.h>
int write(int fd, void *buf, size_t nbytes);
write scrive sui buffer di sistema, non sul disco!
fd = open (file, O_WRONLY | O_SYNC);
O_SYNC forza la sync dei buffer, ma solo su FS ext2
•6
Sistemi operativi – Modulo II
Il File System
close( )
lseek( )
#include <sys/types.h>
#include <unistd.h>
int lseek(int fd, off_t offset, int base);
#include <unistd.h>
int close(int fd);
• Base:
– SEEK_SET
dall’inizio del file
– SEEK_CURR dalla posizione corrente
– SEEK_END
dalla fine del file
• Esempio:
– lseek(fd, (off_t) 0, SEEK_SET);
Return values:
-1
error
0
OK
stat( )
#include <sys/stat.h>
#include <unistd.h>
int fstat(inf fd, struct stat *sbuf);
int stat(char *path, struct stat *sbuf);
int lstat(char *path, struct stat *sbuf);
• Restituisce in sbuf l’inode del file
• Se il file è un link simbolico, lstat restituisce l’inode che
punta al nome file, anziché l’inode che punta al file
struct stat
dev_t
ino_t
umode_t
nlink_t
uid_t
gid_t
dev_t
off_t
time_t
time_t
time_t
st_dev;
st_ino;
st_mode;
st_nlink;
st_uid;
st_gid;
st_rdev;
st_size;
st_atime;
st_mtime;
st_ctime;
/* device number for file */
/* device number for device */
chmod( )
#include <sys/types.h>
#include <unistd.h>
int chmod(char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
G. Di Natale, S. Di Carlo
umask( )
#include <unistd.h>
mode_t umask(mode_t mask);
oldmask = umask(0);
umask(oldmask);
•7
Sistemi operativi – Modulo II
Il File System
chown( )
#include <sys/types.h>
#include <unistd.h>
int chown(char *path, uid_t owner,
gid_t group);
int fchown(int fd, uid_t owner,
gid_t group);
mkdir( ) e rmdir( )
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
int mkdir(char *pathname, mode_t mode);
int rmdir(char *pathname);
opendir( ), readdir( ) e closedir( )
#include <dirent.h>
DIR *opendir(char *pathname);
struct dirent *readdir(DIR *dirptr);
int closedir(DIR *dirptr);
opendir( ), readdir( ) e closedir( )
#include <dirent.h>
#include <stdio.h>
main {
DIR *dp;
struct dirent *link;
dp = opendir (“/home”);
while ((link=readdir(DP))!=0)
printf (“%s\n”, link->d_name);
closedir (dp);
}
link( ) e unlink( )
#include <unistd.h>
int link(char *src_path, char* newLink_path);
int unlink(char *pathname);
unlink rimuove l’inode se link count va a zero
G. Di Natale, S. Di Carlo
•8