source: mainline/uspace/srv/vfs/vfs_ipc.c@ f1380b7

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since f1380b7 was a35b458, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.
  • Property mode set to 100644
File size: 9.5 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(ipc_callid_t rid, 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(rid, rc, outfd);
46}
47
48static void vfs_in_fsprobe(ipc_callid_t rid, ipc_call_t *request)
49{
50 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
51 char *fs_name = NULL;
52 ipc_callid_t callid;
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(rid, rc);
65 return;
66 }
67
68 rc = vfs_op_fsprobe(fs_name, service_id, &info);
69 async_answer_0(rid, rc);
70 if (rc != EOK)
71 goto out;
72
73 /* Now we should get a read request */
74 if (!async_data_read_receive(&callid, &len))
75 goto out;
76
77 if (len > sizeof(info))
78 len = sizeof(info);
79 (void) async_data_read_finalize(callid, &info, len);
80
81out:
82 free(fs_name);
83}
84
85static void vfs_in_fstypes(ipc_callid_t rid, ipc_call_t *request)
86{
87 ipc_callid_t callid;
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(rid, ENOMEM);
95 return;
96 }
97
98 /* Send size of the data */
99 async_answer_1(rid, EOK, fstypes.size);
100
101 /* Now we should get a read request */
102 if (!async_data_read_receive(&callid, &len))
103 goto out;
104
105 if (len > fstypes.size)
106 len = fstypes.size;
107 (void) async_data_read_finalize(callid, fstypes.buf, len);
108
109out:
110 vfs_fstypes_free(&fstypes);
111}
112
113static void vfs_in_mount(ipc_callid_t rid, 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(rid, rc);
135 return;
136 }
137
138 /* Now, we expect the client to send us data with the name of the file
139 * system.
140 */
141 rc = async_data_write_accept((void **) &fs_name, true, 0,
142 FS_NAME_MAXLEN, 0, NULL);
143 if (rc != EOK) {
144 free(opts);
145 async_answer_0(rid, rc);
146 return;
147 }
148
149 int outfd = 0;
150 rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name,
151 &outfd);
152 async_answer_1(rid, rc, outfd);
153
154 free(opts);
155 free(fs_name);
156}
157
158static void vfs_in_open(ipc_callid_t rid, ipc_call_t *request)
159{
160 int fd = IPC_GET_ARG1(*request);
161 int mode = IPC_GET_ARG2(*request);
162
163 errno_t rc = vfs_op_open(fd, mode);
164 async_answer_0(rid, rc);
165}
166
167static void vfs_in_put(ipc_callid_t rid, ipc_call_t *request)
168{
169 int fd = IPC_GET_ARG1(*request);
170 errno_t rc = vfs_op_put(fd);
171 async_answer_0(rid, rc);
172}
173
174static void vfs_in_read(ipc_callid_t rid, ipc_call_t *request)
175{
176 int fd = IPC_GET_ARG1(*request);
177 aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
178 IPC_GET_ARG3(*request));
179
180 size_t bytes = 0;
181 errno_t rc = vfs_op_read(fd, pos, &bytes);
182 async_answer_1(rid, rc, bytes);
183}
184
185static void vfs_in_rename(ipc_callid_t rid, ipc_call_t *request)
186{
187 /* The common base directory. */
188 int basefd;
189 char *old = NULL;
190 char *new = NULL;
191 errno_t rc;
192
193 basefd = IPC_GET_ARG1(*request);
194
195 /* Retrieve the old path. */
196 rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
197 if (rc != EOK)
198 goto out;
199
200 /* Retrieve the new path. */
201 rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL);
202 if (rc != EOK)
203 goto out;
204
205 size_t olen;
206 size_t nlen;
207 char *oldc = canonify(old, &olen);
208 char *newc = canonify(new, &nlen);
209
210 if ((!oldc) || (!newc)) {
211 rc = EINVAL;
212 goto out;
213 }
214
215 assert(oldc[olen] == '\0');
216 assert(newc[nlen] == '\0');
217
218 rc = vfs_op_rename(basefd, oldc, newc);
219
220out:
221 async_answer_0(rid, rc);
222
223 if (old)
224 free(old);
225 if (new)
226 free(new);
227}
228
229static void vfs_in_resize(ipc_callid_t rid, ipc_call_t *request)
230{
231 int fd = IPC_GET_ARG1(*request);
232 int64_t size = MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
233 errno_t rc = vfs_op_resize(fd, size);
234 async_answer_0(rid, rc);
235}
236
237static void vfs_in_stat(ipc_callid_t rid, ipc_call_t *request)
238{
239 int fd = IPC_GET_ARG1(*request);
240 errno_t rc = vfs_op_stat(fd);
241 async_answer_0(rid, rc);
242}
243
244static void vfs_in_statfs(ipc_callid_t rid, ipc_call_t *request)
245{
246 int fd = (int) IPC_GET_ARG1(*request);
247
248 errno_t rc = vfs_op_statfs(fd);
249 async_answer_0(rid, rc);
250}
251
252static void vfs_in_sync(ipc_callid_t rid, ipc_call_t *request)
253{
254 int fd = IPC_GET_ARG1(*request);
255 errno_t rc = vfs_op_sync(fd);
256 async_answer_0(rid, rc);
257}
258
259static void vfs_in_unlink(ipc_callid_t rid, ipc_call_t *request)
260{
261 int parentfd = IPC_GET_ARG1(*request);
262 int expectfd = IPC_GET_ARG2(*request);
263
264 char *path;
265 errno_t rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
266 if (rc == EOK)
267 rc = vfs_op_unlink(parentfd, expectfd, path);
268
269 async_answer_0(rid, rc);
270}
271
272static void vfs_in_unmount(ipc_callid_t rid, ipc_call_t *request)
273{
274 int mpfd = IPC_GET_ARG1(*request);
275 errno_t rc = vfs_op_unmount(mpfd);
276 async_answer_0(rid, rc);
277}
278
279static void vfs_in_wait_handle(ipc_callid_t rid, ipc_call_t *request)
280{
281 bool high_fd = IPC_GET_ARG1(*request);
282 int fd = -1;
283 errno_t rc = vfs_op_wait_handle(high_fd, &fd);
284 async_answer_1(rid, rc, fd);
285}
286
287static void vfs_in_walk(ipc_callid_t rid, ipc_call_t *request)
288{
289 /*
290 * Parent is our relative root for file lookup.
291 * For defined flags, see <ipc/vfs.h>.
292 */
293 int parentfd = IPC_GET_ARG1(*request);
294 int flags = IPC_GET_ARG2(*request);
295
296 int fd = 0;
297 char *path;
298 errno_t rc = async_data_write_accept((void **)&path, true, 0, 0, 0, NULL);
299 if (rc == EOK) {
300 rc = vfs_op_walk(parentfd, flags, path, &fd);
301 free(path);
302 }
303 async_answer_1(rid, rc, fd);
304}
305
306static void vfs_in_write(ipc_callid_t rid, ipc_call_t *request)
307{
308 int fd = IPC_GET_ARG1(*request);
309 aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
310 IPC_GET_ARG3(*request));
311
312 size_t bytes = 0;
313 errno_t rc = vfs_op_write(fd, pos, &bytes);
314 async_answer_1(rid, rc, bytes);
315}
316
317void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
318{
319 bool cont = true;
320
321 /*
322 * The connection was opened via the IPC_CONNECT_ME_TO call.
323 * This call needs to be answered.
324 */
325 async_answer_0(iid, EOK);
326
327 while (cont) {
328 ipc_call_t call;
329 ipc_callid_t callid = async_get_call(&call);
330
331 if (!IPC_GET_IMETHOD(call))
332 break;
333
334 switch (IPC_GET_IMETHOD(call)) {
335 case VFS_IN_CLONE:
336 vfs_in_clone(callid, &call);
337 break;
338 case VFS_IN_FSPROBE:
339 vfs_in_fsprobe(callid, &call);
340 break;
341 case VFS_IN_FSTYPES:
342 vfs_in_fstypes(callid, &call);
343 break;
344 case VFS_IN_MOUNT:
345 vfs_in_mount(callid, &call);
346 break;
347 case VFS_IN_OPEN:
348 vfs_in_open(callid, &call);
349 break;
350 case VFS_IN_PUT:
351 vfs_in_put(callid, &call);
352 break;
353 case VFS_IN_READ:
354 vfs_in_read(callid, &call);
355 break;
356 case VFS_IN_REGISTER:
357 vfs_register(callid, &call);
358 cont = false;
359 break;
360 case VFS_IN_RENAME:
361 vfs_in_rename(callid, &call);
362 break;
363 case VFS_IN_RESIZE:
364 vfs_in_resize(callid, &call);
365 break;
366 case VFS_IN_STAT:
367 vfs_in_stat(callid, &call);
368 break;
369 case VFS_IN_STATFS:
370 vfs_in_statfs(callid, &call);
371 break;
372 case VFS_IN_SYNC:
373 vfs_in_sync(callid, &call);
374 break;
375 case VFS_IN_UNLINK:
376 vfs_in_unlink(callid, &call);
377 break;
378 case VFS_IN_UNMOUNT:
379 vfs_in_unmount(callid, &call);
380 break;
381 case VFS_IN_WAIT_HANDLE:
382 vfs_in_wait_handle(callid, &call);
383 break;
384 case VFS_IN_WALK:
385 vfs_in_walk(callid, &call);
386 break;
387 case VFS_IN_WRITE:
388 vfs_in_write(callid, &call);
389 break;
390 default:
391 async_answer_0(callid, ENOTSUP);
392 break;
393 }
394 }
395
396 /*
397 * Open files for this client will be cleaned up when its last
398 * connection fibril terminates.
399 */
400}
Note: See TracBrowser for help on using the repository browser.