===============================================================================
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.