Subversion Repositories HelenOS

Rev

Rev 4389 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4389 Rev 4691
Line 1... Line 1...
1
/*
1
/*
2
 * Copyright (c) 2008 Jakub Jermar
2
 * Copyright (c) 2009 Jakub Jermar
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:
Line 40... Line 40...
40
#include <async.h>
40
#include <async.h>
41
#include <ipc/ipc.h>
41
#include <ipc/ipc.h>
42
#include <as.h>
42
#include <as.h>
43
#include <assert.h>
43
#include <assert.h>
44
#include <dirent.h>
44
#include <dirent.h>
-
 
45
#include <mem.h>
-
 
46
#include <sys/stat.h>
45
 
47
 
46
/** Register file system server.
48
/** Register file system server.
47
 *
49
 *
48
 * This function abstracts away the tedious registration protocol from
50
 * This function abstracts away the tedious registration protocol from
49
 * file system implementations and lets them to reuse this registration glue
51
 * file system implementations and lets them to reuse this registration glue
Line 66... Line 68...
66
     * Tell VFS that we are here and want to get registered.
68
     * Tell VFS that we are here and want to get registered.
67
     * We use the async framework because VFS will answer the request
69
     * We use the async framework because VFS will answer the request
68
     * out-of-order, when it knows that the operation succeeded or failed.
70
     * out-of-order, when it knows that the operation succeeded or failed.
69
     */
71
     */
70
    ipc_call_t answer;
72
    ipc_call_t answer;
71
    aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
73
    aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
72
 
74
 
73
    /*
75
    /*
74
     * Send our VFS info structure to VFS.
76
     * Send our VFS info structure to VFS.
75
     */
77
     */
76
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
78
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
Line 101... Line 103...
101
        async_wait_for(req, NULL);
103
        async_wait_for(req, NULL);
102
        return rc;
104
        return rc;
103
    }
105
    }
104
     
106
     
105
    /*
107
    /*
106
     * Pick up the answer for the request to the VFS_REQUEST call.
108
     * Pick up the answer for the request to the VFS_IN_REQUEST call.
107
     */
109
     */
108
    async_wait_for(req, NULL);
110
    async_wait_for(req, NULL);
109
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
111
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
110
   
112
   
111
    /*
113
    /*
Line 120... Line 122...
120
    async_set_client_connection(conn);
122
    async_set_client_connection(conn);
121
 
123
 
122
    return IPC_GET_RETVAL(answer);
124
    return IPC_GET_RETVAL(answer);
123
}
125
}
124
 
126
 
-
 
127
void fs_node_initialize(fs_node_t *fn)
-
 
128
{
-
 
129
    memset(fn, 0, sizeof(fs_node_t));
-
 
130
}
-
 
131
 
-
 
132
void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
-
 
133
    ipc_call_t *request)
-
 
134
{
-
 
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);
-
 
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;
-
 
190
    aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
-
 
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
     */
-
 
204
    ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
-
 
205
        IPC_GET_ARG3(answer));
-
 
206
}
-
 
207
 
125
/** Lookup VFS triplet by name in the file system name space.
208
/** Lookup VFS triplet by name in the file system name space.
126
 *
209
 *
127
 * The path passed in the PLB must be in the canonical file system path format
210
 * The path passed in the PLB must be in the canonical file system path format
128
 * as returned by the canonify() function.
211
 * as returned by the canonify() function.
129
 *
212
 *
130
 * @param ops       libfs operations structure with function pointers to
213
 * @param ops       libfs operations structure with function pointers to
131
 *          file system implementation
214
 *                  file system implementation
132
 * @param fs_handle File system handle of the file system where to perform
215
 * @param fs_handle File system handle of the file system where to perform
133
 *          the lookup.
216
 *                  the lookup.
134
 * @param rid       Request ID of the VFS_LOOKUP request.
217
 * @param rid       Request ID of the VFS_OUT_LOOKUP request.
135
 * @param request   VFS_LOOKUP request data itself.
218
 * @param request   VFS_OUT_LOOKUP request data itself.
-
 
219
 *
136
 */
