Subversion Repositories HelenOS

Rev

Rev 2747 | Rev 2751 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2642 jermar 1
/*
2747 jermar 2
 * Copyright (c) 2008 Jakub Jermar
2642 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
/** @addtogroup libfs
30
 * @{
31
 */
32
/**
33
 * @file
34
 * Glue code which is commonod to all FS implementations.
35
 */
36
 
37
#include "libfs.h" 
2643 jermar 38
#include "../../srv/vfs/vfs.h"
39
#include <errno.h>
40
#include <async.h>
41
#include <ipc/ipc.h>
42
#include <as.h>
2747 jermar 43
#include <assert.h>
44
#include <dirent.h>
2642 jermar 45
 
2643 jermar 46
/** Register file system server.
47
 *
48
 * This function abstracts away the tedious registration protocol from
49
 * file system implementations and lets them to reuse this registration glue
50
 * code.
51
 *
52
 * @param vfs_phone Open phone for communication with VFS.
53
 * @param reg       File system registration structure. It will be
54
 *          initialized by this function.
55
 * @param info      VFS info structure supplied by the file system
56
 *          implementation.
57
 * @param conn      Connection fibril for handling all calls originating in
58
 *          VFS.
59
 *
60
 * @return      EOK on success or a non-zero error code on errror.
61
 */
62
int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
63
    async_client_conn_t conn)
64
{
65
    /*
66
     * Tell VFS that we are here and want to get registered.
67
     * We use the async framework because VFS will answer the request
68
     * out-of-order, when it knows that the operation succeeded or failed.
69
     */
70
    ipc_call_t answer;
71
    aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
72
 
73
    /*
74
     * Send our VFS info structure to VFS.
75
     */
2678 jermar 76
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
2643 jermar 77
    if (rc != EOK) {
78
        async_wait_for(req, NULL);
79
        return rc;
80
    }
81
 
82
    /*
83
     * Ask VFS for callback connection.
84
     */
85
    ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
86
 
87
    /*
88
     * Allocate piece of address space for PLB.
89
     */
90
    reg->plb_ro = as_get_mappable_page(PLB_SIZE);
91
    if (!reg->plb_ro) {
92
        async_wait_for(req, NULL);
93
        return ENOMEM;
94
    }
95
 
96
    /*
97
     * Request sharing the Path Lookup Buffer with VFS.
98
     */
2678 jermar 99
    rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
2643 jermar 100
    if (rc) {
101
        async_wait_for(req, NULL);
102
        return rc;
103
    }
104
 
105
    /*
106
     * Pick up the answer for the request to the VFS_REQUEST call.
107
     */
108
    async_wait_for(req, NULL);
109
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
110
 
111
    /*
112
     * Create a connection fibril to handle the callback connection.
113
     */
114
    async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
115
 
116
    /*
117
     * Tell the async framework that other connections are to be handled by
118
     * the same connection fibril as well.
119
     */
120
    async_set_client_connection(conn);
121
 
122
    return IPC_GET_RETVAL(answer);
123
}
124
 
2750 jermar 125
/** Lookup VFS triplet by name in the file system name space.
126
 *
127
 * @param ops       libfs operations structure with function pointers to
128
 *          file system implementation
129
 * @param fs_handle File system handle of the file system where to perform
130
 *          the lookup.
131
 * @param rid       Request ID of the VFS_LOOKUP request.
132
 * @param request   VFS_LOOKUP request data itself.
133
 */
2747 jermar 134
void libfs_lookup(libfs_ops_t *ops, int fs_handle, ipc_callid_t rid,
135
    ipc_call_t *request)
