src/build/libhaikucompat/syscalls.cpp

   1
   2 #include <stdarg.h>
   3 #include <stdio.h>
   4
   5 #include <syscalls.h>
   6
   7
   8 // #prama mark - iterating, retrieving device/partition data
   9 partition_id
  10 _kern_get_next_disk_device_id(int32 *cookie, size_t *neededSize)
  11 {
  12         return -1;
  13 }
  14
  15
  16 partition_id
  17 _kern_find_disk_device(const char *filename, size_t *neededSize)
  18 {
  19         return -1;
  20 }
  21
  22
  23 partition_id
  24 _kern_find_partition(const char *filename, size_t *neededSize)
  25 {
  26         return -1;
  27 }
  28
  29
  30 status_t
  31 _kern_get_disk_device_data(partition_id deviceID, bool deviceOnly,
  32         bool shadow, struct user_disk_device_data *buffer, size_t bufferSize,
  33         size_t *neededSize)
  34 {
  35         return B_ERROR;
  36 }
  37
  38
  39 partition_id
  40 _kern_register_file_device(const char *filename)
  41 {
  42         return -1;
  43 }
  44
  45
  46 status_t
  47 _kern_unregister_file_device(partition_id deviceID, const char *filename)
  48 {
  49         return B_ERROR;
  50 }
  51
  52 // #pragma mark - disk systems
  53
  54 status_t
  55 _kern_get_disk_system_info(disk_system_id id,
  56         struct user_disk_system_info *info)
  57 {
  58         return B_ERROR;
  59 }
  60
  61
  62 status_t
  63 _kern_get_next_disk_system_info(int32 *cookie,
  64         struct user_disk_system_info *info)
  65 {
  66         return B_ERROR;
  67 }
  68
  69
  70 status_t
  71 _kern_find_disk_system(const char *name,
  72         struct user_disk_system_info *info)
  73 {
  74         return B_ERROR;
  75 }
  76
  77
  78 bool
  79 _kern_supports_defragmenting_partition(partition_id partitionID,
  80         int32 changeCounter, bool *whileMounted)
  81 {
  82         return false;
  83 }
  84
  85
  86 bool
  87 _kern_supports_repairing_partition(partition_id partitionID,
  88         int32 changeCounter, bool checkOnly, bool *whileMounted)
  89 {
  90         return false;
  91 }
  92
  93
  94 bool
  95 _kern_supports_resizing_partition(partition_id partitionID,
  96         int32 changeCounter, bool *canResizeContents, bool *whileMounted)
  97 {
  98         return false;
  99 }
 100
 101
 102 bool
 103 _kern_supports_moving_partition(partition_id partitionID,
 104         int32 changeCounter, partition_id *unmovable,
 105         partition_id *needUnmounting, size_t bufferSize)
 106 {
 107         return false;
 108 }
 109
 110
 111 bool
 112 _kern_supports_setting_partition_name(partition_id partitionID,
 113         int32 changeCounter)
 114 {
 115         return false;
 116 }
 117
 118
 119 bool
 120 _kern_supports_setting_partition_content_name(partition_id partitionID,
 121         int32 changeCounter, bool *whileMounted)
 122 {
 123         return false;
 124 }
 125
 126
 127 bool
 128 _kern_supports_setting_partition_type(partition_id partitionID,
 129         int32 changeCounter)
 130 {
 131         return false;
 132 }
 133
 134
 135 bool
 136 _kern_supports_setting_partition_parameters(partition_id partitionID,
 137         int32 changeCounter)
 138 {
 139         return false;
 140 }
 141
 142
 143 bool
 144 _kern_supports_setting_partition_content_parameters(
 145         partition_id partitionID, int32 changeCounter, bool *whileMounted)
 146 {
 147         return false;
 148 }
 149
 150
 151 bool
 152 _kern_supports_initializing_partition(partition_id partitionID,
 153         int32 changeCounter, const char *diskSystemName)
 154 {
 155         return false;
 156 }
 157
 158
 159 bool
 160 _kern_supports_creating_child_partition(partition_id partitionID,
 161         int32 changeCounter)
 162 {
 163         return false;
 164 }
 165
 166
 167 bool
 168 _kern_supports_deleting_child_partition(partition_id partitionID,
 169         int32 changeCounter)
 170 {
 171         return false;
 172 }
 173
 174
 175 bool
 176 _kern_is_sub_disk_system_for(disk_system_id diskSystemID,
 177         partition_id partitionID, int32 changeCounter)
 178
 179 {
 180         return false;
 181 }
 182
 183
 184 status_t
 185 _kern_validate_resize_partition(partition_id partitionID, int32 changeCounter,
 186         off_t *size)
 187 {
 188         return B_ERROR;
 189 }
 190
 191
 192 status_t
 193 _kern_validate_move_partition(partition_id partitionID, int32 changeCounter,
 194         off_t *newOffset)
 195 {
 196         return B_ERROR;
 197 }
 198
 199
 200 status_t
 201 _kern_validate_set_partition_name(partition_id partitionID, int32 changeCounter,
 202         char *name)
 203 {
 204         return B_ERROR;
 205 }
 206
 207
 208 status_t
 209 _kern_validate_set_partition_content_name(partition_id partitionID,
 210         int32 changeCounter, char *name)
 211 {
 212         return B_ERROR;
 213 }
 214
 215
 216 status_t
 217 _kern_validate_set_partition_type(partition_id partitionID, int32 changeCounter,
 218         const char *type)
 219 {
 220         return B_ERROR;
 221 }
 222
 223
 224 status_t
 225 _kern_validate_initialize_partition(partition_id partitionID,
 226         int32 changeCounter, const char *diskSystemName, char *name,
 227         const char *parameters, size_t parametersSize)
 228 {
 229         return B_ERROR;
 230 }
 231
 232
 233 status_t
 234 _kern_validate_create_child_partition(partition_id partitionID,
 235         int32 changeCounter, off_t *offset, off_t *size, const char *type,
 236         const char *parameters, size_t parametersSize)
 237 {
 238         return B_ERROR;
 239 }
 240
 241
 242 status_t
 243 _kern_get_partitionable_spaces(partition_id partitionID, int32 changeCounter,
 244         struct partitionable_space_data *buffer, int32 count, int32 *actualCount)
 245 {
 246         return B_ERROR;
 247 }
 248
 249
 250 status_t
 251 _kern_get_next_supported_partition_type(partition_id partitionID,
 252         int32 changeCounter, int32 *cookie, char *type)
 253 {
 254         return B_ERROR;
 255 }
 256
 257
 258 status_t
 259 _kern_get_partition_type_for_content_type(disk_system_id diskSystemID,
 260         const char *contentType, char *type)
 261 {
 262         return B_ERROR;
 263 }
 264
 265 // #pragma mark - disk device modification
 266
 267 status_t
 268 _kern_prepare_disk_device_modifications(partition_id deviceID)
 269 {
 270         return B_ERROR;
 271 }
 272
 273
 274 status_t
 275 _kern_commit_disk_device_modifications(partition_id deviceID,
 276         port_id port, int32 token, bool completeProgress)
 277 {
 278         return B_ERROR;
 279 }
 280
 281
 282 status_t
 283 _kern_cancel_disk_device_modifications(partition_id deviceID)
 284 {
 285         return B_ERROR;
 286 }
 287
 288
 289 bool
 290 _kern_is_disk_device_modified(partition_id deviceID)
 291 {
 292         return false;
 293 }
 294
 295
 296 status_t
 297 _kern_defragment_partition(partition_id partitionID, int32 changeCounter)
 298 {
 299         return B_ERROR;
 300 }
 301
 302
 303 status_t
 304 _kern_repair_partition(partition_id partitionID, int32 changeCounter,
 305         bool checkOnly)
 306 {
 307         return B_ERROR;
 308 }
 309
 310
 311 status_t
 312 _kern_resize_partition(partition_id partitionID, int32 changeCounter,
 313         off_t size)
 314 {
 315         return B_ERROR;
 316 }
 317
 318
 319 status_t
 320 _kern_move_partition(partition_id partitionID, int32 changeCounter,
 321         off_t newOffset)
 322 {
 323         return B_ERROR;
 324 }
 325
 326
 327 status_t
 328 _kern_set_partition_name(partition_id partitionID, int32 changeCounter,
 329         const char *name)
 330 {
 331         return B_ERROR;
 332 }
 333
 334
 335 status_t
 336 _kern_set_partition_content_name(partition_id partitionID,
 337         int32 changeCounter, const char *name)
 338 {
 339         return B_ERROR;
 340 }
 341
 342
 343 status_t
 344 _kern_set_partition_type(partition_id partitionID, int32 changeCounter,
 345         const char *type)
 346 {
 347         return B_ERROR;
 348 }
 349
 350
 351 status_t
 352 _kern_set_partition_parameters(partition_id partitionID, int32 changeCounter,
 353         const char *parameters, size_t parametersSize)
 354 {
 355         return B_ERROR;
 356 }
 357
 358
 359 status_t
 360 _kern_set_partition_content_parameters(partition_id partitionID,
 361         int32 changeCounter, const char *parameters, size_t parametersSize)
 362 {
 363         return B_ERROR;
 364 }
 365
 366
 367 status_t
 368 _kern_initialize_partition(partition_id partitionID, int32 changeCounter,
 369         const char *diskSystemName, const char *name, const char *parameters,
 370         size_t parametersSize)
 371 {
 372         return B_ERROR;
 373 }
 374
 375
 376 status_t
 377 _kern_uninitialize_partition(partition_id partitionID, int32 changeCounter,
 378         partition_id parentID, int32 parentChangeCounter)
 379 {
 380         return B_ERROR;
 381 }
 382
 383
 384 status_t
 385 _kern_create_child_partition(partition_id partitionID, int32 changeCounter,
 386         off_t offset, off_t size, const char *type, const char *parameters,
 387         size_t parametersSize, partition_id *childID)
 388 {
 389         return B_ERROR;
 390 }
 391
 392
 393 status_t
 394 _kern_delete_partition(partition_id partitionID, int32 changeCounter)
 395 {
 396         return B_ERROR;
 397 }
 398
 399
 400 status_t
 401 _kern_delete_child_partition(partition_id partitionID, int32* changeCounter,
 402         partition_id childID, int32 childChangeCounter)
 403 {
 404         return B_ERROR;
 405 }
 406
 407
 408 // #pragma mark - jobs
 409
 410
 411 status_t
 412 _kern_get_next_disk_device_job_info(int32 *cookie,
 413         struct user_disk_device_job_info *info)
 414 {
 415         return B_ERROR;
 416 }
 417
 418
 419 status_t
 420 _kern_get_disk_device_job_info(disk_job_id id,
 421         struct user_disk_device_job_info *info)
 422 {
 423         return B_ERROR;
 424 }
 425
 426
 427 status_t
 428 _kern_get_disk_device_job_progress_info(disk_job_id id,
 429         struct disk_device_job_progress_info *info)
 430 {
 431         return B_ERROR;
 432 }
 433
 434
 435 status_t
 436 _kern_pause_disk_device_job(disk_job_id id)
 437 {
 438         return B_ERROR;
 439 }
 440
 441
 442 status_t
 443 _kern_cancel_disk_device_job(disk_job_id id, bool reverse)
 444 {
 445         return B_ERROR;
 446 }
 447
 448 // #pragma mark - other syscalls
 449
 450 status_t
 451 _kern_get_safemode_option(const char *parameter, char *buffer,
 452         size_t *_bufferSize)
 453 {
 454         return B_ERROR;
 455 }