Rev 4417 | Rev 4509 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 4417 | Rev 4464 | ||
---|---|---|---|
1 | /* |
1 | /* |
2 | * Copyright (c) 2009 Martin Decky |
2 | * Copyright (c) 2009 Martin Decky |
3 | * All rights reserved. |
3 | * All rights reserved. |
4 | * |
4 | * |
5 | * Redistribution and use in source and binary forms, with or without |
5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions |
6 | * modification, are permitted provided that the following conditions |
7 | * are met: |
7 | * are met: |
8 | * |
8 | * |
9 | * - Redistributions of source code must retain the above copyright |
9 | * - Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. |
10 | * notice, this list of conditions and the following disclaimer. |
11 | * - Redistributions in binary form must reproduce the above copyright |
11 | * - Redistributions in binary form must reproduce the above copyright |
12 | * notice, this list of conditions and the following disclaimer in the |
12 | * notice, this list of conditions and the following disclaimer in the |
13 | * documentation and/or other materials provided with the distribution. |
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 |
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. |
15 | * derived from this software without specific prior written permission. |
16 | * |
16 | * |
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
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 |
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
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 |
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
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 |
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. |
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
27 | */ |
27 | */ |
28 | 28 | ||
29 | /** @addtogroup fs |
29 | /** @addtogroup fs |
30 | * @{ |
30 | * @{ |
31 | */ |
31 | */ |
32 | 32 | ||
33 | /** |
33 | /** |
34 | * @file devfs_ops.c |
34 | * @file devfs_ops.c |
35 | * @brief Implementation of VFS operations for the devfs file system server. |
35 | * @brief Implementation of VFS operations for the devfs file system server. |
36 | */ |
36 | */ |
37 | 37 | ||
38 | #include <ipc/ipc.h> |
38 | #include <ipc/ipc.h> |
39 | #include <bool.h> |
39 | #include <bool.h> |
40 | #include <errno.h> |
40 | #include <errno.h> |
41 | #include <malloc.h> |
41 | #include <malloc.h> |
42 | #include <string.h> |
42 | #include <string.h> |
43 | #include <libfs.h> |
43 | #include <libfs.h> |
- | 44 | #include <libadt/hash_table.h> |
|
44 | #include "devfs.h" |
45 | #include "devfs.h" |
45 | #include "devfs_ops.h" |
46 | #include "devfs_ops.h" |
46 | 47 | ||
47 | #define PLB_GET_CHAR(pos) (devfs_reg.plb_ro[pos % PLB_SIZE]) |
48 | #define PLB_GET_CHAR(pos) (devfs_reg.plb_ro[pos % PLB_SIZE]) |
48 | 49 | ||
- | 50 | /** Opened devices structure */ |
|
- | 51 | typedef struct { |
|
- | 52 | dev_handle_t handle; |
|
- | 53 | int phone; |
|
- | 54 | size_t refcount; |
|
- | 55 | link_t link; |
|
- | 56 | } device_t; |
|
- | 57 | ||
- | 58 | /** Hash table of opened devices */ |
|
- | 59 | static hash_table_t devices; |
|
- | 60 | ||
- | 61 | #define DEVICES_KEYS 1 |
|
- | 62 | #define DEVICES_KEY_HANDLE 0 |
|
- | 63 | #define DEVICES_BUCKETS 256 |
|
- | 64 | ||
- | 65 | /* Implementation of hash table interface for the nodes hash table. */ |
|
- | 66 | static hash_index_t devices_hash(unsigned long key[]) |
|
- | 67 | { |
|
- | 68 | return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS; |
|
- | 69 | } |
|
- | 70 | ||
- | 71 | static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item) |
|
- | 72 | { |
|
- | 73 | device_t *dev = hash_table_get_instance(item, device_t, link); |
|
- | 74 | return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]); |
|
- | 75 | } |
|
- | 76 | ||
- | 77 | static void devices_remove_callback(link_t *item) |
|
- | 78 | { |
|
- | 79 | free(hash_table_get_instance(item, device_t, link)); |
|
- | 80 | } |
|
- | 81 | ||
- | 82 | static hash_table_operations_t devices_ops = { |
|
- | 83 | .hash = devices_hash, |
|
- | 84 | .compare = devices_compare, |
|
- | 85 | .remove_callback = devices_remove_callback |
|
- | 86 | }; |
|
- | 87 | ||
49 | bool devfs_init(void) |
88 | bool devfs_init(void) |
50 | { |
89 | { |
- | 90 | if (!hash_table_create(&devices, DEVICES_BUCKETS, |
|
- | 91 | DEVICES_KEYS, &devices_ops)) |
|
- | 92 | return false; |
|
- | 93 | ||
51 | if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0) |
94 | if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0) |
52 | return false; |
95 | return false; |
53 | 96 | ||
54 | return true; |
97 | return true; |
55 | } |
98 | } |
56 | 99 | ||
57 | void devfs_mounted(ipc_callid_t rid, ipc_call_t *request) |
100 | void devfs_mounted(ipc_callid_t rid, ipc_call_t *request) |
58 | { |
101 | { |
59 | /* Accept the mount options */ |
102 | /* Accept the mount options */ |
60 | ipc_callid_t callid; |
103 | ipc_callid_t callid; |
61 | size_t size; |
104 | size_t size; |
62 | if (!ipc_data_write_receive(&callid, &size)) { |
105 | if (!ipc_data_write_receive(&callid, &size)) { |
63 | ipc_answer_0(callid, EINVAL); |
106 | ipc_answer_0(callid, EINVAL); |
64 | ipc_answer_0(rid, EINVAL); |
107 | ipc_answer_0(rid, EINVAL); |
65 | return; |
108 | return; |
66 | } |
109 | } |
67 | 110 | ||
68 | char *opts = malloc(size + 1); |
111 | char *opts = malloc(size + 1); |
69 | if (!opts) { |
112 | if (!opts) { |
70 | ipc_answer_0(callid, ENOMEM); |
113 | ipc_answer_0(callid, ENOMEM); |
71 | ipc_answer_0(rid, ENOMEM); |
114 | ipc_answer_0(rid, ENOMEM); |
72 | return; |
115 | return; |
73 | } |
116 | } |
74 | 117 | ||
75 | ipcarg_t retval = ipc_data_write_finalize(callid, opts, size); |
118 | ipcarg_t retval = ipc_data_write_finalize(callid, opts, size); |
76 | if (retval != EOK) { |
119 | if (retval != EOK) { |
77 | ipc_answer_0(rid, retval); |
120 | ipc_answer_0(rid, retval); |
78 | free(opts); |
121 | free(opts); |
79 | return; |
122 | return; |
80 | } |
123 | } |
81 | 124 | ||
82 | free(opts); |
125 | free(opts); |
83 | 126 | ||
84 | ipc_answer_3(rid, EOK, 0, 0, 0); |
127 | ipc_answer_3(rid, EOK, 0, 0, 0); |
85 | } |
128 | } |
86 | 129 | ||
87 | void devfs_mount(ipc_callid_t rid, ipc_call_t *request) |
130 | void devfs_mount(ipc_callid_t rid, ipc_call_t *request) |
88 | { |
131 | { |
89 | ipc_answer_0(rid, ENOTSUP); |
132 | ipc_answer_0(rid, ENOTSUP); |
90 | } |
133 | } |
91 | 134 | ||
92 | void devfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
135 | void devfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
93 | { |
136 | { |
94 | ipcarg_t first = IPC_GET_ARG1(*request); |
137 | ipcarg_t first = IPC_GET_ARG1(*request); |
95 | ipcarg_t last = IPC_GET_ARG2(*request); |
138 | ipcarg_t last = IPC_GET_ARG2(*request); |
96 | dev_handle_t dev_handle = IPC_GET_ARG3(*request); |
139 | dev_handle_t dev_handle = IPC_GET_ARG3(*request); |
97 | ipcarg_t lflag = IPC_GET_ARG4(*request); |
140 | ipcarg_t lflag = IPC_GET_ARG4(*request); |
98 | fs_index_t index = IPC_GET_ARG5(*request); |
141 | fs_index_t index = IPC_GET_ARG5(*request); |
99 | 142 | ||
100 | /* Hierarchy is flat, no altroot is supported */ |
143 | /* Hierarchy is flat, no altroot is supported */ |
101 | if (index != 0) { |
144 | if (index != 0) { |
102 | ipc_answer_0(rid, ENOENT); |
145 | ipc_answer_0(rid, ENOENT); |
103 | return; |
146 | return; |
104 | } |
147 | } |
105 | 148 | ||
106 | /* This is a read-only filesystem */ |
- | |
107 | if ((lflag & L_CREATE) || (lflag & L_LINK) || (lflag & L_UNLINK)) { |
149 | if ((lflag & L_LINK) || (lflag & L_UNLINK)) { |
108 | ipc_answer_0(rid, ENOTSUP); |
150 | ipc_answer_0(rid, ENOTSUP); |
109 | return; |
151 | return; |
110 | } |
152 | } |
111 | 153 | ||
112 | /* Eat slash */ |
154 | /* Eat slash */ |
113 | if (PLB_GET_CHAR(first) == '/') { |
155 | if (PLB_GET_CHAR(first) == '/') { |
114 | first++; |
156 | first++; |
115 | first %= PLB_SIZE; |
157 | first %= PLB_SIZE; |
116 | } |
158 | } |
117 | 159 | ||
118 | if (first >= last) { |
160 | if (first >= last) { |
119 | /* Root entry */ |
161 | /* Root entry */ |
120 | if (lflag & L_DIRECTORY) |
162 | if (lflag & L_DIRECTORY) |
121 | ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, 0, 0, 0); |
163 | ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, 0, 0, 0); |
122 | else |
164 | else |
123 | ipc_answer_0(rid, ENOENT); |
165 | ipc_answer_0(rid, ENOENT); |
124 | } else { |
166 | } else { |
125 | if (lflag & L_FILE) { |
167 | if (lflag & L_FILE) { |
126 | count_t len; |
168 | size_t len; |
127 | if (last >= first) |
169 | if (last >= first) |
128 | len = last - first + 1; |
170 | len = last - first + 1; |
129 | else |
171 | else |
130 | len = first + PLB_SIZE - last + 1; |
172 | len = first + PLB_SIZE - last + 1; |
131 | 173 | ||
132 | char *name = (char *) malloc(len + 1); |
174 | char *name = (char *) malloc(len + 1); |
133 | if (name == NULL) { |
175 | if (name == NULL) { |
134 | ipc_answer_0(rid, ENOMEM); |
176 | ipc_answer_0(rid, ENOMEM); |
135 | return; |
177 | return; |
136 | } |
178 | } |
137 | 179 | ||
138 | count_t i; |
180 | size_t i; |
139 | for (i = 0; i < len; i++) |
181 | for (i = 0; i < len; i++) |
140 | name[i] = PLB_GET_CHAR(first + i); |
182 | name[i] = PLB_GET_CHAR(first + i); |
141 | 183 | ||
142 | name[len] = 0; |
184 | name[len] = 0; |
143 | 185 | ||
144 | dev_handle_t handle; |
186 | dev_handle_t handle; |
145 | if (devmap_device_get_handle(name, &handle, 0) != EOK) { |
187 | if (devmap_device_get_handle(name, &handle, 0) != EOK) { |
146 | free(name); |
188 | free(name); |
147 | ipc_answer_0(rid, ENOENT); |
189 | ipc_answer_0(rid, ENOENT); |
148 | return; |
190 | return; |
149 | } |
191 | } |
150 | 192 | ||
- | 193 | if (lflag & L_OPEN) { |
|
- | 194 | unsigned long key[] = { |
|
- | 195 | [DEVICES_KEY_HANDLE] = (unsigned long) handle |
|
- | 196 | }; |
|
- | 197 | ||
- | 198 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 199 | if (lnk == NULL) { |
|
- | 200 | int phone = devmap_device_connect(handle, 0); |
|
- | 201 | if (phone < 0) { |
|
- | 202 | free(name); |
|
- | 203 | ipc_answer_0(rid, ENOENT); |
|
- | 204 | return; |
|
- | 205 | } |
|
- | 206 | ||
- | 207 | device_t *dev = (device_t *) malloc(sizeof(device_t)); |
|
- | 208 | if (dev == NULL) { |
|
- | 209 | free(name); |
|
- | 210 | ipc_answer_0(rid, ENOMEM); |
|
- | 211 | return; |
|
- | 212 | } |
|
- | 213 | ||
- | 214 | dev->handle = handle; |
|
- | 215 | dev->phone = phone; |
|
- | 216 | dev->refcount = 1; |
|
- | 217 | ||
- | 218 | hash_table_insert(&devices, key, &dev->link); |
|
- | 219 | } else { |
|
- | 220 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 221 | dev->refcount++; |
|
- | 222 | } |
|
- | 223 | } |
|
- | 224 | ||
151 | free(name); |
225 | free(name); |
152 | 226 | ||
153 | ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, handle, 0, 1); |
227 | ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, handle, 0, 1); |
154 | } else |
228 | } else |
155 | ipc_answer_0(rid, ENOENT); |
229 | ipc_answer_0(rid, ENOENT); |
156 | } |
230 | } |
157 | } |
231 | } |
158 | 232 | ||
159 | void devfs_read(ipc_callid_t rid, ipc_call_t *request) |
233 | void devfs_open_node(ipc_callid_t rid, ipc_call_t *request) |
160 | { |
234 | { |
161 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
- | |
162 | off_t pos = (off_t) IPC_GET_ARG3(*request); |
235 | dev_handle_t handle = IPC_GET_ARG2(*request); |
163 | 236 | ||
- | 237 | unsigned long key[] = { |
|
- | 238 | [DEVICES_KEY_HANDLE] = (unsigned long) handle |
|
- | 239 | }; |
|
- | 240 | ||
- | 241 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 242 | if (lnk == NULL) { |
|
- | 243 | int phone = devmap_device_connect(handle, 0); |
|
164 | if (index != 0) { |
244 | if (phone < 0) { |
165 | ipc_answer_1(rid, ENOENT, 0); |
245 | ipc_answer_0(rid, ENOENT); |
- | 246 | return; |
|
- | 247 | } |
|
- | 248 | ||
- | 249 | device_t *dev = (device_t *) malloc(sizeof(device_t)); |
|
- | 250 | if (dev == NULL) { |
|
- | 251 | ipc_answer_0(rid, ENOMEM); |
|
166 | return; |
252 | return; |
- | 253 | } |
|
- | 254 | ||
- | 255 | dev->handle = handle; |
|
- | 256 | dev->phone = phone; |
|
- | 257 | dev->refcount = 1; |
|
- | 258 | ||
- | 259 | hash_table_insert(&devices, key, &dev->link); |
|
- | 260 | } else { |
|
- | 261 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 262 | dev->refcount++; |
|
167 | } |
263 | } |
168 | 264 | ||
169 | /* |
- | |
170 | * Receive the read request. |
265 | ipc_answer_3(rid, EOK, 0, 1, L_FILE); |
171 | */ |
266 | } |
172 | ipc_callid_t callid; |
- | |
173 | size_t size; |
267 | |
174 | if (!ipc_data_read_receive(&callid, &size)) { |
268 | void devfs_device(ipc_callid_t rid, ipc_call_t *request) |
175 | ipc_answer_0(callid, EINVAL); |
- | |
176 | ipc_answer_0(rid, EINVAL); |
- | |
177 | return; |
- | |
178 | } |
269 | { |
- | 270 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
|
179 | 271 | ||
180 | size_t bytes = 0; |
- | |
181 | if (index != 0) { |
272 | if (index != 0) { |
- | 273 | unsigned long key[] = { |
|
- | 274 | [DEVICES_KEY_HANDLE] = (unsigned long) index |
|
- | 275 | }; |
|
- | 276 | ||
- | 277 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 278 | if (lnk == NULL) { |
|
- | 279 | ipc_answer_0(rid, ENOENT); |
|
- | 280 | return; |
|
- | 281 | } |
|
- | 282 | ||
- | 283 | ipc_answer_1(rid, EOK, (ipcarg_t) index); |
|
- | 284 | } else |
|
- | 285 | ipc_answer_0(rid, ENOTSUP); |
|
- | 286 | } |
|
- | 287 | ||
- | 288 | void devfs_read(ipc_callid_t rid, ipc_call_t *request) |
|
- | 289 | { |
|
- | 290 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
|
- | 291 | off_t pos = (off_t) IPC_GET_ARG3(*request); |
|
- | 292 | ||
- | 293 | if (index != 0) { |
|
- | 294 | unsigned long key[] = { |
|
- | 295 | [DEVICES_KEY_HANDLE] = (unsigned long) index |
|
- | 296 | }; |
|
- | 297 | ||
- | 298 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 299 | if (lnk == NULL) { |
|
- | 300 | ipc_answer_0(rid, ENOENT); |
|
- | 301 | return; |
|
- | 302 | } |
|
- | 303 | ||
- | 304 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 305 | ||
- | 306 | ipc_callid_t callid; |
|
182 | (void) ipc_data_read_finalize(callid, NULL, bytes); |
307 | if (!ipc_data_read_receive(&callid, NULL)) { |
- | 308 | ipc_answer_0(callid, EINVAL); |
|
- | 309 | ipc_answer_0(rid, EINVAL); |
|
- | 310 | return; |
|
- | 311 | } |
|
- | 312 | ||
- | 313 | /* Make a request at the driver */ |
|
- | 314 | ipc_call_t answer; |
|
- | 315 | aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request), |
|
- | 316 | IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), |
|
- | 317 | IPC_GET_ARG3(*request), &answer); |
|
- | 318 | ||
- | 319 | /* Forward the IPC_M_DATA_READ request to the driver */ |
|
- | 320 | ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); |
|
- | 321 | ||
- | 322 | /* Wait for reply from the driver. */ |
|
- | 323 | ipcarg_t rc; |
|
- | 324 | async_wait_for(msg, &rc); |
|
- | 325 | size_t bytes = IPC_GET_ARG1(answer); |
|
- | 326 | ||
- | 327 | /* Driver reply is the final result of the whole operation */ |
|
- | 328 | ipc_answer_1(rid, rc, bytes); |
|
183 | } else { |
329 | } else { |
- | 330 | ipc_callid_t callid; |
|
- | 331 | size_t size; |
|
- | 332 | if (!ipc_data_read_receive(&callid, &size)) { |
|
- | 333 | ipc_answer_0(callid, EINVAL); |
|
- | 334 | ipc_answer_0(rid, EINVAL); |
|
- | 335 | return; |
|
- | 336 | } |
|
- | 337 | ||
184 | count_t count = devmap_device_get_count(); |
338 | size_t count = devmap_device_get_count(); |
185 | dev_desc_t *desc = malloc(count * sizeof(dev_desc_t)); |
339 | dev_desc_t *desc = malloc(count * sizeof(dev_desc_t)); |
186 | if (desc == NULL) { |
340 | if (desc == NULL) { |
187 | ipc_answer_0(callid, ENOENT); |
341 | ipc_answer_0(callid, ENOMEM); |
188 | ipc_answer_1(rid, ENOENT, 0); |
342 | ipc_answer_1(rid, ENOMEM, 0); |
189 | return; |
343 | return; |
190 | } |
344 | } |
191 | 345 | ||
192 | count_t max = devmap_device_get_devices(count, desc); |
346 | size_t max = devmap_device_get_devices(count, desc); |
193 | 347 | ||
194 | if (pos < max) { |
348 | if (pos < max) { |
195 | ipc_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); |
349 | ipc_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); |
196 | } else { |
350 | } else { |
197 | ipc_answer_0(callid, ENOENT); |
351 | ipc_answer_0(callid, ENOENT); |
198 | ipc_answer_1(rid, ENOENT, 0); |
352 | ipc_answer_1(rid, ENOENT, 0); |
199 | return; |
353 | return; |
200 | } |
354 | } |
201 | 355 | ||
202 | free(desc); |
356 | free(desc); |
- | 357 | ||
203 | bytes = 1; |
358 | ipc_answer_1(rid, EOK, 1); |
204 | } |
359 | } |
205 | - | ||
206 | ipc_answer_1(rid, EOK, bytes); |
- | |
207 | } |
360 | } |
208 | 361 | ||
209 | void devfs_write(ipc_callid_t rid, ipc_call_t *request) |
362 | void devfs_write(ipc_callid_t rid, ipc_call_t *request) |
210 | { |
363 | { |
211 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
364 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
212 | off_t pos = (off_t) IPC_GET_ARG3(*request); |
365 | off_t pos = (off_t) IPC_GET_ARG3(*request); |
213 | 366 | ||
- | 367 | if (index != 0) { |
|
- | 368 | unsigned long key[] = { |
|
- | 369 | [DEVICES_KEY_HANDLE] = (unsigned long) index |
|
- | 370 | }; |
|
214 | /* |
371 | |
- | 372 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 373 | if (lnk == NULL) { |
|
215 | * Receive the write request. |
374 | ipc_answer_0(rid, ENOENT); |
- | 375 | return; |
|
216 | */ |
376 | } |
- | 377 | ||
- | 378 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 379 | ||
217 | ipc_callid_t callid; |
380 | ipc_callid_t callid; |
218 | size_t size; |
- | |
219 | if (!ipc_data_write_receive(&callid, &size)) { |
381 | if (!ipc_data_write_receive(&callid, NULL)) { |
220 | ipc_answer_0(callid, EINVAL); |
382 | ipc_answer_0(callid, EINVAL); |
221 | ipc_answer_0(rid, EINVAL); |
383 | ipc_answer_0(rid, EINVAL); |
222 | return; |
384 | return; |
- | 385 | } |
|
- | 386 | ||
- | 387 | /* Make a request at the driver */ |
|
- | 388 | ipc_call_t answer; |
|
- | 389 | aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request), |
|
- | 390 | IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), |
|
- | 391 | IPC_GET_ARG3(*request), &answer); |
|
- | 392 | ||
- | 393 | /* Forward the IPC_M_DATA_WRITE request to the driver */ |
|
- | 394 | ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); |
|
- | 395 | ||
- | 396 | /* Wait for reply from the driver. */ |
|
- | 397 | ipcarg_t rc; |
|
- | 398 | async_wait_for(msg, &rc); |
|
- | 399 | size_t bytes = IPC_GET_ARG1(answer); |
|
- | 400 | ||
- | 401 | /* Driver reply is the final result of the whole operation */ |
|
- | 402 | ipc_answer_1(rid, rc, bytes); |
|
- | 403 | } else { |
|
- | 404 | /* Read-only filesystem */ |
|
- | 405 | ipc_answer_0(rid, ENOTSUP); |
|
223 | } |
406 | } |
224 | - | ||
225 | // TODO |
- | |
226 | ipc_answer_0(callid, ENOENT); |
- | |
227 | ipc_answer_2(rid, ENOENT, 0, 0); |
- | |
228 | } |
407 | } |
229 | 408 | ||
230 | void devfs_truncate(ipc_callid_t rid, ipc_call_t *request) |
409 | void devfs_truncate(ipc_callid_t rid, ipc_call_t *request) |
231 | { |
410 | { |
232 | ipc_answer_0(rid, ENOTSUP); |
411 | ipc_answer_0(rid, ENOTSUP); |
233 | } |
412 | } |
234 | 413 | ||
- | 414 | void devfs_close(ipc_callid_t rid, ipc_call_t *request) |
|
- | 415 | { |
|
- | 416 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
|
- | 417 | ||
- | 418 | if (index != 0) { |
|
- | 419 | unsigned long key[] = { |
|
- | 420 | [DEVICES_KEY_HANDLE] = (unsigned long) index |
|
- | 421 | }; |
|
- | 422 | ||
- | 423 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 424 | if (lnk == NULL) { |
|
- | 425 | ipc_answer_0(rid, ENOENT); |
|
- | 426 | return; |
|
- | 427 | } |
|
- | 428 | ||
- | 429 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 430 | dev->refcount--; |
|
- | 431 | ||
- | 432 | if (dev->refcount == 0) { |
|
- | 433 | ipc_hangup(dev->phone); |
|
- | 434 | hash_table_remove(&devices, key, DEVICES_KEYS); |
|
- | 435 | } |
|
- | 436 | ||
- | 437 | ipc_answer_0(rid, EOK); |
|
- | 438 | } else |
|
- | 439 | ipc_answer_0(rid, ENOTSUP); |
|
- | 440 | } |
|
- | 441 | ||
- | 442 | void devfs_sync(ipc_callid_t rid, ipc_call_t *request) |
|
- | 443 | { |
|
- | 444 | fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
|
- | 445 | ||
- | 446 | if (index != 0) { |
|
- | 447 | unsigned long key[] = { |
|
- | 448 | [DEVICES_KEY_HANDLE] = (unsigned long) index |
|
- | 449 | }; |
|
- | 450 | ||
- | 451 | link_t *lnk = hash_table_find(&devices, key); |
|
- | 452 | if (lnk == NULL) { |
|
- | 453 | ipc_answer_0(rid, ENOENT); |
|
- | 454 | return; |
|
- | 455 | } |
|
- | 456 | ||
- | 457 | device_t *dev = hash_table_get_instance(lnk, device_t, link); |
|
- | 458 | ||
- | 459 | /* Make a request at the driver */ |
|
- | 460 | ipc_call_t answer; |
|
- | 461 | aid_t msg = async_send_2(dev->phone, IPC_GET_METHOD(*request), |
|
- | 462 | IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer); |
|
- | 463 | ||
- | 464 | /* Wait for reply from the driver */ |
|
- | 465 | ipcarg_t rc; |
|
- | 466 | async_wait_for(msg, &rc); |
|
- | 467 | ||
- | 468 | /* Driver reply is the final result of the whole operation */ |
|
- | 469 | ipc_answer_0(rid, rc); |
|
- | 470 | } else |
|
- | 471 | ipc_answer_0(rid, ENOTSUP); |
|
- | 472 | } |
|
- | 473 | ||
235 | void devfs_destroy(ipc_callid_t rid, ipc_call_t *request) |
474 | void devfs_destroy(ipc_callid_t rid, ipc_call_t *request) |
236 | { |
475 | { |
237 | ipc_answer_0(rid, ENOTSUP); |
476 | ipc_answer_0(rid, ENOTSUP); |
238 | } |
477 | } |
239 | 478 | ||
240 | /** |
479 | /** |
241 | * @} |
480 | * @} |
242 | */ |
481 | */ |
243 | 482 |