241 lines
8.6 KiB
C
241 lines
8.6 KiB
C
//----------------------------------------------------------------------
|
|
// 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
|