From b8ba8f58d7c5424d1726c310aac3d805b7f7cc53 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Wed, 28 Mar 2007 15:20:08 +0000 Subject: [PATCH] Added the disk device API to the libbe_haiku.so, so that libtracker.so builds again for target libbe_test. Added respective syscall stubs and other functions to libhaikucompat.a. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20447 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- build/jam/BuildSetup | 3 +- headers/build/os/storage/DiskDeviceDefs.h | 156 ++++++++ headers/build/private/kernel/syscalls.h | 25 +- src/build/libhaikucompat/Jamfile | 5 + src/build/libhaikucompat/misc.cpp | 30 ++ src/build/libhaikucompat/syscalls.cpp | 436 ++++++++++++++++++++++ src/kits/Jamfile | 1 - src/kits/storage/Jamfile | 8 +- src/kits/tracker/AutoMounter.cpp | 1 + 9 files changed, 646 insertions(+), 19 deletions(-) create mode 100644 headers/build/os/storage/DiskDeviceDefs.h create mode 100644 src/build/libhaikucompat/misc.cpp create mode 100644 src/build/libhaikucompat/syscalls.cpp diff --git a/build/jam/BuildSetup b/build/jam/BuildSetup index a12d4d7e3c..79d2923808 100644 --- a/build/jam/BuildSetup +++ b/build/jam/BuildSetup @@ -639,7 +639,8 @@ if $(TARGET_PLATFORM) != haiku && $(TARGET_PLATFORM_BEOS_COMPATIBLE) { if $(TARGET_PLATFORM) = libbe_test { # headers and flags - TARGET_HDRS += [ PublicHeaders app game interface storage support ] + TARGET_HDRS += + [ PublicHeaders app drivers game interface kernel storage support ] [ PrivateHeaders $(DOT) ] ; TARGET_DEFINES += __HAIKU__ ; diff --git a/headers/build/os/storage/DiskDeviceDefs.h b/headers/build/os/storage/DiskDeviceDefs.h new file mode 100644 index 0000000000..f099488e00 --- /dev/null +++ b/headers/build/os/storage/DiskDeviceDefs.h @@ -0,0 +1,156 @@ +/* + * Copyright 2003-2006, Haiku, Inc. All Rights Reserved. + * Distributed under the terms of the MIT License. + */ +#ifndef _DISK_DEVICE_DEFS_H +#define _DISK_DEVICE_DEFS_H + + +#include + + +typedef int32 partition_id; +typedef int32 disk_system_id; +typedef int32 disk_job_id; + +// partition flags +enum { + B_PARTITION_IS_DEVICE = 0x01, + B_PARTITION_FILE_SYSTEM = 0x02, + B_PARTITION_PARTITIONING_SYSTEM = 0x04, + B_PARTITION_READ_ONLY = 0x08, + B_PARTITION_MOUNTED = 0x10, // needed? + B_PARTITION_BUSY = 0x20, + B_PARTITION_DESCENDANT_BUSY = 0x40, +}; + +// partition statuses +enum { + B_PARTITION_VALID, + B_PARTITION_CORRUPT, + B_PARTITION_UNRECOGNIZED, + B_PARTITION_UNINITIALIZED, // Only when uninitialized manually. + // When not recognized while scanning it's + // B_PARTITION_UNRECOGNIZED. +}; + +// partition change flags +enum { + B_PARTITION_CHANGED_OFFSET = 0x000001, + B_PARTITION_CHANGED_SIZE = 0x000002, + B_PARTITION_CHANGED_CONTENT_SIZE = 0x000004, + B_PARTITION_CHANGED_BLOCK_SIZE = 0x000008, + B_PARTITION_CHANGED_STATUS = 0x000010, + B_PARTITION_CHANGED_FLAGS = 0x000020, + B_PARTITION_CHANGED_VOLUME = 0x000040, + B_PARTITION_CHANGED_NAME = 0x000080, + B_PARTITION_CHANGED_CONTENT_NAME = 0x000100, + B_PARTITION_CHANGED_TYPE = 0x000200, + B_PARTITION_CHANGED_CONTENT_TYPE = 0x000400, + B_PARTITION_CHANGED_PARAMETERS = 0x000800, + B_PARTITION_CHANGED_CONTENT_PARAMETERS = 0x001000, + B_PARTITION_CHANGED_CHILDREN = 0x002000, + B_PARTITION_CHANGED_DESCENDANTS = 0x004000, + B_PARTITION_CHANGED_DEFRAGMENTATION = 0x008000, + B_PARTITION_CHANGED_CHECK = 0x010000, + B_PARTITION_CHANGED_REPAIR = 0x020000, + B_PARTITION_CHANGED_INITIALIZATION = 0x040000, +}; + +// disk device flags +enum { + B_DISK_DEVICE_REMOVABLE = 0x01, + B_DISK_DEVICE_HAS_MEDIA = 0x02, + B_DISK_DEVICE_READ_ONLY = 0x04, + B_DISK_DEVICE_WRITE_ONCE = 0x08, +}; + +// disk system flags +enum { + B_DISK_SYSTEM_IS_FILE_SYSTEM = 0x0001, + + // flags common for both file and partitioning systems + B_DISK_SYSTEM_SUPPORTS_CHECKING = 0x0002, + B_DISK_SYSTEM_SUPPORTS_REPAIRING = 0x0004, + B_DISK_SYSTEM_SUPPORTS_RESIZING = 0x0008, + B_DISK_SYSTEM_SUPPORTS_MOVING = 0x0010, + B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_NAME = 0x0020, + B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_PARAMETERS = 0x0040, + + // file system specific flags + B_DISK_SYSTEM_SUPPORTS_DEFRAGMENTING = 0x0100, + B_DISK_SYSTEM_SUPPORTS_DEFRAGMENTING_WHILE_MOUNTED = 0x0200, + B_DISK_SYSTEM_SUPPORTS_CHECKING_WHILE_MOUNTED = 0x0400, + B_DISK_SYSTEM_SUPPORTS_REPAIRING_WHILE_MOUNTED = 0x0800, + B_DISK_SYSTEM_SUPPORTS_RESIZING_WHILE_MOUNTED = 0x1000, + B_DISK_SYSTEM_SUPPORTS_MOVING_WHILE_MOUNTED = 0x2000, + B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_NAME_WHILE_MOUNTED = 0x4000, + B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_PARAMETERS_WHILE_MOUNTED = 0x8000, + + // partitioning system specific flags + B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD = 0x0100, + B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD = 0x0200, + B_DISK_SYSTEM_SUPPORTS_SETTING_NAME = 0x0400, + B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE = 0x0800, + B_DISK_SYSTEM_SUPPORTS_SETTING_PARAMETERS = 0x1000, + B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD = 0x2000, + B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD = 0x4000, + B_DISK_SYSTEM_SUPPORTS_INITIALIZING = 0x8000, +}; + +// disk device job types +enum { + B_DISK_DEVICE_JOB_BAD_TYPE, + B_DISK_DEVICE_JOB_DEFRAGMENT, + B_DISK_DEVICE_JOB_REPAIR, + B_DISK_DEVICE_JOB_RESIZE, + B_DISK_DEVICE_JOB_MOVE, + B_DISK_DEVICE_JOB_SET_NAME, + B_DISK_DEVICE_JOB_SET_CONTENT_NAME, + B_DISK_DEVICE_JOB_SET_TYPE, + B_DISK_DEVICE_JOB_SET_PARMETERS, + B_DISK_DEVICE_JOB_SET_CONTENT_PARMETERS, + B_DISK_DEVICE_JOB_INITIALIZE, + B_DISK_DEVICE_JOB_UNINITIALIZE, + B_DISK_DEVICE_JOB_CREATE, + B_DISK_DEVICE_JOB_DELETE, + B_DISK_DEVICE_JOB_SCAN, +}; + +// disk device job statuses +enum { + B_DISK_DEVICE_JOB_UNINITIALIZED, + B_DISK_DEVICE_JOB_SCHEDULED, + B_DISK_DEVICE_JOB_IN_PROGRESS, + B_DISK_DEVICE_JOB_SUCCEEDED, + B_DISK_DEVICE_JOB_FAILED, + B_DISK_DEVICE_JOB_CANCELED, +}; + +// disk device job progress info +typedef struct disk_device_job_progress_info { + uint32 status; + uint32 interrupt_properties; + int32 task_count; + int32 completed_tasks; + float current_task_progress; + char current_task_description[256]; +} disk_device_job_progress_info; + +// disk device job interrupt properties +enum { + B_DISK_DEVICE_JOB_CAN_CANCEL = 0x01, + B_DISK_DEVICE_JOB_STOP_ON_CANCEL = 0x02, + B_DISK_DEVICE_JOB_REVERSE_ON_CANCEL = 0x04, + B_DISK_DEVICE_JOB_CAN_PAUSE = 0x08, +}; + +// string length constants, all of which include the NULL terminator +#define B_DISK_DEVICE_TYPE_LENGTH B_FILE_NAME_LENGTH +#define B_DISK_DEVICE_NAME_LENGTH B_FILE_NAME_LENGTH +#define B_DISK_SYSTEM_NAME_LENGTH B_PATH_NAME_LENGTH + +// max size of parameter string buffers, including NULL terminator +#define B_DISK_DEVICE_MAX_PARAMETER_SIZE (32 * 1024) + +#endif // _DISK_DEVICE_DEFS_H diff --git a/headers/build/private/kernel/syscalls.h b/headers/build/private/kernel/syscalls.h index 7e68ae1f8b..7e2514630b 100644 --- a/headers/build/private/kernel/syscalls.h +++ b/headers/build/private/kernel/syscalls.h @@ -9,6 +9,7 @@ #include #include //#include +#include //#include #include @@ -290,13 +291,13 @@ extern status_t _kern_unlock_node(int fd); /* Disk Device Manager syscalls */ -/* + // iterating, retrieving device/partition data extern partition_id _kern_get_next_disk_device_id(int32 *cookie, size_t *neededSize); extern partition_id _kern_find_disk_device(const char *filename, size_t *neededSize); extern partition_id _kern_find_partition(const char *filename, size_t *neededSize); extern status_t _kern_get_disk_device_data(partition_id deviceID, bool deviceOnly, - bool shadow, user_disk_device_data *buffer, + bool shadow, struct user_disk_device_data *buffer, size_t bufferSize, size_t *neededSize); extern partition_id _kern_register_file_device(const char *filename); extern status_t _kern_unregister_file_device(partition_id deviceID, @@ -306,10 +307,11 @@ extern status_t _kern_unregister_file_device(partition_id deviceID, // disk systems extern status_t _kern_get_disk_system_info(disk_system_id id, - user_disk_system_info *info); + struct user_disk_system_info *info); extern status_t _kern_get_next_disk_system_info(int32 *cookie, - user_disk_system_info *info); -extern status_t _kern_find_disk_system(const char *name, user_disk_system_info *info); + struct user_disk_system_info *info); +extern status_t _kern_find_disk_system(const char *name, + struct user_disk_system_info *info); extern bool _kern_supports_defragmenting_partition(partition_id partitionID, int32 changeCounter, bool *whileMounted); extern bool _kern_supports_repairing_partition(partition_id partitionID, @@ -356,8 +358,9 @@ extern status_t _kern_validate_create_child_partition(partition_id partitionID, const char *type, const char *parameters, size_t parametersSize); extern status_t _kern_get_partitionable_spaces(partition_id partitionID, - int32 changeCounter, partitionable_space_data *buffer, - int32 count, int32 *actualCount); + int32 changeCounter, + struct partitionable_space_data *buffer, int32 count, + int32 *actualCount); extern status_t _kern_get_next_supported_partition_type(partition_id partitionID, int32 changeCounter, int32 *cookie, char *type); extern status_t _kern_get_partition_type_for_content_type(disk_system_id diskSystemID, @@ -403,13 +406,13 @@ extern status_t _kern_delete_partition(partition_id partitionID, int32 changeCo // jobs extern status_t _kern_get_next_disk_device_job_info(int32 *cookie, - user_disk_device_job_info *info); + struct user_disk_device_job_info *info); extern status_t _kern_get_disk_device_job_info(disk_job_id id, - user_disk_device_job_info *info); + struct user_disk_device_job_info *info); extern status_t _kern_get_disk_device_job_progress_info(disk_job_id id, - disk_device_job_progress_info *info); + struct disk_device_job_progress_info *info); extern status_t _kern_pause_disk_device_job(disk_job_id id); -extern status_t _kern_cancel_disk_device_job(disk_job_id id, bool reverse);*/ +extern status_t _kern_cancel_disk_device_job(disk_job_id id, bool reverse); #if 0 diff --git a/src/build/libhaikucompat/Jamfile b/src/build/libhaikucompat/Jamfile index aca5045b18..f90a091963 100644 --- a/src/build/libhaikucompat/Jamfile +++ b/src/build/libhaikucompat/Jamfile @@ -2,11 +2,16 @@ SubDir HAIKU_TOP src build libhaikucompat ; SetSubDirSupportedPlatforms libbe_test r5 dano bone ; +UseHeaders [ FDirName $(HAIKU_TOP) headers build private kernel ] : true ; + StaticLibrary libhaikucompat.a : strcasestr.c strlcat.c strlcpy.c strnlen.c + + misc.cpp + syscalls.cpp ; SEARCH on [ FGristFiles strcasestr.c strlcat.c strlcpy.c strnlen.c ] diff --git a/src/build/libhaikucompat/misc.cpp b/src/build/libhaikucompat/misc.cpp new file mode 100644 index 0000000000..92f5f2a22b --- /dev/null +++ b/src/build/libhaikucompat/misc.cpp @@ -0,0 +1,30 @@ + +#include +#include + +#include + +extern "C" void +debug_printf(const char *format, ...) +{ + va_list list; + + va_start(list, format); + vprintf(format, list); + va_end(list); +} + + +dev_t +fs_mount_volume(const char *where, const char *device, const char *filesystem, + uint32 flags, const char *parameters) +{ + return B_ERROR; +} + + +status_t +fs_unmount_volume(const char *path, uint32 flags) +{ + return B_ERROR; +} diff --git a/src/build/libhaikucompat/syscalls.cpp b/src/build/libhaikucompat/syscalls.cpp new file mode 100644 index 0000000000..5641e8f0f6 --- /dev/null +++ b/src/build/libhaikucompat/syscalls.cpp @@ -0,0 +1,436 @@ + +#include +#include + +#include + + +// #prama mark - iterating, retrieving device/partition data +partition_id +_kern_get_next_disk_device_id(int32 *cookie, size_t *neededSize) +{ + return -1; +} + + +partition_id +_kern_find_disk_device(const char *filename, size_t *neededSize) +{ + return -1; +} + + +partition_id +_kern_find_partition(const char *filename, size_t *neededSize) +{ + return -1; +} + + +status_t +_kern_get_disk_device_data(partition_id deviceID, bool deviceOnly, + bool shadow, struct user_disk_device_data *buffer, size_t bufferSize, + size_t *neededSize) +{ + return B_ERROR; +} + + +partition_id +_kern_register_file_device(const char *filename) +{ + return -1; +} + + +status_t +_kern_unregister_file_device(partition_id deviceID, const char *filename) +{ + return B_ERROR; +} + +// #pragma mark - disk systems + +status_t +_kern_get_disk_system_info(disk_system_id id, + struct user_disk_system_info *info) +{ + return B_ERROR; +} + + +status_t +_kern_get_next_disk_system_info(int32 *cookie, + struct user_disk_system_info *info) +{ + return B_ERROR; +} + + +status_t +_kern_find_disk_system(const char *name, + struct user_disk_system_info *info) +{ + return B_ERROR; +} + + +bool +_kern_supports_defragmenting_partition(partition_id partitionID, + int32 changeCounter, bool *whileMounted) +{ + return false; +} + + +bool +_kern_supports_repairing_partition(partition_id partitionID, + int32 changeCounter, bool checkOnly, bool *whileMounted) +{ + return false; +} + + +bool +_kern_supports_resizing_partition(partition_id partitionID, + int32 changeCounter, bool *canResizeContents, bool *whileMounted) +{ + return false; +} + + +bool +_kern_supports_moving_partition(partition_id partitionID, + int32 changeCounter, partition_id *unmovable, + partition_id *needUnmounting, size_t bufferSize) +{ + return false; +} + + +bool +_kern_supports_setting_partition_name(partition_id partitionID, + int32 changeCounter) +{ + return false; +} + + +bool +_kern_supports_setting_partition_content_name(partition_id partitionID, + int32 changeCounter, bool *whileMounted) +{ + return false; +} + + +bool +_kern_supports_setting_partition_type(partition_id partitionID, + int32 changeCounter) +{ + return false; +} + + +bool +_kern_supports_setting_partition_parameters(partition_id partitionID, + int32 changeCounter) +{ + return false; +} + + +bool +_kern_supports_setting_partition_content_parameters( + partition_id partitionID, int32 changeCounter, bool *whileMounted) +{ + return false; +} + + +bool +_kern_supports_initializing_partition(partition_id partitionID, + int32 changeCounter, const char *diskSystemName) +{ + return false; +} + + +bool +_kern_supports_creating_child_partition(partition_id partitionID, + int32 changeCounter) +{ + return false; +} + + +bool +_kern_supports_deleting_child_partition(partition_id partitionID, + int32 changeCounter) +{ + return false; +} + + +bool +_kern_is_sub_disk_system_for(disk_system_id diskSystemID, + partition_id partitionID, int32 changeCounter) + +{ + return false; +} + + +status_t +_kern_validate_resize_partition(partition_id partitionID, int32 changeCounter, + off_t *size) +{ + return B_ERROR; +} + + +status_t +_kern_validate_move_partition(partition_id partitionID, int32 changeCounter, + off_t *newOffset) +{ + return B_ERROR; +} + + +status_t +_kern_validate_set_partition_name(partition_id partitionID, int32 changeCounter, + char *name) +{ + return B_ERROR; +} + + +status_t +_kern_validate_set_partition_content_name(partition_id partitionID, + int32 changeCounter, char *name) +{ + return B_ERROR; +} + + +status_t +_kern_validate_set_partition_type(partition_id partitionID, int32 changeCounter, + const char *type) +{ + return B_ERROR; +} + + +status_t +_kern_validate_initialize_partition(partition_id partitionID, + int32 changeCounter, const char *diskSystemName, char *name, + const char *parameters, size_t parametersSize) +{ + return B_ERROR; +} + + +status_t +_kern_validate_create_child_partition(partition_id partitionID, + int32 changeCounter, off_t *offset, off_t *size, const char *type, + const char *parameters, size_t parametersSize) +{ + return B_ERROR; +} + + +status_t +_kern_get_partitionable_spaces(partition_id partitionID, int32 changeCounter, + struct partitionable_space_data *buffer, int32 count, int32 *actualCount) +{ + return B_ERROR; +} + + +status_t +_kern_get_next_supported_partition_type(partition_id partitionID, + int32 changeCounter, int32 *cookie, char *type) +{ + return B_ERROR; +} + + +status_t +_kern_get_partition_type_for_content_type(disk_system_id diskSystemID, + const char *contentType, char *type) +{ + return B_ERROR; +} + +// #pragma mark - disk device modification + +status_t +_kern_prepare_disk_device_modifications(partition_id deviceID) +{ + return B_ERROR; +} + + +status_t +_kern_commit_disk_device_modifications(partition_id deviceID, + port_id port, int32 token, bool completeProgress) +{ + return B_ERROR; +} + + +status_t +_kern_cancel_disk_device_modifications(partition_id deviceID) +{ + return B_ERROR; +} + + +bool +_kern_is_disk_device_modified(partition_id deviceID) +{ + return false; +} + + +status_t +_kern_defragment_partition(partition_id partitionID, int32 changeCounter) +{ + return B_ERROR; +} + + +status_t +_kern_repair_partition(partition_id partitionID, int32 changeCounter, + bool checkOnly) +{ + return B_ERROR; +} + + +status_t +_kern_resize_partition(partition_id partitionID, int32 changeCounter, + off_t size) +{ + return B_ERROR; +} + + +status_t +_kern_move_partition(partition_id partitionID, int32 changeCounter, + off_t newOffset) +{ + return B_ERROR; +} + + +status_t +_kern_set_partition_name(partition_id partitionID, int32 changeCounter, + const char *name) +{ + return B_ERROR; +} + + +status_t +_kern_set_partition_content_name(partition_id partitionID, + int32 changeCounter, const char *name) +{ + return B_ERROR; +} + + +status_t +_kern_set_partition_type(partition_id partitionID, int32 changeCounter, + const char *type) +{ + return B_ERROR; +} + + +status_t +_kern_set_partition_parameters(partition_id partitionID, int32 changeCounter, + const char *parameters, size_t parametersSize) +{ + return B_ERROR; +} + + +status_t +_kern_set_partition_content_parameters(partition_id partitionID, + int32 changeCounter, const char *parameters, size_t parametersSize) +{ + return B_ERROR; +} + + +status_t +_kern_initialize_partition(partition_id partitionID, int32 changeCounter, + const char *diskSystemName, const char *name, const char *parameters, + size_t parametersSize) +{ + return B_ERROR; +} + + +status_t +_kern_uninitialize_partition(partition_id partitionID, int32 changeCounter) +{ + return B_ERROR; +} + + +status_t +_kern_create_child_partition(partition_id partitionID, int32 changeCounter, + off_t offset, off_t size, const char *type, const char *parameters, + size_t parametersSize, partition_id *childID) +{ + return B_ERROR; +} + + +status_t +_kern_delete_partition(partition_id partitionID, int32 changeCounter) +{ + return B_ERROR; +} + +// #pragma mark - jobs + +status_t +_kern_get_next_disk_device_job_info(int32 *cookie, + struct user_disk_device_job_info *info) +{ + return B_ERROR; +} + + +status_t +_kern_get_disk_device_job_info(disk_job_id id, + struct user_disk_device_job_info *info) +{ + return B_ERROR; +} + + +status_t +_kern_get_disk_device_job_progress_info(disk_job_id id, + struct disk_device_job_progress_info *info) +{ + return B_ERROR; +} + + +status_t +_kern_pause_disk_device_job(disk_job_id id) +{ + return B_ERROR; +} + + +status_t +_kern_cancel_disk_device_job(disk_job_id id, bool reverse) +{ + return B_ERROR; +} + diff --git a/src/kits/Jamfile b/src/kits/Jamfile index ffb0df60e8..a358532f7d 100644 --- a/src/kits/Jamfile +++ b/src/kits/Jamfile @@ -30,7 +30,6 @@ SharedLibrary libbe.so : app_kit.o interface_kit.o storage_kit.o - storage_diskdevice_kit.o support_kit.o libqoca.so diff --git a/src/kits/storage/Jamfile b/src/kits/storage/Jamfile index 379d632c93..935f8d6edc 100644 --- a/src/kits/storage/Jamfile +++ b/src/kits/storage/Jamfile @@ -67,13 +67,8 @@ MergeObject storage_kit.o : RPattern.cpp RPatternList.cpp Rule.cpp -; -# We need to keep the DiskDevice API out of libbe_haiku as long as the -# Interface Kit is not fully functional (at least the part we are using). -# So, we build it separately. - -MergeObject storage_diskdevice_kit.o : + # disk device API DiskDevice.cpp DiskDeviceJob.cpp DiskDeviceList.cpp @@ -86,6 +81,7 @@ MergeObject storage_diskdevice_kit.o : PartitioningInfo.cpp ; + # The adapter library we need (Storage Kit). # diff --git a/src/kits/tracker/AutoMounter.cpp b/src/kits/tracker/AutoMounter.cpp index c1a65eb9dd..243536103e 100644 --- a/src/kits/tracker/AutoMounter.cpp +++ b/src/kits/tracker/AutoMounter.cpp @@ -57,6 +57,7 @@ All rights reserved. #include #include +#include static const char *kAutoMounterSettings = "automounter_settings";