Unix file systems system calls

Definición

Las system calls de archivos pueden dividirse en dos clases:

Las que operan sobre los archivos
Las que operan sobre los metadatos de los archivos

`Open()`

Definición

La System call open() convierte el nombre de un Archivo en una entrada de la tabla de descriptores de archivos, y devuelve dicho valor. Siempre devuelve el descriptor más pequeño que no está abierto.

Las flags, estos flags pueden combinarse:

O_RDONLY: modo solo lectura.

O_WRONLY: modo solo escritura.

O_RDWR: modo lectura y escritura.

O_APPEND: el archivo se abre en modo lectura y el offset se setear al final, de forma tal que este pueda agregar al final.

O_CREATE: si el archivo no existe se crea con los permisos seteados en el parámetro mode:

S_IRWXU 00700 user (file owner) el usuario tiene permisos par leer, escribir y ejecutar

S_IRUSR 00400 el usuario tiene permisos para leer.

S_IWUSR 00200 el usuario tiene permisos para escribir.

S_IXUSR 00100 el usuario tiene permisos para ejecutar.

S_IRWXG 00070 el grupo tiene permisos para leer, escribir y ejecutar

S_IRGRP 00040 el grupo tiene permisos para leer.

S_IWGRP 00020 el grupo tiene permisos para escribir

S_IXGRP 00010 el grupo tiene permisos para ejecutar.

S_IRWXO 00007 otros tienen permisos para leer, escribir y ejecutar

S_IROTH 00004 otros tienen permisos para leer

S_IWOTH 00002 otros tienen permisos para escribir.

S_IXOTH 00001 otros tienen permisos para ejecutar
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
Link to original

`Creat()`

Definición

La System call creat() equivale a llamar a open() con los flags O_CREAT | O_WRONGLY | O_TRUNC
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int creat(const char *pathname, mode_t mode);
Link to original

`Close()`

Definición

La System call close() cierra un file descriptor. Si este ya está cerrado devuelve un error.
#include <unistd.h>
 
int close(int fd);
Devuelve si salió bien, y si hubo un error.
Link to original

`Read()`

Definición

La System call read() se utiliza para hacer intentos de lecturas hasta un número dado de bytes de un archivo. La lectura comienza en la posición señalada por el file descriptor, y tras ella se incrementa ésta en el número de bytes leídos.
#include <unistd.h>
 
ssize_t read(int fd, void *buf, size_t count);
Devuelve el número de bytes leídos si salió bien, si encuentra el End Of File (EOF) y si hubo un error.
Link to original

`Write()`

Definición

La System call write() escribe hasta una determinada cantidad de bytes desde un buffer que comienza en buf al archivo referenciado por el file descriptor.
#inlude <unistd.h>
 
ssized_t write(int fd, const void *buf, size_t count);
Link to original

`Lseek()`

Definición

La System call lseek() reposiciona el desplazamiento (offset) de un Archivo abierto con el file descriptor fd de acuerdo con el parámetro whence:

SEEK_SET: el desplazamiento

SEEK_CUR: el desplazamiento es sumado a la posición actual del archivo

SEEK_END: el desplazamiento se suma a partir del final del archivo
#include <sys/types.h>
#include <unistd.h>
 
off_t lseek(int fd, off_t offset, int whence);
Link to original

`Dup()`

Definición

La System call dup() crea una copia del file descriptor del Archivo cuyo nombre es oldfld
#include <unistd.h>
 
int dup(int oldfd);
int dup2(int oldfd, int newfd);
Después de que retorna en forma exitosa, el viejo y nuevo file descriptor pueden ser usados de forma intercambiable. Estos se refieren al mismo archivo abierto y por ende comparten el offset y los flags de estado.

dup2() hace lo mismo pero en vez de usar la política de seleccionar el file descriptor más pequeño utiliza e newfd como nuevo file descriptor.
Link to original

`Link()`

Definición

La System call link() crea un nuevo nombre para un Archivo. Esto también se conoce como un link (hard link)
#include <unistd.h>
 
int link(const char *oldpath, const char *newpath);
Link to original

`Unlink()`

Definición

La System call unlink() elimina un nombre de un Archivo del sistema de archivos. Si además ese nombre era el último nombre o link del archivo y no hay nadie que tenga el archivo abierto, lo borra completamente del sistema de archivos.
#include <unistd.h>
 
int unlink(const char *pathname);
Link to original

`Mkdir()`

Definición

La System call mkdir()

#include <sys/stat.h>
#include <sys/types.h>
 
int mkdir(const char *pathname, mode_t mode);

Link to original

`Rmdir()`

Definición

La System call rmdir()
#include <unistd.h>
 
int rmdir(const char *pathname);
Link to original

