haiku/headers/private/disk_scanner/disk_scanner.h

241 lines
8.6 KiB
C
Raw Normal View History

//----------------------------------------------------------------------
// This software is part of the OpenBeOS distribution and is covered
// by the OpenBeOS license.
//---------------------------------------------------------------------
/*!
\file disk_scanner.h
hook function declarations for disk_scanner module
*/
#ifndef _DISKSCANNER_H
#define _DISKSCANNER_H
#include <Drivers.h>
#include <module.h>
struct extended_partition_info;
struct partition_module_info;
struct session_info;
struct session_module_info;
#define DISK_SCANNER_MODULE_NAME "disk_scanner/disk_scanner/v1"
typedef status_t (*disk_scanner_get_session_module_hook)(int deviceFD,
off_t deviceSize, int32 blockSize,
struct session_module_info **sessionModule);
typedef status_t (*disk_scanner_get_partition_module_hook)(int deviceFD,
const struct session_info *sessionInfo,
struct partition_module_info **partitionModule);
typedef status_t (*disk_scanner_get_nth_session_info_hook)(int deviceFD,
int32 index, struct session_info *sessionInfo,
struct session_module_info **sessionModule);
typedef status_t (*disk_scanner_get_nth_partition_info_hook)(int deviceFD,
const struct session_info *sessionInfo, int32 partitionIndex,
struct extended_partition_info *partitionInfo, char *partitionMapName,
struct partition_module_info **partitionModule);
typedef status_t (*disk_scanner_get_partition_fs_info_hook)(int deviceFD,
struct extended_partition_info *partitionInfo);
typedef status_t (*disk_scanner_get_partitioning_params_hook)(int deviceFD,
const struct session_info *sessionInfo, const char *identifier,
char *buffer, size_t bufferSize, size_t *actualSize);
typedef status_t (*disk_scanner_partition_hook)(int deviceFD,
const struct session_info *sessionInfo, const char *identifier,
const char *parameters);
typedef struct disk_scanner_module_info {
module_info module;
disk_scanner_get_session_module_hook get_session_module;
disk_scanner_get_partition_module_hook get_partition_module;
disk_scanner_get_nth_session_info_hook get_nth_session_info;
disk_scanner_get_nth_partition_info_hook get_nth_partition_info;
disk_scanner_get_partition_fs_info_hook get_partition_fs_info;
disk_scanner_get_partitioning_params_hook get_partitioning_params;
disk_scanner_partition_hook partition;
} disk_scanner_module_info;
/*
get_session_module:
------------------
Searches for a module that can deal with the sessions on the specified
device and returns a module_info for it. put_module() must be called, when
done with the module.
params:
deviceFD: a device FD
deviceSize: size of the device in bytes
blockSize: the logical block size
sessionModule: buffer the pointer to the found module_info shall be
written into
Returns B_OK, if a module could be found, B_ENTRY_NOT_FOUND, if no
module was suitable for the job.
get_partition_module:
--------------------
Searches for a module that can deal with the partitions on the specified
session and returns a module_info for it. put_module() must be called, when
done with the module.
params:
deviceFD: a device FD
sessionInfo: a complete info about the session the partition resides on
partitionModule: buffer the pointer to the found module_info shall be
written into
Returns B_OK, if a module could be found, B_ENTRY_NOT_FOUND, if no
module was suitable for the job.
get_nth_session_info():
----------------------
Fills in all fields of sessionInfo with information about
the indexth session on the specified device.
params:
deviceFD: a device FD
index: the session index
sessionInfo: the session info
sessionModule: pointer to session_module_info*
The function first checks, whether the device is one that usually has
sessions (a CD). If so, it tries to find a suitable module and delegates
the work to that module. Otherwise, it is assumed, that the device does
not have sessions and for index == 0 the info is filled out with data
for a "virtual" session, i.e. one that spans the whole device.
If sessionModule is NULL, it is ignored. Otherwise, if it points to a
NULL pointer, then a pointer to the module that has been recognized to
handle the session layout is returned therein (NULL in case of a
a device other than a CD). If it points to a non-NULL pointer, the
referred to session module is used get the session info. The caller is
responsible to put_module() the module returned in sessionModule.
To sum it up, the feature can be used to avoid recognizing and
re- and unloading the respective module when iterating through the
sessions of a device -- before the first call *sessionModule is to be
initialized to NULL, after the last call, put_module() has to be invoked,
if *sessionModule is not NULL.
Returns B_OK, if successful, B_ENTRY_NOT_FOUND, if no suitable session
module could be found or if the session index is out of range.
get_nth_partition_info():
------------------------
Fills in the following fields of partitionInfo with information about
the indexth partition on the specified session:
* offset
* size
* logical_block_size
* session
* partition
* flags
* partition_name
* partition_type
params:
deviceFD: a device FD
sessionInfo: a complete info about the session the partition resides on
partitionIndex: partition index
partitionInfo: the partition info to be filled in
partitionMapName: Pointer to a pre-allocated char buffer of minimal
size B_FILE_NAME_LENGTH, into which the short name of
the partitioning system shall be written. The result is
the empty string (""), if no partitioning system is used
(e.g. for floppies). May be NULL.
partitionModule: pointer to partition_module_info*
The function first tries to find a suitable partition module and to
delagate the work to that module. If no module could be found, for
partition index == 0 the info is filled out with data for a "virtual"
partition, i.e. one that spans the whole session.
If partitionModule is NULL, it is ignored. Otherwise, if it points to a
NULL pointer, then a pointer to the module that has been recognized to
handle the partition layout is returned therein (NULL in case none
could be found). If it points to a non-NULL pointer, the referred to
partition module is used get the partition info. The caller is
responsible to put_module() the module returned in partitionModule.
To sum it up, the feature can be used to avoid recognizing and
re- and unloading the respective module when iterating through the
partitions of a session -- before the first call *partitionModule is to
be initialized to NULL, after the last call, put_module() has to be
invoked, if *partitionModule is not NULL.
Returns B_OK, if successful, B_ENTRY_NOT_FOUND, if the index is out of
range.
get_partition_fs_info():
-----------------------
Expects partitionInfo to be partially initialized and, if a module could
be found, that recognizes the FS on the partition, fills in
the fields:
* file_system_short_name
* file_system_long_name
* volume_name
The minimally required fields are:
* offset
* size
* logical_block_size
params:
deviceFD: a device FD
partitionInfo: the partition info
Returns B_OK, if successful (i.e. the FS was recognized),
B_ENTRY_NOT_FOUND, if no suitable module could be found.
get_partitioning_params():
-------------------------
Returns parameters for partitioning the supplied session.
If the session is already partitioned using the specified module, then
the parameters describing the current layout will be returned, otherwise
default values.
If the supplied buffer is too small for the parameters, the function
returns B_OK, but doesn't fill in the buffer; the required buffer
size is returned in actualSize. If the buffer is large enough,
actualSize is set to the actually used size. The size includes the
terminating null.
params:
deviceFD: a device FD
sessionInfo: a complete info about the session to be partitioned
identifier: identifies the partition module to be used
buffer: pointer to a pre-allocated buffer of size bufferSize
bufferSize: the size of buffer
actualSize: pointer to a pre-allocated size_t to be set to the
actually needed buffer size
Returns B_OK, if the parameters could be returned successfully or the
buffer is too small, an error code otherwise.
partition():
-----------
Partitions the specified session of the device using the partition module
identified by an identifier and according to the supplied parameters.
deviceFD: a device FD
sessionInfo: a complete info about the session the partitions reside on
identifier: identifies the partition module to be used
parameters: the parameters for partitioning
Returns B_OK, if everything went fine, an error code otherwise.
*/
#endif // _DISKSCANNER_H