ENTORNO DE PROGRAMACIÓN EN GNU/LINUX
Existen gran número de lenguajes de programación que se pueden utilizar:
El más habitual es el C/C++ pues la mayor parte el propio S.O. está escrita en este lenguaje sólo una pequeña parte del núcleo está en ensamblador (la parte dependiente del procesador y parte de los controladores de dispositivos )
Herramientas
• gcc : es el compilador de C desarrollado por GNU (cc), g++ en C++ Incluye
Preprocesador cpp genera .i Compilador cc1 genera .s Ensamblador as genera .o
Enlazador ld genera ejecutables
Cada uno puede ir por separador todos invocador por gcc
Fichero ejecutable por omisión es a.out, para ejecutar un archivo debe estar en el PATH su camino o indicarselo ./a.out
• Uso de librerías ( Conjunto de funciones y Estructuras de datos ) Ficheros .a librerías conjunto de archivos .o (ar)
Existen multitud de librerías para utilizar a parte de las estándares
ncurses, X windows, OpenGL, conectarse con BD, Podemos crear nuestras propias librerías - Librerías estáticas : El código se incluye en el ejecutable
- Librerías dinámicas (share) : No se integra, se copia a memoria cuando se utilice, sólo se carga una vez aunque la usen varios procesos. Ejecutables + pequeños, puede cambiar la librería sin tener que recompilar los ejecutables.
• make
Un proyecto escrito de programación puede estar formado por decenas de archivos C y librerías, no siempre la modificación de un archivo implica recompilar todo el proyecto, depende de la dependencias, los otros ficheros que usan o llaman ese módulo, el comando make, permite realizar las operaciones que sean necesarias compilar, borrar , enlazar según las dependencias que hayamos indicado en un fichero ( Makefile ), funciona en base a las fechas de actualización de cada archivo
Esquema básico
Objetivo : dependencias Acciones
• gdb , Depurador de GNU, buscar y detectar el errores (opción –g)
Seguimiento, paso a paso, punto de parada, preguntar por el valor de variables, remota, postmortem (core), en tiempo real (captura un proceso), modificar el valor de variables
Existen entornos visuales donde se integran todas las herramientas, por menús.
LLAMADAS AL SISTEMA
Arquitectura del Sistema Operativo• Núcleo del sistema operativo: kernel
• Programas de Sistema ( shell, cc, X, mkfs, init, getty, telnet ) • Programas de Aplicación (Oracle, xclock, netscape, openoffice)
Concepto
Son las puertas de acceso a los servicios que ofrece el sistema operativo. Son una especie de llamada a un procedimiento, que se realiza mediante una interrupción software que cambia el entorno ejecución del proceso de modo de Usuario a modo Sistema (kernel) lo que permite el acceso libre a todos los recursos del ordenador. El proceso sólo podrá ejecutar el código de la llamada al sistema. Un proceso en modo usuario no se puede salir de madre, ni realizar libremente operaciones no permitidas, lo que no pasa en MS-DOS o en las primeras versiones de Windows. La existencia de un modo protegido o sistema permite una mayor protección ante fallos de las aplicaciones de usuarios y programas malintencionados (Ej.- virus)
En el núcleo están codificadas las llamadas, es el corazón del S.O. el resto es accesorio: vi, sh, rc, son comando y programas que podríamos codificar a nuestro interés.
Si se cambia el kernel internamente pero se mantienen las llamadas al sistema los programas siguen funcionando sin necesidad de recompilarlos. Si el programa se porta entre procesadores distintos pero con kernel compatibles sólo hay que recompilar para que el programa pueda funcionar. El núcleo de Linux es libre, por lo podemos acceder al código fuente y modificarlo libremente.
La mayoría de las Llamadas al sistema son compatibles con cualquier versión de Unix: Unix Sys V, HP-UX, Solaris, SunOS, Linux, etc y algunas con otros sistemas operativos Ej.- Msdos o Windows aunque en menor grado.
Casi todas las llamadas al sistema cumplen el siguiente esquema:
int Nombrellamada ( Parámetros )
Devuelve –1 si no se ha podido realizar.
Ejemplo: int access(const char *pathname, int mode);
(Consultar man 2 access, En el capítulo (2) del man se encuentran todas las llamadas al sistema.)
Variables globales relacionadas
extern int errno Código de error del la última llamada (0 a sys_nerr ) extern int sys_nerr Número de máximo de códigos de error
extern char *sys_errlist[] Lista de textos asociados a un código de error la función
SISTEMAS DE FICHEROS EN SISTEMA UNIX
ARQUITECTURA DEL SISTEMA DE FICHEROS
Características• Estructura jerárquica. Un árbol de directorios que comienza en el directorio raíz :/ • Todos los ficheros pertenecen a un usuario y grupo y tiene unos permisos asignados
rwx
• La mayor parte de los dispositivos ( discos, puertos serie, paralelo, terminales, memoria ) se van a tratar como ficheros especiales.
• La unidades de almacenamiento son transparentes al usuario, estando montadas sobre el árbol general de archivos
ESTRUCTURA
El S.O. Linux puede manejar distintos sistemas de ficheros (tipos de particiones): MS-DOS, Window 95/98 (vfat), Window NT (NTFS), iso9660, OS/2
los sistemas de ficheros más habituarles en GNU/Linux son: ext2, ext3, ReiserFS : Denominación de las unidades de disco en un PC:
Discos IDE 2 Primarios y 2 Esclavos /dev/hda - /dev/hdb Discos SCSI /USB /dev/sda (+10 Unidades de disco o ) Floppy /dev/fd0
CDROM /dev/cdrom
Cada una de las particiones Linux que existen en un sistema tiene una estructura de control: /dev/hda3 ( 3º Partición de la primera unidad IDE )
# fdisk /dev/hda
Disco /dev/hda: 255 cabezas, 63 sectores, 526 cilindros Unidades = cilindros de 16065 * 512 bytes
Disposit. Inicio Principio Fin Bloques Id Sistema /dev/hda1 * 1 324 2602498+ 83 Linux /dev/hda2 325 420 771120 5 Extendida /dev/hda5 325 358 273073+ 82 Linux swap /dev/hda6 359 420 497983+ 83 Linux #df -h
S.ficheros Tamaño Usado Disp Uso% Montado en /dev/hda1 2.5G 1.4G 1020M 58% /
/dev/hda6 471M 269M 203M 57% /home
Cada partición es en un sistema de ficheros. Tener varias particiones y discos permite una mayor seguridad y tolerancia a fallos. Una de ellas debe ser la partición de arranque. Siempre suele existir una partición de swapping (Zona de intercambio de memoria, de paginación, memoria virtual ), que no es propiamente un sistema de ficheros.
Importancia del tamaño de bloque
Un sistema de ficheros se compone de una secuencias de bloques de datos de un mismo tipo Ej - 1024 bytes, 2K, 8K. El tamaño de bloque o cluster determina el espacio mínimo asignado a un fichero. Un fichero aunque su tamaño sea de un byte, ocupa como mínimo un bloque.
Hay que considerar:
- Problema entre la rapidez y el aprovechamiento del espacio
- Por eficiencia los ficheros no siempre se guardan en bloques consecutivos, para evitar dejar huecos no utilizados -> Se produce la fragmentación de los ficheros - La mayor parte de los ficheros son pequeños
¿Que debe controlar el sistema de ficheros de una unidad de almacenamiento?
Hay que tener control de los bloques libres y ocupados por cada fichero, mantener la información sobre los directorios, manejar los buffers en las operaciones de entrada y salida, controlar que ficheros están abierto, por que procesos, almacenar los premisos, permitir enlaces, controlar el acceso compartido a un mismo fichero....
Estructura básica de un sistema de ficheros GNU/Linux
Boot Superbloque Lista de i-nodos Bloques de datos ...
Boot
Programa de arranque del sistema, se encarga de cargar el inicio del sistema operativo
Superbloque
Contiene la información básica de control del sistema de ficheros: • Tamaño del S.F.
• Tamaño del bloque (1024 bytes, 1K hasta 8K) • Número máximo de fichero (i-nodos)
• Lista de bloques libres, índice al primer bloque libre • Lista de i-nodos libres, índice al primer i-nodo libre
• Información adicional : Si ha sido modificado, nº de montajes, primer i-nodo (/), si el sistema está actualizado, si hay que chequearlo,etc.
Lista I-nodos
Esta lista se carga en memoria en una tabla interna del S.O. para mayor rapidez. Cada fichero tiene asociado un número de I-nodo (que es único). Los archivos se identifican internamente por el número de I-nodo, no por el nombre o enlace, pues un fichero en GNU/Linux puede tener varios nombres.
Información que contiene un i-nodo:
• Número de i-nodo ( único para cada archivo ) • Propietarios: identificador de usuario y grupo • Tipo de fichero ( Ordinario, directorio, dispositivo ) • Permisos (RWX) para dueño, grupo y otros
• Tiempo de acceso, creación, modificación • Número de enlaces ( Distintos nombres ) • Tamaño de fichero
• Estado del i-nodo ( bloqueado, hay copia del datos en buffer ) • Punteros a los bloques de datos
• Tabla de direcciones de bloques en disco:
(Ejemplo si suponemos que el tamaño de bloque es un 1K cual seria el tamaño máximo de fichero que podemos manejar )
10 Direcciones a bloques directas, 10 * 1K 10 K 1 Una indirección simple 256 * 1K= 256 K
1 Una indirección doble 256 * 256 * 1K = 65.536 K = 64 Mb 1 Una indirección triple 256 * 256 * 256 = 16.777.216 K = 16 Gb
El sistema de ficheros FAT
Es tipo de partición implementado en MS-DOS y Windows 98. Su estructura es muy sencilla pues no permite el control de usuarios en el acceso a los ficheros. En sistemas servidores ( NT o W2K) lo habitual es utilizar particiones NTFS.
Boot Tabla de asignación de ficheros Directorio Raíz Bloques de datos
En las particiones FAT no existe el concepto de i_nodo, la información de los archivos se almacena en los directorios. La asignación de espacios se realiza mediante una lista encadena de los bloques que ocupa el archivo en la tabla de asignación de ficheros. El directorio raíz es un directorio especial que se tiene un tamaño fijo.
Información de un directorio en una partición FAT
- Nombre del archivo - Extensión
- Atributos (Sólo lectura, oculto, sistema, normal) - Tamaño
- Hora y fecha de creación / modificación / acceso
- Puntero al primer bloque ocupado por el fichero en la Tabla de asignación. La asignación de bloques se mantiene en la tabla de asignación de ficheros mediante una lista encadenada
TIPOS DE FICHEROS EN UNIX:
Ordinarios, directorios, dispositivos, fifos y sockets Ordinarios
Lista consecutivas de byte ( Visión del S.O. ) Operaciones básicas:
abrir, cerrar, leer, escribir, añadir (escribir al final), posicionarnos, truncarlo a 0 o a un tamaño determinado.
No se puede insertar o eliminar bytes directamente.
Directorios
Un archivo especial ( no podemos leer o escribir directamente ) Información [ Nombre de fichero, i-nodo ]
Mínimo dos entradas para .. y . ( El directorio padre y el propio directorio) Cuando un mismo i_nodo tiene varios nombres, decimos que tiene varios enlaces. Un fichero no se borra hasta que no se eliminan todos sus enlaces, se borran todos sus nombre.
Estructura
Nº inodo Longitud del Nombre
Nombre del archivo
2334 10 Programa.c
3784 4 saco
Tamaño mínimo de un directorio : un bloque Operaciones
• Leer ( Leer el directorio)
• Escribir ( borrar, crear archivos )
• Ejecutar ( Explorar el directorio, buscar un nombre )
Tipos de enlaces:
- Un enlace duro es dar un nuevo nombre de fichero para un mismo I-nodo $ln pepe jose.
Sólo se pueden establecer si ambos nombre pertenecen al mismo sistema de ficheros. Sólo el superusuario puede hacer enlaces entre directorios, para evitar en el recorrido del árbol de directorios.
-Un enlace simbólico o blando es un fichero con el camino a otro fichero ( semejante a los enlaces directo a archivos de Windows)
$ln –s pepe jose
Se pueden crear enlaces simbólicos entre ficheros de distintas particiones (sistema de ficheros) y entre directorio.
Dispositivos
En este caso el i-nodo no guarda información sobre almacenamiento sino sobre las características del dispositivo ( major number y menor number ) Tipo de dispositivo y número de unidad del dispositivo. En muchos caso vamos a poder realizar operaciones de lectura/ escritura como si fuesen archivos convencionales. Normalmente los dispositivos se almacenan en le diretorio /dev.
Dos tipos básicos:
-Dispositivos de bloques (E/S direccionable) Ej.- disco duro, memoria ( /dev/hda) -Dispositivos de caracteres (E/S secuencial), un puerto serie, un módem (/dev/tty,
/dev/lp)
Un mismo dispositivo físico puede tener varios dispositivos lógicos asociados según el tipo de operaciones que vayamos a realizar.
Fifos y Sockets
Son Ficheros especiales utilizados para la comunicación entre procesos que no ocupan espacio en disco. Los Fifos (pipe) se utilizan para comunicar procesos dentro de una misma máquina y los sockets para comunicar proceso dentro de una misma máquina o entre máquinas distintas.
TABLAS DE CONTROL DE FICHEROS
Para gestionar los sistemas de ficheros el kernel mantiene una serie de tablas de control en memoria principal:
- Tabla de i-nodos (UNA)
Copia de la lista de i-nodos almacenada en la partición en memoria principal -Tabla de ficheros abiertos (UNA)
Tabla con la información de los ficheros abiertos en el sistema
i-nodo, proceso que lo ha abierto, permisos de ese proceso, tipo de apertura, posición en el fichero, buffer de E/S
- Tabla de descriptores de ficheros (MÚLTIPLES, una por cada proceso activo) Es una tabla de interna de cada proceso activo en el sistema
Cada fichero que abre tiene un descriptor asociado de 0 – N, siendo N el máximo de ficheros abiertos por un proceso.
Normalmente el sistema cuando arranca un proceso le abre los tres primeros descriptores:
Nº Descriptor Fichero
0 Entrada estándar stdin
1 Salida estándar stdout
2 Salida estándar de errores stderr
3 -- Generalmente es el primer descriptor libre que se asignará al ejecutar el primer open
Se permite que varios procesos puedan abrir el mismo fichero o que un mismo fichero lo pueda abrir varias veces un mismo proceso. En este caso tendrá distinto número de descriptor. Cuando se abre un fichero siempre se asigna el número de descriptor más bajo disponible.
Manejo de ficheros ordinarios
Llamadas al Sistema: Operaciones básicas
Trabaja con descriptores (números enteros)
int fd;
-Open : int open ( char *nombre fichero, int flag, [ mode_t modo ] ) flag :
O_RDONLY O_WRONLY O_RDWR
O_NDELAY ( No esperar en FIFOs o Línea de comunicaciones ) O_APPEND
O_CREAT O_EXCL O_TRUNC
El parámetro mode ( Sólo se utiliza cuando está el flag O_CREAT ) Permisos del nuevo fichero Ej- 0666
Devuelve un número descriptor de fichero o -1
-Creat: int creat ( char * nombre, [ mode_t modo ] ) Crea y abre el fichero de escritura
-Read: int read ( int fd, char * buffer, unsigned int nbytes ) Devuelve el número de octetos leídos o -1
-Write: int write ( int fd, char *buffer, unsigned int nbytes ) Devuelve el número de octetos leídos o -1
-Close : int close ( int fd )
-Lseek : off_t lseek ( ing fd, off_t desplazamiento, int origen ) origen :
SEEK_SET ( Inicio del fichero ) SEEK_CUR ( Posición actual ) SEEK_END (Final de fichero ) off_t ( long int )
Devuelve la nueva posición desde el principio de fichero o -1
-Dup : int dup (int fd )
Asigna un segundo descriptor al un fichero que ya estaba abierto con el descritor fp. Es como si lo abriese dos veces.
Librerías estándar <stdio.h>
La librería de entrada y salida estándar está implementada a partir de las llamadas al sistema. Utilizan una estructura de control propia (FILE *) para manejar los ficheros y gestionar su propio buffer de E/S.
FILE * fp
Funciones:
fopen, fread, fwrite, fclose, fseek, rewind, fclose, foef
-Lectura y escritura en ficheros de texto
fgets, fgetchar, fputs, fputchar, fprintf, fscanf
-Lectura y escritura en ficheros binarios planos, con estructura
size_t fread ( & Registro, sizeof(Registro ),size_t numreg,FILE *stream ) size_t fwrite( & Registro, sizeof(Registro ),size_t numreg,FILE *stream )
Lista las principales funciones de la librería stdio.h:
fcloseall fwrite
fdopen getc
feof getchar
ferror gets
fflush sprintf – Escribe a una cadena
fgetc sscanf - Lee de una cadena
fgetchar perror fgetpos fgets printf fileno putc flushall putchar fopen puts fprintf ungetc fputc remove unlink
fputchar rename fputs rewind fread freopen scanf fscanf fseek fsetpos
Llamadas al sistema: Operaciones de control
chmod : Cambia los permisos de un fichero:
int chmod(const char *path, mode_t mode); int fchmod(int fildes, mode_t mode);
umask : Define la mascara de permisos de creación de ficheros
mode_t umask(mode_t mask);
access: Comprueba si se puede acceder a un fichero
int access(const char *pathname, int mode);
mode =
R_OK, W_OK, X_OK y F_OK.
R_OK, W_OK y X_OK se utilizan para la comprobación de tura, escritura o ejecución del fichero, respectivamente. F_OK se utiliza para ver si se permite la mera compro- bación de la existencia del fichero.
chown : Cambia el propietario de un fichero
int chown(const char *path, uid_t owner, gid_t group); int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);
Cambia el propietario del fichero especificado por path o fd. Solamente el superusuario puede cambiar el propi- etario de un fichero. El propietario de un fichero puede cambiar el grupo de dicho fichero a cualquier grupo al que dicho usuario pertenezca. El superusuario puede cambiar el grupo arbitrariamente.
truncate : Trunca a un número de bytes el fichero indicado
int truncate(const char *path, off_t length); int ftruncate(int fd, off_t length);
truncate hace que el fichero nombrado por path o referido por fd sea truncado a una longitud máxima de length bytes. Si el fichero era mayor que dicha longitud, los datos extra se perderán. Con ftruncate, el fichero debe estar abierto para escritura.
stat : Información detallada sobre un fichero
int stat(const char *file_name, struct stat *buf); int fstat(int filedes, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);
ficado. No se necesitan derechos de acceso al fichero para conseguir la información pero sí se necesitan derechos de búsqueda para todos los directorios del camino al fichero.
struct stat {
dev_t st_dev; /* dispositivo */ ino_t st_ino; /* inodo */
mode_t st_mode; /* protección */
nlink_t st_nlink; /* número de enlaces físicos */ uid_t st_uid; /* ID del usuario propietario */ gid_t st_gid; /* ID del grupo propietario */ dev_t st_rdev; /* tipo dispositivo (si es dispositivo inodo) */ off_t st_size; /* tamaño total, en bytes */ unsigned long st_blksize; /* tamaño de bloque para el sistema de ficheros de E/S */ unsigned long st_blocks; /* número de bloques asignados */ time_t st_atime; /* hora último acceso */
time_t st_mtime; /* hora última modificación */ time_t st_ctime; /* hora último cambio */ };
utime : Cambia las fechas de acceso y modificación de un fichero.
int utime(const char *nombrefichero, struct utimbuf *buf);
utime cambia los tiempos de acceso y modificación del nodo-í especificado por nombrefichero a los campos actime y modtime de buf respectivamente. Si buf es NULL, entonces los tiempos de acceso y modificación del fichero se ponen al tiempo actual. La estructura utimbuf es:
struct utimbuf {
time_t actime; /* tiempo de acceso */
time_t modtime; /* tiempo de modificación */ };
El tiempo se almacena en forma de segundos transcurridos desde el 1 de Enero de 1970.
fcntl : Realiza operaciones de control sobre el fichero
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock * lock);
fcntl realiza una de las diversas y variadas operaciones sobre fd. La operación en cuestión se determina mediante cmd:
Cambiar/ Consultar los modos de apertura
Control de archivos entre procesos
CONTROL DE ACCESO MÚLTIPLE SOBRE FICHEROS
Cuando varios procesos acceden simultáneamente a un fichero pueden ocurrir condiciones de carrera que produzcan datos inconsistentes y errores de funcionamiento en las aplicaciones. El control de acceso a los recursos compartidos es una de las funciones básicas realizadas por el S.O. para lo que ofrece una serie de mecanismos para regularlo.
Ej.- El acceso no controlado a un fichero de reservas aéreas donde acceden procesos de distintas agencias de viajes podría reservar plazas donde no existen.
En las aplicaciones comerciales la gestión de los bloqueos se realiza automáticamente por los SGBD (Sistemas de gestión de bases de datos)
Procedimiento general de acceso al un fichero compartido
... FijarBloqueo() Procesar el fichero() QuitarBloqueo() .... Problemas a evitar:
Interbloqueo : Que dos o más proceso se queden en una espera
infinita por espera de recurso cruzada. Solución: los recursos siempre se deben solicitar el mismo orden.
Inanición : Evitar que un proceso se quede esperando de forma
infinita por el acceso a un recurso. Solución: quitar siempre el bloqueo y establecerlo durante el mínimo tiempo posible.
TIPOS DE BLOQUEOS O CANDADOS
Según el control del recurso
- Consultivo : Procesos cooperativos, se debe consultar el estado de recurso antes de usarlo, depende del programador, si no se pregunta por el candado podemos acceder libremente al recurso.
- Obligado : Procesos no cooperativos, el sistema operativo
controla en todo momento el acceso al recurso, impidiendo el acceso si está bloqueado aunque no se haya consultado el candado.
Según la espera por el recurso:
- Activa, El proceso está en un ciclo permanente a la espera de que el recurso esté libre.
- Pasiva, el proceso no consume CPU, está dormido, el sistema operativo se encargará de activar el proceso cuando el recurso sea liberado.
Según la granularidad o tamaño del bloqueo:
- Bloqueo total a nivel de fichero, se impide el acceso a todo el fichero
- Bloqueo parcial a nivel de zona del fichero, se impide el acceso a una parte del fichero, normalmente a un registro determinado.
Según la operación a realizar:
- Bloqueo de Lectura (compartidos), normalmente no hay problemas si varios procesos lee simultáneamente el mismo archivo.
- Bloqueo de Escritura (Exclusivos), si un proceso está escribiendo de un archivo, normalmente hay que controlar que otro proceso lea o escriba del mismo antes que el archivo esté totalmente actualizado.
IMPLEMENTACIÓN EN UNIX:
Existen tres formas de controlar el acceso. Los tres son métodos independientes y generalmente para procesos cooperativos. En algunos sistemas Unix o Linux con fcntl se puede implementar bloqueos obligados, aunque está característica implica un retardo en todas la operaciones de E/S sobre ficheros. Algunas versiones de Unix incluyen la función lockf en vez de flock, que permite bloquear del acceso a parte del fichero.
• Fichero auxiliar de candado ( open + O_EXCL )
• flock ( Bloqueo cooperativos )
• fcntl ( + Completo : cooperativo y en zonas )
Mediante un fichero auxiliar de candado:
El candado está bloqueado si existe un fichero auxiliar: Sólo uno proceso puede crear el fichero. Si puedo crearlo accedo al recurso, después lo borro para indicar que el recurso está libre.
En la llamada open al opción O_CREAT con O_EXCL falla si el fichero ya existe.
EJEMPLO:
fd = open (“ficherocandado”,O_CREAT | 0_EXCL | O_RDWR , 0600))
if ( fd ¡= -1 ) {
//Accedo al recurso compartido HacerAlgo()
// Libero el recurso: Cierro el fichero y lo borro. close(fd); unlink(“ficherocandado”); } else { if ( errno == EEXIST ) // Recurso bloqueado else
// Otro tipo de error Ej.- fallo en los permisos }
Este es un método sencillo que funciona prácticamente en todos los sistemas operativos y plataformas independientemente de la versión.
int flock(int fd, int operation)
Impone o elimina un candado de recomendación (advisory lock) en un fichero abierto. El fichero está especificado por fd. Las operaciones válidas son:
LOCK_SH Candado compartido. Más de un proceso puede tener un candado compartido para un fichero en un momento dado.
LOCK_EX Candado exclusivo. Solamente un proceso puede tener un candado exclusivo para un fichero en un momento dado.
LOCK_UN Desbloqueo.
LOCK_NB No se queda en espera al intentar un bloqueo. Se utiliza junto con las dos primeras opciones.
Sobre un fichero sólo puede existir un tipo de bloqueo
Mediante la llamada fcntl
La función fcntl permite realizar varias operaciones, entre otras cosas fijar candados sobre ficheros, estos candados pueden ser lectura o escritura en todo o en parte del fichero (bloqueo de registros)
int fcntl ( int df, int orden, struct flock *candado )
orden:
F_SETLK ( Intenta fijar un bloqueo y vuelve si no puede hacerlo ) F_SETLKW ( Intenta fija un bloqueo, si no puede espera )
F_GETLK ( Recupera información sobre los bloques existentes)
Utilizamos la estructura:
struct flock {
short l_type; // Tipo candado
short l_whence; // Posición relatica del candado off_t l_start; // Posición Inicial
off_t l_len; // Posición Final
pid_t l_pid; // Nº de proceso que ha hecho el bloqueo };
Tipo (l_type):
F_UNLCK, si no hay candado.
F_RDLCK, Si hay un candado de lectura F_WRLCK, Si hay un candado de escritura Posición relativa (l_whence):
SEEK_SET, SEEK_CUR, SEEK_END
