=============================================================================== API de GNU libparted =============================================================================== by Andrew Clausen traducido por Jesús Burgos Copyright (C) 1999-2003, 2005 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the no Invariant Sections, with the no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the file, COPYING.DOC. CONTENIDOS ---------- 1 Introducción 2 Inicializando libparted 3 PedDevice 4 PedDisk, PedDiskType 5 PedGeometry 6 PedPartition, PedPartitionType 7 PedFileSystem, PedFileSystemType 8 PedConstraint, PedAlignment 9 PedTimer 10 PedUnit 11 Excepciones ------------------------------------------------------------------------------- 1 INTRODUCCIÓN ------------------------------------------------------------------------------- GNU Parted está construido sobre libparted, que es el que realiza todo el trabajo real. libparted provee un API capaz de manipular tablas de parti- ciones, y sus sistemas de ficheros. El motivo principal para separar el back-end en una librería a parte era que las distintas distribuciones de GNU/Linux pudieran escribir sus propias interfaces para después usarlas en el proceso de instalación. Aquí se documenta el API -- no los detalles de implementación de libparted. La documentación que no es relativa a los programas que usan el API lleva la marca INTERNAL. Además de este fichero, un buen sitio donde buscar podría ser parted/parted.c, el código fuente del fron-end, y el TUTORIAL (¡no se ha terminado todavía!) Esta documentación no es tan completa como debería. Puedes hacer preguntas, bien personalmente a mi (address@hidden) (Nota del traductor: envie los correos en inglés), o bien a la lista de correo (address@hidden). 1.1 TERMINOLOGÍA -------------------- Parte de la termnología es un poco extraña, así que puede que quieras leer esto: CONSTRAINT restricciones, un conjunto de condiciones que deben ser satisfechas, para una GEOMETRÍA o una PARTICIÓN dada. DISPOSITIVO un dispositivo de almacenamiento DISCO un dispositivo de almacenamiento, con una tabla de particiones válida. EXCEPCIÓN un evento que necesita atención. PARTICIÓN EXTENDIDA una PARTICIÓN PRIMARIA, que puede contener PARTICIONES LÓGICAS en lugar de un sistema de ficheros. Nunca habrá mas de una partición extendida por disco. SISTEMA DE FICHEROS la información que reside en una partición. Para los propósitos de GNU Parted, esto incluye dispositivos swap. GEOMETRÍA una descripción de una región continua de un disco. ej, las particiones tienen una geometría. PARTICIÓN OCULTA una partición que está oculta de sistemas operativos de MS. Solo se pueden ocultar las particiones FAT. PARTICIÓN LÓGICA como las particiones normales, pero residen dentro de una partición extendida PARTICIÓN una región continua en un disco donde puede residir un sistema de ficheros. PARTICIÓN PRIMARIA una partición normal, original. TABLA DE PARTICIONES también ETIQUETA DE DISCO. Una descripción de dónde están las particiones, e información acerca de esas particiones. Por ejemplo, qué tipo de sistema de ficheros residen en su interior. La tabla de particiones está normalmente en el principio del disco. TIMER una barra de progreso. Es una entidad que guarda la barra de tiempo, y a quién informar cuando ocurra algo de interés. 1.2 DISEÑO -------------- libparted tiene un diseño orientado a objetos. Los objetos mas importantes son: PedArchitecture describe el soporte para una "arquitectura", que es del tipo "sistema operativo", pero también puede ser, por ejemplo, otro entorno de libparted, EVMS, etc. PedConstraint una restricción de la geometría del disco PedDevice un dispositivo de almacenamiento PedDisk un dispositivo de almacen. + tabla de particiones PedFileSystem un sistema de ficheros, asociado con un PedGeometry, NO con un PedPartition. PedGeometry una región continua de un dispositivo PedPartition una partición (básicamente PedGeometry con algunos atributos) PedTimer guarda una barra de progreso y tiempo Todas las funciones devuelven 0 (o NULL) en caso de fallo, y distinto de cero (o distinto de NULL) y todo sucede de la forma esperada. Si una función falla, una excepción es lanzada. Esto puede ser manipulado por un manejador de excepciones, o llamando a la función (mira la sección de excepciones) Todos los objetos deberían ser considerados de solo-lectura; solo deberían ser modificados mediante llamadas a el API de libparted. ------------------------------------------------------------------------------- 2 INICIALIZANDO LIBPARTED ------------------------------------------------------------------------------- libparted puede incluirse de esta manera: #include Parted se inicializa automáticamente mediante una función__attribute__ ((constructor)) Sin embargo, puede que quieras configurar el manejador de excepciones con ped_exception_set_handler(). libparted viene con un manejador de excepciones por defecto, por si eres perezoso. Aquí hay un pequeño ejemplo: #include int main() { /* inicializado automáticamente */ ped_exception_set_handler(exception_handler); /* vea la sección 7 */ return 0; /* borrado automáticamente */ } ----------------------------------------------------------------------------- 3 PEDDEVICE ----------------------------------------------------------------------------- interfaz: implementación: libparted/device.c, libparted/llseek.c. Cuando ped_device_probe_all() es llamado, libparted intenta detectar todos los dispositivos. Construye uan lista, a la que se puede acceder con ped_device_get_next(). Si quieres usar un dispositivo que no está en la lista, usa ped_device_get(). También, puede haber constructores específicos para determinado SO, para crear dispositivos desde un descriptor de fichero, etc. Por ejemplo, ped_device_new_from_store(). 3.1 CAMPOS -------------- #define PED_SECTOR_SIZE 512 typedef long long PedSector; /* se planea quitar esto del API */ typedef enum { PED_DEVICE_UNKNOWN = 0, PED_DEVICE_SCSI = 1, PED_DEVICE_IDE = 2, PED_DEVICE_DAC960 = 3, PED_DEVICE_CPQARRAY = 4, PED_DEVICE_FILE = 5, PED_DEVICE_ATARAID = 6, PED_DEVICE_I2O = 7 } PedDeviceType; typedef struct _PedCHSGeometry PedCHSGeometry; struct _PedCHSGeometry { int cylinders; int heads; int sectors; }; typedef struct _PedDevice PedDevice; struct _PedDevice { PedDevice* next; char* model; char* path; PedDeviceType type; /* Se planea quitar esto del API */ int sector_size; PedSector length; int open_count; int dirty; int external_mode; int boot_dirty; PedCHSGeometry hw_geom; PedCHSGeometry bios_geom; short host, did; void* arch_specific; }; Campos útiles: char* model Una descrpición del fabricandte y el model del hardware. char* path Normalmente el dispositivo de bloques. Ej. /dev/sdb, /dev/hda, etc. PedSector length Tamaño del dispositivo, en sectores. 3.2 FUNCIONES ----------------- void ped_device_probe_all () Intenta detectar todos los dispositivos. void ped_device_free_all () Cierra/libera todos los dispositivos. Es llamada por ped_done(), así que no te tienes que preocupar por ella. PedDevice* ped_device_get (char* name) Obtiene el "nombre" de dispositivo, donde nombre es normalmente el dispositivo de bloques, ej. /dev/sdb. Si el dispositivo no fue detectado con ped_device_probe_all(), se intentará detectar otra vez más. Si es encontrado, será añadido a la lista. PedDevice* ped_device_get_next (PedDevice* dev) Devuelve el siguiente dispositivo que fue detectado por ped_device_probe_all(), o llama a ped_device_get_next(). Si dev es NULL, devuelve el primer dispositivo. Devuelve NULL si dev es el último dispositivo. int ped_device_open (PedDevice* dev) Intenta abrir dev, para permitir el uso de ped_device_read(), ped_device_write() y ped_device_sync(). Devuelve cero cuando hay fallo. Puede asignar recursos. Cualquier recuso asignado aquí será liberado por un ped_device_close() final. (ped_device_open() puede ser llamado múltiples veces.. es un mecanismo que funciona por referencias) int ped_device_close (PedDevice* dev) Cierra dev. Devuelve cero cuando se produce algún fallo. Si este es el "close final", entonces los recursos asignados por ped_device_open() son liberados. void ped_device_destroy (PedDevice* dev) Destruye un dispositivo y lo elimina de la lista de dispositivos, y libera todos los recursos asociados con el dispositivo (todos los recursos asignados cuando el dispositivo fue creado). int ped_device_read (PedDevice* dev, void* buffer, PedSector start, PedSector count) INTERNAL: Lee count sectores, empezando en el sector start, de dev. Devuelve cero en caso de fallo. int ped_device_write (PedDevice* dev, void* buffer, PedSector start, PedSector count) INTERNAL: Escribe count sectores, empezando en el sector strt, de dev. int ped_device_sync (PedDevice* dev) INTERNAL: Escribe a disco la caché de escritura. Devuelve cero en caso de fallo. int ped_device_sync_fast (PedDevice* dev) INTERNAL: Escribe a disco la caché de escritura, pero no asegura la consistencia entre las cachés de partición/dispositivo del sistema operativo. Devuelve cero en caso de fallo. int ped_device_begin_external_access (PedDevice* dev) Comienza en modo acceso externo. El modo acceso externo te permite hacer IO sobre el dispositivo de forma segura. Si un PedDevice es abierto, entonces no deberías hacer ningún IO en ese dispositivo, ej. llamado a un programa externo como e2fsck, a no ser que actives el modo acceso externo. No deberías usar ningún comando de libparted que haga IO a un dispositivo, ej. ped_file_system_{open|resize|copy}, ped_disk_{read|write}, mientras un dispositivo está en modo acceso externo. Además, no deberías cerrar un dispositivo, mientras está en modo acceso externo. Nota: ped_device_begin_external_access_mode() hace cosas como pedir al kernel que sincronice su caché. Devuelve cero en caso de fallo. int ped_device_end_external_access (PedDevice* dev) Termina el modo acceso externo. Nota: ped_device_end_external_access_mode() hace cosas como pedir al kernel que sincronice su caché. Devuelve cero en caso de fallo. ----------------------------------------------------------------------------- 4 PEDDISK, PEDDISKTYPE ----------------------------------------------------------------------------- interfaz: implementación: libparted/disk.c Muchos programas necesitarán usar ped_disk_new() o ped_disk_new_fresh() para tener algo hecho. Un PedDisk siempre es asociado con un dispositivo, y tiene una tabla de particiones. Hay distintos tipos de tablas de particiones (o etiquetas de disco). Estos son representados por PedDiskType. 4.1 CAMPOS -------------- typedef enum { PED_DISK_TYPE_EXTENDED=1, /* soporta particiones extendidas */ PED_DISK_TYPE_PARTITION_NAME=2 /* soporta nombres de particiones */ } PedDiskTypeFeature; struct _PedDiskType { PedDiskType* next; char* name; PedDiskOps* ops; PedDiskTypeFeature features; /* bitmap de características soportadas */ }; Campos útiles: char* name el nombre del tipo de la tabla de particiones. struct _PedDisk { PedDevice* dev; PedDiskType* type; PedPartition* part_list; void* disk_specific; /* solo de uso interno ;-) */ int needs_clobber; int update_mode; }; Los campos útiles: PedDevice* dev el dispositivo donde reside la tabla de particiones PedDiskType* type el tipo de etiqueta de disco PedPartition* part_list esto es la lista de particiones del disco. Se debería acceder a ella con ped_disk_next_partition() 4.2 FUNCIONES ----------------- PedDiskType* ped_disk_type_get_next (PedDiskType* type) Devuelve el registro del siguiente tipo de disco, despues de "type". Si "type" es NULL, devuelve el primer tipo de disco. Si "type" es el último tipo de disco, devuelve NULL. PedDiskType* ped_disk_type_get (char* name) Devuelve el tipo del disco con el nombre "name". Si no lo hay, devuelve NULL. int ped_disk_type_check_feature (const PedDiskType* disk_type, PedDiskTypeFeature feature) Devuelve 1 si el tipo de tabla de particones "disk_type" tiene soporte para "feature". Devuelve 0 cualquier otro caso. PedDiskType* ped_disk_probe (PedDevice* dev) Devuelve el tipo de tabla de particion detectado en "dev", o NULL si no se detecta ninguno. int ped_disk_clobber (PedDevice* dev) Sobreescribe todas las marcas de tabla de particiones en "dev". int ped_disk_clobber_exclude (PedDevice* dev, const PedDiskType* exclude) Sobrescribe todas las marcas de tabla de particiones en "dev", EXCEPTO la marca para el tipo "exclude". PedDisk* ped_disk_new (PedDevice* dev) Construye un objeto PedDisk de dev, y lee la tabla de particiones. Devuelve cero cuando hay fallo. ADVERTENCIA: esto puede modificar dev->cylinders, dev->heads y dev->sectors, porque la tabla de particines puede indicar que los valores existentes son incorrectos. PedDisk* ped_disk_new_fresh (PedDevice* dev, PedDiskType* type) Crea una tabla de particiones en dev, y contruye un objeto PedDisk para ello. Devuelve NULL si hay fallo. PedDisk* ped_disk_duplicate (PedDisk* disk) Devuelve una copia "profunda" de "disk" o NULL cuando hay fallo. void ped_disk_destroy (PedDisk* disk) Cierra "disk". int ped_disk_commit (PedDisk* disk) Escribe la tabla de particiones a "disk" (ej, disk->dev), e informa al sistema operativo de la nueva disposición. Esto es implementado llamando a ped_disk_commit_to_dev() y luego a pd_disk_commit_to_os(). Devuelve 0 cuando se produce algún fallo. int ped_disk_commit_to_dev (PedDisk* disk) Escribe la tabla de particiones a "disk" (ej. disk->dev). Devuelve 0 cuando se produce algún fallo. int ped_disk_commit_to_os (PedDisk* disk) Informa al kernel de la disposición de la tabla de particiones de disk. Esto es algo difícil de definir... dependiendo de sistema operativo, etc. Por ejemplo, en versiones viejas de Linux, solo llama al ioctl BLKRRPART, el cual pide al kernel que re-lea la tabla de particiones. En versiones mas nuevas (2.4.x), usará la nueva interfaz blkpg para decirle al kernel dónde empieza/termina cada partición, etc. En este caso, Linux no necesita tener soporte para este tipo de tabla de particiones. Devuelve 0 cuando se produce algún fallo. int ped_disk_check (PedDisk* disk) Comprueba que no hay errores en la tabla de particiones "disk". Nota: muchos de los errores ocurren cuando la tabla de particiones es cargada desde disk, en ped_disk_new(). Devuelve 1 cuando no hay fallos, 0 en caso contrario. void ped_disk_print (PedDisk* disk) Muestra un sumario de las particiones de disk. Útil para hacer debug. int ped_disk_add_partition (PedDisk* disk, PedPartition* part, PedConstraint* constraint) Añade "part" a "disk". La geometría de "part" puede ser cambiada, depende de "constraint". Tu podrías fijar "constraint" a ped_constraint_exact(&part->geom), pero muchos esquemas de tabla de particiones tienen requisitos especiales en el inicio y el final de las particiones. Por lo tanto, teniendo un constraint excesivamente estricto probablemente provoque que ped_disk_add_partition() falle (en tal caso, "part" no será modificado) "part" toma un número (part->num) en este proceso. Devuelve 0 cuando hay fallo. int ped_disk_remove_partition (PedDisk* disk, PedPartition* part) Elimina "part" de "disk". Si "part" es una partición extendida, no debe contener particiones lógicas. "part" *NO* es destruida. Se debe llamar a ped_partition_destroy(), o usar ped_disk_delete_partition() en su lugar. int ped_disk_delete_partition (PedDisk* disk, PedPartition* part) Elimina "part" de "disk", y destruye "part". Devuelve 0 si hay fallo. int ped_disk_delete_all (PedDisk* disk) Elimina y destruye todas las particiones de "disk". Devuelve 0 si ocurre un fallo. int ped_disk_set_partition_geom (PedDisk* disk, PedPartition* part, PedConstraint* constraint, PedSector start, PedSector end) fija la geometría de "part". Esto puede fallar por muchas razones, ej. no se puede superponer con otras particiones. Si falla, "part" permanecerá sin cambios. Devuelve 0 si hay fallo. La geometría de "part" puede ser distinta de "start" y "end" en función de "constraint". int ped_disk_maximize_partition (PedDisk* disk, PedPartition* part, PedConstraint* constraint) Expande "part" al máximo posible, respetando a "constraint". La nueva geometría será superpuesta a la vieja. Devuelve 0 cuando hay fallo. PedGeometry* ped_disk_get_max_partition_geometry (PedDisk* disk, PedPartition* part, PedConstraint* constraint) Devuelve la máxima geometría a la que puede crecer "part", respetando a "constraint". Devuelve NULL cuando hay fallo int ped_disk_minimize_extended_partition (PedDisk* disk) Reduce la partición extendida de "disk" al mínimo posible. Devuelve 0 cuando hay fallo. PedPartition* ped_disk_next_partition (PedDisk* disk, PedPartition* part) Devuelve la siguiente partición despues de "part" en "disk". Si "part" es NULL, devuelve la primera partición. Si "part" es la última partición, devuelve NULL. Si "part" es una partición extendida, devuelve la primera partición lógica. Si es llamada repetidamente pasando el valor de retorno como "part", se recorrerán todas las particiones. PedPartition* ped_disk_get_partition (PedDisk* disk, int num) Devuelve la partición con el número "num". Si no existe tal partición, devuelve NULL PedPartition* ped_disk_get_partition_by_sector (PedDisk* disk, PedSector sect) Devuelve la particion que posee el sector "sect". si sect está dentro de una particón lógica, la partición lógica es devuelta. PedPartition* ped_disk_extended_partition (PedDisk* disk) Devuelve la partición extendida, o NULL si no la hay. int ped_disk_get_primary_partition_count (PedDisk* disk) Devuelve el número de particiones primarias. int ped_disk_get_max_primary_partition_count (PedDisk* disk) Devuelve el número máximo de particiones primarias que puede tener esta tabla de particiones. int ped_disk_get_last_partition_num (PedDisk* disk) Devuelve el mayor part->num de todas las particiones. ----------------------------------------------------------------------------- 5 PEDGEOMETRY ----------------------------------------------------------------------------- interfaz: implementación: libparted/geom.c PedGeometry es creado por ped_geometry_new() a partir PedDevice. Representa una región continua de un dispositivo. Todo el direccionamiento a través de PedGeometry está en términos del inicio de la región continua. Las siguientes condiciones siempre son verdaderas en un objeto PedGeometry: * start + length - 1 == end * length > 0 [STRICTLY > 0] * start >= 0 * end < dev->length 5.1 CAMPOS -------------- struct _PedGeometry { PedDevice* dev; PedSector start; PedSector length; PedSector end; }; Campos útiles: PedDevice* dev el dispositivo. PedSector start el inicio de la región en sectores (un sector == 512 bytes). PedSector length la longitud de la región en sectores. PedSector end el final de la región en sectores. 5.2 FUNCIONES ----------------- int ped_geometry_init (PedGeometry* geom, const PedDevice* dev, PedSector start, PedSector length) Inicializa un objeto PedGeometry. PedGeometry* ped_geometry_new (PedDevice* dev, PedSector start, PedSector length) Crea un nuevo objeto PedGeometry en "dev", iniciando en "start", de "length" sectores (unidades de 512 bytes). Devuelve NULL si hay fallo PedGeometry* ped_geometry_duplicate (PedGeometry* geom) Duplica un objeto PedGeometry. Devuelve NULL si hay fallo. PedGeometry* ped_geometry_intersect (const PedGeometry* a, const PedGeometry* b) Si a y b se superponen, devuelve un objeto PedGeometry que representa la intersección de las dos regiones. Si no, devuelve NULL. void ped_geometry_destroy (PedGeometry* geom) Destruye un objeto PedGeometry. void ped_geometry_set (PedGeometry* geom, PedSector start, PedSector length) Asigna una nueva geom->start, geom->end y geom->length a "geom". geom->end se calcula a partir de "start" y "length". void ped_geometry_set_start (PedGeometry* geom, PedSector start) Asigna una nueva geom->start a "geom" sin cambiar geom->end. geom->length se actualiza como corresponda. void ped_geometry_set_end (PedGeometry* geom, PedSector end); Asigna un nuevo geom->end a "geom" sin cambiar geom->start. geom->length se actualiza como corresponda. int ped_geometry_test_overlap (PedGeometry* a, PedGeometry* b) Prueba si "a" se superpone con "b". Esto es, las dos residen en el mismo disco físico, y comparten (parte de) la misma región física. int ped_geometry_test_inside (PedGeometry* a, PedGeometry* b); Prueba si "b" está completamente dentro de "a". Esto es, si los dos están en el mismo disco físico, y toda la región de "a" está dentro de la región de "b". int ped_geometry_test_equal (PedGeometry* a, PedGeometry* b); Prueba si "a" y "b" se refieren a la misma región física. int ped_geometry_test_sector_inside (const PedGeometry* geom, PedSector sect) Prueba si sect está dentro de geom. int ped_geometry_read (PedGeometry* geom, void* buffer, PedSector offset, PedSector count) Lee datos de la región representada en "geom". "offset" es la ubicación desde el inicio de la región, no desde el inicio del disco. "count" sectores son leídos y guardados en "buffer". Esto es esencialmente equivalente a: ped_device_read (geom->disk->dev, buffer, geom->start + offset, count) Returns 0 on failure. int ped_geometry_write (PedGeometry* geom, void* buffer, PedSector offset, PedSector count) Escribe datos en la región representada por "geom". "offset" es la ubicación desde el inicio de la región, no desde el inicio del disco. "count" sectores son escritos. Devuelve 0 en caso de fallo. PedSector ped_geometry_check (PedGeometry* geom, void* buffer, PedSector buffer_size, PedSector offset, PedSector granularity, PedSector count) Comprueba si una región tiene defectos físicos en "geom". "buffer" se usa para el almacenamiento temporal de ped_geometry_check(), y tiene un valor indefinido. "buffer" mide "buffer_size" sectores. La región comprobada empieza en el sector "offset" dentro de la región representada por "geom", y mide "count" sectores. Es devuelto el primer sector defectuoso, o 0 si no hubo errores físicos. "granularity" especifica cómo deberían ser agrupados los sectores. El primer sector defectuosos a ser devuelto siempre será de la forma: offset + n * granularity int ped_geometry_sync (PedGeometry* geom) Sincroniza la caché en "geom". Devuelve 0 si hay fallo. int ped_geometry_sync_fast (PedGeometry* geom) Sincroniza la caché en "geom". No asegura la consistencia entre particiones y cachés de dispositivo del sistema operativo. Devuelve 0 si ocurre algún fallo. PedSector ped_geometry_map (PedGeometry* dst, PedGeometry* src, PedSector sector) Si "src" y "dst" se superponen, y "sector" en "src" también existe en "dst", entonces el sector equivalente es devuelto. Devuelve -1 si "sector" no está en el espacio dentro de "dst" ----------------------------------------------------------------------------- 6 PEDPARTITION, PEDPARTITIONTYPE ----------------------------------------------------------------------------- interfaz: implementación: libparted/disk.c Una PedPartition representa a una partición (¡sorprendente!). Estas particiones tienen una extraña relación con PedDisk. Por lo tanto, muchas funciones para manipular particiones serán llamadas ped_disk_* - así que echale también un vistazo a la documentación de PedDisk. Parted crea unas particiones "imaginarias" de espacio libre y de metadatos. Tú no puedes hacer operaciones en esas particiones (como set_geometry, {set,get}_flag, etc.). Las particiones que no son de espacio libre o de metadatos se dice que son particiones "activas". Puedes usar ped_partition_is_active() para probarlo. 6.1 CAMPOS -------------- typedef enum { PED_PARTITION_NORMAL = 0x00, PED_PARTITION_LOGICAL = 0x01, PED_PARTITION_EXTENDED = 0x02, PED_PARTITION_FREESPACE = 0x04, PED_PARTITION_METADATA = 0x08 } PedPartitionType; typedef enum { PED_PARTITION_BOOT=1, PED_PARTITION_ROOT=2, PED_PARTITION_SWAP=3, PED_PARTITION_HIDDEN=4, PED_PARTITION_RAID=5, PED_PARTITION_LVM=6, PED_PARTITION_LBA=7 } PedPartitionFlag; #define PED_PARTITION_FIRST_FLAG PED_PARTITION_BOOT #define PED_PARTITION_LAST_FLAG PED_PARTITION_LBA struct _PedPartition { PedPartition* prev; PedPartition* next; PedDisk* disk; PedGeometry geom; int num; PedPartitionType type; const PedFileSystemType* fs_type; PedPartition* part_list; /* for extended partitions */ void* disk_specific; }; Useful fields: PedDisk* disk la tabla de particiones de la partición PedGeometry geom geometrria de la partición int num el número de partición. En Linux, este es igual al minor de la partición. No se debería asumir que "num" o "type" debe tener cierto valor - diferentes etiquetas de disco tienen distintas reglas PedPartitionType type el tipo de partición: un bitmap de PED_PARTITION_LOGICAL, PED_PARTITION_EXTENDED, PED_PARTITION_METADATA y PED_PARTITION_FREESPACE. Los dos primeros y los dos últimos son mutuamente excluyentes. Una partición extendida es una partición primaria que puede contener particiones lógicas. En un disco no puede haber mas de una partición extendida. Una partición lógica es como una partición primaria, excepto en que está dentro de una partición extendida. Internamente, las pseudo-particiones son asignadas para representar el espacio vacío, o los metadatos. Estos contienen los bits PED_PARTITION_FREESPACE o PED_PARTITION_METADATA activados. PedPartition* part_list Solo se usa para particiones extendidas. Es la lista de particiones lógicas (y el espacio libre/metadatos dentro de la partición extendida). PedFileSystemType* fs_type El tipo de sistema de ficheros de la partición. NULL si se desconoce. 6.2 FUNCIONES ----------------- PedPartition* ped_partition_new (PedDisk* disk, PedPartitionType type, const PedFileSystemType* fs_type PedSector start, PedSector end) Crea una nueva PedPartition en "disk", comenzando en el sector "start", y terminando en "end". "type" es uno de 0 ("normal"), PED_PARTITION_LOGICAL o PED_PARTITION_EXTENDED. (PED_PARTITION_FREE y PED_PARTITION_METADATA son usadas internamente). La nueva partición no es añadida a la representación del disco de la tabla de particiones. Úsese ped_disk_add_partition() para ello. void ped_partition_destroy (PedPartition* part) Destruye una partición. No debería ser llamada sobre una partición que está en una tabla de particiones. Para ese caso, úsese ped_disk_delete_partition() int ped_partition_is_active (PedPartition* part) Devuelve si la partición part está "activa". Si part->type es PED_PARTITION_METADATA o PED_PARTITION_FREE, entonces no está "activa". De lo contrario, está activa. int ped_partition_set_flag (PedPartition* part, PedPartitionFlag flag, int state) Fija el estado (1 o 0) de la bandera de una partición. Las banderas son específicas para cada etiqueta de disco, aunque tienen una parte global. ej. la bandera PED_PARTITION_BOOT significa "esta partición es arrancable". Pero esto significa cosas distintas en diferentes etiquetas de disco (y puede que no esté definido en algunas etiquetas de disco). Por ejemplo, en etiquetas de disco de msdos, solo puede haber una particion arrancable, y esto indica la partición que será arrancada en el proceso de arranque. En etiquetas de disco PC98, el usuario puede elegir cualquier partición arrancable durante el proceso de arranque del PC. Es un error llamar a esta función con una bandera que no está disponible -- ver ped_partition_is_flag_available(). int ped_partition_get_flag (const PedPartition* part, PedPartitionFlag flag) Devuelve el estado (1 o 0) de una bandera en una partición. Es un error llamar a esta función con una bandera que no está disponible -- ver ped_partition_is_flag_available(). int ped_partition_is_flag_available (const PedPartition* part, PedPartitionFlag flag) Devuelve 1 si la bandera flag está disponible en la particion part, 0 en caso contrario. int ped_partition_set_system (PedPartition* part, PedFileSystemType* fs_type) Fija el tipo de sistema a fs_type en la partición part. Nota: El sistema de ficheros puede estar abierto, para obtener mas información acerca del sistema de ficheros, ej. para determinar si es FAT16 o FAT32. int ped_partition_set_name (PedPartition* part, const char* name) Establece el nombre de la partición part. Esto solo funcionará si la etiqueta de disco lo soporta. Puedes comprobarlo de esta manera: ped_disk_type_check_feature (part->disk->type, PED_DISK_TYPE_PARTITION_NAME); Nota: el "char *name" no será modificado por libparted. Puede ser liberado inmediatamente después de llamar a ped_partition_set_name(). const char* ped_partition_get_name (const PedPartition* part) Devuelve el nombre de la partición part. Esto solo funcionará si la etiqueta de disco del dispositivo lo soporta. Nota: la cadena devuelta no debería ser modificada. Tampoco debería ser acedida despues de que la partición sea destruida. char* ped_partition_get_path (const PedPartition* part) Devuelve un path que puede ser utilizado para acceder a la partición en el sistema operativo. Debes liberar (ver free(3)) la cadena cuando hayas terminado con ella. int ped_partition_is_busy (PedPartition* part) Devuelve 1 si la partición está ocupada, ej. montada, 0 en caso contrario. Si part es una partición extendida, entonces estará ocupada si alguna de sus particiones lógicas está montada. const char* ped_partition_type_get_name (PedPartitionType part_type) Devuelve un nombre que parece apropiado para el tipo de partición. Ej. si pasas (PED_PARTITION_LOGICAL & PED_PARTITION_FREESPACE), devolverá "free". Esto no se debe tomar seriamente - solo es útil para interfa- ces de usuario, para que puedas mostrar algo al usuario ;-) NOTA: la cadena devuelta estará en inglés. Sin embargo, se incluyen traducciones, así que se puede llamar a dgettext("parted", RESULT) con el resultado. const char* ped_partition_flag_get_name (PedPartitionFlag flag) Devuelve un nombre asociado a flag, ej. PED_PARTITION_BOOT devolverá "boot". NOTA: la cadena devuelta estará en inglés. Sin embargo, se incluyen traducciones, así que se puede llamar a dgettext("parted", RESULT) con el resultado. PedPartitionFlag ped_partition_flag_get_by_name (const char* name) Devuelve la bandera asociada con "name". "name" puede ser la cadena en inglés, o la traducción al idioma nativo. PedPartitionFlag ped_partition_flag_next (PedPartitionFlag flag) Avanza hasta la siguiente iteración de bandera. Devuelve la siguiente bandera de un orden. ped_partition_flag_next(0) devuelve la primera bandera. Devuelve 0 si no hay mas banderas. ----------------------------------------------------------------------------- 7 PEDFILESYSTEM, PEDFILESYSTEMTYPE ----------------------------------------------------------------------------- interfaz: implementación: libparted/filesys.c, cada sistema de ficheros en fs_ Los sistemas de ficheros existen en una PedGeometry - NO en una PedPartition. 7.1 CAMPOS -------------- struct _PedFileSystemType { PedFileSystemType* next; const char* const name; PedFileSystemOps* const ops; }; Useful fields: char* name name of the file system type struct _PedFileSystem { PedFileSystemType* type; PedGeometry* geom; int checked; void* type_specific; }; Useful fields: PedFileSystemType* type el tipo de sistema de ficheros. PedGeometry* geom donde está el sistema de ficheros actual. int checked 1 si se ha comprobado el sistema de ficheros. 0 en caso contrario. 7.2 FUNCIONES ----------------- PedFileSystemType* ped_file_system_type_get (char* name) Devuelve el PedFileSystemType con el nombre "name". Si no se encuentra ninguno devuelve NULL. PedFileSystemType* ped_file_system_type_get_next (PedFileSystemType* fs_type) Devuelve el siguiente PedFileSystemType, después de "fs_type". Si "fs_type" es el último, devuelve NULL. PedFileSystemType* ped_file_system_probe (PedGeometry* geom) Intenta detectar un sistema de ficheros en "geom". Si se encuentra alguno, el PedFileSystemType es devuelto. En caso contrario, devuelve NULL. PedGeometry* ped_file_system_probe_specific (const PedFileSystemType* fs_type, PedGeometry* geom) Intenta encontrar un sistema de ficheros en particular, devuelve la región que ocupa el sistema de ficheros. Devuelve NULL si no se pudo encontrar ese sistema de ficheros. int ped_file_system_clobber (PedGeometry* geom) Destruye todas las marcas de sistema de ficheros, de modo que no podrá ser detectado por ped_file_system_probe(). Nota: ped_file_system_create() llama a esta función después de crear un nuevo sistema de ficheros. PedFileSystem* ped_file_system_open (PedGeometry* geom) Abre un sistema de ficheros en "geom". Devuelve un objeto PedFileSystem si todo sucede conforme a lo esperado. Devuelve NULL cuando hay fallo. A menudo se llama a esta función de este modo: fs = ped_file_system_open (&part.geom) PedFileSystem* ped_file_system_create (PedGeometry* geom, PedFileSystemType* type, PedTimer* timer) Crea un nuevo sistema de ficheros, y devuelve un PedFileSystem que lo representa. devuelve NULL si hay error. Si "timer" no es NULL, es usado como el medidor de progreso. int ped_file_system_close (PedFileSystem* fs) Cierra "fs". Devuelve 0 si se produce algún fallo. int ped_file_system_check (PedFileSystem* fs, PedTimer* timer) Comprueba errores en "fs". Devuelve 0 si hay fallo (ej. errores no corregidos). PedFileSystem* ped_file_system_copy (PedFileSystem* fs, PedGeometry* geom, PedTimer* timer) Crea un nuevo sistema de ficheros (del mismo tipo) en "geom", y copia el contenido de "fs" en el nuevo sistema de ficheros. Se devuelve el nuevo sistema de ficheros (NULL cuando hay fallo). Si "timer" no es NULL, será usado como medidor de progreso. int ped_file_system_resize (PedFileSystem* fs, PedGeometry* geom, PedTimer* timer) Redimensiona "fs" a la nueva geometría "geom". Devuelve 0 cuando hay fallo. Nota: "geom" debería satisfacer a ped_file_system_get_resize_constraint(). (esto no está implementado, así que no es un bug... simplemente es mas probable que falle ;). Si "timer" no es NULL, será usado como medidor de progreso. PedConstraint* ped_file_system_get_create_constraint ( const PedFileSystemType* fs_type, const PedDevice* dev) Devuelve el constraint para crear un sistema de ficheros de tipo "fs_type" en "dev" con ped_file_system_create(). PedConstraint* ped_file_system_get_resize_constraint (const PedFileSystem* fs) Devuelve una restricción (un PedConstraint), que representa todas las formas posibles en que un sistema de ficheros puede ser redimensionado con ped_file_system_resize(). Consejos: * si constraint->start_align->grain_size == 0, o constraint->start_geom->length == 1, entonces el inicio de la partición no puede ser desplazado. * constraint->min_size es el tamaño mínimo al que puedes redimensionar la partición. Puede que quieras mostrar al usuario esa cifra ;-). PedConstraint* ped_file_system_get_copy_constraint ( const PedFileSystem* fs, const PedDevice* dev) Devuelve las restricciones (constraints) para copiar "fs" con ped_file_system_copy() a cualquier lugar de "dev". ----------------------------------------------------------------------------- 8 PEDCONSTRAINT, PEDALIGNMENT ----------------------------------------------------------------------------- interfaz: , implementación: libparted/constraint.c, libparted/natmath.c Las «constraints» son usadas para comunicar las restricciones de operaciones (solo para ped_file_system_resize() actualmente). Estas restricciones se dan en la ubicación y alineamiento del inicio y el final de una partición, y el tamaño mínimo. Los "alineamientos" son restricciones sobre la posición de un sector del siguiente modo: sector = offset + X * grain_size Por ejemplo, en las particiones lógicas de discos con etiquetas msdos existe una restricción de offset = 63 y grain_size = 16065 (por una larga historia). Una propiedad importante (pero no obvia) de las restricciones de alineamiento es que están cerradas bajo intersección, ej. si tu tomas dos restricciones, como (offset, grain_size) = (63, 16065) y (0, 4), entonces podrá suceder una de estas cosas: * no hay soluciones válidas (no hay intersección) * todas las soluciones pueden ser expresadas de la forma de (offset + X * grain_size) En el ejemplo, la intersección de la restricción es (16128, 64260). Para mas información sobre las matemáticas, vea el código fuente -- hay un extenso comentario que contiene pruebas de ped_alignment_intersect() en libparted/natmath.c Las restricciones en la ubicación en el inicio y el fin están guardados en objetos PedGeometry -- regiones continuas en las que el inicio y el final deben residir. Obviamente, estas restricciones también están cerradas bajo intersección. La otra restricción -- el tamaño mínimo -- también está cerrada bajo intersección. (La intersección de 2 tamaños mínimos es el máximo de 2 valores) Por eso, las restricciones están cerradas bajo intersección. libparted puede computar la intersección de las restricciones de manera muy eficiente. Así que puedes satisfacer un número de restricciones arbitrario encontrando las intersecciones de todas las restricciones. La interfaz consiste en la construcción de «constraints», la búsqueda de las intersecciones, y la búsqueda de soluciones para esas restricciones. 8.1 CAMPOS -------------- struct _PedConstraint { PedAlignment* start_align; PedAlignment* end_align; PedGeometry* start_range; PedGeometry* end_range; PedSector min_size; PedSector max_size; }; struct _PedAlignment { PedSector offset; PedSector grain_size; }; 8.2 FUNCIONES ----------------- int ped_constraint_init ( PedConstraint* constraint, const PedAlignment* start_align, const PedAlignment* end_align, const PedGeometry* start_range, const PedGeometry* end_range, PedSector min_size, PedSector max_size) Inicializa una porción de memoria pre-asignada para guardar una restricción (constraint). Devuelve 0 cuando hay fallo. PedConstraint* ped_constraint_new ( const PedAlignment* start_align, const PedAlignment* end_align, const PedGeometry* start_range, const PedGeometry* end_range, PedSector min_size) PedSector max_size) Crea una nueva restricción. Devuelve NULL cuando hay fallo. PedConstraint* ped_constraint_duplicate (const PedConstraint* constraint) Duplica "constraint". void ped_constraint_done (PedConstraint* constraint) Libera la memoria reservada para "constraint" inicializada por ped_constraint_init(). void ped_constraint_destroy (PedConstraint* constraint) Libera la memoria reservada para "constraint" reservada por ped_constraint_new(). PedConstraint* ped_constraint_intersect ( const PedConstraint* a, const PedConstraint* b) Crea una nueva restricción, esa PedGeometry es una solución a la nueva restricción si, y solo si, es una solucion para "a" y "b". Si ningún objeto PedGeometry puede servir para satisfacer a "a" y a "b", entonces devuelve NULL. NULL es un PedConstraint válido que puede usarse para todas las funciones ped_constraint_*. PedGeometry* ped_constraint_solve_max (const PedConstraint* constraint) Encuentra la solución mas larga, ej. la geometría de mayor longitud para "constraint". Devuelve NULL si no hay ninguna solucion posible. PedGeometry* ped_constraint_solve_nearest ( const PedConstraint* constraint, const PedGeometry* geom) Soluciona "constraint" devuelviendo lo mas cercano a "geom". Si no hay solucion posible, se devuelve NULL. int ped_constraint_is_solution (const PedConstraint* constraint, const PedGeometry* geom) Devuelve 1 si "geom" es una solucion para "constraint", y 0 si no lo es. PedConstraint* ped_constraint_any (const PedDevice* dev) Devuelve una «constraint», de manera que cualquier PedGeometry (válida) en "dev" puede ser solucion de ese constraint. PedConstraint* ped_constraint_exact (const PedGeometry* geom) Devuelve una restricción que solo tiene una solución: "geom". int ped_alignment_init (PedAlignment* align, PedSector offset, PedSector grain_size) Inicializa una pre-reservada área de memoria para un objeto de alineamiento (usado por PedConstraint), representando todos los PedSector'es que son de la forma "offset + X * grain_size". PedAlignment* ped_alignment_new (PedSector offset, PedSector grain_size) Devuelve un objeto de alineamiento (usado por PedConstraint), repre- sentando todos los PedSector'es que son de la forma "offset + X * grain_size". void ped_alignment_destroy (PedAlignment* align) Libera la memoria asociada con "align". PedAlignment* ped_alignment_duplicate (const PedAlignment* align) Duplica a "align". PedAlignment* ped_alignment_intersect (const PedAlignment* a, const PedAlignment* b) Devuelve un objeto PedAlignment, de manera que un PedSector es una solución si, y solo si, es una solución para "a" y "b". Nota: si no hay soluciones (ej. ningún PedSector es solucion para "a" y "b"), entonces se devuelve NULL. NULL es un objeto PedAlignment, y puede ser usado por las funciones ped_alignment_*(). PedSector ped_alignment_align_up (const PedAlignment* align, const PedGeometry* geom, PedSector sector) Devuelve el PedSector mas cercano a "sector", que reside en "geom" y que satisface la restricción "align", o -1 si no existe ese PedSector. Los PedSector'es que no son menores que "sector" siempre se consideran cercanos. PedSector ped_alignment_align_down (const PedAlignment* align, const PedGeometry* geom, PedSector sector) Devuelve el PedSector mas cercano a "sector", que reside en "geom" y que satisface la restricción "align", o -1 si no existe ese PedSector. Los PedSector'es que no son mayores que "sector" siempre se consideran cercanos. PedSector ped_alignment_align_nearest (const PedAlignment* align, const PedGeometry* geom, PedSector sector) Devuelve el PedSector mas cercano a "sector", que reside en "geom" y que satisface la restricción "align", o -1 si no existe ese PedSector. int ped_alignment_is_aligned (const PedAlignment* align, const PedGeometry* geom, PedSector sector) Devuelve 1 si "sector" reside en "geom" y satisface las restricciones de "align", y 0 en caso contrario. ----------------------------------------------------------------------------- 9 PEDTIMER ----------------------------------------------------------------------------- Un PedTimer guarda una barra de progreso de una operación simple (puede que compuesta). El usuario de libparted construye un PedTimer, y lo pasa a las funciones de libparted que conlleven grandes operaciones (como por ejemplo ped_file_system_resize). El uso de estos objetos es opcional... puede que prefieras usar NULL en su lugar. Cuando usted crea un PedTimer, debe especificar una función que lo maneje. Este será llamado cuando haya una actualización en el progreso del trabajo. Los «timers» pueden estar anidados. Cuando un timer es construído, puede asignarselo a un padre, junto con una estimación de la proporción del total (del padre) que será asignado a la operación anidada. En ese caso, el manejador del «timer» es interno para libparted, y simplemente actualiza el progreso del padre, y llama a su manejador. 9.1 CAMPOS -------------- typedef void PedTimerHandler (PedTimer* timer, void* context); struct _PedTimer { float frac; /* fracción completada de la operación */ time_t start; /* tiempo de inicio de la operación */ time_t now; /* tiempo de la última actualización (¡ahora!) */ time_t predicted_end; /* tiempo estimado de terminación */ const char* state_name; /* eg: "copiando datos" */ PedTimerHandler* handler; /* a quien avisar cuando haya actualizaciones */ void* context; /* contexto a pasar al manejador */ }; 9.2 FUNCIONES ----------------- PedTimer* ped_timer_new (PedTimerHandler* handler, void* context) Crea un temporizador (timer). "context" será pasado al manejador cuando sea invocado. void ped_timer_destroy (PedTimer* timer) Destruye un temporizador. PedTimer* ped_timer_new_nested (PedTimer* parent, float nest_frac) Crea un nuevo temporizador anidado. "parent" es el temporizador padre, y "nested_frac" es la proporción estimada (entre 0 y 1) del tiempo que que será dedicado al temporizador anidado de la operación El temporizador solo debería ser construído inmediatamente antes del comienzo de la operación anidada. (De lo contrario será impreciso) void ped_timer_destroy_nested (PedTimer* timer) Destruye un temporizador anidado. void ped_timer_touch (PedTimer* timer) INTERNO. Actualiza timer->now y re-calcula timer->predicted_end, y llama al manejador. void ped_timer_reset (PedTimer* timer) INTERNO. Reinicia el timer, fijando timer->start y timer->now al momento actual. void ped_timer_update (PedTimer* timer, float new_frac) INTERNO. Fija el nuevo timer->frac, y llama a ped_timer_touch(). void ped_timer_set_state_name (PedTimer* timer, const char* state_name) INTERNO. Fija un nuevo nombre para la "fase" actual de la operación, y llama a ped_timer_touch(). ----------------------------------------------------------------------------- 10 PEDUNIT ----------------------------------------------------------------------------- interfaz: implementación: libparted/unit.c El módulo PedUnit provee un mecanismo estándar para describir y procesar las posiciones de dispositivo de una manera orientada al usuario. Internamente, libparted usa PedSector (que está definido como un long long en ) para describir una ubicación en un dispositivo como el inicio y el fin de las particiones. Sin embarto, los números de sector son a menudo largos y poco intuitivos. Por ejmplo, mi partición extendida comienza en el sector 208845. PedUnit permite que esta dirección de disco sea representada de forma mas intuitiva, como "106Mb", "0Gb" y "0%", o también así: "208845s". PedUnit trata de proveer facilidades para ofrecer un sistema de descripción de ubicaciones consistente. PedUnit profee dos servicios básicos, convertir un PedSector en una representación textual (char *), y procesar una representación de texto (humana). PedUnit soporta actualmente estas unidades: sectores, bytes, kilobytes, megabytes, gigabytes, terabytes, compact, cilindros y porcentaje. PedUnit tiene una variable global que contiene la unidad por defecto para todas las conversiones. 10.1 CONSTANTES ------------------ typedef enum { PED_UNIT_SECTOR, PED_UNIT_BYTE, PED_UNIT_KILOBYTE, PED_UNIT_MEGABYTE, PED_UNIT_GIGABYTE, PED_UNIT_TERABYTE, PED_UNIT_COMPACT, PED_UNIT_CYLINDER, PED_UNIT_PERCENT } PedUnit; 10.2 FUNCIONES ----------------- const char* ped_unit_get_name (PedUnit unit) Devuelve una representación textual de "unit". Por ejemplo, la representación textual de PED_UNIT_SECTOR es "s". Esto no incluye soporte para la internacionalización. PedUnit ped_unit_get_by_name (const char* unit_name) Devuelve una unidad basada en su representación textual. Por ejemplo, ped_unit_get_by_name("Mb") devuelve PED_UNIT_MEGABYTE. void ped_unit_set_default (PedUnit unit) Fija la unidad por defecto. PedUnit ped_unit_get_default () Devuelve la unidad por defecto. char* ped_unit_format (PedDevice* dev, PedSector sector) Devuelve una cadena que describe la ubicación de "sector" en el dispositivo "dev". La cadena está descrita con la unidad por defecto, que es definida por ped_unit_get_default(). La cadena resultante debe ser liberada con ped_free(). char* ped_unit_format_custom (PedDevice* dev, PedSector sector, PedUnit unit) Devuelve una cadena que describe la ubicación de "sector" en el dispositivo "dev". La cadena está descrita con la unidad deseada. La cadena devuelta debe ser liberada con ped_free(). int ped_unit_parse (const char* str, PedDevice* dev, PedSector *sector, PedGeometry** range) Si str contiene una descripción válida de una posición de dev, entonces *sector es modificado para describir la ubicación y se crea una geometría en *range, describiendo un área de 2 undidades de grande centrada en *sector. Si el rango que se describe aquí estuviera parcialmente fuera del dispositivo, la geometría devuelta estaría recortada por el final del disco. Si no se especifican unidades, se asume la unidad por defecto. Esta función devuelve 1 si str es una ubicación válida, y 0 en caso contrario. int ped_unit_parse_custom (const char* str, PedDevice* dev, PedUnit unit, PedSector *sector, PedGeometry** range) Si str contiene una descripción válida de una posición de dev, entonces *sector es modificado para describir la ubicación y se crea una geometría en *range, describiendo un área de 2 undidades de grande centrada en *sector. Si el rango que se describe aquí estuviera parcialmente fuera del dispositivo, la geometría devuelta estaría recortada por el final del disco. Si no se especifican unidades, se usa "unit". Esta función devuelve 1 si str es una ubicación válida, y 0 en caso contrario. ----------------------------------------------------------------------------- 11 EXCEPTIONS ----------------------------------------------------------------------------- interfaz: implementación: libparted/exception.c Hay varios tipos de excepciones: PED_EXCEPTION_INFORMATION, PED_EXCEPTION_WARNING, PED_EXCEPTION_ERROR, PED_EXCEPTION_FATAL, PED_EXCEPTION_BUG. Son lanzadas cuando una de los eventos de abajo ocurren mientras se está ejecutando una función de libparted. Por ejemplo, si ped_device_open() falla porque el dispositivo no existe, se lanzará una excepción. Las excepciones contienen texto describiendo el evento. Dará al menos una opción para resolver la excepción: PED_EXCEPTION_FIX, PED_EXCEPTION_YES, PED_EXCEPTION_NO, PED_EXCEPTION_OK, PED_EXCEPTION_RETRY, PED_EXCEPTION_IGNORE, PED_EXCEPTION_CANCEL. Después de que una excepción sea lanzada, hay dos cosas que pueden ocurrir: (1) un manejador de excepciones es llamado, el cual elige cómo tiene que ser resuelta la excepción (normalmente preguntando al usuario). Note también: un manejador de excepciones puede devolver PED_EXCEPTION_UNHANDLED. En ese caso, una acción predeterminada por libparted será emprendida. En general, una acción predeterminada será "segura". (2) la excepción no es manejada, porque el que llama a la función quiere manejar todo por sí mismo. En ese caso, se devuelve PED_EXCEPTION_UNHANDLED. 11.1 CAMPOS -------------- enum _PedExceptionType { PED_EXCEPTION_INFORMATION=1, PED_EXCEPTION_WARNING=2, PED_EXCEPTION_ERROR=3, PED_EXCEPTION_FATAL=4, PED_EXCEPTION_BUG=5, PED_EXCEPTION_NO_FEATURE=6 }; typedef enum _PedExceptionType PedExceptionType; enum _PedExceptionOption { PED_EXCEPTION_UNHANDLED=0, PED_EXCEPTION_FIX=1, PED_EXCEPTION_YES=2, PED_EXCEPTION_NO=4, PED_EXCEPTION_OK=8, PED_EXCEPTION_RETRY=16, PED_EXCEPTION_IGNORE=32, PED_EXCEPTION_CANCEL=64, }; typedef enum _PedExceptionOption PedExceptionOption; struct _PedException { char* message; PedExceptionType type; PedExceptionOption options; }; PedExceptionType type el tipo de excepción PedExceptionOption options el modo en que puede ser resuelta la excepción 11.2 FUNCIONES ----------------- char* ped_exception_get_type_string (PedExceptionType ex_type) Devuelve una cadena describiendo el tipo de excepción. char* ped_exception_get_option_string (PedExceptionOption ex_opt) Devuelve una cadena describiendo una opción de excepción. typedef PedExceptionOption (PedExceptionHandler) (PedException* ex); void ped_exception_set_handler (PedExceptionHandler* handler) Fija el manejador de excepciones. El manejado de excepciones debería devolver UNA de las opciones de ex->options, indicando el modo en que debería ser resuelto el evento. PedExceptionOption ped_exception_throw (PedExceptionType ex_type, PedExceptionOption ex_opt, const char* message, ...) INTERNO: lanza una excepción. También puede usar esto en un front-end para libparted. "message" está en el formato de printf. Así que puedes hacer: ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_RETRY_CANCEL, "No se pudo abrir %s", file_name); Devuelve la opción seleccionada para resolver la excepción. Si la excepción no fue manejada, se devuelve PED_EXCEPTION_UNHANDLED. PedExceptionOption ped_exception_rethrow() Re-lanza una excepción no manejada. void ped_exception_catch() Asume que la excepción ha sido resuelta. void ped_exception_fetch_all() Indica las excepciones que no deberían llegar al manejador de, pero sí pasadas a la(s) función(es) llamadora(s). Todas las llamadas a ped_dexception_throw() devolverán PED_EXCEPTION_UNHANDLED. void ped_exception_leave_all() Indica que la función llamadora no quiere aceptar ninguna responsabilidad para las excepciones nunca mas. Nota: una función que llama a ped_exception_leave_all() puede todavía querer responsabilidad, de modo que ped_exception_throw() no puede invocar al manejador.