136
{
137
    unsigned next = IPC_GET_ARG1(*request);
138
    unsigned last = IPC_GET_ARG2(*request);
139
    int dev_handle = IPC_GET_ARG3(*request);
140
    int lflag = IPC_GET_ARG4(*request);
141
 
142
    if (last < next)
143
        last += PLB_SIZE;
144
 
145
    void *cur = ops->root_get();
146
    void *tmp = ops->child_get(cur);
147
 
148
    if (ops->plb_get_char(next) == '/')
149
        next++;     /* eat slash */
150
 
151
    char component[NAME_MAX + 1];
152
    int len = 0;
153
    while (tmp && next <= last) {
154
 
155
        /* collect the component */
156
        if (ops->plb_get_char(next) != '/') {
157
            if (len + 1 == NAME_MAX) {
158
                /* comopnent length overflow */
159
                ipc_answer_0(rid, ENAMETOOLONG);
160
                return;
161
            }
162
            component[len++] = ops->plb_get_char(next);
163
            next++; /* process next character */
164
            if (next <= last)
165
                continue;
166
        }
167
 
168
        assert(len);
169
        component[len] = '\0';
170
        next++;     /* eat slash */
171
        len = 0;
172
 
173
        /* match the component */
174
        while (tmp && !ops->match(tmp, component))
175
            tmp = ops->sibling_get(tmp);
176
 
177
        /* handle miss: match amongst siblings */
178
        if (!tmp) {
179
            if ((next > last) && (lflag & L_CREATE)) {
180
                /* no components left and L_CREATE specified */
181
                if (!ops->is_directory(cur)) {
182
                    ipc_answer_0(rid, ENOTDIR);
183
                    return;
184
                }
185
                void *nodep = ops->create(lflag);
186
                if (nodep) {
187
                    if (!ops->link(cur, nodep, component)) {
188
                        ops->destroy(nodep);
189
                        ipc_answer_0(rid, ENOSPC);
190
                    } else {
191
                        ipc_answer_5(rid, EOK,
192
                            fs_handle, dev_handle,
193
                            ops->index_get(nodep), 0,
194
                            ops->lnkcnt_get(nodep));
195
                    }
196
                } else {
197
                    ipc_answer_0(rid, ENOSPC);
198
                }
199
                return;
200
            }
201
            ipc_answer_0(rid, ENOENT);
202
            return;
203
        }
204
 
205
        /* descend one level */
206
        cur = tmp;
207
        tmp = ops->child_get(tmp);
208
    }
209
 
210
    /* handle miss: excessive components */
211
    if (!tmp && next <= last) {
212
        if (lflag & L_CREATE) {
213
            if (!ops->is_directory(cur)) {
214
                ipc_answer_0(rid, ENOTDIR);
215
                return;
216
            }
217
 
218
            /* collect next component */
219
            while (next <= last) {
220
                if (ops->plb_get_char(next) == '/') {
221
                    /* more than one component */
222
                    ipc_answer_0(rid, ENOENT);
223
                    return;
224
                }
225
                if (len + 1 == NAME_MAX) {
226
                    /* component length overflow */
227
                    ipc_answer_0(rid, ENAMETOOLONG);
228
                    return;
229
                }
230
                component[len++] = ops->plb_get_char(next);
231
                next++; /* process next character */
232
            }
233
            assert(len);
234
            component[len] = '\0';
235
            len = 0;
236
 
237
            void *nodep = ops->create(lflag);
238
            if (nodep) {
239
                if (!ops->link(cur, nodep, component)) {
240
                    ops->destroy(nodep);
241
                    ipc_answer_0(rid, ENOSPC);
242
                } else {
243
                    ipc_answer_5(rid, EOK,
244
                        fs_handle, dev_handle,
245
                        ops->index_get(nodep), 0,
246
                        ops->lnkcnt_get(nodep));
247
                }
248
            } else {
249
                ipc_answer_0(rid, ENOSPC);
250
            }
251
            return;
252
        }
253
        ipc_answer_0(rid, ENOENT);
254
        return;
255
    }
256
 
257
    /* handle hit */
258
    if (lflag & L_DESTROY) {
259
        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
260
        int res = ops->unlink(cur);
261
        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
262
            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
263
        return;
264
    }
265
    if ((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) {
266
        ipc_answer_0(rid, EEXIST);
267
        return;
268
    }
269
    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
270
        ipc_answer_0(rid, EISDIR);
271
        return;
272
    }
273
    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
274
        ipc_answer_0(rid, ENOTDIR);
275
        return;
276
    }
277
 
278
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
279
        ops->size_get(cur), ops->lnkcnt_get(cur));
280
}
281
 
2642 jermar 282
/** @}
283
 */