source: mainline/uspace/lib/libfs/libfs.c@ dd2cfa7

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since dd2cfa7 was 0143f72, checked in by Jakub Jermar <jakub@…>, 16 years ago

Statically allocated stat structure will do.
  • Property mode set to 100644
File size: 12.7 KB
RevLine 
[74303b6]1/*
[83937ccd]2 * Copyright (c) 2009 Jakub Jermar
[74303b6]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 libfs
30 * @{
31 */
32/**
33 * @file
34 * Glue code which is commonod to all FS implementations.
35 */
36
37#include "libfs.h"
[efd4a72]38#include "../../srv/vfs/vfs.h"
39#include <errno.h>
40#include <async.h>
41#include <ipc/ipc.h>
42#include <as.h>
[2c448fb]43#include <assert.h>
44#include <dirent.h>
[595edf5]45#include <mem.h>
[75160a6]46#include <sys/stat.h>
[efd4a72]47
48/** Register file system server.
49 *
50 * This function abstracts away the tedious registration protocol from
51 * file system implementations and lets them to reuse this registration glue
52 * code.
53 *
54 * @param vfs_phone Open phone for communication with VFS.
55 * @param reg File system registration structure. It will be
56 * initialized by this function.
57 * @param info VFS info structure supplied by the file system
58 * implementation.
59 * @param conn Connection fibril for handling all calls originating in
60 * VFS.
61 *
62 * @return EOK on success or a non-zero error code on errror.
63 */
64int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
65 async_client_conn_t conn)
66{
67 /*
68 * Tell VFS that we are here and want to get registered.
69 * We use the async framework because VFS will answer the request
70 * out-of-order, when it knows that the operation succeeded or failed.
71 */
72 ipc_call_t answer;
[4198f9c3]73 aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
[efd4a72]74
75 /*
76 * Send our VFS info structure to VFS.
77 */
[215e375]78 int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
[efd4a72]79 if (rc != EOK) {
80 async_wait_for(req, NULL);
81 return rc;
82 }
83
84 /*
85 * Ask VFS for callback connection.
86 */
87 ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
88
89 /*
90 * Allocate piece of address space for PLB.
91 */
92 reg->plb_ro = as_get_mappable_page(PLB_SIZE);
93 if (!reg->plb_ro) {
94 async_wait_for(req, NULL);
95 return ENOMEM;
96 }
97
98 /*
99 * Request sharing the Path Lookup Buffer with VFS.
100 */
[215e375]101 rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
[efd4a72]102 if (rc) {
103 async_wait_for(req, NULL);
104 return rc;
105 }
106
107 /*
[4198f9c3]108 * Pick up the answer for the request to the VFS_IN_REQUEST call.
[efd4a72]109 */
110 async_wait_for(req, NULL);
111 reg->fs_handle = (int) IPC_GET_ARG1(answer);
112
113 /*
114 * Create a connection fibril to handle the callback connection.
115 */
116 async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
117
118 /*
119 * Tell the async framework that other connections are to be handled by
120 * the same connection fibril as well.
121 */
122 async_set_client_connection(conn);
123
124 return IPC_GET_RETVAL(answer);
125}
[74303b6]126
[83937ccd]127void fs_node_initialize(fs_node_t *fn)
128{
129 memset(fn, 0, sizeof(fs_node_t));
130}
131
[16d17ca]132void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
133 ipc_call_t *request)
[83937ccd]134{
[55982d6]135 dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
136 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
137 fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
138 dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
[83937ccd]139 int res;
140 ipcarg_t rc;
141
142 ipc_call_t call;
143 ipc_callid_t callid;
144
145 /* accept the phone */
146 callid = async_get_call(&call);
147 int mountee_phone = (int)IPC_GET_ARG1(call);
148 if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
149 mountee_phone < 0) {
150 ipc_answer_0(callid, EINVAL);
151 ipc_answer_0(rid, EINVAL);
152 return;
153 }
154 ipc_answer_0(callid, EOK); /* acknowledge the mountee_phone */
155
156 res = ipc_data_write_receive(&callid, NULL);
157 if (!res) {
158 ipc_hangup(mountee_phone);
159 ipc_answer_0(callid, EINVAL);
160 ipc_answer_0(rid, EINVAL);
161 return;
162 }
163
164 fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
165 if (!fn) {
166 ipc_hangup(mountee_phone);
167 ipc_answer_0(callid, ENOENT);
168 ipc_answer_0(rid, ENOENT);
169 return;
170 }
171
172 if (fn->mp_data.mp_active) {
173 ipc_hangup(mountee_phone);
174 ops->node_put(fn);
175 ipc_answer_0(callid, EBUSY);
176 ipc_answer_0(rid, EBUSY);
177 return;
178 }
179
180 rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
181 if (rc != 0) {
182 ipc_hangup(mountee_phone);
183 ops->node_put(fn);
184 ipc_answer_0(callid, rc);
185 ipc_answer_0(rid, rc);
186 return;
187 }
188
189 ipc_call_t answer;
[4198f9c3]190 aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
[83937ccd]191 &answer);
192 ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
193 async_wait_for(msg, &rc);
194
195 if (rc == EOK) {
196 fn->mp_data.mp_active = true;
197 fn->mp_data.fs_handle = mr_fs_handle;
198 fn->mp_data.dev_handle = mr_dev_handle;
199 fn->mp_data.phone = mountee_phone;
200 }
201 /*
202 * Do not release the FS node so that it stays in memory.
203 */
[0442c02]204 ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
205 IPC_GET_ARG3(answer));
[83937ccd]206}
207
[1e50f81]208/** Lookup VFS triplet by name in the file system name space.
[9bb85f3]209 *
210 * The path passed in the PLB must be in the canonical file system path format
211 * as returned by the canonify() function.
[1e50f81]212 *
[595edf5]213 * @param ops libfs operations structure with function pointers to
214 * file system implementation
215 * @param fs_handle File system handle of the file system where to perform
216 * the lookup.
[4198f9c3]217 * @param rid Request ID of the VFS_OUT_LOOKUP request.
218 * @param request VFS_OUT_LOOKUP request data itself.
[595edf5]219 *
[1e50f81]220 */
[f2ec8c8]221void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
[2c448fb]222 ipc_call_t *request)
223{
[83937ccd]224 unsigned first = IPC_GET_ARG1(*request);
[2c448fb]225 unsigned last = IPC_GET_ARG2(*request);
[83937ccd]226 unsigned next = first;
[f2ec8c8]227 dev_handle_t dev_handle = IPC_GET_ARG3(*request);
[2c448fb]228 int lflag = IPC_GET_ARG4(*request);
[f2ec8c8]229 fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
[c9f6e49f]230 char component[NAME_MAX + 1];
231 int len;
[2c448fb]232
233 if (last < next)
234 last += PLB_SIZE;
235
[b6035ba]236 fs_node_t *par = NULL;
237 fs_node_t *cur = ops->root_get(dev_handle);
238 fs_node_t *tmp = NULL;
[2c448fb]239
[83937ccd]240 if (cur->mp_data.mp_active) {
[4198f9c3]241 ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
[83937ccd]242 next, last, cur->mp_data.dev_handle, lflag, index,
243 IPC_FF_ROUTE_FROM_ME);
244 ops->node_put(cur);
245 return;
246 }
247
[2c448fb]248 if (ops->plb_get_char(next) == '/')
249 next++; /* eat slash */
250
[92f9baca]251 while (next <= last && ops->has_children(cur)) {
[2c448fb]252 /* collect the component */
[c9f6e49f]253 len = 0;
[fa832eb]254 while ((next <= last) && (ops->plb_get_char(next) != '/')) {
[2c448fb]255 if (len + 1 == NAME_MAX) {
[abb2865]256 /* component length overflow */
[2c448fb]257 ipc_answer_0(rid, ENAMETOOLONG);
[06901c6b]258 goto out;
[2c448fb]259 }
260 component[len++] = ops->plb_get_char(next);
261 next++; /* process next character */
262 }
263
264 assert(len);
265 component[len] = '\0';
266 next++; /* eat slash */
267
268 /* match the component */
[736c164]269 tmp = ops->match(cur, component);
[83937ccd]270 if (tmp && tmp->mp_data.mp_active) {
271 if (next > last)
272 next = last = first;
273 else
274 next--;
275
[4198f9c3]276 ipc_forward_slow(rid, tmp->mp_data.phone,
277 VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
278 lflag, index, IPC_FF_ROUTE_FROM_ME);
[83937ccd]279 ops->node_put(cur);
280 ops->node_put(tmp);
281 if (par)
282 ops->node_put(par);
283 return;
284 }
[2c448fb]285
286 /* handle miss: match amongst siblings */
287 if (!tmp) {
[a8e9ab8d]288 if (next <= last) {
289 /* there are unprocessed components */
290 ipc_answer_0(rid, ENOENT);
[06901c6b]291 goto out;
[a8e9ab8d]292 }
293 /* miss in the last component */
294 if (lflag & (L_CREATE | L_LINK)) {
295 /* request to create a new link */
[2c448fb]296 if (!ops->is_directory(cur)) {
297 ipc_answer_0(rid, ENOTDIR);
[06901c6b]298 goto out;
[a8e9ab8d]299 }
[b6035ba]300 fs_node_t *fn;
[a8e9ab8d]301 if (lflag & L_CREATE)
[b6035ba]302 fn = ops->create(dev_handle, lflag);
[a8e9ab8d]303 else
[b6035ba]304 fn = ops->node_get(dev_handle,
[34f62f8]305 index);
[b6035ba]306 if (fn) {
[0013b9ce]307 int rc;
308
[b6035ba]309 rc = ops->link(cur, fn, component);
[0013b9ce]310 if (rc != EOK) {
[92f9baca]311 if (lflag & L_CREATE) {
[b6035ba]312 (void)ops->destroy(fn);
[92f9baca]313 }
[0013b9ce]314 ipc_answer_0(rid, rc);
[2c448fb]315 } else {
316 ipc_answer_5(rid, EOK,
317 fs_handle, dev_handle,
[b6035ba]318 ops->index_get(fn),
319 ops->size_get(fn),
320 ops->lnkcnt_get(fn));
321 ops->node_put(fn);
[2c448fb]322 }
323 } else {
324 ipc_answer_0(rid, ENOSPC);
325 }
[06901c6b]326 goto out;
[a8e9ab8d]327 }
[2c448fb]328 ipc_answer_0(rid, ENOENT);
[06901c6b]329 goto out;
[2c448fb]330 }
331
[06901c6b]332 if (par)
333 ops->node_put(par);
334
[2c448fb]335 /* descend one level */
[7b6d98b]336 par = cur;
[2c448fb]337 cur = tmp;
[06901c6b]338 tmp = NULL;
[2c448fb]339 }
340
341 /* handle miss: excessive components */
[92f9baca]342 if (next <= last && !ops->has_children(cur)) {
[a8e9ab8d]343 if (lflag & (L_CREATE | L_LINK)) {
[2c448fb]344 if (!ops->is_directory(cur)) {
345 ipc_answer_0(rid, ENOTDIR);
[06901c6b]346 goto out;
[2c448fb]347 }
348
349 /* collect next component */
[c9f6e49f]350 len = 0;
[2c448fb]351 while (next <= last) {
352 if (ops->plb_get_char(next) == '/') {
353 /* more than one component */
354 ipc_answer_0(rid, ENOENT);
[06901c6b]355 goto out;
[2c448fb]356 }
357 if (len + 1 == NAME_MAX) {
358 /* component length overflow */
359 ipc_answer_0(rid, ENAMETOOLONG);
[06901c6b]360 goto out;
[2c448fb]361 }
362 component[len++] = ops->plb_get_char(next);
363 next++; /* process next character */
364 }
365 assert(len);
366 component[len] = '\0';
367
[b6035ba]368 fs_node_t *fn;
[a8e9ab8d]369 if (lflag & L_CREATE)
[b6035ba]370 fn = ops->create(dev_handle, lflag);
[a8e9ab8d]371 else
[b6035ba]372 fn = ops->node_get(dev_handle, index);
373 if (fn) {
[0013b9ce]374 int rc;
375
[b6035ba]376 rc = ops->link(cur, fn, component);
[0013b9ce]377 if (rc != EOK) {
[a8e9ab8d]378 if (lflag & L_CREATE)
[b6035ba]379 (void)ops->destroy(fn);
[0013b9ce]380 ipc_answer_0(rid, rc);
[2c448fb]381 } else {
382 ipc_answer_5(rid, EOK,
383 fs_handle, dev_handle,
[b6035ba]384 ops->index_get(fn),
385 ops->size_get(fn),
386 ops->lnkcnt_get(fn));
387 ops->node_put(fn);
[2c448fb]388 }
389 } else {
390 ipc_answer_0(rid, ENOSPC);
391 }
[06901c6b]392 goto out;
[2c448fb]393 }
394 ipc_answer_0(rid, ENOENT);
[06901c6b]395 goto out;
[2c448fb]396 }
397
398 /* handle hit */
[a8e9ab8d]399 if (lflag & L_UNLINK) {
[2c448fb]400 unsigned old_lnkcnt = ops->lnkcnt_get(cur);
[cf95bc0]401 int res = ops->unlink(par, cur, component);
[2c448fb]402 ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
403 ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
[06901c6b]404 goto out;
[2c448fb]405 }
[a8e9ab8d]406 if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
407 (lflag & L_LINK)) {
[2c448fb]408 ipc_answer_0(rid, EEXIST);
[06901c6b]409 goto out;
[2c448fb]410 }
411 if ((lflag & L_FILE) && (ops->is_directory(cur))) {
412 ipc_answer_0(rid, EISDIR);
[06901c6b]413 goto out;
[2c448fb]414 }
415 if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
416 ipc_answer_0(rid, ENOTDIR);
[06901c6b]417 goto out;
[2c448fb]418 }
419
420 ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
421 ops->size_get(cur), ops->lnkcnt_get(cur));
[06901c6b]422
423out:
424 if (par)
425 ops->node_put(par);
426 if (cur)
427 ops->node_put(cur);
428 if (tmp)
429 ops->node_put(tmp);
[2c448fb]430}
431
[75160a6]432void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
433 ipc_call_t *request)
434{
435 dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
436 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
437 fs_node_t *fn = ops->node_get(dev_handle, index);
438
439 ipc_callid_t callid;
440 size_t size;
441 if (!ipc_data_read_receive(&callid, &size) ||
[0143f72]442 size != sizeof(struct stat)) {
[75160a6]443 ipc_answer_0(callid, EINVAL);
444 ipc_answer_0(rid, EINVAL);
445 return;
446 }
447
[0143f72]448 struct stat stat;
449 memset(&stat, 0, sizeof(struct stat));
[75160a6]450
[0143f72]451 stat.fs_handle = fs_handle;
452 stat.dev_handle = dev_handle;
453 stat.index = index;
454 stat.lnkcnt = ops->lnkcnt_get(fn);
455 stat.is_file = ops->is_file(fn);
456 stat.size = ops->size_get(fn);
457
458 ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
[75160a6]459 ipc_answer_0(rid, EOK);
460}
461
[595edf5]462/** Open VFS triplet.
463 *
464 * @param ops libfs operations structure with function pointers to
465 * file system implementation
[4198f9c3]466 * @param rid Request ID of the VFS_OUT_OPEN_NODE request.
467 * @param request VFS_OUT_OPEN_NODE request data itself.
[595edf5]468 *
469 */
470void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
471 ipc_call_t *request)
472{
473 dev_handle_t dev_handle = IPC_GET_ARG1(*request);
474 fs_index_t index = IPC_GET_ARG2(*request);
475
476 fs_node_t *node = ops->node_get(dev_handle, index);
477
478 if (node == NULL) {
479 ipc_answer_0(rid, ENOENT);
480 return;
481 }
482
483 ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,
484 ops->size_get(node), ops->lnkcnt_get(node));
485
486 ops->node_put(node);
487}
488
[74303b6]489/** @}
490 */
Note: See TracBrowser for help on using the repository browser.