Changeset 15f3c3f in mainline for uspace/srv/fs/locfs/locfs_ops.c
- Timestamp:
- 2011-06-22T22:00:52Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 86ffa27f
- Parents:
- ef09a7a
- File:
-
- 1 moved
-
uspace/srv/fs/locfs/locfs_ops.c (moved) (moved from uspace/srv/fs/devfs/devfs_ops.c ) (41 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/fs/locfs/locfs_ops.c
ref09a7a r15f3c3f 32 32 33 33 /** 34 * @file devfs_ops.c35 * @brief Implementation of VFS operations for the devfs file system server.34 * @file locfs_ops.c 35 * @brief Implementation of VFS operations for the locfs file system server. 36 36 */ 37 37 … … 44 44 #include <fibril_synch.h> 45 45 #include <adt/hash_table.h> 46 #include <ipc/ devmap.h>46 #include <ipc/loc.h> 47 47 #include <sys/stat.h> 48 48 #include <libfs.h> 49 49 #include <assert.h> 50 #include " devfs.h"51 #include " devfs_ops.h"50 #include "locfs.h" 51 #include "locfs_ops.h" 52 52 53 53 typedef struct { 54 devmap_handle_type_t type;55 devmap_handle_t handle;56 } devfs_node_t;57 58 /** Opened devices structure */54 loc_object_type_t type; 55 service_id_t service_id; 56 } locfs_node_t; 57 58 /** Opened services structure */ 59 59 typedef struct { 60 devmap_handle_t handle;60 service_id_t service_id; 61 61 async_sess_t *sess; /**< If NULL, the structure is incomplete. */ 62 62 size_t refcount; 63 63 link_t link; 64 64 fibril_condvar_t cv; /**< Broadcast when completed. */ 65 } device_t;66 67 /** Hash table of opened devices */68 static hash_table_t devices;65 } service_t; 66 67 /** Hash table of opened services */ 68 static hash_table_t services; 69 69 70 70 /** Hash table mutex */ 71 static FIBRIL_MUTEX_INITIALIZE( devices_mutex);72 73 #define DEVICES_KEYS 174 #define DEVICES_KEY_HANDLE 075 #define DEVICES_BUCKETS 25671 static FIBRIL_MUTEX_INITIALIZE(services_mutex); 72 73 #define SERVICES_KEYS 1 74 #define SERVICES_KEY_HANDLE 0 75 #define SERVICES_BUCKETS 256 76 76 77 77 /* Implementation of hash table interface for the nodes hash table. */ 78 static hash_index_t devices_hash(unsigned long key[])79 { 80 return key[ DEVICES_KEY_HANDLE] % DEVICES_BUCKETS;81 } 82 83 static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item)84 { 85 device_t *dev = hash_table_get_instance(item, device_t, link);86 return (dev-> handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]);87 } 88 89 static void devices_remove_callback(link_t *item)90 { 91 free(hash_table_get_instance(item, device_t, link));92 } 93 94 static hash_table_operations_t devices_ops = {95 .hash = devices_hash,96 .compare = devices_compare,97 .remove_callback = devices_remove_callback78 static hash_index_t services_hash(unsigned long key[]) 79 { 80 return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS; 81 } 82 83 static int services_compare(unsigned long key[], hash_count_t keys, link_t *item) 84 { 85 service_t *dev = hash_table_get_instance(item, service_t, link); 86 return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]); 87 } 88 89 static void services_remove_callback(link_t *item) 90 { 91 free(hash_table_get_instance(item, service_t, link)); 92 } 93 94 static hash_table_operations_t services_ops = { 95 .hash = services_hash, 96 .compare = services_compare, 97 .remove_callback = services_remove_callback 98 98 }; 99 99 100 static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,101 devmap_handle_t handle)102 { 103 devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));100 static int locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type, 101 service_id_t service_id) 102 { 103 locfs_node_t *node = (locfs_node_t *) malloc(sizeof(locfs_node_t)); 104 104 if (node == NULL) { 105 105 *rfn = NULL; … … 116 116 fs_node_initialize(*rfn); 117 117 node->type = type; 118 node-> handle = handle;118 node->service_id = service_id; 119 119 120 120 (*rfn)->data = node; … … 122 122 } 123 123 124 static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)125 { 126 return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);127 } 128 129 static int devfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)130 { 131 devfs_node_t *node = (devfs_node_t *) pfn->data;124 static int locfs_root_get(fs_node_t **rfn, service_id_t service_id) 125 { 126 return locfs_node_get_internal(rfn, LOC_OBJECT_NONE, 0); 127 } 128 129 static int locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component) 130 { 131 locfs_node_t *node = (locfs_node_t *) pfn->data; 132 132 int ret; 133 133 134 if (node-> handle== 0) {134 if (node->service_id == 0) { 135 135 /* Root directory */ 136 136 137 dev_desc_t *devs;138 size_t count = devmap_get_namespaces(&devs);137 loc_sdesc_t *nspaces; 138 size_t count = loc_get_namespaces(&nspaces); 139 139 140 140 if (count > 0) { … … 142 142 for (pos = 0; pos < count; pos++) { 143 143 /* Ignore root namespace */ 144 if (str_cmp( devs[pos].name, "") == 0)144 if (str_cmp(nspaces[pos].name, "") == 0) 145 145 continue; 146 146 147 if (str_cmp( devs[pos].name, component) == 0) {148 ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);149 free( devs);147 if (str_cmp(nspaces[pos].name, component) == 0) { 148 ret = locfs_node_get_internal(rfn, LOC_OBJECT_NAMESPACE, nspaces[pos].id); 149 free(nspaces); 150 150 return ret; 151 151 } 152 152 } 153 153 154 free( devs);154 free(nspaces); 155 155 } 156 156 157 157 /* Search root namespace */ 158 devmap_handle_t namespace; 159 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { 160 count = devmap_get_devices(namespace, &devs); 158 service_id_t namespace; 159 loc_sdesc_t *svcs; 160 if (loc_namespace_get_id("", &namespace, 0) == EOK) { 161 count = loc_get_services(namespace, &svcs); 161 162 162 163 if (count > 0) { 163 164 size_t pos; 164 165 for (pos = 0; pos < count; pos++) { 165 if (str_cmp( devs[pos].name, component) == 0) {166 ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);167 free( devs);166 if (str_cmp(svcs[pos].name, component) == 0) { 167 ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id); 168 free(svcs); 168 169 return ret; 169 170 } 170 171 } 171 172 172 free( devs);173 free(svcs); 173 174 } 174 175 } … … 178 179 } 179 180 180 if (node->type == DEV_HANDLE_NAMESPACE) {181 if (node->type == LOC_OBJECT_NAMESPACE) { 181 182 /* Namespace directory */ 182 183 183 dev_desc_t *devs;184 size_t count = devmap_get_devices(node->handle, &devs);184 loc_sdesc_t *svcs; 185 size_t count = loc_get_services(node->service_id, &svcs); 185 186 if (count > 0) { 186 187 size_t pos; 187 188 for (pos = 0; pos < count; pos++) { 188 if (str_cmp( devs[pos].name, component) == 0) {189 ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);190 free( devs);189 if (str_cmp(svcs[pos].name, component) == 0) { 190 ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id); 191 free(svcs); 191 192 return ret; 192 193 } 193 194 } 194 195 195 free( devs);196 free(svcs); 196 197 } 197 198 … … 204 205 } 205 206 206 static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)207 { 208 return devfs_node_get_internal(rfn, devmap_handle_probe(index), index);209 } 210 211 static int devfs_node_open(fs_node_t *fn)212 { 213 devfs_node_t *node = (devfs_node_t *) fn->data;214 215 if (node-> handle== 0) {207 static int locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) 208 { 209 return locfs_node_get_internal(rfn, loc_id_probe(index), index); 210 } 211 212 static int locfs_node_open(fs_node_t *fn) 213 { 214 locfs_node_t *node = (locfs_node_t *) fn->data; 215 216 if (node->service_id == 0) { 216 217 /* Root directory */ 217 218 return EOK; 218 219 } 219 220 220 devmap_handle_type_t type = devmap_handle_probe(node->handle);221 222 if (type == DEV_HANDLE_NAMESPACE) {221 loc_object_type_t type = loc_id_probe(node->service_id); 222 223 if (type == LOC_OBJECT_NAMESPACE) { 223 224 /* Namespace directory */ 224 225 return EOK; 225 226 } 226 227 227 if (type == DEV_HANDLE_DEVICE) {228 if (type == LOC_OBJECT_SERVICE) { 228 229 /* Device node */ 229 230 230 231 unsigned long key[] = { 231 [ DEVICES_KEY_HANDLE] = (unsigned long) node->handle232 [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id 232 233 }; 233 234 link_t *lnk; 234 235 235 fibril_mutex_lock(& devices_mutex);236 fibril_mutex_lock(&services_mutex); 236 237 restart: 237 lnk = hash_table_find(& devices, key);238 lnk = hash_table_find(&services, key); 238 239 if (lnk == NULL) { 239 device_t *dev = (device_t *) malloc(sizeof(device_t));240 service_t *dev = (service_t *) malloc(sizeof(service_t)); 240 241 if (dev == NULL) { 241 fibril_mutex_unlock(& devices_mutex);242 fibril_mutex_unlock(&services_mutex); 242 243 return ENOMEM; 243 244 } 244 245 245 dev-> handle = node->handle;246 dev->service_id = node->service_id; 246 247 247 248 /* Mark as incomplete */ … … 255 256 * below. 256 257 */ 257 hash_table_insert(& devices, key, &dev->link);258 hash_table_insert(&services, key, &dev->link); 258 259 259 260 /* 260 * Drop the mutex to allow recursive devfs requests.261 * Drop the mutex to allow recursive locfs requests. 261 262 */ 262 fibril_mutex_unlock(& devices_mutex);263 264 async_sess_t *sess = devmap_device_connect(EXCHANGE_SERIALIZE,265 node->handle, 0);266 267 fibril_mutex_lock(& devices_mutex);263 fibril_mutex_unlock(&services_mutex); 264 265 async_sess_t *sess = loc_service_connect( 266 EXCHANGE_SERIALIZE, node->service_id, 0); 267 268 fibril_mutex_lock(&services_mutex); 268 269 269 270 /* … … 278 279 * entry and free the device structure. 279 280 */ 280 hash_table_remove(& devices, key, DEVICES_KEYS);281 fibril_mutex_unlock(& devices_mutex);281 hash_table_remove(&services, key, SERVICES_KEYS); 282 fibril_mutex_unlock(&services_mutex); 282 283 283 284 return ENOENT; … … 287 288 dev->sess = sess; 288 289 } else { 289 device_t *dev = hash_table_get_instance(lnk, device_t, link);290 service_t *dev = hash_table_get_instance(lnk, service_t, link); 290 291 291 292 if (!dev->sess) { … … 297 298 * fibril_condvar_wait(). 298 299 */ 299 fibril_condvar_wait(&dev->cv, & devices_mutex);300 fibril_condvar_wait(&dev->cv, &services_mutex); 300 301 goto restart; 301 302 } … … 304 305 } 305 306 306 fibril_mutex_unlock(& devices_mutex);307 fibril_mutex_unlock(&services_mutex); 307 308 308 309 return EOK; … … 312 313 } 313 314 314 static int devfs_node_put(fs_node_t *fn)315 static int locfs_node_put(fs_node_t *fn) 315 316 { 316 317 free(fn->data); … … 319 320 } 320 321 321 static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)322 static int locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag) 322 323 { 323 324 assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); … … 327 328 } 328 329 329 static int devfs_destroy_node(fs_node_t *fn)330 static int locfs_destroy_node(fs_node_t *fn) 330 331 { 331 332 return ENOTSUP; 332 333 } 333 334 334 static int devfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)335 static int locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) 335 336 { 336 337 return ENOTSUP; 337 338 } 338 339 339 static int devfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)340 static int locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) 340 341 { 341 342 return ENOTSUP; 342 343 } 343 344 344 static int devfs_has_children(bool *has_children, fs_node_t *fn)345 { 346 devfs_node_t *node = (devfs_node_t *) fn->data;347 348 if (node-> handle== 0) {349 size_t count = devmap_count_namespaces();345 static int locfs_has_children(bool *has_children, fs_node_t *fn) 346 { 347 locfs_node_t *node = (locfs_node_t *) fn->data; 348 349 if (node->service_id == 0) { 350 size_t count = loc_count_namespaces(); 350 351 if (count > 0) { 351 352 *has_children = true; … … 354 355 355 356 /* Root namespace */ 356 devmap_handle_t namespace;357 if ( devmap_namespace_get_handle("", &namespace, 0) == EOK) {358 count = devmap_count_devices(namespace);357 service_id_t namespace; 358 if (loc_namespace_get_id("", &namespace, 0) == EOK) { 359 count = loc_count_services(namespace); 359 360 if (count > 0) { 360 361 *has_children = true; … … 367 368 } 368 369 369 if (node->type == DEV_HANDLE_NAMESPACE) {370 size_t count = devmap_count_devices(node->handle);370 if (node->type == LOC_OBJECT_NAMESPACE) { 371 size_t count = loc_count_services(node->service_id); 371 372 if (count > 0) { 372 373 *has_children = true; … … 382 383 } 383 384 384 static fs_index_t devfs_index_get(fs_node_t *fn)385 { 386 devfs_node_t *node = (devfs_node_t *) fn->data;387 return node-> handle;388 } 389 390 static aoff64_t devfs_size_get(fs_node_t *fn)385 static fs_index_t locfs_index_get(fs_node_t *fn) 386 { 387 locfs_node_t *node = (locfs_node_t *) fn->data; 388 return node->service_id; 389 } 390 391 static aoff64_t locfs_size_get(fs_node_t *fn) 391 392 { 392 393 return 0; 393 394 } 394 395 395 static unsigned int devfs_lnkcnt_get(fs_node_t *fn)396 { 397 devfs_node_t *node = (devfs_node_t *) fn->data;398 399 if (node-> handle== 0)396 static unsigned int locfs_lnkcnt_get(fs_node_t *fn) 397 { 398 locfs_node_t *node = (locfs_node_t *) fn->data; 399 400 if (node->service_id == 0) 400 401 return 0; 401 402 … … 403 404 } 404 405 405 static char devfs_plb_get_char(unsigned pos)406 { 407 return devfs_reg.plb_ro[pos % PLB_SIZE];408 } 409 410 static bool devfs_is_directory(fs_node_t *fn)411 { 412 devfs_node_t *node = (devfs_node_t *) fn->data;413 414 return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE));415 } 416 417 static bool devfs_is_file(fs_node_t *fn)418 { 419 devfs_node_t *node = (devfs_node_t *) fn->data;420 421 return (node->type == DEV_HANDLE_DEVICE);422 } 423 424 static devmap_handle_t devfs_device_get(fs_node_t *fn)425 { 426 devfs_node_t *node = (devfs_node_t *) fn->data;427 428 if (node->type == DEV_HANDLE_DEVICE)429 return node-> handle;406 static char locfs_plb_get_char(unsigned pos) 407 { 408 return locfs_reg.plb_ro[pos % PLB_SIZE]; 409 } 410 411 static bool locfs_is_directory(fs_node_t *fn) 412 { 413 locfs_node_t *node = (locfs_node_t *) fn->data; 414 415 return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE)); 416 } 417 418 static bool locfs_is_file(fs_node_t *fn) 419 { 420 locfs_node_t *node = (locfs_node_t *) fn->data; 421 422 return (node->type == LOC_OBJECT_SERVICE); 423 } 424 425 static service_id_t locfs_device_get(fs_node_t *fn) 426 { 427 locfs_node_t *node = (locfs_node_t *) fn->data; 428 429 if (node->type == LOC_OBJECT_SERVICE) 430 return node->service_id; 430 431 431 432 return 0; … … 433 434 434 435 /** libfs operations */ 435 libfs_ops_t devfs_libfs_ops = {436 .root_get = devfs_root_get,437 .match = devfs_match,438 .node_get = devfs_node_get,439 .node_open = devfs_node_open,440 .node_put = devfs_node_put,441 .create = devfs_create_node,442 .destroy = devfs_destroy_node,443 .link = devfs_link_node,444 .unlink = devfs_unlink_node,445 .has_children = devfs_has_children,446 .index_get = devfs_index_get,447 .size_get = devfs_size_get,448 .lnkcnt_get = devfs_lnkcnt_get,449 .plb_get_char = devfs_plb_get_char,450 .is_directory = devfs_is_directory,451 .is_file = devfs_is_file,452 .device_get = devfs_device_get436 libfs_ops_t locfs_libfs_ops = { 437 .root_get = locfs_root_get, 438 .match = locfs_match, 439 .node_get = locfs_node_get, 440 .node_open = locfs_node_open, 441 .node_put = locfs_node_put, 442 .create = locfs_create_node, 443 .destroy = locfs_destroy_node, 444 .link = locfs_link_node, 445 .unlink = locfs_unlink_node, 446 .has_children = locfs_has_children, 447 .index_get = locfs_index_get, 448 .size_get = locfs_size_get, 449 .lnkcnt_get = locfs_lnkcnt_get, 450 .plb_get_char = locfs_plb_get_char, 451 .is_directory = locfs_is_directory, 452 .is_file = locfs_is_file, 453 .device_get = locfs_device_get 453 454 }; 454 455 455 bool devfs_init(void)456 { 457 if (!hash_table_create(& devices, DEVICES_BUCKETS,458 DEVICES_KEYS, &devices_ops))456 bool locfs_init(void) 457 { 458 if (!hash_table_create(&services, SERVICES_BUCKETS, 459 SERVICES_KEYS, &services_ops)) 459 460 return false; 460 461 … … 462 463 } 463 464 464 void devfs_mounted(ipc_callid_t rid, ipc_call_t *request)465 void locfs_mounted(ipc_callid_t rid, ipc_call_t *request) 465 466 { 466 467 char *opts; … … 478 479 } 479 480 480 void devfs_mount(ipc_callid_t rid, ipc_call_t *request)481 { 482 libfs_mount(& devfs_libfs_ops, devfs_reg.fs_handle, rid, request);483 } 484 485 void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)481 void locfs_mount(ipc_callid_t rid, ipc_call_t *request) 482 { 483 libfs_mount(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request); 484 } 485 486 void locfs_unmounted(ipc_callid_t rid, ipc_call_t *request) 486 487 { 487 488 async_answer_0(rid, ENOTSUP); 488 489 } 489 490 490 void devfs_unmount(ipc_callid_t rid, ipc_call_t *request)491 { 492 libfs_unmount(& devfs_libfs_ops, rid, request);493 } 494 495 void devfs_lookup(ipc_callid_t rid, ipc_call_t *request)496 { 497 libfs_lookup(& devfs_libfs_ops, devfs_reg.fs_handle, rid, request);498 } 499 500 void devfs_open_node(ipc_callid_t rid, ipc_call_t *request)501 { 502 libfs_open_node(& devfs_libfs_ops, devfs_reg.fs_handle, rid, request);503 } 504 505 void devfs_stat(ipc_callid_t rid, ipc_call_t *request)506 { 507 libfs_stat(& devfs_libfs_ops, devfs_reg.fs_handle, rid, request);508 } 509 510 void devfs_read(ipc_callid_t rid, ipc_call_t *request)491 void locfs_unmount(ipc_callid_t rid, ipc_call_t *request) 492 { 493 libfs_unmount(&locfs_libfs_ops, rid, request); 494 } 495 496 void locfs_lookup(ipc_callid_t rid, ipc_call_t *request) 497 { 498 libfs_lookup(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request); 499 } 500 501 void locfs_open_node(ipc_callid_t rid, ipc_call_t *request) 502 { 503 libfs_open_node(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request); 504 } 505 506 void locfs_stat(ipc_callid_t rid, ipc_call_t *request) 507 { 508 libfs_stat(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request); 509 } 510 511 void locfs_read(ipc_callid_t rid, ipc_call_t *request) 511 512 { 512 513 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); … … 523 524 } 524 525 525 dev_desc_t *desc;526 size_t count = devmap_get_namespaces(&desc);526 loc_sdesc_t *desc; 527 size_t count = loc_get_namespaces(&desc); 527 528 528 529 /* Get rid of root namespace */ … … 548 549 549 550 /* Search root namespace */ 550 devmap_handle_t namespace;551 if ( devmap_namespace_get_handle("", &namespace, 0) == EOK) {552 count = devmap_get_devices(namespace, &desc);551 service_id_t namespace; 552 if (loc_namespace_get_id("", &namespace, 0) == EOK) { 553 count = loc_get_services(namespace, &desc); 553 554 554 555 if (pos < count) { … … 567 568 } 568 569 569 devmap_handle_type_t type = devmap_handle_probe(index);570 571 if (type == DEV_HANDLE_NAMESPACE) {570 loc_object_type_t type = loc_id_probe(index); 571 572 if (type == LOC_OBJECT_NAMESPACE) { 572 573 /* Namespace directory */ 573 574 ipc_callid_t callid; … … 579 580 } 580 581 581 dev_desc_t *desc;582 size_t count = devmap_get_devices(index, &desc);582 loc_sdesc_t *desc; 583 size_t count = loc_get_services(index, &desc); 583 584 584 585 if (pos < count) { … … 595 596 } 596 597 597 if (type == DEV_HANDLE_DEVICE) {598 if (type == LOC_OBJECT_SERVICE) { 598 599 /* Device node */ 599 600 600 601 unsigned long key[] = { 601 [ DEVICES_KEY_HANDLE] = (unsigned long) index602 [SERVICES_KEY_HANDLE] = (unsigned long) index 602 603 }; 603 604 604 fibril_mutex_lock(& devices_mutex);605 link_t *lnk = hash_table_find(& devices, key);605 fibril_mutex_lock(&services_mutex); 606 link_t *lnk = hash_table_find(&services, key); 606 607 if (lnk == NULL) { 607 fibril_mutex_unlock(& devices_mutex);608 fibril_mutex_unlock(&services_mutex); 608 609 async_answer_0(rid, ENOENT); 609 610 return; 610 611 } 611 612 612 device_t *dev = hash_table_get_instance(lnk, device_t, link);613 service_t *dev = hash_table_get_instance(lnk, service_t, link); 613 614 assert(dev->sess); 614 615 615 616 ipc_callid_t callid; 616 617 if (!async_data_read_receive(&callid, NULL)) { 617 fibril_mutex_unlock(& devices_mutex);618 fibril_mutex_unlock(&services_mutex); 618 619 async_answer_0(callid, EINVAL); 619 620 async_answer_0(rid, EINVAL); … … 634 635 async_exchange_end(exch); 635 636 636 fibril_mutex_unlock(& devices_mutex);637 fibril_mutex_unlock(&services_mutex); 637 638 638 639 /* Wait for reply from the driver. */ … … 649 650 } 650 651 651 void devfs_write(ipc_callid_t rid, ipc_call_t *request)652 void locfs_write(ipc_callid_t rid, ipc_call_t *request) 652 653 { 653 654 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); … … 657 658 } 658 659 659 devmap_handle_type_t type = devmap_handle_probe(index);660 661 if (type == DEV_HANDLE_NAMESPACE) {660 loc_object_type_t type = loc_id_probe(index); 661 662 if (type == LOC_OBJECT_NAMESPACE) { 662 663 /* Namespace directory */ 663 664 async_answer_0(rid, ENOTSUP); … … 665 666 } 666 667 667 if (type == DEV_HANDLE_DEVICE) {668 if (type == LOC_OBJECT_SERVICE) { 668 669 /* Device node */ 669 670 unsigned long key[] = { 670 [ DEVICES_KEY_HANDLE] = (unsigned long) index671 [SERVICES_KEY_HANDLE] = (unsigned long) index 671 672 }; 672 673 673 fibril_mutex_lock(& devices_mutex);674 link_t *lnk = hash_table_find(& devices, key);674 fibril_mutex_lock(&services_mutex); 675 link_t *lnk = hash_table_find(&services, key); 675 676 if (lnk == NULL) { 676 fibril_mutex_unlock(& devices_mutex);677 fibril_mutex_unlock(&services_mutex); 677 678 async_answer_0(rid, ENOENT); 678 679 return; 679 680 } 680 681 681 device_t *dev = hash_table_get_instance(lnk, device_t, link);682 service_t *dev = hash_table_get_instance(lnk, service_t, link); 682 683 assert(dev->sess); 683 684 684 685 ipc_callid_t callid; 685 686 if (!async_data_write_receive(&callid, NULL)) { 686 fibril_mutex_unlock(& devices_mutex);687 fibril_mutex_unlock(&services_mutex); 687 688 async_answer_0(callid, EINVAL); 688 689 async_answer_0(rid, EINVAL); … … 703 704 async_exchange_end(exch); 704 705 705 fibril_mutex_unlock(& devices_mutex);706 fibril_mutex_unlock(&services_mutex); 706 707 707 708 /* Wait for reply from the driver. */ … … 718 719 } 719 720 720 void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)721 void locfs_truncate(ipc_callid_t rid, ipc_call_t *request) 721 722 { 722 723 async_answer_0(rid, ENOTSUP); 723 724 } 724 725 725 void devfs_close(ipc_callid_t rid, ipc_call_t *request)726 void locfs_close(ipc_callid_t rid, ipc_call_t *request) 726 727 { 727 728 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); … … 732 733 } 733 734 734 devmap_handle_type_t type = devmap_handle_probe(index);735 736 if (type == DEV_HANDLE_NAMESPACE) {735 loc_object_type_t type = loc_id_probe(index); 736 737 if (type == LOC_OBJECT_NAMESPACE) { 737 738 /* Namespace directory */ 738 739 async_answer_0(rid, EOK); … … 740 741 } 741 742 742 if (type == DEV_HANDLE_DEVICE) {743 if (type == LOC_OBJECT_SERVICE) { 743 744 unsigned long key[] = { 744 [ DEVICES_KEY_HANDLE] = (unsigned long) index745 [SERVICES_KEY_HANDLE] = (unsigned long) index 745 746 }; 746 747 747 fibril_mutex_lock(& devices_mutex);748 link_t *lnk = hash_table_find(& devices, key);748 fibril_mutex_lock(&services_mutex); 749 link_t *lnk = hash_table_find(&services, key); 749 750 if (lnk == NULL) { 750 fibril_mutex_unlock(& devices_mutex);751 fibril_mutex_unlock(&services_mutex); 751 752 async_answer_0(rid, ENOENT); 752 753 return; 753 754 } 754 755 755 device_t *dev = hash_table_get_instance(lnk, device_t, link);756 service_t *dev = hash_table_get_instance(lnk, service_t, link); 756 757 assert(dev->sess); 757 758 dev->refcount--; … … 759 760 if (dev->refcount == 0) { 760 761 async_hangup(dev->sess); 761 hash_table_remove(& devices, key, DEVICES_KEYS);762 } 763 764 fibril_mutex_unlock(& devices_mutex);762 hash_table_remove(&services, key, SERVICES_KEYS); 763 } 764 765 fibril_mutex_unlock(&services_mutex); 765 766 766 767 async_answer_0(rid, EOK); … … 771 772 } 772 773 773 void devfs_sync(ipc_callid_t rid, ipc_call_t *request)774 void locfs_sync(ipc_callid_t rid, ipc_call_t *request) 774 775 { 775 776 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); … … 780 781 } 781 782 782 devmap_handle_type_t type = devmap_handle_probe(index);783 784 if (type == DEV_HANDLE_NAMESPACE) {783 loc_object_type_t type = loc_id_probe(index); 784 785 if (type == LOC_OBJECT_NAMESPACE) { 785 786 /* Namespace directory */ 786 787 async_answer_0(rid, EOK); … … 788 789 } 789 790 790 if (type == DEV_HANDLE_DEVICE) {791 if (type == LOC_OBJECT_SERVICE) { 791 792 unsigned long key[] = { 792 [ DEVICES_KEY_HANDLE] = (unsigned long) index793 [SERVICES_KEY_HANDLE] = (unsigned long) index 793 794 }; 794 795 795 fibril_mutex_lock(& devices_mutex);796 link_t *lnk = hash_table_find(& devices, key);796 fibril_mutex_lock(&services_mutex); 797 link_t *lnk = hash_table_find(&services, key); 797 798 if (lnk == NULL) { 798 fibril_mutex_unlock(& devices_mutex);799 fibril_mutex_unlock(&services_mutex); 799 800 async_answer_0(rid, ENOENT); 800 801 return; 801 802 } 802 803 803 device_t *dev = hash_table_get_instance(lnk, device_t, link);804 service_t *dev = hash_table_get_instance(lnk, service_t, link); 804 805 assert(dev->sess); 805 806 … … 813 814 async_exchange_end(exch); 814 815 815 fibril_mutex_unlock(& devices_mutex);816 fibril_mutex_unlock(&services_mutex); 816 817 817 818 /* Wait for reply from the driver */ … … 827 828 } 828 829 829 void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)830 void locfs_destroy(ipc_callid_t rid, ipc_call_t *request) 830 831 { 831 832 async_answer_0(rid, ENOTSUP);
Note:
See TracChangeset
for help on using the changeset viewer.
