source: mainline/uspace/srv/vfs/vfs_ipc.c@ 76f566d

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 76f566d was 7c3fb9b, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix block comment formatting (ccheck).
  • Property mode set to 100644
File size: 9.9 KB
Line 
1/*
2 * Copyright (c) 2008 Jakub Jermar
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#include <vfs/vfs.h>
30#include "vfs.h"
31
32#include <errno.h>
33#include <stdlib.h>
34#include <str.h>
35#include <vfs/canonify.h>
36
37static void vfs_in_clone(cap_call_handle_t req_handle, ipc_call_t *request)
38{
39 int oldfd = IPC_GET_ARG1(*request);
40 int newfd = IPC_GET_ARG2(*request);
41 bool desc = IPC_GET_ARG3(*request);
42
43 int outfd = -1;
44 errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd);
45 async_answer_1(req_handle, rc, outfd);
46}
47
48static void vfs_in_fsprobe(cap_call_handle_t req_handle, ipc_call_t *request)
49{
50 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
51 char *fs_name = NULL;
52 cap_call_handle_t chandle;
53 vfs_fs_probe_info_t info;
54 size_t len;
55 errno_t rc;
56
57 /*
58 * Now we expect the client to send us data with the name of the file
59 * system.
60 */
61 rc = async_data_write_accept((void **) &fs_name, true, 0,
62 FS_NAME_MAXLEN, 0, NULL);
63 if (rc != EOK) {
64 async_answer_0(req_handle, rc);
65 return;
66 }
67
68 rc = vfs_op_fsprobe(fs_name, service_id, &info);
69 async_answer_0(req_handle, rc);
70 if (rc != EOK)
71 goto out;
72
73 /* Now we should get a read request */
74 if (!async_data_read_receive(&chandle, &len))
75 goto out;
76
77 if (len > sizeof(info))
78 len = sizeof(info);
79 (void) async_data_read_finalize(chandle, &info, len);
80
81out:
82 free(fs_name);
83}
84
85static void vfs_in_fstypes(cap_call_handle_t req_handle, ipc_call_t *request)
86{
87 cap_call_handle_t chandle;
88 size_t len;
89 vfs_fstypes_t fstypes;
90 errno_t rc;
91
92 rc = vfs_get_fstypes(&fstypes);
93 if (rc != EOK) {
94 async_answer_0(req_handle, ENOMEM);
95 return;
96 }
97
98 /* Send size of the data */
99 async_answer_1(req_handle, EOK, fstypes.size);
100
101 /* Now we should get a read request */
102 if (!async_data_read_receive(&chandle, &len))
103 goto out;
104
105 if (len > fstypes.size)
106 len = fstypes.size;
107 (void) async_data_read_finalize(chandle, fstypes.buf, len);
108
109out:
110 vfs_fstypes_free(&fstypes);
111}
112
113static void vfs_in_mount(cap_call_handle_t req_handle, ipc_call_t *request)
114{
115 int mpfd = IPC_GET_ARG1(*request);
116
117 /*
118 * We expect the library to do the device-name to device-handle
119 * translation for us, thus the device handle will arrive as ARG1
120 * in the request.
121 */
122 service_id_t service_id = (service_id_t) IPC_GET_ARG2(*request);
123
124 unsigned int flags = (unsigned int) IPC_GET_ARG3(*request);
125 unsigned int instance = IPC_GET_ARG4(*request);
126
127 char *opts = NULL;
128 char *fs_name = NULL;
129
130 /* Now we expect to receive the mount options. */
131 errno_t rc = async_data_write_accept((void **) &opts, true, 0,
132 MAX_MNTOPTS_LEN, 0, NULL);
133 if (rc != EOK) {
134 async_answer_0(req_handle, rc);
135 return;
136 }
137
138 /*
139 * Now we expect the client to send us data with the name of the file
140 * system.
141 */
142 rc = async_data_write_accept((void **) &fs_name, true, 0,
143 FS_NAME_MAXLEN, 0, NULL);
144 if (rc != EOK) {
145 free(opts);
146 async_answer_0(req_handle, rc);
147 return;
148 }
149
150 int outfd = 0;
151 rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name,
152 &outfd);
153 async_answer_1(req_handle, rc, outfd);
154
155 free(opts);
156 free(fs_name);
157}
158
159static void vfs_in_open(cap_call_handle_t req_handle, ipc_call_t *request)
160{
161 int fd = IPC_GET_ARG1(*request);
162 int mode = IPC_GET_ARG2(*request);
163
164 errno_t rc = vfs_op_open(fd, mode);
165 async_answer_0(req_handle, rc);
166}
167
168static void vfs_in_put(cap_call_handle_t req_handle, ipc_call_t *request)
169{
170 int fd = IPC_GET_ARG1(*request);
171 errno_t rc = vfs_op_put(fd);
172 async_answer_0(req_handle, rc);
173}
174
175static void vfs_in_read(cap_call_handle_t req_handle, ipc_call_t *request)
176{
177 int fd = IPC_GET_ARG1(*request);
178 aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
179 IPC_GET_ARG3(*request));
180
181 size_t bytes = 0;
182 errno_t rc = vfs_op_read(fd, pos, &bytes);
183 async_answer_1(req_handle, rc, bytes);
184}
185
186static void vfs_in_rename(cap_call_handle_t req_handle, ipc_call_t *request)
187{
188 /* The common base directory. */
189 int basefd;
190 char *old = NULL;
191 char *new = NULL;
192 errno_t rc;
193
194 basefd = IPC_GET_ARG1(*request);
195
196 /* Retrieve the old path. */
197 rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
198 if (rc != EOK)
199 goto out;
200
201 /* Retrieve the new path. */
202 rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL);
203 if (rc != EOK)
204 goto out;
205
206 size_t olen;
207 size_t nlen;
208 char *oldc = canonify(old, &olen);
209 char *newc = canonify(new, &nlen);
210
211 if ((!oldc) || (!newc)) {
212 rc = EINVAL;
213 goto out;
214 }
215
216 assert(oldc[olen] == '\0');
217 assert(newc[nlen] == '\0');
218
219 rc = vfs_op_rename(basefd, oldc, newc);
220
221out:
222 async_answer_0(req_handle, rc);
223
224 if (old)
225 free(old);
226 if (new)
227 free(new);
228}
229
230static void vfs_in_resize(cap_call_handle_t req_handle, ipc_call_t *request)
231{
232 int fd = IPC_GET_ARG1(*request);
233 int64_t size = MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
234 errno_t rc = vfs_op_resize(fd, size);
235 async_answer_0(req_handle, rc);
236}
237
238static void vfs_in_stat(cap_call_handle_t req_handle, ipc_call_t *request)
239{
240 int fd = IPC_GET_ARG1(*request);
241 errno_t rc = vfs_op_stat(fd);
242 async_answer_0(req_handle, rc);
243}
244
245static void vfs_in_statfs(cap_call_handle_t req_handle, ipc_call_t *request)
246{
247 int fd = (int) IPC_GET_ARG1(*request);
248
249 errno_t rc = vfs_op_statfs(fd);
250 async_answer_0(req_handle, rc);
251}
252
253static void vfs_in_sync(cap_call_handle_t req_handle, ipc_call_t *request)
254{
255 int fd = IPC_GET_ARG1(*request);
256 errno_t rc = vfs_op_sync(fd);
257 async_answer_0(req_handle, rc);
258}
259
260static void vfs_in_unlink(cap_call_handle_t req_handle, ipc_call_t *request)
261{
262 int parentfd = IPC_GET_ARG1(*request);
263 int expectfd = IPC_GET_ARG2(*request);
264
265 char *path;
266 errno_t rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
267 if (rc == EOK)
268 rc = vfs_op_unlink(parentfd, expectfd, path);
269
270 async_answer_0(req_handle, rc);
271}
272
273static void vfs_in_unmount(cap_call_handle_t req_handle, ipc_call_t *request)
274{
275 int mpfd = IPC_GET_ARG1(*request);
276 errno_t rc = vfs_op_unmount(mpfd);
277 async_answer_0(req_handle, rc);
278}
279
280static void vfs_in_wait_handle(cap_call_handle_t req_handle, ipc_call_t *request)
281{
282 bool high_fd = IPC_GET_ARG1(*request);
283 int fd = -1;
284 errno_t rc = vfs_op_wait_handle(high_fd, &fd);
285 async_answer_1(req_handle, rc, fd);
286}
287
288static void vfs_in_walk(cap_call_handle_t req_handle, ipc_call_t *request)
289{
290 /*
291 * Parent is our relative root for file lookup.
292 * For defined flags, see <ipc/vfs.h>.
293 */
294 int parentfd = IPC_GET_ARG1(*request);
295 int flags = IPC_GET_ARG2(*request);
296
297 int fd = 0;
298 char *path;
299 errno_t rc = async_data_write_accept((void **)&path, true, 0, 0, 0, NULL);
300 if (rc == EOK) {
301 rc = vfs_op_walk(parentfd, flags, path, &fd);
302 free(path);
303 }
304 async_answer_1(req_handle, rc, fd);
305}
306
307static void vfs_in_write(cap_call_handle_t req_handle, ipc_call_t *request)
308{
309 int fd = IPC_GET_ARG1(*request);
310 aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
311 IPC_GET_ARG3(*request));
312
313 size_t bytes = 0;
314 errno_t rc = vfs_op_write(fd, pos, &bytes);
315 async_answer_1(req_handle, rc, bytes);
316}
317
318void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
319{
320 bool cont = true;
321
322 /*
323 * The connection was opened via the IPC_CONNECT_ME_TO call.
324 * This call needs to be answered.
325 */
326 async_answer_0(icall_handle, EOK);
327
328 while (cont) {
329 ipc_call_t call;
330 cap_call_handle_t chandle = async_get_call(&call);
331
332 if (!IPC_GET_IMETHOD(call))
333 break;
334
335 switch (IPC_GET_IMETHOD(call)) {
336 case VFS_IN_CLONE:
337 vfs_in_clone(chandle, &call);
338 break;
339 case VFS_IN_FSPROBE:
340 vfs_in_fsprobe(chandle, &call);
341 break;
342 case VFS_IN_FSTYPES:
343 vfs_in_fstypes(chandle, &call);
344 break;
345 case VFS_IN_MOUNT:
346 vfs_in_mount(chandle, &call);
347 break;
348 case VFS_IN_OPEN:
349 vfs_in_open(chandle, &call);
350 break;
351 case VFS_IN_PUT:
352 vfs_in_put(chandle, &call);
353 break;
354 case VFS_IN_READ:
355 vfs_in_read(chandle, &call);
356 break;
357 case VFS_IN_REGISTER:
358 vfs_register(chandle, &call);
359 cont = false;
360 break;
361 case VFS_IN_RENAME:
362 vfs_in_rename(chandle, &call);
363 break;
364 case VFS_IN_RESIZE:
365 vfs_in_resize(chandle, &call);
366 break;
367 case VFS_IN_STAT:
368 vfs_in_stat(chandle, &call);
369 break;
370 case VFS_IN_STATFS:
371 vfs_in_statfs(chandle, &call);
372 break;
373 case VFS_IN_SYNC:
374 vfs_in_sync(chandle, &call);
375 break;
376 case VFS_IN_UNLINK:
377 vfs_in_unlink(chandle, &call);
378 break;
379 case VFS_IN_UNMOUNT:
380 vfs_in_unmount(chandle, &call);
381 break;
382 case VFS_IN_WAIT_HANDLE:
383 vfs_in_wait_handle(chandle, &call);
384 break;
385 case VFS_IN_WALK:
386 vfs_in_walk(chandle, &call);
387 break;
388 case VFS_IN_WRITE:
389 vfs_in_write(chandle, &call);
390 break;
391 default:
392 async_answer_0(chandle, ENOTSUP);
393 break;
394 }
395 }
396
397 /*
398 * Open files for this client will be cleaned up when its last
399 * connection fibril terminates.
400 */
401}
Note: See TracBrowser for help on using the repository browser.