`Chdir()`

Definición

La System call chdir()
#include <unistd.h>
 
int chdir(const char *path);
int fchdir(int fd);
Link to original

`Opendir()`

Definición

La System call opendir() abre y devuelve un stream que corresponde al Directorio que se está leyendo en dirname. El stream es de tipo Dir *.
#include <sys/types.h>
#include <dirent.h>
 
DIR *opendir(const char *dirname);
Link to original

`Closedir()`

Definición

La System call closedir() cierra el stream de tipo DIR * cuyo nombre es dirstream
#include <sys/types.h>
#include <dirent.h>
 
int closedir(DIR *dirstream);
Link to original

`Stat()`

Definición

La System call stat() devuelve información sobre un Archivo, en el buffer apuntado por statbuf. No se requiere ningún permiso sobre el archivo en cuestión, pero si en los directorios que conforma el path hasta llegar el archivo

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
int stat(const char *pathname, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);

Donde la estructura apuntada por statbuf se describe de la siguiente manera:

struct stat { 
	dev_t st_dev; /* ID of device containing file */ 
	ino_t st_ino; /* Inode number */ 
	mode_t st_mode; /* File type and mode */ 
	nlink_t st_nlink; /* Number of hard links */ 
	uid_t st_uid; /* User ID of owner */ 
	gid_t st_gid; /* Group ID of owner */ 
	dev_t st_rdev; /* Device ID (if special file) */ 
	off_t st_size; /* Total size, in bytes */ 
	blksize_t st_blksize; /* Block size for filesystem I/O */ 
	blkcnt_t st_blocks; /* Number of 512B blocks allocated */ 
	
	/*  Since Linux 2.6, the kernel supports nanosecond 
		precision for the following timestamp fields. 
		For the details before Linux 2.6, see NOTES. */ 
	
	struct timespec st_atim; /* Time of last access */ 
	struct timespec st_mtim; /* Time of last modification */ 
	struct timespec st_ctim; /* Time of last status change */ 
	
	#define st_atime st_atim.tv_sec /* Backward compatibility */ 
	#define st_mtime st_mtim.tv_sec 
	#define st_ctime st_ctim.tv_sec 
};

Link to original

`Access()`

Definición

La System call access() chequea si un proceso tiene o no los permisos para utilizar el Archivo con un determinado pathname. El argumento mode determina el tipo de permiso a ser chequeado.
#include <unistd.h>
 
int access(const char *pathname, int mode);
El mode especificado el tipo de accesibilidad a ser chequeada, los valores pueden conjugarse como una mascara de bits con el operador |:

F_OK: el archivo existe

R_OK: el archivo puede ser leído

W_OK: el archivo puede ser escrito

X_OK: el archivo puede ser ejecutado

Link to original

`Chmod()`

Definición

La System call chmod() cambia los bits de modos de acceso
#include <sys/stat.h>
 
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
S_IRUSR (00400) read by owner

S_IWUSR (00200) write by owner

S_IXUSR (00100) execute/search by owner (“search” applies for directories, and means that entries within the directory can be accessed)

S_IRGRP (00040) read by group

S_IWGRP (00020) write by group

S_IXGRP (00010) execute/search by group

S_IROTH (00004) read by others

S_IWOTH (00002) write by others

S_IXOTH (00001) execute/search by others

La única diferencia entre ambas system calls es la forma en que se accede al Archivo en cuestión
Link to original

`Chown()`

Definición

La System call chown() cambia el id del propietario del Archivo y el grupo de un archivo
#include <unistd.h>
 
int chown(const char *pathname, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
Link to original

`Umask()`

Definición

La System call umask() setea la máscara con el modo de permisos para la creación de archivos. La máscara por defecto es la
#include <sys/types.h>
#include <sys/stat.h>
 
mode_t umask(mode_t mask);
Link to original

Apuntes de la facultad

Explorer

Unix file systems system calls

Definición

Open()

Definición

Creat()

Definición

Close()

Definición

Read()

Definición

Write()

Definición

Lseek()

Definición

Dup()

Definición

Link()

Definición

Unlink()

Definición

Mkdir()

Definición

Rmdir()

Definición

Chdir()

Definición

Opendir()

Definición

Closedir()

Definición

Stat()

Definición

Access()

Definición

Chmod()

Definición

Chown()

Definición

Umask()

Definición

Table of Contents

Backlinks

`Open()`

`Creat()`

`Close()`

`Read()`

`Write()`

`Lseek()`

`Dup()`

`Link()`

`Unlink()`

`Mkdir()`

`Rmdir()`

`Chdir()`

`Opendir()`

`Closedir()`

`Stat()`

`Access()`

`Chmod()`

`Chown()`

`Umask()`