source: mainline/uspace/srv/fs/devfs/devfs_ops.c@ e27cf669

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since e27cf669 was 4cac2d69, checked in by Martin Decky <martin@…>, 15 years ago

fix futile typedef to a working one
  • Property mode set to 100644
File size: 17.3 KB
RevLine 
[a095d20]1/*
2 * Copyright (c) 2009 Martin Decky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup fs
30 * @{
31 */
32
33/**
34 * @file devfs_ops.c
35 * @brief Implementation of VFS operations for the devfs file system server.
36 */
37
38#include <ipc/ipc.h>
39#include <bool.h>
40#include <errno.h>
41#include <malloc.h>
42#include <string.h>
43#include <libfs.h>
[1e4cada]44#include <fibril_synch.h>
[d9c8c81]45#include <adt/hash_table.h>
[1313ee9]46#include <ipc/devmap.h>
[852b801]47#include <sys/stat.h>
[1313ee9]48#include <libfs.h>
49#include <assert.h>
[a095d20]50#include "devfs.h"
51#include "devfs_ops.h"
52
[1313ee9]53typedef struct {
54 devmap_handle_type_t type;
55 dev_handle_t handle;
56} devfs_node_t;
[a095d20]57
[17fd1d4]58/** Opened devices structure */
59typedef struct {
60 dev_handle_t handle;
61 int phone;
62 size_t refcount;
63 link_t link;
64} device_t;
65
66/** Hash table of opened devices */
67static hash_table_t devices;
68
[2dfd9fa]69/** Hash table mutex */
70static FIBRIL_MUTEX_INITIALIZE(devices_mutex);
71
[17fd1d4]72#define DEVICES_KEYS 1
73#define DEVICES_KEY_HANDLE 0
74#define DEVICES_BUCKETS 256
75
76/* Implementation of hash table interface for the nodes hash table. */
77static hash_index_t devices_hash(unsigned long key[])
78{
79 return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS;
80}
81
82static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item)
83{
84 device_t *dev = hash_table_get_instance(item, device_t, link);
85 return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]);
86}
87
88static void devices_remove_callback(link_t *item)
89{
90 free(hash_table_get_instance(item, device_t, link));
91}
92
93static hash_table_operations_t devices_ops = {
94 .hash = devices_hash,
95 .compare = devices_compare,
96 .remove_callback = devices_remove_callback
97};
98
[1313ee9]99static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,
100 dev_handle_t handle)
[a095d20]101{
[1313ee9]102 devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));
103 if (node == NULL) {
104 *rfn = NULL;
105 return ENOMEM;
106 }
[17fd1d4]107
[1313ee9]108 *rfn = (fs_node_t *) malloc(sizeof(fs_node_t));
109 if (*rfn == NULL) {
110 free(node);
111 *rfn = NULL;
112 return ENOMEM;
113 }
[a095d20]114
[1313ee9]115 fs_node_initialize(*rfn);
116 node->type = type;
117 node->handle = handle;
118
119 (*rfn)->data = node;
120 return EOK;
[a095d20]121}
122
[1313ee9]123static int devfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
[a095d20]124{
[1313ee9]125 return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);
126}
127
128static int devfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
129{
130 devfs_node_t *node = (devfs_node_t *) pfn->data;
[a095d20]131
[1313ee9]132 if (node->handle == 0) {
133 /* Root directory */
134
135 dev_desc_t *devs;
136 size_t count = devmap_get_namespaces(&devs);
137
138 if (count > 0) {
139 size_t pos;
140 for (pos = 0; pos < count; pos++) {
141 /* Ignore root namespace */
142 if (str_cmp(devs[pos].name, "") == 0)
143 continue;
144
145 if (str_cmp(devs[pos].name, component) == 0) {
146 free(devs);
147 return devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
148 }
149 }
150
151 free(devs);
152 }
153
154 /* Search root namespace */
155 dev_handle_t namespace;
156 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
157 count = devmap_get_devices(namespace, &devs);
158
159 if (count > 0) {
160 size_t pos;
161 for (pos = 0; pos < count; pos++) {
162 if (str_cmp(devs[pos].name, component) == 0) {
163 free(devs);
164 return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
165 }
166 }
167
168 free(devs);
169 }
170 }
171
172 *rfn = NULL;
173 return EOK;
[a095d20]174 }
175
[1313ee9]176 if (node->type == DEV_HANDLE_NAMESPACE) {
177 /* Namespace directory */
178
179 dev_desc_t *devs;
180 size_t count = devmap_get_devices(node->handle, &devs);
181 if (count > 0) {
182 size_t pos;
183 for (pos = 0; pos < count; pos++) {
184 if (str_cmp(devs[pos].name, component) == 0) {
185 free(devs);
186 return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
187 }
188 }
189
190 free(devs);
191 }
192
193 *rfn = NULL;
194 return EOK;
[a095d20]195 }
196
[1313ee9]197 *rfn = NULL;
198 return EOK;
[a095d20]199}
200
[1313ee9]201static int devfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
[a095d20]202{
[1313ee9]203 return devfs_node_get_internal(rfn, devmap_handle_probe(index), index);
[a095d20]204}
205
[1313ee9]206static int devfs_node_open(fs_node_t *fn)
[a095d20]207{
[1313ee9]208 devfs_node_t *node = (devfs_node_t *) fn->data;
[a095d20]209
[1313ee9]210 if (node->handle == 0) {
211 /* Root directory */
212 return EOK;
[a095d20]213 }
214
[1313ee9]215 devmap_handle_type_t type = devmap_handle_probe(node->handle);
[a095d20]216
[1313ee9]217 if (type == DEV_HANDLE_NAMESPACE) {
218 /* Namespace directory */
219 return EOK;
[a095d20]220 }
221
[1313ee9]222 if (type == DEV_HANDLE_DEVICE) {
223 /* Device node */
224
225 unsigned long key[] = {
226 [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
227 };
228
229 fibril_mutex_lock(&devices_mutex);
230 link_t *lnk = hash_table_find(&devices, key);
231 if (lnk == NULL) {
232 device_t *dev = (device_t *) malloc(sizeof(device_t));
233 if (dev == NULL) {
234 fibril_mutex_unlock(&devices_mutex);
235 return ENOMEM;
[a095d20]236 }
237
[1313ee9]238 int phone = devmap_device_connect(node->handle, 0);
239 if (phone < 0) {
[2dfd9fa]240 fibril_mutex_unlock(&devices_mutex);
[1313ee9]241 free(dev);
242 return ENOENT;
[17fd1d4]243 }
244
[1313ee9]245 dev->handle = node->handle;
246 dev->phone = phone;
247 dev->refcount = 1;
[a095d20]248
[1313ee9]249 hash_table_insert(&devices, key, &dev->link);
250 } else {
251 device_t *dev = hash_table_get_instance(lnk, device_t, link);
252 dev->refcount++;
253 }
254
255 fibril_mutex_unlock(&devices_mutex);
256
257 return EOK;
[a095d20]258 }
[1313ee9]259
260 return ENOENT;
[a095d20]261}
262
[1313ee9]263static int devfs_node_put(fs_node_t *fn)
[a095d20]264{
[1313ee9]265 free(fn->data);
266 free(fn);
267 return EOK;
268}
269
270static int devfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
271{
272 assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
[a095d20]273
[1313ee9]274 *rfn = NULL;
275 return ENOTSUP;
276}
277
278static int devfs_destroy_node(fs_node_t *fn)
279{
280 return ENOTSUP;
281}
282
283static int devfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
284{
285 return ENOTSUP;
286}
287
288static int devfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
289{
290 return ENOTSUP;
291}
292
293static int devfs_has_children(bool *has_children, fs_node_t *fn)
294{
295 devfs_node_t *node = (devfs_node_t *) fn->data;
[a095d20]296
[1313ee9]297 if (node->handle == 0) {
298 size_t count = devmap_count_namespaces();
299 if (count > 0) {
300 *has_children = true;
301 return EOK;
[17fd1d4]302 }
303
[1313ee9]304 /* Root namespace */
305 dev_handle_t namespace;
306 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
307 count = devmap_count_devices(namespace);
308 if (count > 0) {
309 *has_children = true;
310 return EOK;
311 }
[17fd1d4]312 }
313
[1313ee9]314 *has_children = false;
315 return EOK;
316 }
317
318 if (node->type == DEV_HANDLE_NAMESPACE) {
319 size_t count = devmap_count_devices(node->handle);
320 if (count > 0) {
321 *has_children = true;
322 return EOK;
323 }
[17fd1d4]324
[1313ee9]325 *has_children = false;
326 return EOK;
[a095d20]327 }
328
[1313ee9]329 *has_children = false;
330 return EOK;
[17fd1d4]331}
332
[1313ee9]333static fs_index_t devfs_index_get(fs_node_t *fn)
[17fd1d4]334{
[1313ee9]335 devfs_node_t *node = (devfs_node_t *) fn->data;
336 return node->handle;
337}
338
339static size_t devfs_size_get(fs_node_t *fn)
340{
341 return 0;
342}
343
344static unsigned int devfs_lnkcnt_get(fs_node_t *fn)
345{
346 devfs_node_t *node = (devfs_node_t *) fn->data;
[17fd1d4]347
[1313ee9]348 if (node->handle == 0)
349 return 0;
350
351 return 1;
352}
[852b801]353
[1313ee9]354static char devfs_plb_get_char(unsigned pos)
355{
356 return devfs_reg.plb_ro[pos % PLB_SIZE];
357}
[852b801]358
[1313ee9]359static bool devfs_is_directory(fs_node_t *fn)
360{
361 devfs_node_t *node = (devfs_node_t *) fn->data;
[852b801]362
[1313ee9]363 return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE));
364}
365
366static bool devfs_is_file(fs_node_t *fn)
367{
368 devfs_node_t *node = (devfs_node_t *) fn->data;
369
370 return (node->type == DEV_HANDLE_DEVICE);
371}
372
373static dev_handle_t devfs_device_get(fs_node_t *fn)
374{
375 devfs_node_t *node = (devfs_node_t *) fn->data;
376
377 if (node->type == DEV_HANDLE_DEVICE)
378 return node->handle;
379
380 return 0;
381}
382
383/** libfs operations */
384libfs_ops_t devfs_libfs_ops = {
385 .root_get = devfs_root_get,
386 .match = devfs_match,
387 .node_get = devfs_node_get,
388 .node_open = devfs_node_open,
389 .node_put = devfs_node_put,
390 .create = devfs_create_node,
391 .destroy = devfs_destroy_node,
392 .link = devfs_link_node,
393 .unlink = devfs_unlink_node,
394 .has_children = devfs_has_children,
395 .index_get = devfs_index_get,
396 .size_get = devfs_size_get,
397 .lnkcnt_get = devfs_lnkcnt_get,
398 .plb_get_char = devfs_plb_get_char,
399 .is_directory = devfs_is_directory,
400 .is_file = devfs_is_file,
401 .device_get = devfs_device_get
402};
403
404bool devfs_init(void)
405{
406 if (!hash_table_create(&devices, DEVICES_BUCKETS,
407 DEVICES_KEYS, &devices_ops))
408 return false;
409
410 if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0)
411 return false;
412
413 return true;
414}
415
416void devfs_mounted(ipc_callid_t rid, ipc_call_t *request)
417{
418 char *opts;
419
420 /* Accept the mount options */
[4cac2d69]421 ipcarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
[eda925a]422 0, NULL);
[1313ee9]423 if (retval != EOK) {
424 ipc_answer_0(rid, retval);
425 return;
[852b801]426 }
[1313ee9]427
428 free(opts);
429 ipc_answer_3(rid, EOK, 0, 0, 0);
430}
431
432void devfs_mount(ipc_callid_t rid, ipc_call_t *request)
433{
434 libfs_mount(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
435}
436
[3c11713]437void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
438{
439 ipc_answer_0(rid, ENOTSUP);
440}
441
442void devfs_unmount(ipc_callid_t rid, ipc_call_t *request)
443{
444 libfs_unmount(&devfs_libfs_ops, rid, request);
445}
446
[1313ee9]447void devfs_lookup(ipc_callid_t rid, ipc_call_t *request)
448{
449 libfs_lookup(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
450}
[852b801]451
[1313ee9]452void devfs_open_node(ipc_callid_t rid, ipc_call_t *request)
453{
454 libfs_open_node(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
455}
456
457void devfs_stat(ipc_callid_t rid, ipc_call_t *request)
458{
459 libfs_stat(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
[17fd1d4]460}
461
462void devfs_read(ipc_callid_t rid, ipc_call_t *request)
463{
464 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
465 off_t pos = (off_t) IPC_GET_ARG3(*request);
466
[1313ee9]467 if (index == 0) {
468 ipc_callid_t callid;
469 size_t size;
470 if (!async_data_read_receive(&callid, &size)) {
471 ipc_answer_0(callid, EINVAL);
472 ipc_answer_0(rid, EINVAL);
473 return;
474 }
475
476 dev_desc_t *desc;
477 size_t count = devmap_get_namespaces(&desc);
478
479 /* Get rid of root namespace */
480 size_t i;
481 for (i = 0; i < count; i++) {
482 if (str_cmp(desc[i].name, "") == 0) {
483 if (pos >= i)
484 pos++;
485
486 break;
487 }
488 }
489
490 if (pos < count) {
491 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
492 free(desc);
493 ipc_answer_1(rid, EOK, 1);
494 return;
495 }
496
497 free(desc);
498 pos -= count;
499
500 /* Search root namespace */
501 dev_handle_t namespace;
502 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
503 count = devmap_get_devices(namespace, &desc);
504
505 if (pos < count) {
506 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
507 free(desc);
508 ipc_answer_1(rid, EOK, 1);
509 return;
510 }
511
512 free(desc);
513 }
514
515 ipc_answer_0(callid, ENOENT);
516 ipc_answer_1(rid, ENOENT, 0);
517 return;
518 }
519
520 devmap_handle_type_t type = devmap_handle_probe(index);
521
522 if (type == DEV_HANDLE_NAMESPACE) {
523 /* Namespace directory */
524 ipc_callid_t callid;
525 size_t size;
526 if (!async_data_read_receive(&callid, &size)) {
527 ipc_answer_0(callid, EINVAL);
528 ipc_answer_0(rid, EINVAL);
529 return;
530 }
531
532 dev_desc_t *desc;
533 size_t count = devmap_get_devices(index, &desc);
534
535 if (pos < count) {
536 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
537 free(desc);
538 ipc_answer_1(rid, EOK, 1);
539 return;
540 }
541
542 free(desc);
543 ipc_answer_0(callid, ENOENT);
544 ipc_answer_1(rid, ENOENT, 0);
545 return;
546 }
547
548 if (type == DEV_HANDLE_DEVICE) {
549 /* Device node */
550
[17fd1d4]551 unsigned long key[] = {
552 [DEVICES_KEY_HANDLE] = (unsigned long) index
553 };
554
[2dfd9fa]555 fibril_mutex_lock(&devices_mutex);
[17fd1d4]556 link_t *lnk = hash_table_find(&devices, key);
557 if (lnk == NULL) {
[2dfd9fa]558 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]559 ipc_answer_0(rid, ENOENT);
560 return;
561 }
562
563 device_t *dev = hash_table_get_instance(lnk, device_t, link);
564
565 ipc_callid_t callid;
[0da4e41]566 if (!async_data_read_receive(&callid, NULL)) {
[2dfd9fa]567 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]568 ipc_answer_0(callid, EINVAL);
569 ipc_answer_0(rid, EINVAL);
570 return;
571 }
572
573 /* Make a request at the driver */
574 ipc_call_t answer;
575 aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
576 IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
577 IPC_GET_ARG3(*request), &answer);
578
579 /* Forward the IPC_M_DATA_READ request to the driver */
580 ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
[2dfd9fa]581 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]582
583 /* Wait for reply from the driver. */
584 ipcarg_t rc;
585 async_wait_for(msg, &rc);
586 size_t bytes = IPC_GET_ARG1(answer);
587
588 /* Driver reply is the final result of the whole operation */
589 ipc_answer_1(rid, rc, bytes);
[1313ee9]590 return;
[a095d20]591 }
[1313ee9]592
593 ipc_answer_0(rid, ENOENT);
[a095d20]594}
595
596void devfs_write(ipc_callid_t rid, ipc_call_t *request)
597{
598 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
599 off_t pos = (off_t) IPC_GET_ARG3(*request);
600
[1313ee9]601 if (index == 0) {
602 ipc_answer_0(rid, ENOTSUP);
603 return;
604 }
605
606 devmap_handle_type_t type = devmap_handle_probe(index);
607
608 if (type == DEV_HANDLE_NAMESPACE) {
609 /* Namespace directory */
610 ipc_answer_0(rid, ENOTSUP);
611 return;
612 }
613
614 if (type == DEV_HANDLE_DEVICE) {
615 /* Device node */
[17fd1d4]616 unsigned long key[] = {
617 [DEVICES_KEY_HANDLE] = (unsigned long) index
618 };
619
[2dfd9fa]620 fibril_mutex_lock(&devices_mutex);
[17fd1d4]621 link_t *lnk = hash_table_find(&devices, key);
622 if (lnk == NULL) {
[2dfd9fa]623 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]624 ipc_answer_0(rid, ENOENT);
625 return;
626 }
627
628 device_t *dev = hash_table_get_instance(lnk, device_t, link);
629
630 ipc_callid_t callid;
[0da4e41]631 if (!async_data_write_receive(&callid, NULL)) {
[2dfd9fa]632 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]633 ipc_answer_0(callid, EINVAL);
634 ipc_answer_0(rid, EINVAL);
635 return;
636 }
637
638 /* Make a request at the driver */
639 ipc_call_t answer;
640 aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
641 IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
642 IPC_GET_ARG3(*request), &answer);
643
644 /* Forward the IPC_M_DATA_WRITE request to the driver */
645 ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
646
[2dfd9fa]647 fibril_mutex_unlock(&devices_mutex);
648
[17fd1d4]649 /* Wait for reply from the driver. */
650 ipcarg_t rc;
651 async_wait_for(msg, &rc);
652 size_t bytes = IPC_GET_ARG1(answer);
653
654 /* Driver reply is the final result of the whole operation */
655 ipc_answer_1(rid, rc, bytes);
[1313ee9]656 return;
[a095d20]657 }
[1313ee9]658
659 ipc_answer_0(rid, ENOENT);
[a095d20]660}
661
662void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
663{
664 ipc_answer_0(rid, ENOTSUP);
665}
666
[17fd1d4]667void devfs_close(ipc_callid_t rid, ipc_call_t *request)
668{
669 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
670
[1313ee9]671 if (index == 0) {
672 ipc_answer_0(rid, EOK);
673 return;
674 }
675
676 devmap_handle_type_t type = devmap_handle_probe(index);
677
678 if (type == DEV_HANDLE_NAMESPACE) {
679 /* Namespace directory */
680 ipc_answer_0(rid, EOK);
681 return;
682 }
683
684 if (type == DEV_HANDLE_DEVICE) {
[17fd1d4]685 unsigned long key[] = {
686 [DEVICES_KEY_HANDLE] = (unsigned long) index
687 };
688
[2dfd9fa]689 fibril_mutex_lock(&devices_mutex);
[17fd1d4]690 link_t *lnk = hash_table_find(&devices, key);
691 if (lnk == NULL) {
[2dfd9fa]692 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]693 ipc_answer_0(rid, ENOENT);
694 return;
695 }
696
697 device_t *dev = hash_table_get_instance(lnk, device_t, link);
698 dev->refcount--;
699
700 if (dev->refcount == 0) {
701 ipc_hangup(dev->phone);
702 hash_table_remove(&devices, key, DEVICES_KEYS);
703 }
704
[2dfd9fa]705 fibril_mutex_unlock(&devices_mutex);
706
[17fd1d4]707 ipc_answer_0(rid, EOK);
[1313ee9]708 return;
709 }
710
711 ipc_answer_0(rid, ENOENT);
[17fd1d4]712}
713
714void devfs_sync(ipc_callid_t rid, ipc_call_t *request)
715{
716 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
717
[1313ee9]718 if (index == 0) {
719 ipc_answer_0(rid, EOK);
720 return;
721 }
722
723 devmap_handle_type_t type = devmap_handle_probe(index);
724
725 if (type == DEV_HANDLE_NAMESPACE) {
726 /* Namespace directory */
727 ipc_answer_0(rid, EOK);
728 return;
729 }
730
731 if (type == DEV_HANDLE_DEVICE) {
[17fd1d4]732 unsigned long key[] = {
733 [DEVICES_KEY_HANDLE] = (unsigned long) index
734 };
735
[2dfd9fa]736 fibril_mutex_lock(&devices_mutex);
[17fd1d4]737 link_t *lnk = hash_table_find(&devices, key);
738 if (lnk == NULL) {
[2dfd9fa]739 fibril_mutex_unlock(&devices_mutex);
[17fd1d4]740 ipc_answer_0(rid, ENOENT);
741 return;
742 }
743
744 device_t *dev = hash_table_get_instance(lnk, device_t, link);
745
746 /* Make a request at the driver */
747 ipc_call_t answer;
748 aid_t msg = async_send_2(dev->phone, IPC_GET_METHOD(*request),
749 IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
750
[2dfd9fa]751 fibril_mutex_unlock(&devices_mutex);
752
[17fd1d4]753 /* Wait for reply from the driver */
754 ipcarg_t rc;
755 async_wait_for(msg, &rc);
756
757 /* Driver reply is the final result of the whole operation */
758 ipc_answer_0(rid, rc);
[1313ee9]759 return;
760 }
761
762 ipc_answer_0(rid, ENOENT);
[17fd1d4]763}
764
[a095d20]765void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
766{
767 ipc_answer_0(rid, ENOTSUP);
768}
769
770/**
771 * @}
[17fd1d4]772 */
Note: See TracBrowser for help on using the repository browser.