4.2 Commit request processing

Function int commit_disks(struct final *fin, int (*process_progress)(float progress,ERR_PARAM), int check_only, ERR_PARAM) checks and modifies partition structure on disks according to struct final *fin. It can be called in two modes: `check-only' and `modification' mode. It only checks correctness of operations demanded by data stored in fin in `check-only' mode. It does not make any modification on disks. In `modification' mode it also modifies partition structure if there are no fatal conflicts in data stored in fin. It also modifies partition structure case that there are just warnings. Note that modification of partition structure with warnings is dangerous and you should always call commit_disks in `check-only' mode first and then in `modification' mode to prevent lost of data.

Function comit_disks is responsible for checking that there is enough free space to successfully modified partition structure of the disks, modified partitions are not mounted, there are no illegal operations not supported by general converter etc. Thus the function is very complex to ensure that all the conditions for successful conversion are satisfied.

Function commit_disks processes in several steps:

• The function parses global conversion parameters.
• If on-line conversion demanded it calls function check_online of on-line conversion module to ensure that the support for on-line conversion is compiled into the kernel.
• It finds out which disks' partition structures and which partitions have changed and marked them as dirty. It maintains an array of renamed partitions used by lilo support functions.
• If finds out which partitions are converted and which ones are deleted.
• It calls commit_partitions in `check-only' mode to check that the partition structure is non-conflicting with restrictions special for the selected partition type.
• It creates struct partition for general converter now; it opens the device, fills in struct partition for imported and exported partitions and deleted partitions are delcared as free space (general converter can store there its data).
• Array of exported partitions is sorted to be newly created partitions at its end.
• Flag nomove is determined. This flag is one if the only modifications of partition structure are moves of some partitions.
• In case that flag nomove is one filesystem info (struct fs_info) is filled for all the imported and exported partitions. Then the validity of newly created filesystem is checked by calling fc_check.
• In case that flag nomove is one number of blocks available and needed for conversion is counted.
• In case that on-line conversion is demanded restrictions special for on-line conversion are checked - only one-to-one conversions are supported, the partition must be mounted etc.
• In case of off-line conversion the needed space is checked and it is checked that all the modified partitions are unmounted.
• In case that `check-only' mode is on the function leaves now.
• In case of on-line conversion the on-line converter is called and the function then continues with partitioner step.
• The deleted partitions are deleted and filled with random data if demanded.
• In case that flag nomove is zero the accelaration routine is called and the function then continues with partitioner step.
• The general converter is called if conversion of any partition is to be processed.
• If any new partition is to be created a special accleration routine is called.
• The deleted partitions are again filled with random data if demanded.
• The partitioner module is called to change partition structure on the device.
• Lilo support functions are called if demanded.

Local variables of function commit_disks

There are a pretty lot of local variables in function commit_disks. This is due to the process of checking and modification of partitions is very complex and a lot of structures are required to be stored and maintain. Only the variables with special values are listed; variables used only as an auxiliary ones in for-cycles or when opening or closing device are not listed.

int dirty_parts

Number of partitions which are dirty; these are the partitions which were modified or newly created.

int dirty_part[][]

Array of `dirtness' flags for all partitions.

int used_parts

Number of partitions on which are stored files which will be used during conversion.

int used_part[][]

Array of `used files' flags for all partitions.

int del_parts

Number of completely deleted partitions.

int del_part[][]

Array of `deleted' flags for all partitions.

int dirty_disk[]

Number of disks on which some modifications are to be done.

int renames

Number of partitions which are to be renamed.

char *renamed_orig[]

Array of original partitions' names.

char *renamed_finl[]

Array of new partitions' names.

struct partition imp[]

Array of struct partition of modified partitions prepared to be passed to the general converter.

struct partition exp[]

Array of struct partition of modified and newly created partitions prepared to be passed to the general converter.

int fspaces

Number of free space blocks to be passed to the general converter.

struct space fspace[]

Array of struct space of free space blocks prepared to be passed to the general converter.

struct part_info imp_part_info[][]

Array containing partition information about imported modified partitions.

struct fs_info imp_fs_info[][]

Array containing filesystem information about imported modified partitions.

struct fs_info exp_fs_info[][]

Array containing filesystem information about exported modified partitions.

block_t exp_size[]

Array containing minimal sizes of new filesystems (whose on exported partitions).

block_t exp_struct[]

Array containing minimal sizes of internal filesystem structures for new filesystems (whose on exported partitions).

block_t available_blocks

Number of blocks available for conversion.

block_t needed1_blocks

Number of blocks needed by internal filesystem structures during conversion.

block_t needed2_blocks

Number of blocks needed to store all data contained in the files during conversion.

Special functions called by commit_disks

There are some special purpose functions called by function commit during the checking and conversion process. These functions implements simple technical manipulations with used data structures.

void clear_fs_info(struct fs_info *)

This function initialize struct fs_info. The structured is filled with values corresponding to empty filesystem.

void add_fs_info(struct fs_info *, struct fs_info *)

This function increases the values stored in the structure passed as the first parameter by values stored in the second parameter structure.

block_t count_intersect(struct partition_base *,struct partition_base *)

This function returns number of blocks in the intersections of two partitions; if the partitions are disjoint zero is returned.

int disjoint_space(int from,int *num,struct space **space,struct partition_base *base,ERR_PARAM)

This function receives array space containing

*num

entries corresponding to free space areas on the disk. The first from entries are declared as free by user. This function checks that the entries are disjoint with partition located at *base and in case that they are not, array space is appropriately modified.