220
 */
137
void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
221
void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
138
    ipc_call_t *request)
222
    ipc_call_t *request)
139
{
223
{
140
    unsigned next = IPC_GET_ARG1(*request);
224
    unsigned first = IPC_GET_ARG1(*request);
141
    unsigned last = IPC_GET_ARG2(*request);
225
    unsigned last = IPC_GET_ARG2(*request);
-
 
226
    unsigned next = first;
142
    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
227
    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
143
    int lflag = IPC_GET_ARG4(*request);
228
    int lflag = IPC_GET_ARG4(*request);
144
    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
229
    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
145
    char component[NAME_MAX + 1];
230
    char component[NAME_MAX + 1];
146
    int len;
231
    int len;
Line 150... Line 235...
150
 
235
 
151
    fs_node_t *par = NULL;
236
    fs_node_t *par = NULL;
152
    fs_node_t *cur = ops->root_get(dev_handle);
237
    fs_node_t *cur = ops->root_get(dev_handle);
153
    fs_node_t *tmp = NULL;
238
    fs_node_t *tmp = NULL;
154
 
239
 
-
 
240
    if (cur->mp_data.mp_active) {
-
 
241
        ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
-
 
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
 
155
    if (ops->plb_get_char(next) == '/')
248
    if (ops->plb_get_char(next) == '/')
156
        next++;     /* eat slash */
249
        next++;     /* eat slash */
157
   
250
   
158
    while (next <= last && ops->has_children(cur)) {
251
    while (next <= last && ops->has_children(cur)) {
159
        /* collect the component */
252
        /* collect the component */
Line 172... Line 265...
172
        component[len] = '\0';
265
        component[len] = '\0';
173
        next++;     /* eat slash */
266
        next++;     /* eat slash */
174
 
267
 
175
        /* match the component */
268
        /* match the component */
176
        tmp = ops->match(cur, component);
269
        tmp = ops->match(cur, component);
-
 
270
        if (tmp && tmp->mp_data.mp_active) {
-
 
271
            if (next > last)
-
 
272
                next = last = first;
-
 
273
            else
-
 
274
                next--;
-
 
275
               
-
 
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);
-
 
279
            ops->node_put(cur);
-
 
280
            ops->node_put(tmp);
-
 
281
            if (par)
-
 
282
                ops->node_put(par);
-
 
283
            return;
-
 
284
        }
177
 
285
 
178
        /* handle miss: match amongst siblings */
286
        /* handle miss: match amongst siblings */
179
        if (!tmp) {
287
        if (!tmp) {
180
            if (next <= last) {
288
            if (next <= last) {
181
                /* there are unprocessed components */
289
                /* there are unprocessed components */
Line 319... Line 427...
319
        ops->node_put(cur);
427
        ops->node_put(cur);
320
    if (tmp)
428
    if (tmp)
321
        ops->node_put(tmp);
429
        ops->node_put(tmp);
322
}
430
}
323
 
431
 
-
 
432
void 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) ||
-
 
442
        size != sizeof(struct stat)) {
-
 
443
        ipc_answer_0(callid, EINVAL);
-
 
444
        ipc_answer_0(rid, EINVAL);
-
 
445
        return;
-
 
446
    }
-
 
447
 
-
 
448
    struct stat stat;
-
 
449
    memset(&stat, 0, sizeof(struct stat));
-
 
450
   
-
 
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));
-
 
459
    ipc_answer_0(rid, EOK);
-
 
460
}
-
 
461
 
-
 
462
/** Open VFS triplet.
-
 
463
 *
-
 
464
 * @param ops       libfs operations structure with function pointers to
-
 
465
 *                  file system implementation
-
 
466
 * @param rid       Request ID of the VFS_OUT_OPEN_NODE request.
-
 
467
 * @param request   VFS_OUT_OPEN_NODE request data itself.
-
 
468
 *
-
 
469
 */
-
 
470
void 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
 
324
/** @}
489
/** @}
325
 */
490
 */