Subversion Repositories HelenOS

Rev

Rev 4668 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4668 Rev 4688
1 
/*
 1 
/*
2 
 * Copyright (c) 2008 Jakub Jermar
 2 
 * Copyright (c) 2008 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:
8 
 *
 8 
 *
9 
 * - Redistributions of source code must retain the above copyright
 9 
 * - Redistributions of source code must retain the above copyright
10 
 *   notice, this list of conditions and the following disclaimer.
 10 
 *   notice, this list of conditions and the following disclaimer.
11 
 * - Redistributions in binary form must reproduce the above copyright
 11 
 * - Redistributions in binary form must reproduce the above copyright
12 
 *   notice, this list of conditions and the following disclaimer in the
 12 
 *   notice, this list of conditions and the following disclaimer in the
13 
 *   documentation and/or other materials provided with the distribution.
 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
 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.
 15 
 *   derived from this software without specific prior written permission.
16 
 *
 16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 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
 18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 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
 23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 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
 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.
 26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
 27 
 */
28 
 
 28 
 
29 
/** @addtogroup fs
 29 
/** @addtogroup fs
30 
 * @{
 30 
 * @{
31 
 */
 31 
 */
32 
 
 32 
 
33 
/**
 33 
/**
34 
 * @file vfs_ops.c
 34 
 * @file vfs_ops.c
35 
 * @brief Operations that VFS offers to its clients.
 35 
 * @brief Operations that VFS offers to its clients.
36 
 */
 36 
 */
37 
 
 37 
 
38 
#include "vfs.h"
 38 
#include "vfs.h"
39 
#include <ipc/ipc.h>
 39 
#include <ipc/ipc.h>
40 
#include <async.h>
 40 
#include <async.h>
41 
#include <errno.h>
 41 
#include <errno.h>
42 
#include <stdio.h>
 42 
#include <stdio.h>
43 
#include <stdlib.h>
 43 
#include <stdlib.h>
44 
#include <string.h>
 44 
#include <string.h>
45 
#include <bool.h>
 45 
#include <bool.h>
46 
#include <fibril_sync.h>
 46 
#include <fibril_sync.h>
47 
#include <adt/list.h>
 47 
#include <adt/list.h>
48 
#include <unistd.h>
 48 
#include <unistd.h>
49 
#include <ctype.h>
 49 
#include <ctype.h>
50 
#include <fcntl.h>
 50 
#include <fcntl.h>
51 
#include <assert.h>
 51 
#include <assert.h>
52 
#include <vfs/canonify.h>
 52 
#include <vfs/canonify.h>
53 
 
 53 
 
54 
/* Forward declarations of static functions. */
 54 
/* Forward declarations of static functions. */
55 
static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
 55 
static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
56 
 
 56 
 
57 
/**
 57 
/**
58 
 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
 58 
 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
59 
 * concurrent VFS operation which modifies the file system namespace.
 59 
 * concurrent VFS operation which modifies the file system namespace.
60 
 */
 60 
 */
61 
FIBRIL_RWLOCK_INITIALIZE(namespace_rwlock);
 61 
FIBRIL_RWLOCK_INITIALIZE(namespace_rwlock);
62 
 
 62 
 
63 
vfs_pair_t rootfs = {
 63 
vfs_pair_t rootfs = {
64 
    .fs_handle = 0,
 64 
    .fs_handle = 0,
65 
    .dev_handle = 0
 65 
    .dev_handle = 0
66 
};
 66 
};
67 
 
 67 
 
68 
static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
 68 
static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
69 
    fs_handle_t fs_handle, char *mp, char *opts)
 69 
    fs_handle_t fs_handle, char *mp, char *opts)
70 
{
 70 
{
71 
    vfs_lookup_res_t mp_res;
 71 
    vfs_lookup_res_t mp_res;
72 
    vfs_lookup_res_t mr_res;
 72 
    vfs_lookup_res_t mr_res;
73 
    vfs_node_t *mp_node = NULL;
 73 
    vfs_node_t *mp_node = NULL;
74 
    vfs_node_t *mr_node;
 74 
    vfs_node_t *mr_node;
75 
    fs_index_t rindex;
 75 
    fs_index_t rindex;
76 
    size_t rsize;
 76 
    size_t rsize;
77 
    unsigned rlnkcnt;
 77 
    unsigned rlnkcnt;
78 
    ipcarg_t rc;
 78 
    ipcarg_t rc;
79 
    int phone;
 79 
    int phone;
80 
    aid_t msg;
 80 
    aid_t msg;
81 
    ipc_call_t answer;
 81 
    ipc_call_t answer;
82 
   
 82 
   
83 
    /* Resolve the path to the mountpoint. */
 83 
    /* Resolve the path to the mountpoint. */
84 
    fibril_rwlock_write_lock(&namespace_rwlock);
 84 
    fibril_rwlock_write_lock(&namespace_rwlock);
85 
    if (rootfs.fs_handle) {
 85 
    if (rootfs.fs_handle) {
86 
        /* We already have the root FS. */
 86 
        /* We already have the root FS. */
87 
        if (str_cmp(mp, "/") == 0) {
 87 
        if (str_cmp(mp, "/") == 0) {
88 
            /* Trying to mount root FS over root FS */
 88 
            /* Trying to mount root FS over root FS */
89 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 89 
            fibril_rwlock_write_unlock(&namespace_rwlock);
90 
            ipc_answer_0(rid, EBUSY);
 90 
            ipc_answer_0(rid, EBUSY);
91 
            return;
 91 
            return;
92 
        }
 92 
        }
93 
       
 93 
       
94 
        rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
 94 
        rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
95 
        if (rc != EOK) {
 95 
        if (rc != EOK) {
96 
            /* The lookup failed for some reason. */
 96 
            /* The lookup failed for some reason. */
97 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 97 
            fibril_rwlock_write_unlock(&namespace_rwlock);
98 
            ipc_answer_0(rid, rc);
 98 
            ipc_answer_0(rid, rc);
99 
            return;
 99 
            return;
100 
        }
 100 
        }
101 
       
 101 
       
102 
        mp_node = vfs_node_get(&mp_res);
 102 
        mp_node = vfs_node_get(&mp_res);
103 
        if (!mp_node) {
 103 
        if (!mp_node) {
104 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 104 
            fibril_rwlock_write_unlock(&namespace_rwlock);
105 
            ipc_answer_0(rid, ENOMEM);
 105 
            ipc_answer_0(rid, ENOMEM);
106 
            return;
 106 
            return;
107 
        }
 107 
        }
108 
       
 108 
       
109 
        /*
 109 
        /*
110 
         * Now we hold a reference to mp_node.
 110 
         * Now we hold a reference to mp_node.
111 
         * It will be dropped upon the corresponding VFS_IN_UNMOUNT.
 111 
         * It will be dropped upon the corresponding VFS_IN_UNMOUNT.
112 
         * This prevents the mount point from being deleted.
 112 
         * This prevents the mount point from being deleted.
113 
         */
 113 
         */
114 
    } else {
 114 
    } else {
115 
        /* We still don't have the root file system mounted. */
 115 
        /* We still don't have the root file system mounted. */
116 
        if (str_cmp(mp, "/") == 0) {
 116 
        if (str_cmp(mp, "/") == 0) {
117 
            /*
 117 
            /*
118 
             * For this simple, but important case,
 118 
             * For this simple, but important case,
119 
             * we are almost done.
 119 
             * we are almost done.
120 
             */
 120 
             */
121 
           
 121 
           
122 
            /* Tell the mountee that it is being mounted. */
 122 
            /* Tell the mountee that it is being mounted. */
123 
            phone = vfs_grab_phone(fs_handle);
 123 
            phone = vfs_grab_phone(fs_handle);
124 
            msg = async_send_1(phone, VFS_OUT_MOUNTED,
 124 
            msg = async_send_1(phone, VFS_OUT_MOUNTED,
125 
                (ipcarg_t) dev_handle, &answer);
 125 
                (ipcarg_t) dev_handle, &answer);
126 
            /* send the mount options */
 126 
            /* send the mount options */
127 
            rc = ipc_data_write_start(phone, (void *)opts,
 127 
            rc = ipc_data_write_start(phone, (void *)opts,
128 
                str_size(opts));
 128 
                str_size(opts));
129 
            if (rc != EOK) {
 129 
            if (rc != EOK) {
130 
                async_wait_for(msg, NULL);
 130 
                async_wait_for(msg, NULL);
131 
                vfs_release_phone(phone);
 131 
                vfs_release_phone(phone);
132 
                fibril_rwlock_write_unlock(&namespace_rwlock);
 132 
                fibril_rwlock_write_unlock(&namespace_rwlock);
133 
                ipc_answer_0(rid, rc);
 133 
                ipc_answer_0(rid, rc);
134 
                return;
 134 
                return;
135 
            }
 135 
            }
136 
            async_wait_for(msg, &rc);
 136 
            async_wait_for(msg, &rc);
137 
            vfs_release_phone(phone);
 137 
            vfs_release_phone(phone);
138 
           
 138 
           
139 
            if (rc != EOK) {
 139 
            if (rc != EOK) {
140 
                fibril_rwlock_write_unlock(&namespace_rwlock);
 140 
                fibril_rwlock_write_unlock(&namespace_rwlock);
141 
                ipc_answer_0(rid, rc);
 141 
                ipc_answer_0(rid, rc);
142 
                return;
 142 
                return;
143 
            }
 143 
            }
144 
 
 144 
 
145 
            rindex = (fs_index_t) IPC_GET_ARG1(answer);
 145 
            rindex = (fs_index_t) IPC_GET_ARG1(answer);
146 
            rsize = (size_t) IPC_GET_ARG2(answer);
 146 
            rsize = (size_t) IPC_GET_ARG2(answer);
147 
            rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
 147 
            rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
148 
           
 148 
           
149 
            mr_res.triplet.fs_handle = fs_handle;
 149 
            mr_res.triplet.fs_handle = fs_handle;
150 
            mr_res.triplet.dev_handle = dev_handle;
 150 
            mr_res.triplet.dev_handle = dev_handle;
151 
            mr_res.triplet.index = rindex;
 151 
            mr_res.triplet.index = rindex;
152 
            mr_res.size = rsize;
 152 
            mr_res.size = rsize;
153 
            mr_res.lnkcnt = rlnkcnt;
 153 
            mr_res.lnkcnt = rlnkcnt;
154 
            mr_res.type = VFS_NODE_DIRECTORY;
 154 
            mr_res.type = VFS_NODE_DIRECTORY;
155 
           
 155 
           
156 
            rootfs.fs_handle = fs_handle;
 156 
            rootfs.fs_handle = fs_handle;
157 
            rootfs.dev_handle = dev_handle;
 157 
            rootfs.dev_handle = dev_handle;
158 
           
 158 
           
159 
            /* Add reference to the mounted root. */
 159 
            /* Add reference to the mounted root. */
160 
            mr_node = vfs_node_get(&mr_res);
 160 
            mr_node = vfs_node_get(&mr_res);
161 
            assert(mr_node);
 161 
            assert(mr_node);
162 
           
 162 
           
163 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 163 
            fibril_rwlock_write_unlock(&namespace_rwlock);
164 
            ipc_answer_0(rid, rc);
 164 
            ipc_answer_0(rid, rc);
165 
            return;
 165 
            return;
166 
        } else {
 166 
        } else {
167 
            /*
 167 
            /*
168 
             * We can't resolve this without the root filesystem
 168 
             * We can't resolve this without the root filesystem
169 
             * being mounted first.
 169 
             * being mounted first.
170 
             */
 170 
             */
171 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 171 
            fibril_rwlock_write_unlock(&namespace_rwlock);
172 
            ipc_answer_0(rid, ENOENT);
 172 
            ipc_answer_0(rid, ENOENT);
173 
            return;
 173 
            return;
174 
        }
 174 
        }
175 
    }
 175 
    }
176 
   
 176 
   
177 
    /*
 177 
    /*
178 
     * At this point, we have all necessary pieces: file system and device
 178 
     * At this point, we have all necessary pieces: file system and device
179 
     * handles, and we know the mount point VFS node.
 179 
     * handles, and we know the mount point VFS node.
180 
     */
 180 
     */
181 
   
 181 
   
182 
    int mountee_phone = vfs_grab_phone(fs_handle);
 182 
    int mountee_phone = vfs_grab_phone(fs_handle);
183 
    assert(mountee_phone >= 0);
 183 
    assert(mountee_phone >= 0);
184 
 
 184 
 
185 
    phone = vfs_grab_phone(mp_res.triplet.fs_handle);
 185 
    phone = vfs_grab_phone(mp_res.triplet.fs_handle);
186 
    msg = async_send_4(phone, VFS_OUT_MOUNT,
 186 
    msg = async_send_4(phone, VFS_OUT_MOUNT,
187 
        (ipcarg_t) mp_res.triplet.dev_handle,
 187 
        (ipcarg_t) mp_res.triplet.dev_handle,
188 
        (ipcarg_t) mp_res.triplet.index,
 188 
        (ipcarg_t) mp_res.triplet.index,
189 
        (ipcarg_t) fs_handle,
 189 
        (ipcarg_t) fs_handle,
190 
        (ipcarg_t) dev_handle, &answer);
 190 
        (ipcarg_t) dev_handle, &answer);
191 
   
 191 
   
192 
    /* send connection */
 192 
    /* send connection */
193 
    rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
 193 
    rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
194 
    if (rc != EOK) {
 194 
    if (rc != EOK) {
195 
        async_wait_for(msg, NULL);
 195 
        async_wait_for(msg, NULL);
196 
        vfs_release_phone(mountee_phone);
 196 
        vfs_release_phone(mountee_phone);
197 
        vfs_release_phone(phone);
 197 
        vfs_release_phone(phone);
198 
        /* Mount failed, drop reference to mp_node. */
 198 
        /* Mount failed, drop reference to mp_node. */
199 
        if (mp_node)
 199 
        if (mp_node)
200 
            vfs_node_put(mp_node);
 200 
            vfs_node_put(mp_node);
201 
        ipc_answer_0(rid, rc);
 201 
        ipc_answer_0(rid, rc);
202 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 202 
        fibril_rwlock_write_unlock(&namespace_rwlock);
203 
        return;
 203 
        return;
204 
    }
 204 
    }
205 
 
 205 
 
206 
    vfs_release_phone(mountee_phone);
 206 
    vfs_release_phone(mountee_phone);
207 
   
 207 
   
208 
    /* send the mount options */
 208 
    /* send the mount options */
209 
    rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
 209 
    rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
210 
    if (rc != EOK) {
 210 
    if (rc != EOK) {
211 
        async_wait_for(msg, NULL);
 211 
        async_wait_for(msg, NULL);
212 
        vfs_release_phone(phone);
 212 
        vfs_release_phone(phone);
213 
        /* Mount failed, drop reference to mp_node. */
 213 
        /* Mount failed, drop reference to mp_node. */
214 
        if (mp_node)
 214 
        if (mp_node)
215 
            vfs_node_put(mp_node);
 215 
            vfs_node_put(mp_node);
216 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 216 
        fibril_rwlock_write_unlock(&namespace_rwlock);
217 
        ipc_answer_0(rid, rc);
 217 
        ipc_answer_0(rid, rc);
218 
        return;
 218 
        return;
219 
    }
 219 
    }
220 
    async_wait_for(msg, &rc);
 220 
    async_wait_for(msg, &rc);
221 
    vfs_release_phone(phone);
 221 
    vfs_release_phone(phone);
222 
   
 222 
   
223 
    if (rc == EOK) {
 223 
    if (rc == EOK) {
224 
        rindex = (fs_index_t) IPC_GET_ARG1(answer);
 224 
        rindex = (fs_index_t) IPC_GET_ARG1(answer);
225 
        rsize = (size_t) IPC_GET_ARG2(answer);
 225 
        rsize = (size_t) IPC_GET_ARG2(answer);
226 
        rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
 226 
        rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
227 
   
 227 
   
228 
        mr_res.triplet.fs_handle = fs_handle;
 228 
        mr_res.triplet.fs_handle = fs_handle;
229 
        mr_res.triplet.dev_handle = dev_handle;
 229 
        mr_res.triplet.dev_handle = dev_handle;
230 
        mr_res.triplet.index = rindex;
 230 
        mr_res.triplet.index = rindex;
231 
        mr_res.size = rsize;
 231 
        mr_res.size = rsize;
232 
        mr_res.lnkcnt = rlnkcnt;
 232 
        mr_res.lnkcnt = rlnkcnt;
233 
        mr_res.type = VFS_NODE_DIRECTORY;
 233 
        mr_res.type = VFS_NODE_DIRECTORY;
234 
   
 234 
   
235 
        /* Add reference to the mounted root. */
 235 
        /* Add reference to the mounted root. */
236 
        mr_node = vfs_node_get(&mr_res);
 236 
        mr_node = vfs_node_get(&mr_res);
237 
        assert(mr_node);
 237 
        assert(mr_node);
238 
    } else {
 238 
    } else {
239 
        /* Mount failed, drop reference to mp_node. */
 239 
        /* Mount failed, drop reference to mp_node. */
240 
        if (mp_node)
 240 
        if (mp_node)
241 
            vfs_node_put(mp_node);
 241 
            vfs_node_put(mp_node);
242 
    }
 242 
    }
243 
 
 243 
 
244 
    ipc_answer_0(rid, rc);
 244 
    ipc_answer_0(rid, rc);
245 
    fibril_rwlock_write_unlock(&namespace_rwlock);
 245 
    fibril_rwlock_write_unlock(&namespace_rwlock);
246 
}
 246 
}
247 
 
 247 
 
248 
void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
 248 
void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
249 
{
 249 
{
250 
    /*
 250 
    /*
251 
     * We expect the library to do the device-name to device-handle
 251 
     * We expect the library to do the device-name to device-handle
252 
     * translation for us, thus the device handle will arrive as ARG1
 252 
     * translation for us, thus the device handle will arrive as ARG1
253 
     * in the request.
 253 
     * in the request.
254 
     */
 254 
     */
255 
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
 255 
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
256 
   
 256 
   
257 
    /*
 257 
    /*
258 
     * Mount flags are passed as ARG2.
 258 
     * Mount flags are passed as ARG2.
259 
     */
 259 
     */
260 
    unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
 260 
    unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
261 
   
 261 
   
262 
    /*
 262 
    /*
263 
     * For now, don't make use of ARG3, but it can be used to
 263 
     * For now, don't make use of ARG3, but it can be used to
264 
     * carry mount options in the future.
 264 
     * carry mount options in the future.
265 
     */
 265 
     */
266 
   
 266 
   
267 
    /* We want the client to send us the mount point. */
 267 
    /* We want the client to send us the mount point. */
268 
    ipc_callid_t callid;
 268 
    ipc_callid_t callid;
269 
    size_t size;
 269 
    size_t size;
270 
    if (!ipc_data_write_receive(&callid, &size)) {
 270 
    if (!ipc_data_write_receive(&callid, &size)) {
271 
        ipc_answer_0(callid, EINVAL);
 271 
        ipc_answer_0(callid, EINVAL);
272 
        ipc_answer_0(rid, EINVAL);
 272 
        ipc_answer_0(rid, EINVAL);
273 
        return;
 273 
        return;
274 
    }
 274 
    }
275 
   
 275 
   
276 
    /* Check whether size is reasonable wrt. the mount point. */
 276 
    /* Check whether size is reasonable wrt. the mount point. */
277 
    if ((size < 1) || (size > MAX_PATH_LEN)) {
 277 
    if ((size < 1) || (size > MAX_PATH_LEN)) {
278 
        ipc_answer_0(callid, EINVAL);
 278 
        ipc_answer_0(callid, EINVAL);
279 
        ipc_answer_0(rid, EINVAL);
 279 
        ipc_answer_0(rid, EINVAL);
280 
        return;
 280 
        return;
281 
    }
 281 
    }
282 
   
 282 
   
283 
    /* Allocate buffer for the mount point data being received. */
 283 
    /* Allocate buffer for the mount point data being received. */
284 
    char *mp = malloc(size + 1);
 284 
    char *mp = malloc(size + 1);
285 
    if (!mp) {
 285 
    if (!mp) {
286 
        ipc_answer_0(callid, ENOMEM);
 286 
        ipc_answer_0(callid, ENOMEM);
287 
        ipc_answer_0(rid, ENOMEM);
 287 
        ipc_answer_0(rid, ENOMEM);
288 
        return;
 288 
        return;
289 
    }
 289 
    }
290 
   
 290 
   
291 
    /* Deliver the mount point. */
 291 
    /* Deliver the mount point. */
292 
    ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
 292 
    ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
293 
    if (retval != EOK) {
 293 
    if (retval != EOK) {
294 
        ipc_answer_0(rid, retval);
 294 
        ipc_answer_0(rid, retval);
295 
        free(mp);
 295 
        free(mp);
296 
        return;
 296 
        return;
297 
    }
 297 
    }
298 
    mp[size] = '\0';
 298 
    mp[size] = '\0';
299 
   
 299 
   
300 
    /* Now we expect to receive the mount options. */
 300 
    /* Now we expect to receive the mount options. */
301 
    if (!ipc_data_write_receive(&callid, &size)) {
 301 
    if (!ipc_data_write_receive(&callid, &size)) {
302 
        ipc_answer_0(callid, EINVAL);
 302 
        ipc_answer_0(callid, EINVAL);
303 
        ipc_answer_0(rid, EINVAL);
 303 
        ipc_answer_0(rid, EINVAL);
304 
        free(mp);
 304 
        free(mp);
305 
        return;
 305 
        return;
306 
    }
 306 
    }
307 
 
 307 
 
308 
    /* Check the offered options size. */
 308 
    /* Check the offered options size. */
309 
    if (size < 0 || size > MAX_MNTOPTS_LEN) {
 309 
    if (size > MAX_MNTOPTS_LEN) {
310 
        ipc_answer_0(callid, EINVAL);
 310 
        ipc_answer_0(callid, EINVAL);
311 
        ipc_answer_0(rid, EINVAL);
 311 
        ipc_answer_0(rid, EINVAL);
312 
        free(mp);
 312 
        free(mp);
313 
        return;
 313 
        return;
314 
    }
 314 
    }
315 
 
 315 
 
316 
    /* Allocate buffer for the mount options. */
 316 
    /* Allocate buffer for the mount options. */
317 
    char *opts = (char *) malloc(size + 1);
 317 
    char *opts = (char *) malloc(size + 1);
318 
    if (!opts) {
 318 
    if (!opts) {
319 
        ipc_answer_0(callid, ENOMEM);
 319 
        ipc_answer_0(callid, ENOMEM);
320 
        ipc_answer_0(rid, ENOMEM);
 320 
        ipc_answer_0(rid, ENOMEM);
321 
        free(mp);
 321 
        free(mp);
322 
        return;
 322 
        return;
323 
    }
 323 
    }
324 
 
 324 
 
325 
    /* Deliver the mount options. */
 325 
    /* Deliver the mount options. */
326 
    retval = ipc_data_write_finalize(callid, opts, size);
 326 
    retval = ipc_data_write_finalize(callid, opts, size);
327 
    if (retval != EOK) {
 327 
    if (retval != EOK) {
328 
        ipc_answer_0(rid, retval);
 328 
        ipc_answer_0(rid, retval);
329 
        free(mp);
 329 
        free(mp);
330 
        free(opts);
 330 
        free(opts);
331 
        return;
 331 
        return;
332 
    }
 332 
    }
333 
    opts[size] = '\0';
 333 
    opts[size] = '\0';
334 
   
 334 
   
335 
    /*
 335 
    /*
336 
     * Now, we expect the client to send us data with the name of the file
 336 
     * Now, we expect the client to send us data with the name of the file
337 
     * system.
 337 
     * system.
338 
     */
 338 
     */
339 
    if (!ipc_data_write_receive(&callid, &size)) {
 339 
    if (!ipc_data_write_receive(&callid, &size)) {
340 
        ipc_answer_0(callid, EINVAL);
 340 
        ipc_answer_0(callid, EINVAL);
341 
        ipc_answer_0(rid, EINVAL);
 341 
        ipc_answer_0(rid, EINVAL);
342 
        free(mp);
 342 
        free(mp);
343 
        free(opts);
 343 
        free(opts);
344 
        return;
 344 
        return;
345 
    }
 345 
    }
346 
   
 346 
   
347 
    /*
 347 
    /*
348 
     * Don't receive more than is necessary for storing a full file system
 348 
     * Don't receive more than is necessary for storing a full file system
349 
     * name.
 349 
     * name.
350 
     */
 350 
     */
351 
    if ((size < 1) || (size > FS_NAME_MAXLEN)) {
 351 
    if ((size < 1) || (size > FS_NAME_MAXLEN)) {
352 
        ipc_answer_0(callid, EINVAL);
 352 
        ipc_answer_0(callid, EINVAL);
353 
        ipc_answer_0(rid, EINVAL);
 353 
        ipc_answer_0(rid, EINVAL);
354 
        free(mp);
 354 
        free(mp);
355 
        free(opts);
 355 
        free(opts);
356 
        return;
 356 
        return;
357 
    }
 357 
    }
358 
   
 358 
   
359 
    /*
 359 
    /*
360 
     * Allocate buffer for file system name.
 360 
     * Allocate buffer for file system name.
361 
     */
 361 
     */
362 
    char *fs_name = (char *) malloc(size + 1);
 362 
    char *fs_name = (char *) malloc(size + 1);
363 
    if (fs_name == NULL) {
 363 
    if (fs_name == NULL) {
364 
        ipc_answer_0(callid, ENOMEM);
 364 
        ipc_answer_0(callid, ENOMEM);
365 
        ipc_answer_0(rid, ENOMEM);
 365 
        ipc_answer_0(rid, ENOMEM);
366 
        free(mp);
 366 
        free(mp);
367 
        free(opts);
 367 
        free(opts);
368 
        return;
 368 
        return;
369 
    }
 369 
    }
370 
   
 370 
   
371 
    /* Deliver the file system name. */
 371 
    /* Deliver the file system name. */
372 
    retval = ipc_data_write_finalize(callid, fs_name, size);
 372 
    retval = ipc_data_write_finalize(callid, fs_name, size);
373 
    if (retval != EOK) {
 373 
    if (retval != EOK) {
374 
        ipc_answer_0(rid, retval);
 374 
        ipc_answer_0(rid, retval);
375 
        free(mp);
 375 
        free(mp);
376 
        free(opts);
 376 
        free(opts);
377 
        free(fs_name);
 377 
        free(fs_name);
378 
        return;
 378 
        return;
379 
    }
 379 
    }
380 
    fs_name[size] = '\0';
 380 
    fs_name[size] = '\0';
381 
 
 381 
 
382 
    /*
 382 
    /*
383 
     * Wait for IPC_M_PING so that we can return an error if we don't know
 383 
     * Wait for IPC_M_PING so that we can return an error if we don't know
384 
     * fs_name.
 384 
     * fs_name.
385 
     */
 385 
     */
386 
    ipc_call_t data;
 386 
    ipc_call_t data;
387 
    callid = async_get_call(&data);
 387 
    callid = async_get_call(&data);
388 
    if (IPC_GET_METHOD(data) != IPC_M_PING) {
 388 
    if (IPC_GET_METHOD(data) != IPC_M_PING) {
389 
        ipc_answer_0(callid, ENOTSUP);
 389 
        ipc_answer_0(callid, ENOTSUP);
390 
        ipc_answer_0(rid, ENOTSUP);
 390 
        ipc_answer_0(rid, ENOTSUP);
391 
        free(mp);
 391 
        free(mp);
392 
        free(opts);
 392 
        free(opts);
393 
        free(fs_name);
 393 
        free(fs_name);
394 
        return;
 394 
        return;
395 
    }
 395 
    }
396 
 
 396 
 
397 
    /*
 397 
    /*
398 
     * Check if we know a file system with the same name as is in fs_name.
 398 
     * Check if we know a file system with the same name as is in fs_name.
399 
     * This will also give us its file system handle.
 399 
     * This will also give us its file system handle.
400 
     */
 400 
     */
401 
    fibril_mutex_lock(&fs_head_lock);
 401 
    fibril_mutex_lock(&fs_head_lock);
402 
    fs_handle_t fs_handle;
 402 
    fs_handle_t fs_handle;
403 
recheck:
 403 
recheck:
404 
    fs_handle = fs_name_to_handle(fs_name, false);
 404 
    fs_handle = fs_name_to_handle(fs_name, false);
405 
    if (!fs_handle) {
 405 
    if (!fs_handle) {
406 
        if (flags & IPC_FLAG_BLOCKING) {
 406 
        if (flags & IPC_FLAG_BLOCKING) {
407 
            fibril_condvar_wait(&fs_head_cv, &fs_head_lock);
 407 
            fibril_condvar_wait(&fs_head_cv, &fs_head_lock);
408 
            goto recheck;
 408 
            goto recheck;
409 
        }
 409 
        }
410 
       
 410 
       
411 
        fibril_mutex_unlock(&fs_head_lock);
 411 
        fibril_mutex_unlock(&fs_head_lock);
412 
        ipc_answer_0(callid, ENOENT);
 412 
        ipc_answer_0(callid, ENOENT);
413 
        ipc_answer_0(rid, ENOENT);
 413 
        ipc_answer_0(rid, ENOENT);
414 
        free(mp);
 414 
        free(mp);
415 
        free(fs_name);
 415 
        free(fs_name);
416 
        free(opts);
 416 
        free(opts);
417 
        return;
 417 
        return;
418 
    }
 418 
    }
419 
    fibril_mutex_unlock(&fs_head_lock);
 419 
    fibril_mutex_unlock(&fs_head_lock);
420 
   
 420 
   
421 
    /* Acknowledge that we know fs_name. */
 421 
    /* Acknowledge that we know fs_name. */
422 
    ipc_answer_0(callid, EOK);
 422 
    ipc_answer_0(callid, EOK);
423 
   
 423 
   
424 
    /* Do the mount */
 424 
    /* Do the mount */
425 
    vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
 425 
    vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
426 
    free(mp);
 426 
    free(mp);
427 
    free(fs_name);
 427 
    free(fs_name);
428 
    free(opts);
 428 
    free(opts);
429 
}
 429 
}
430 
 
 430 
 
431 
void vfs_open(ipc_callid_t rid, ipc_call_t *request)
 431 
void vfs_open(ipc_callid_t rid, ipc_call_t *request)
432 
{
 432 
{
433 
    if (!vfs_files_init()) {
 433 
    if (!vfs_files_init()) {
434 
        ipc_answer_0(rid, ENOMEM);
 434 
        ipc_answer_0(rid, ENOMEM);
435 
        return;
 435 
        return;
436 
    }
 436 
    }
437 
   
 437 
   
438 
    /*
 438 
    /*
439 
     * The POSIX interface is open(path, oflag, mode).
 439 
     * The POSIX interface is open(path, oflag, mode).
440 
     * We can receive oflags and mode along with the VFS_IN_OPEN call;
 440 
     * We can receive oflags and mode along with the VFS_IN_OPEN call;
441 
     * the path will need to arrive in another call.
 441 
     * the path will need to arrive in another call.
442 
     *
 442 
     *
443 
     * We also receive one private, non-POSIX set of flags called lflag
 443 
     * We also receive one private, non-POSIX set of flags called lflag
444 
     * used to pass information to vfs_lookup_internal().
 444 
     * used to pass information to vfs_lookup_internal().
445 
     */
 445 
     */
446 
    int lflag = IPC_GET_ARG1(*request);
 446 
    int lflag = IPC_GET_ARG1(*request);
447 
    int oflag = IPC_GET_ARG2(*request);
 447 
    int oflag = IPC_GET_ARG2(*request);
448 
    int mode = IPC_GET_ARG3(*request);
 448 
    int mode = IPC_GET_ARG3(*request);
449 
    size_t len;
 449 
    size_t len;
- 
 
 450 
 
- 
 
 451 
    /* Ignore mode for now. */
- 
 
 452 
    (void) mode;
450 
   
 453 
   
451 
    /*
 454 
    /*
452 
     * Make sure that we are called with exactly one of L_FILE and
 455 
     * Make sure that we are called with exactly one of L_FILE and
453 
     * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
 456 
     * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
454 
     */
 457 
     */
455 
    if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
 458 
    if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
456 
        ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
 459 
        ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
457 
        ((lflag & L_OPEN) != 0)) {
 460 
        ((lflag & L_OPEN) != 0)) {
458 
        ipc_answer_0(rid, EINVAL);
 461 
        ipc_answer_0(rid, EINVAL);
459 
        return;
 462 
        return;
460 
    }
 463 
    }
461 
   
 464 
   
462 
    if (oflag & O_CREAT)
 465 
    if (oflag & O_CREAT)
463 
        lflag |= L_CREATE;
 466 
        lflag |= L_CREATE;
464 
    if (oflag & O_EXCL)
 467 
    if (oflag & O_EXCL)
465 
        lflag |= L_EXCLUSIVE;
 468 
        lflag |= L_EXCLUSIVE;
466 
   
 469 
   
467 
    ipc_callid_t callid;
 470 
    ipc_callid_t callid;
468 
    if (!ipc_data_write_receive(&callid, &len)) {
 471 
    if (!ipc_data_write_receive(&callid, &len)) {
469 
        ipc_answer_0(callid, EINVAL);
 472 
        ipc_answer_0(callid, EINVAL);
470 
        ipc_answer_0(rid, EINVAL);
 473 
        ipc_answer_0(rid, EINVAL);
471 
        return;
 474 
        return;
472 
    }
 475 
    }
473 
   
 476 
   
474 
    char *path = malloc(len + 1);
 477 
    char *path = malloc(len + 1);
475 
    if (!path) {
 478 
    if (!path) {
476 
        ipc_answer_0(callid, ENOMEM);
 479 
        ipc_answer_0(callid, ENOMEM);
477 
        ipc_answer_0(rid, ENOMEM);
 480 
        ipc_answer_0(rid, ENOMEM);
478 
        return;
 481 
        return;
479 
    }
 482 
    }
480 
   
 483 
   
481 
    int rc;
 484 
    int rc;
482 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
 485 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
483 
        ipc_answer_0(rid, rc);
 486 
        ipc_answer_0(rid, rc);
484 
        free(path);
 487 
        free(path);
485 
        return;
 488 
        return;
486 
    }
 489 
    }
487 
    path[len] = '\0';
 490 
    path[len] = '\0';
488 
   
 491 
   
489 
    /*
 492 
    /*
490 
     * Avoid the race condition in which the file can be deleted before we
 493 
     * Avoid the race condition in which the file can be deleted before we
491 
     * find/create-and-lock the VFS node corresponding to the looked-up
 494 
     * find/create-and-lock the VFS node corresponding to the looked-up
492 
     * triplet.
 495 
     * triplet.
493 
     */
 496 
     */
494 
    if (lflag & L_CREATE)
 497 
    if (lflag & L_CREATE)
495 
        fibril_rwlock_write_lock(&namespace_rwlock);
 498 
        fibril_rwlock_write_lock(&namespace_rwlock);
496 
    else
 499 
    else
497 
        fibril_rwlock_read_lock(&namespace_rwlock);
 500 
        fibril_rwlock_read_lock(&namespace_rwlock);
498 
   
 501 
   
499 
    /* The path is now populated and we can call vfs_lookup_internal(). */
 502 
    /* The path is now populated and we can call vfs_lookup_internal(). */
500 
    vfs_lookup_res_t lr;
 503 
    vfs_lookup_res_t lr;
501 
    rc = vfs_lookup_internal(path, lflag | L_OPEN, &lr, NULL);
 504 
    rc = vfs_lookup_internal(path, lflag | L_OPEN, &lr, NULL);
502 
    if (rc != EOK) {
 505 
    if (rc != EOK) {
503 
        if (lflag & L_CREATE)
 506 
        if (lflag & L_CREATE)
504 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 507 
            fibril_rwlock_write_unlock(&namespace_rwlock);
505 
        else
 508 
        else
506 
            fibril_rwlock_read_unlock(&namespace_rwlock);
 509 
            fibril_rwlock_read_unlock(&namespace_rwlock);
507 
        ipc_answer_0(rid, rc);
 510 
        ipc_answer_0(rid, rc);
508 
        free(path);
 511 
        free(path);
509 
        return;
 512 
        return;
510 
    }
 513 
    }
511 
   
 514 
   
512 
    /* Path is no longer needed. */
 515 
    /* Path is no longer needed. */
513 
    free(path);
 516 
    free(path);
514 
   
 517 
   
515 
    vfs_node_t *node = vfs_node_get(&lr);
 518 
    vfs_node_t *node = vfs_node_get(&lr);
516 
    if (lflag & L_CREATE)
 519 
    if (lflag & L_CREATE)
517 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 520 
        fibril_rwlock_write_unlock(&namespace_rwlock);
518 
    else
 521 
    else
519 
        fibril_rwlock_read_unlock(&namespace_rwlock);
 522 
        fibril_rwlock_read_unlock(&namespace_rwlock);
520 
   
 523 
   
521 
    /* Truncate the file if requested and if necessary. */
 524 
    /* Truncate the file if requested and if necessary. */
522 
    if (oflag & O_TRUNC) {
 525 
    if (oflag & O_TRUNC) {
523 
        fibril_rwlock_write_lock(&node->contents_rwlock);
 526 
        fibril_rwlock_write_lock(&node->contents_rwlock);
524 
        if (node->size) {
 527 
        if (node->size) {
525 
            rc = vfs_truncate_internal(node->fs_handle,
 528 
            rc = vfs_truncate_internal(node->fs_handle,
526 
                node->dev_handle, node->index, 0);
 529 
                node->dev_handle, node->index, 0);
527 
            if (rc) {
 530 
            if (rc) {
528 
                fibril_rwlock_write_unlock(&node->contents_rwlock);
 531 
                fibril_rwlock_write_unlock(&node->contents_rwlock);
529 
                vfs_node_put(node);
 532 
                vfs_node_put(node);
530 
                ipc_answer_0(rid, rc);
 533 
                ipc_answer_0(rid, rc);
531 
                return;
 534 
                return;
532 
            }
 535 
            }
533 
            node->size = 0;
 536 
            node->size = 0;
534 
        }
 537 
        }
535 
        fibril_rwlock_write_unlock(&node->contents_rwlock);
 538 
        fibril_rwlock_write_unlock(&node->contents_rwlock);
536 
    }
 539 
    }
537 
   
 540 
   
538 
    /*
 541 
    /*
539 
     * Get ourselves a file descriptor and the corresponding vfs_file_t
 542 
     * Get ourselves a file descriptor and the corresponding vfs_file_t
540 
     * structure.
 543 
     * structure.
541 
     */
 544 
     */
542 
    int fd = vfs_fd_alloc();
 545 
    int fd = vfs_fd_alloc();
543 
    if (fd < 0) {
 546 
    if (fd < 0) {
544 
        vfs_node_put(node);
 547 
        vfs_node_put(node);
545 
        ipc_answer_0(rid, fd);
 548 
        ipc_answer_0(rid, fd);
546 
        return;
 549 
        return;
547 
    }
 550 
    }
548 
    vfs_file_t *file = vfs_file_get(fd);
 551 
    vfs_file_t *file = vfs_file_get(fd);
549 
    file->node = node;
 552 
    file->node = node;
550 
    if (oflag & O_APPEND)
 553 
    if (oflag & O_APPEND)
551 
        file->append = true;
 554 
        file->append = true;
552 
   
 555 
   
553 
    /*
 556 
    /*
554 
     * The following increase in reference count is for the fact that the
 557 
     * The following increase in reference count is for the fact that the
555 
     * file is being opened and that a file structure is pointing to it.
 558 
     * file is being opened and that a file structure is pointing to it.
556 
     * It is necessary so that the file will not disappear when
 559 
     * It is necessary so that the file will not disappear when
557 
     * vfs_node_put() is called. The reference will be dropped by the
 560 
     * vfs_node_put() is called. The reference will be dropped by the
558 
     * respective VFS_IN_CLOSE.
 561 
     * respective VFS_IN_CLOSE.
559 
     */
 562 
     */
560 
    vfs_node_addref(node);
 563 
    vfs_node_addref(node);
561 
    vfs_node_put(node);
 564 
    vfs_node_put(node);
562 
   
 565 
   
563 
    /* Success! Return the new file descriptor to the client. */
 566 
    /* Success! Return the new file descriptor to the client. */
564 
    ipc_answer_1(rid, EOK, fd);
 567 
    ipc_answer_1(rid, EOK, fd);
565 
}
 568 
}
566 
 
 569 
 
567 
void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
 570 
void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
568 
{
 571 
{
569 
    // FIXME: check for sanity of the supplied fs, dev and index
 572 
    // FIXME: check for sanity of the supplied fs, dev and index
570 
   
 573 
   
571 
    if (!vfs_files_init()) {
 574 
    if (!vfs_files_init()) {
572 
        ipc_answer_0(rid, ENOMEM);
 575 
        ipc_answer_0(rid, ENOMEM);
573 
        return;
 576 
        return;
574 
    }
 577 
    }
575 
   
 578 
   
576 
    /*
 579 
    /*
577 
     * The interface is open_node(fs, dev, index, oflag).
 580 
     * The interface is open_node(fs, dev, index, oflag).
578 
     */
 581 
     */
579 
    vfs_lookup_res_t lr;
 582 
    vfs_lookup_res_t lr;
580 
   
 583 
   
581 
    lr.triplet.fs_handle = IPC_GET_ARG1(*request);
 584 
    lr.triplet.fs_handle = IPC_GET_ARG1(*request);
582 
    lr.triplet.dev_handle = IPC_GET_ARG2(*request);
 585 
    lr.triplet.dev_handle = IPC_GET_ARG2(*request);
583 
    lr.triplet.index = IPC_GET_ARG3(*request);
 586 
    lr.triplet.index = IPC_GET_ARG3(*request);
584 
    int oflag = IPC_GET_ARG4(*request);
 587 
    int oflag = IPC_GET_ARG4(*request);
585 
   
 588 
   
586 
    fibril_rwlock_read_lock(&namespace_rwlock);
 589 
    fibril_rwlock_read_lock(&namespace_rwlock);
587 
   
 590 
   
588 
    int rc = vfs_open_node_internal(&lr);
 591 
    int rc = vfs_open_node_internal(&lr);
589 
    if (rc != EOK) {
 592 
    if (rc != EOK) {
590 
        fibril_rwlock_read_unlock(&namespace_rwlock);
 593 
        fibril_rwlock_read_unlock(&namespace_rwlock);
591 
        ipc_answer_0(rid, rc);
 594 
        ipc_answer_0(rid, rc);
592 
        return;
 595 
        return;
593 
    }
 596 
    }
594 
   
 597 
   
595 
    vfs_node_t *node = vfs_node_get(&lr);
 598 
    vfs_node_t *node = vfs_node_get(&lr);
596 
    fibril_rwlock_read_unlock(&namespace_rwlock);
 599 
    fibril_rwlock_read_unlock(&namespace_rwlock);
597 
   
 600 
   
598 
    /* Truncate the file if requested and if necessary. */
 601 
    /* Truncate the file if requested and if necessary. */
599 
    if (oflag & O_TRUNC) {
 602 
    if (oflag & O_TRUNC) {
600 
        fibril_rwlock_write_lock(&node->contents_rwlock);
 603 
        fibril_rwlock_write_lock(&node->contents_rwlock);
601 
        if (node->size) {
 604 
        if (node->size) {
602 
            rc = vfs_truncate_internal(node->fs_handle,
 605 
            rc = vfs_truncate_internal(node->fs_handle,
603 
                node->dev_handle, node->index, 0);
 606 
                node->dev_handle, node->index, 0);
604 
            if (rc) {
 607 
            if (rc) {
605 
                fibril_rwlock_write_unlock(&node->contents_rwlock);
 608 
                fibril_rwlock_write_unlock(&node->contents_rwlock);
606 
                vfs_node_put(node);
 609 
                vfs_node_put(node);
607 
                ipc_answer_0(rid, rc);
 610 
                ipc_answer_0(rid, rc);
608 
                return;
 611 
                return;
609 
            }
 612 
            }
610 
            node->size = 0;
 613 
            node->size = 0;
611 
        }
 614 
        }
612 
        fibril_rwlock_write_unlock(&node->contents_rwlock);
 615 
        fibril_rwlock_write_unlock(&node->contents_rwlock);
613 
    }
 616 
    }
614 
   
 617 
   
615 
    /*
 618 
    /*
616 
     * Get ourselves a file descriptor and the corresponding vfs_file_t
 619 
     * Get ourselves a file descriptor and the corresponding vfs_file_t
617 
     * structure.
 620 
     * structure.
618 
     */
 621 
     */
619 
    int fd = vfs_fd_alloc();
 622 
    int fd = vfs_fd_alloc();
620 
    if (fd < 0) {
 623 
    if (fd < 0) {
621 
        vfs_node_put(node);
 624 
        vfs_node_put(node);
622 
        ipc_answer_0(rid, fd);
 625 
        ipc_answer_0(rid, fd);
623 
        return;
 626 
        return;
624 
    }
 627 
    }
625 
    vfs_file_t *file = vfs_file_get(fd);
 628 
    vfs_file_t *file = vfs_file_get(fd);
626 
    file->node = node;
 629 
    file->node = node;
627 
    if (oflag & O_APPEND)
 630 
    if (oflag & O_APPEND)
628 
        file->append = true;
 631 
        file->append = true;
629 
   
 632 
   
630 
    /*
 633 
    /*
631 
     * The following increase in reference count is for the fact that the
 634 
     * The following increase in reference count is for the fact that the
632 
     * file is being opened and that a file structure is pointing to it.
 635 
     * file is being opened and that a file structure is pointing to it.
633 
     * It is necessary so that the file will not disappear when
 636 
     * It is necessary so that the file will not disappear when
634 
     * vfs_node_put() is called. The reference will be dropped by the
 637 
     * vfs_node_put() is called. The reference will be dropped by the
635 
     * respective VFS_IN_CLOSE.
 638 
     * respective VFS_IN_CLOSE.
636 
     */
 639 
     */
637 
    vfs_node_addref(node);
 640 
    vfs_node_addref(node);
638 
    vfs_node_put(node);
 641 
    vfs_node_put(node);
639 
   
 642 
   
640 
    /* Success! Return the new file descriptor to the client. */
 643 
    /* Success! Return the new file descriptor to the client. */
641 
    ipc_answer_1(rid, EOK, fd);
 644 
    ipc_answer_1(rid, EOK, fd);
642 
}
 645 
}
643 
 
 646 
 
644 
void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
 647 
void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
645 
{
 648 
{
646 
    int fd = IPC_GET_ARG1(*request);
 649 
    int fd = IPC_GET_ARG1(*request);
647 
   
 650 
   
648 
    /* Lookup the file structure corresponding to the file descriptor. */
 651 
    /* Lookup the file structure corresponding to the file descriptor. */
649 
    vfs_file_t *file = vfs_file_get(fd);
 652 
    vfs_file_t *file = vfs_file_get(fd);
650 
    if (!file) {
 653 
    if (!file) {
651 
        ipc_answer_0(rid, ENOENT);
 654 
        ipc_answer_0(rid, ENOENT);
652 
        return;
 655 
        return;
653 
    }
 656 
    }
654 
   
 657 
   
655 
    /*
 658 
    /*
656 
     * Lock the open file structure so that no other thread can manipulate
 659 
     * Lock the open file structure so that no other thread can manipulate
657 
     * the same open file at a time.
 660 
     * the same open file at a time.
658 
     */
 661 
     */
659 
    fibril_mutex_lock(&file->lock);
 662 
    fibril_mutex_lock(&file->lock);
660 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
 663 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
661 
   
 664 
   
662 
    /* Make a VFS_OUT_SYMC request at the destination FS server. */
 665 
    /* Make a VFS_OUT_SYMC request at the destination FS server. */
663 
    aid_t msg;
 666 
    aid_t msg;
664 
    ipc_call_t answer;
 667 
    ipc_call_t answer;
665 
    msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
 668 
    msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
666 
        file->node->index, &answer);
 669 
        file->node->index, &answer);
667 
 
 670 
 
668 
    /* Wait for reply from the FS server. */
 671 
    /* Wait for reply from the FS server. */
669 
    ipcarg_t rc;
 672 
    ipcarg_t rc;
670 
    async_wait_for(msg, &rc);
 673 
    async_wait_for(msg, &rc);
671 
   
 674 
   
672 
    vfs_release_phone(fs_phone);
 675 
    vfs_release_phone(fs_phone);
673 
    fibril_mutex_unlock(&file->lock);
 676 
    fibril_mutex_unlock(&file->lock);
674 
   
 677 
   
675 
    ipc_answer_0(rid, rc);
 678 
    ipc_answer_0(rid, rc);
676 
}
 679 
}
677 
 
 680 
 
678 
void vfs_close(ipc_callid_t rid, ipc_call_t *request)
 681 
void vfs_close(ipc_callid_t rid, ipc_call_t *request)
679 
{
 682 
{
680 
    int fd = IPC_GET_ARG1(*request);
 683 
    int fd = IPC_GET_ARG1(*request);
681 
   
 684 
   
682 
    /* Lookup the file structure corresponding to the file descriptor. */
 685 
    /* Lookup the file structure corresponding to the file descriptor. */
683 
    vfs_file_t *file = vfs_file_get(fd);
 686 
    vfs_file_t *file = vfs_file_get(fd);
684 
    if (!file) {
 687 
    if (!file) {
685 
        ipc_answer_0(rid, ENOENT);
 688 
        ipc_answer_0(rid, ENOENT);
686 
        return;
 689 
        return;
687 
    }
 690 
    }
688 
   
 691 
   
689 
    /*
 692 
    /*
690 
     * Lock the open file structure so that no other thread can manipulate
 693 
     * Lock the open file structure so that no other thread can manipulate
691 
     * the same open file at a time.
 694 
     * the same open file at a time.
692 
     */
 695 
     */
693 
    fibril_mutex_lock(&file->lock);
 696 
    fibril_mutex_lock(&file->lock);
694 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
 697 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
695 
   
 698 
   
696 
    /* Make a VFS_OUT_CLOSE request at the destination FS server. */
 699 
    /* Make a VFS_OUT_CLOSE request at the destination FS server. */
697 
    aid_t msg;
 700 
    aid_t msg;
698 
    ipc_call_t answer;
 701 
    ipc_call_t answer;
699 
    msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
 702 
    msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
700 
        file->node->index, &answer);
 703 
        file->node->index, &answer);
701 
 
 704 
 
702 
    /* Wait for reply from the FS server. */
 705 
    /* Wait for reply from the FS server. */
703 
    ipcarg_t rc;
 706 
    ipcarg_t rc;
704 
    async_wait_for(msg, &rc);
 707 
    async_wait_for(msg, &rc);
705 
 
 708 
 
706 
    vfs_release_phone(fs_phone);
 709 
    vfs_release_phone(fs_phone);
707 
    fibril_mutex_unlock(&file->lock);
 710 
    fibril_mutex_unlock(&file->lock);
708 
   
 711 
   
709 
    int retval = IPC_GET_ARG1(answer);
 712 
    int retval = IPC_GET_ARG1(answer);
710 
    if (retval != EOK)
 713 
    if (retval != EOK)
711 
        ipc_answer_0(rid, retval);
 714 
        ipc_answer_0(rid, retval);
712 
   
 715 
   
713 
    retval = vfs_fd_free(fd);
 716 
    retval = vfs_fd_free(fd);
714 
    ipc_answer_0(rid, retval);
 717 
    ipc_answer_0(rid, retval);
715 
}
 718 
}
716 
 
 719 
 
717 
static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 720 
static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
718 
{
 721 
{
719 
 
 722 
 
720 
    /*
 723 
    /*
721 
     * The following code strongly depends on the fact that the files data
 724 
     * The following code strongly depends on the fact that the files data
722 
     * structure can be only accessed by a single fibril and all file
 725 
     * structure can be only accessed by a single fibril and all file
723 
     * operations are serialized (i.e. the reads and writes cannot
 726 
     * operations are serialized (i.e. the reads and writes cannot
724 
     * interleave and a file cannot be closed while it is being read).
 727 
     * interleave and a file cannot be closed while it is being read).
725 
     *
 728 
     *
726 
     * Additional synchronization needs to be added once the table of
 729 
     * Additional synchronization needs to be added once the table of
727 
     * open files supports parallel access!
 730 
     * open files supports parallel access!
728 
     */
 731 
     */
729 
 
 732 
 
730 
    int fd = IPC_GET_ARG1(*request);
 733 
    int fd = IPC_GET_ARG1(*request);
731 
   
 734 
   
732 
    /* Lookup the file structure corresponding to the file descriptor. */
 735 
    /* Lookup the file structure corresponding to the file descriptor. */
733 
    vfs_file_t *file = vfs_file_get(fd);
 736 
    vfs_file_t *file = vfs_file_get(fd);
734 
    if (!file) {
 737 
    if (!file) {
735 
        ipc_answer_0(rid, ENOENT);
 738 
        ipc_answer_0(rid, ENOENT);
736 
        return;
 739 
        return;
737 
    }
 740 
    }
738 
   
 741 
   
739 
    /*
 742 
    /*
740 
     * Now we need to receive a call with client's
 743 
     * Now we need to receive a call with client's
741 
     * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
 744 
     * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
742 
     */
 745 
     */
743 
    ipc_callid_t callid;
 746 
    ipc_callid_t callid;
744 
    int res;
 747 
    int res;
745 
    if (read)
 748 
    if (read)
746 
        res = ipc_data_read_receive(&callid, NULL);
 749 
        res = ipc_data_read_receive(&callid, NULL);
747 
    else
 750 
    else
748 
        res = ipc_data_write_receive(&callid, NULL);
 751 
        res = ipc_data_write_receive(&callid, NULL);
749 
    if (!res) {
 752 
    if (!res) {
750 
        ipc_answer_0(callid, EINVAL);
 753 
        ipc_answer_0(callid, EINVAL);
751 
        ipc_answer_0(rid, EINVAL);
 754 
        ipc_answer_0(rid, EINVAL);
752 
        return;
 755 
        return;
753 
    }
 756 
    }
754 
   
 757 
   
755 
    /*
 758 
    /*
756 
     * Lock the open file structure so that no other thread can manipulate
 759 
     * Lock the open file structure so that no other thread can manipulate
757 
     * the same open file at a time.
 760 
     * the same open file at a time.
758 
     */
 761 
     */
759 
    fibril_mutex_lock(&file->lock);
 762 
    fibril_mutex_lock(&file->lock);
760 
 
 763 
 
761 
    /*
 764 
    /*
762 
     * Lock the file's node so that no other client can read/write to it at
 765 
     * Lock the file's node so that no other client can read/write to it at
763 
     * the same time.
 766 
     * the same time.
764 
     */
 767 
     */
765 
    if (read)
 768 
    if (read)
766 
        fibril_rwlock_read_lock(&file->node->contents_rwlock);
 769 
        fibril_rwlock_read_lock(&file->node->contents_rwlock);
767 
    else
 770 
    else
768 
        fibril_rwlock_write_lock(&file->node->contents_rwlock);
 771 
        fibril_rwlock_write_lock(&file->node->contents_rwlock);
769 
 
 772 
 
770 
    if (file->node->type == VFS_NODE_DIRECTORY) {
 773 
    if (file->node->type == VFS_NODE_DIRECTORY) {
771 
        /*
 774 
        /*
772 
         * Make sure that no one is modifying the namespace
 775 
         * Make sure that no one is modifying the namespace
773 
         * while we are in readdir().
 776 
         * while we are in readdir().
774 
         */
 777 
         */
775 
        assert(read);
 778 
        assert(read);
776 
        fibril_rwlock_read_lock(&namespace_rwlock);
 779 
        fibril_rwlock_read_lock(&namespace_rwlock);
777 
    }
 780 
    }
778 
   
 781 
   
779 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);  
 782 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);  
780 
   
 783 
   
781 
    /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
 784 
    /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
782 
    aid_t msg;
 785 
    aid_t msg;
783 
    ipc_call_t answer;
 786 
    ipc_call_t answer;
784 
    if (!read && file->append)
 787 
    if (!read && file->append)
785 
        file->pos = file->node->size;
 788 
        file->pos = file->node->size;
786 
    msg = async_send_3(fs_phone, read ? VFS_OUT_READ : VFS_OUT_WRITE,
 789 
    msg = async_send_3(fs_phone, read ? VFS_OUT_READ : VFS_OUT_WRITE,
787 
        file->node->dev_handle, file->node->index, file->pos, &answer);
 790 
        file->node->dev_handle, file->node->index, file->pos, &answer);
788 
   
 791 
   
789 
    /*
 792 
    /*
790 
     * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
 793 
     * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
791 
     * destination FS server. The call will be routed as if sent by
 794 
     * destination FS server. The call will be routed as if sent by
792 
     * ourselves. Note that call arguments are immutable in this case so we
 795 
     * ourselves. Note that call arguments are immutable in this case so we
793 
     * don't have to bother.
 796 
     * don't have to bother.
794 
     */
 797 
     */
795 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 798 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
796 
 
 799 
 
797 
    /* Wait for reply from the FS server. */
 800 
    /* Wait for reply from the FS server. */
798 
    ipcarg_t rc;
 801 
    ipcarg_t rc;
799 
    async_wait_for(msg, &rc);
 802 
    async_wait_for(msg, &rc);
800 
   
 803 
   
801 
    vfs_release_phone(fs_phone);
 804 
    vfs_release_phone(fs_phone);
802 
   
 805 
   
803 
    size_t bytes = IPC_GET_ARG1(answer);
 806 
    size_t bytes = IPC_GET_ARG1(answer);
804 
 
 807 
 
805 
    if (file->node->type == VFS_NODE_DIRECTORY)
 808 
    if (file->node->type == VFS_NODE_DIRECTORY)
806 
        fibril_rwlock_read_unlock(&namespace_rwlock);
 809 
        fibril_rwlock_read_unlock(&namespace_rwlock);
807 
   
 810 
   
808 
    /* Unlock the VFS node. */
 811 
    /* Unlock the VFS node. */
809 
    if (read)
 812 
    if (read)
810 
        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
 813 
        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
811 
    else {
 814 
    else {
812 
        /* Update the cached version of node's size. */
 815 
        /* Update the cached version of node's size. */
813 
        if (rc == EOK)
 816 
        if (rc == EOK)
814 
            file->node->size = IPC_GET_ARG2(answer);
 817 
            file->node->size = IPC_GET_ARG2(answer);
815 
        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
 818 
        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
816 
    }
 819 
    }
817 
   
 820 
   
818 
    /* Update the position pointer and unlock the open file. */
 821 
    /* Update the position pointer and unlock the open file. */
819 
    if (rc == EOK)
 822 
    if (rc == EOK)
820 
        file->pos += bytes;
 823 
        file->pos += bytes;
821 
    fibril_mutex_unlock(&file->lock);
 824 
    fibril_mutex_unlock(&file->lock);
822 
   
 825 
   
823 
    /*
 826 
    /*
824 
     * FS server's reply is the final result of the whole operation we
 827 
     * FS server's reply is the final result of the whole operation we
825 
     * return to the client.
 828 
     * return to the client.
826 
     */
 829 
     */
827 
    ipc_answer_1(rid, rc, bytes);
 830 
    ipc_answer_1(rid, rc, bytes);
828 
}
 831 
}
829 
 
 832 
 
830 
void vfs_read(ipc_callid_t rid, ipc_call_t *request)
 833 
void vfs_read(ipc_callid_t rid, ipc_call_t *request)
831 
{
 834 
{
832 
    vfs_rdwr(rid, request, true);
 835 
    vfs_rdwr(rid, request, true);
833 
}
 836 
}
834 
 
 837 
 
835 
void vfs_write(ipc_callid_t rid, ipc_call_t *request)
 838 
void vfs_write(ipc_callid_t rid, ipc_call_t *request)
836 
{
 839 
{
837 
    vfs_rdwr(rid, request, false);
 840 
    vfs_rdwr(rid, request, false);
838 
}
 841 
}
839 
 
 842 
 
840 
void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
 843 
void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
841 
{
 844 
{
842 
    int fd = (int) IPC_GET_ARG1(*request);
 845 
    int fd = (int) IPC_GET_ARG1(*request);
843 
    off_t off = (off_t) IPC_GET_ARG2(*request);
 846 
    off_t off = (off_t) IPC_GET_ARG2(*request);
844 
    int whence = (int) IPC_GET_ARG3(*request);
 847 
    int whence = (int) IPC_GET_ARG3(*request);
845 
 
 848 
 
846 
 
 849 
 
847 
    /* Lookup the file structure corresponding to the file descriptor. */
 850 
    /* Lookup the file structure corresponding to the file descriptor. */
848 
    vfs_file_t *file = vfs_file_get(fd);
 851 
    vfs_file_t *file = vfs_file_get(fd);
849 
    if (!file) {
 852 
    if (!file) {
850 
        ipc_answer_0(rid, ENOENT);
 853 
        ipc_answer_0(rid, ENOENT);
851 
        return;
 854 
        return;
852 
    }
 855 
    }
853 
 
 856 
 
854 
    off_t newpos;
 857 
    off_t newpos;
855 
    fibril_mutex_lock(&file->lock);
 858 
    fibril_mutex_lock(&file->lock);
856 
    if (whence == SEEK_SET) {
 859 
    if (whence == SEEK_SET) {
857 
        file->pos = off;
 860 
        file->pos = off;
858 
        fibril_mutex_unlock(&file->lock);
 861 
        fibril_mutex_unlock(&file->lock);
859 
        ipc_answer_1(rid, EOK, off);
 862 
        ipc_answer_1(rid, EOK, off);
860 
        return;
 863 
        return;
861 
    }
 864 
    }
862 
    if (whence == SEEK_CUR) {
 865 
    if (whence == SEEK_CUR) {
863 
        if (file->pos + off < file->pos) {
 866 
        if (file->pos + off < file->pos) {
864 
            fibril_mutex_unlock(&file->lock);
 867 
            fibril_mutex_unlock(&file->lock);
865 
            ipc_answer_0(rid, EOVERFLOW);
 868 
            ipc_answer_0(rid, EOVERFLOW);
866 
            return;
 869 
            return;
867 
        }
 870 
        }
868 
        file->pos += off;
 871 
        file->pos += off;
869 
        newpos = file->pos;
 872 
        newpos = file->pos;
870 
        fibril_mutex_unlock(&file->lock);
 873 
        fibril_mutex_unlock(&file->lock);
871 
        ipc_answer_1(rid, EOK, newpos);
 874 
        ipc_answer_1(rid, EOK, newpos);
872 
        return;
 875 
        return;
873 
    }
 876 
    }
874 
    if (whence == SEEK_END) {
 877 
    if (whence == SEEK_END) {
875 
        fibril_rwlock_read_lock(&file->node->contents_rwlock);
 878 
        fibril_rwlock_read_lock(&file->node->contents_rwlock);
876 
        size_t size = file->node->size;
 879 
        size_t size = file->node->size;
877 
        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
 880 
        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
878 
        if (size + off < size) {
 881 
        if (size + off < size) {
879 
            fibril_mutex_unlock(&file->lock);
 882 
            fibril_mutex_unlock(&file->lock);
880 
            ipc_answer_0(rid, EOVERFLOW);
 883 
            ipc_answer_0(rid, EOVERFLOW);
881 
            return;
 884 
            return;
882 
        }
 885 
        }
883 
        newpos = size + off;
 886 
        newpos = size + off;
884 
        fibril_mutex_unlock(&file->lock);
 887 
        fibril_mutex_unlock(&file->lock);
885 
        ipc_answer_1(rid, EOK, newpos);
 888 
        ipc_answer_1(rid, EOK, newpos);
886 
        return;
 889 
        return;
887 
    }
 890 
    }
888 
    fibril_mutex_unlock(&file->lock);
 891 
    fibril_mutex_unlock(&file->lock);
889 
    ipc_answer_0(rid, EINVAL);
 892 
    ipc_answer_0(rid, EINVAL);
890 
}
 893 
}
891 
 
 894 
 
892 
int
 895 
int
893 
vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
 896 
vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
894 
    fs_index_t index, size_t size)
 897 
    fs_index_t index, size_t size)
895 
{
 898 
{
896 
    ipcarg_t rc;
 899 
    ipcarg_t rc;
897 
    int fs_phone;
 900 
    int fs_phone;
898 
   
 901 
   
899 
    fs_phone = vfs_grab_phone(fs_handle);
 902 
    fs_phone = vfs_grab_phone(fs_handle);
900 
    rc = async_req_3_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t)dev_handle,
 903 
    rc = async_req_3_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t)dev_handle,
901 
        (ipcarg_t)index, (ipcarg_t)size);
 904 
        (ipcarg_t)index, (ipcarg_t)size);
902 
    vfs_release_phone(fs_phone);
 905 
    vfs_release_phone(fs_phone);
903 
    return (int)rc;
 906 
    return (int)rc;
904 
}
 907 
}
905 
 
 908 
 
906 
void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
 909 
void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
907 
{
 910 
{
908 
    int fd = IPC_GET_ARG1(*request);
 911 
    int fd = IPC_GET_ARG1(*request);
909 
    size_t size = IPC_GET_ARG2(*request);
 912 
    size_t size = IPC_GET_ARG2(*request);
910 
    int rc;
 913 
    int rc;
911 
 
 914 
 
912 
    vfs_file_t *file = vfs_file_get(fd);
 915 
    vfs_file_t *file = vfs_file_get(fd);
913 
    if (!file) {
 916 
    if (!file) {
914 
        ipc_answer_0(rid, ENOENT);
 917 
        ipc_answer_0(rid, ENOENT);
915 
        return;
 918 
        return;
916 
    }
 919 
    }
917 
    fibril_mutex_lock(&file->lock);
 920 
    fibril_mutex_lock(&file->lock);
918 
 
 921 
 
919 
    fibril_rwlock_write_lock(&file->node->contents_rwlock);
 922 
    fibril_rwlock_write_lock(&file->node->contents_rwlock);
920 
    rc = vfs_truncate_internal(file->node->fs_handle,
 923 
    rc = vfs_truncate_internal(file->node->fs_handle,
921 
        file->node->dev_handle, file->node->index, size);
 924 
        file->node->dev_handle, file->node->index, size);
922 
    if (rc == EOK)
 925 
    if (rc == EOK)
923 
        file->node->size = size;
 926 
        file->node->size = size;
924 
    fibril_rwlock_write_unlock(&file->node->contents_rwlock);
 927 
    fibril_rwlock_write_unlock(&file->node->contents_rwlock);
925 
 
 928 
 
926 
    fibril_mutex_unlock(&file->lock);
 929 
    fibril_mutex_unlock(&file->lock);
927 
    ipc_answer_0(rid, (ipcarg_t)rc);
 930 
    ipc_answer_0(rid, (ipcarg_t)rc);
928 
}
 931 
}
929 
 
 932 
 
930 
void vfs_fstat(ipc_callid_t rid, ipc_call_t *request)
 933 
void vfs_fstat(ipc_callid_t rid, ipc_call_t *request)
931 
{
 934 
{
932 
    int fd = IPC_GET_ARG1(*request);
 935 
    int fd = IPC_GET_ARG1(*request);
933 
    size_t size = IPC_GET_ARG2(*request);
 936 
    size_t size = IPC_GET_ARG2(*request);
934 
    ipcarg_t rc;
 937 
    ipcarg_t rc;
935 
 
 938 
 
936 
    vfs_file_t *file = vfs_file_get(fd);
 939 
    vfs_file_t *file = vfs_file_get(fd);
937 
    if (!file) {
 940 
    if (!file) {
938 
        ipc_answer_0(rid, ENOENT);
 941 
        ipc_answer_0(rid, ENOENT);
939 
        return;
 942 
        return;
940 
    }
 943 
    }
941 
 
 944 
 
942 
    ipc_callid_t callid;
 945 
    ipc_callid_t callid;
943 
    if (!ipc_data_read_receive(&callid, NULL)) {
 946 
    if (!ipc_data_read_receive(&callid, NULL)) {
944 
        ipc_answer_0(callid, EINVAL);
 947 
        ipc_answer_0(callid, EINVAL);
945 
        ipc_answer_0(rid, EINVAL);
 948 
        ipc_answer_0(rid, EINVAL);
946 
        return;
 949 
        return;
947 
    }
 950 
    }
948 
 
 951 
 
949 
    fibril_mutex_lock(&file->lock);
 952 
    fibril_mutex_lock(&file->lock);
950 
 
 953 
 
951 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
 954 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
952 
   
 955 
   
953 
    aid_t msg;
 956 
    aid_t msg;
954 
    msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
 957 
    msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
955 
        file->node->index, true, NULL);
 958 
        file->node->index, true, NULL);
956 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 959 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
957 
    async_wait_for(msg, &rc);
 960 
    async_wait_for(msg, &rc);
958 
    vfs_release_phone(fs_phone);
 961 
    vfs_release_phone(fs_phone);
959 
 
 962 
 
960 
    fibril_mutex_unlock(&file->lock);
 963 
    fibril_mutex_unlock(&file->lock);
961 
    ipc_answer_0(rid, rc);
 964 
    ipc_answer_0(rid, rc);
962 
}
 965 
}
963 
 
 966 
 
964 
void vfs_stat(ipc_callid_t rid, ipc_call_t *request)
 967 
void vfs_stat(ipc_callid_t rid, ipc_call_t *request)
965 
{
 968 
{
966 
    size_t len;
 969 
    size_t len;
967 
    ipc_callid_t callid;
 970 
    ipc_callid_t callid;
968 
 
 971 
 
969 
    if (!ipc_data_write_receive(&callid, &len)) {
 972 
    if (!ipc_data_write_receive(&callid, &len)) {
970 
        ipc_answer_0(callid, EINVAL);
 973 
        ipc_answer_0(callid, EINVAL);
971 
        ipc_answer_0(rid, EINVAL);
 974 
        ipc_answer_0(rid, EINVAL);
972 
        return;
 975 
        return;
973 
    }
 976 
    }
974 
    char *path = malloc(len + 1);
 977 
    char *path = malloc(len + 1);
975 
    if (!path) {
 978 
    if (!path) {
976 
        ipc_answer_0(callid, ENOMEM);
 979 
        ipc_answer_0(callid, ENOMEM);
977 
        ipc_answer_0(rid, ENOMEM);
 980 
        ipc_answer_0(rid, ENOMEM);
978 
        return;
 981 
        return;
979 
    }
 982 
    }
980 
    int rc;
 983 
    int rc;
981 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
 984 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
982 
        ipc_answer_0(rid, rc);
 985 
        ipc_answer_0(rid, rc);
983 
        free(path);
 986 
        free(path);
984 
        return;
 987 
        return;
985 
    }
 988 
    }
986 
    path[len] = '\0';
 989 
    path[len] = '\0';
987 
 
 990 
 
988 
    if (!ipc_data_read_receive(&callid, NULL)) {
 991 
    if (!ipc_data_read_receive(&callid, NULL)) {
989 
        free(path);
 992 
        free(path);
990 
        ipc_answer_0(callid, EINVAL);
 993 
        ipc_answer_0(callid, EINVAL);
991 
        ipc_answer_0(rid, EINVAL);
 994 
        ipc_answer_0(rid, EINVAL);
992 
        return;
 995 
        return;
993 
    }
 996 
    }
994 
 
 997 
 
995 
    vfs_lookup_res_t lr;
 998 
    vfs_lookup_res_t lr;
996 
    fibril_rwlock_read_lock(&namespace_rwlock);
 999 
    fibril_rwlock_read_lock(&namespace_rwlock);
997 
    rc = vfs_lookup_internal(path, L_NONE, &lr, NULL);
 1000 
    rc = vfs_lookup_internal(path, L_NONE, &lr, NULL);
998 
    free(path);
 1001 
    free(path);
999 
    if (rc != EOK) {
 1002 
    if (rc != EOK) {
1000 
        fibril_rwlock_read_unlock(&namespace_rwlock);
 1003 
        fibril_rwlock_read_unlock(&namespace_rwlock);
1001 
        ipc_answer_0(callid, rc);
 1004 
        ipc_answer_0(callid, rc);
1002 
        ipc_answer_0(rid, rc);
 1005 
        ipc_answer_0(rid, rc);
1003 
        return;
 1006 
        return;
1004 
    }
 1007 
    }
1005 
    vfs_node_t *node = vfs_node_get(&lr);
 1008 
    vfs_node_t *node = vfs_node_get(&lr);
1006 
    if (!node) {
 1009 
    if (!node) {
1007 
        fibril_rwlock_read_unlock(&namespace_rwlock);
 1010 
        fibril_rwlock_read_unlock(&namespace_rwlock);
1008 
        ipc_answer_0(callid, ENOMEM);
 1011 
        ipc_answer_0(callid, ENOMEM);
1009 
        ipc_answer_0(rid, ENOMEM);
 1012 
        ipc_answer_0(rid, ENOMEM);
1010 
        return;
 1013 
        return;
1011 
    }
 1014 
    }
1012 
 
 1015 
 
1013 
    fibril_rwlock_read_unlock(&namespace_rwlock);
 1016 
    fibril_rwlock_read_unlock(&namespace_rwlock);
1014 
 
 1017 
 
1015 
    int fs_phone = vfs_grab_phone(node->fs_handle);
 1018 
    int fs_phone = vfs_grab_phone(node->fs_handle);
1016 
    aid_t msg;
 1019 
    aid_t msg;
1017 
    msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
 1020 
    msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
1018 
        node->index, false, NULL);
 1021 
        node->index, false, NULL);
1019 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 1022 
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
1020 
   
 1023 
   
1021 
    ipcarg_t rv;
 1024 
    ipcarg_t rv;
1022 
    async_wait_for(msg, &rv);
 1025 
    async_wait_for(msg, &rv);
1023 
    vfs_release_phone(fs_phone);
 1026 
    vfs_release_phone(fs_phone);
1024 
 
 1027 
 
1025 
    ipc_answer_0(rid, rv);
 1028 
    ipc_answer_0(rid, rv);
1026 
 
 1029 
 
1027 
    vfs_node_put(node);
 1030 
    vfs_node_put(node);
1028 
}
 1031 
}
1029 
 
 1032 
 
1030 
void vfs_mkdir(ipc_callid_t rid, ipc_call_t *request)
 1033 
void vfs_mkdir(ipc_callid_t rid, ipc_call_t *request)
1031 
{
 1034 
{
1032 
    int mode = IPC_GET_ARG1(*request);
 1035 
    int mode = IPC_GET_ARG1(*request);
1033 
 
 1036 
 
1034 
    size_t len;
 1037 
    size_t len;
1035 
    ipc_callid_t callid;
 1038 
    ipc_callid_t callid;
1036 
 
 1039 
 
1037 
    if (!ipc_data_write_receive(&callid, &len)) {
 1040 
    if (!ipc_data_write_receive(&callid, &len)) {
1038 
        ipc_answer_0(callid, EINVAL);
 1041 
        ipc_answer_0(callid, EINVAL);
1039 
        ipc_answer_0(rid, EINVAL);
 1042 
        ipc_answer_0(rid, EINVAL);
1040 
        return;
 1043 
        return;
1041 
    }
 1044 
    }
1042 
    char *path = malloc(len + 1);
 1045 
    char *path = malloc(len + 1);
1043 
    if (!path) {
 1046 
    if (!path) {
1044 
        ipc_answer_0(callid, ENOMEM);
 1047 
        ipc_answer_0(callid, ENOMEM);
1045 
        ipc_answer_0(rid, ENOMEM);
 1048 
        ipc_answer_0(rid, ENOMEM);
1046 
        return;
 1049 
        return;
1047 
    }
 1050 
    }
1048 
    int rc;
 1051 
    int rc;
1049 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
 1052 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
1050 
        ipc_answer_0(rid, rc);
 1053 
        ipc_answer_0(rid, rc);
1051 
        free(path);
 1054 
        free(path);
1052 
        return;
 1055 
        return;
1053 
    }
 1056 
    }
1054 
    path[len] = '\0';
 1057 
    path[len] = '\0';
- 
 
 1058 
 
- 
 
 1059 
    /* Ignore mode for now. */
- 
 
 1060 
    (void) mode;
1055 
   
 1061 
   
1056 
    fibril_rwlock_write_lock(&namespace_rwlock);
 1062 
    fibril_rwlock_write_lock(&namespace_rwlock);
1057 
    int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
 1063 
    int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
1058 
    rc = vfs_lookup_internal(path, lflag, NULL, NULL);
 1064 
    rc = vfs_lookup_internal(path, lflag, NULL, NULL);
1059 
    fibril_rwlock_write_unlock(&namespace_rwlock);
 1065 
    fibril_rwlock_write_unlock(&namespace_rwlock);
1060 
    free(path);
 1066 
    free(path);
1061 
    ipc_answer_0(rid, rc);
 1067 
    ipc_answer_0(rid, rc);
1062 
}
 1068 
}
1063 
 
 1069 
 
1064 
void vfs_unlink(ipc_callid_t rid, ipc_call_t *request)
 1070 
void vfs_unlink(ipc_callid_t rid, ipc_call_t *request)
1065 
{
 1071 
{
1066 
    int lflag = IPC_GET_ARG1(*request);
 1072 
    int lflag = IPC_GET_ARG1(*request);
1067 
 
 1073 
 
1068 
    size_t len;
 1074 
    size_t len;
1069 
    ipc_callid_t callid;
 1075 
    ipc_callid_t callid;
1070 
 
 1076 
 
1071 
    if (!ipc_data_write_receive(&callid, &len)) {
 1077 
    if (!ipc_data_write_receive(&callid, &len)) {
1072 
        ipc_answer_0(callid, EINVAL);
 1078 
        ipc_answer_0(callid, EINVAL);
1073 
        ipc_answer_0(rid, EINVAL);
 1079 
        ipc_answer_0(rid, EINVAL);
1074 
        return;
 1080 
        return;
1075 
    }
 1081 
    }
1076 
    char *path = malloc(len + 1);
 1082 
    char *path = malloc(len + 1);
1077 
    if (!path) {
 1083 
    if (!path) {
1078 
        ipc_answer_0(callid, ENOMEM);
 1084 
        ipc_answer_0(callid, ENOMEM);
1079 
        ipc_answer_0(rid, ENOMEM);
 1085 
        ipc_answer_0(rid, ENOMEM);
1080 
        return;
 1086 
        return;
1081 
    }
 1087 
    }
1082 
    int rc;
 1088 
    int rc;
1083 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
 1089 
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
1084 
        ipc_answer_0(rid, rc);
 1090 
        ipc_answer_0(rid, rc);
1085 
        free(path);
 1091 
        free(path);
1086 
        return;
 1092 
        return;
1087 
    }
 1093 
    }
1088 
    path[len] = '\0';
 1094 
    path[len] = '\0';
1089 
   
 1095 
   
1090 
    fibril_rwlock_write_lock(&namespace_rwlock);
 1096 
    fibril_rwlock_write_lock(&namespace_rwlock);
1091 
    lflag &= L_DIRECTORY;   /* sanitize lflag */
 1097 
    lflag &= L_DIRECTORY;   /* sanitize lflag */
1092 
    vfs_lookup_res_t lr;
 1098 
    vfs_lookup_res_t lr;
1093 
    rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
 1099 
    rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
1094 
    free(path);
 1100 
    free(path);
1095 
    if (rc != EOK) {
 1101 
    if (rc != EOK) {
1096 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1102 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1097 
        ipc_answer_0(rid, rc);
 1103 
        ipc_answer_0(rid, rc);
1098 
        return;
 1104 
        return;
1099 
    }
 1105 
    }
1100 
 
 1106 
 
1101 
    /*
 1107 
    /*
1102 
     * The name has already been unlinked by vfs_lookup_internal().
 1108 
     * The name has already been unlinked by vfs_lookup_internal().
1103 
     * We have to get and put the VFS node to ensure that it is
 1109 
     * We have to get and put the VFS node to ensure that it is
1104 
     * VFS_OUT_DESTROY'ed after the last reference to it is dropped.
 1110 
     * VFS_OUT_DESTROY'ed after the last reference to it is dropped.
1105 
     */
 1111 
     */
1106 
    vfs_node_t *node = vfs_node_get(&lr);
 1112 
    vfs_node_t *node = vfs_node_get(&lr);
1107 
    fibril_mutex_lock(&nodes_mutex);
 1113 
    fibril_mutex_lock(&nodes_mutex);
1108 
    node->lnkcnt--;
 1114 
    node->lnkcnt--;
1109 
    fibril_mutex_unlock(&nodes_mutex);
 1115 
    fibril_mutex_unlock(&nodes_mutex);
1110 
    fibril_rwlock_write_unlock(&namespace_rwlock);
 1116 
    fibril_rwlock_write_unlock(&namespace_rwlock);
1111 
    vfs_node_put(node);
 1117 
    vfs_node_put(node);
1112 
    ipc_answer_0(rid, EOK);
 1118 
    ipc_answer_0(rid, EOK);
1113 
}
 1119 
}
1114 
 
 1120 
 
1115 
void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
 1121 
void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
1116 
{
 1122 
{
1117 
    size_t olen, nlen;
 1123 
    size_t olen, nlen;
1118 
    ipc_callid_t callid;
 1124 
    ipc_callid_t callid;
1119 
    int rc;
 1125 
    int rc;
1120 
 
 1126 
 
1121 
    /* Retrieve the old path. */
 1127 
    /* Retrieve the old path. */
1122 
    if (!ipc_data_write_receive(&callid, &olen)) {
 1128 
    if (!ipc_data_write_receive(&callid, &olen)) {
1123 
        ipc_answer_0(callid, EINVAL);
 1129 
        ipc_answer_0(callid, EINVAL);
1124 
        ipc_answer_0(rid, EINVAL);
 1130 
        ipc_answer_0(rid, EINVAL);
1125 
        return;
 1131 
        return;
1126 
    }
 1132 
    }
1127 
    char *old = malloc(olen + 1);
 1133 
    char *old = malloc(olen + 1);
1128 
    if (!old) {
 1134 
    if (!old) {
1129 
        ipc_answer_0(callid, ENOMEM);
 1135 
        ipc_answer_0(callid, ENOMEM);
1130 
        ipc_answer_0(rid, ENOMEM);
 1136 
        ipc_answer_0(rid, ENOMEM);
1131 
        return;
 1137 
        return;
1132 
    }
 1138 
    }
1133 
    if ((rc = ipc_data_write_finalize(callid, old, olen))) {
 1139 
    if ((rc = ipc_data_write_finalize(callid, old, olen))) {
1134 
        ipc_answer_0(rid, rc);
 1140 
        ipc_answer_0(rid, rc);
1135 
        free(old);
 1141 
        free(old);
1136 
        return;
 1142 
        return;
1137 
    }
 1143 
    }
1138 
    old[olen] = '\0';
 1144 
    old[olen] = '\0';
1139 
   
 1145 
   
1140 
    /* Retrieve the new path. */
 1146 
    /* Retrieve the new path. */
1141 
    if (!ipc_data_write_receive(&callid, &nlen)) {
 1147 
    if (!ipc_data_write_receive(&callid, &nlen)) {
1142 
        ipc_answer_0(callid, EINVAL);
 1148 
        ipc_answer_0(callid, EINVAL);
1143 
        ipc_answer_0(rid, EINVAL);
 1149 
        ipc_answer_0(rid, EINVAL);
1144 
        free(old);
 1150 
        free(old);
1145 
        return;
 1151 
        return;
1146 
    }
 1152 
    }
1147 
    char *new = malloc(nlen + 1);
 1153 
    char *new = malloc(nlen + 1);
1148 
    if (!new) {
 1154 
    if (!new) {
1149 
        ipc_answer_0(callid, ENOMEM);
 1155 
        ipc_answer_0(callid, ENOMEM);
1150 
        ipc_answer_0(rid, ENOMEM);
 1156 
        ipc_answer_0(rid, ENOMEM);
1151 
        free(old);
 1157 
        free(old);
1152 
        return;
 1158 
        return;
1153 
    }
 1159 
    }
1154 
    if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
 1160 
    if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
1155 
        ipc_answer_0(rid, rc);
 1161 
        ipc_answer_0(rid, rc);
1156 
        free(old);
 1162 
        free(old);
1157 
        free(new);
 1163 
        free(new);
1158 
        return;
 1164 
        return;
1159 
    }
 1165 
    }
1160 
    new[nlen] = '\0';
 1166 
    new[nlen] = '\0';
1161 
 
 1167 
 
1162 
    char *oldc = canonify(old, &olen);
 1168 
    char *oldc = canonify(old, &olen);
1163 
    char *newc = canonify(new, &nlen);
 1169 
    char *newc = canonify(new, &nlen);
1164 
    if (!oldc || !newc) {
 1170 
    if (!oldc || !newc) {
1165 
        ipc_answer_0(rid, EINVAL);
 1171 
        ipc_answer_0(rid, EINVAL);
1166 
        free(old);
 1172 
        free(old);
1167 
        free(new);
 1173 
        free(new);
1168 
        return;
 1174 
        return;
1169 
    }
 1175 
    }
1170 
    oldc[olen] = '\0';
 1176 
    oldc[olen] = '\0';
1171 
    newc[nlen] = '\0';
 1177 
    newc[nlen] = '\0';
1172 
    if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
 1178 
    if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
1173 
        ((newc[str_length(oldc)] == '/') ||
 1179 
        ((newc[str_length(oldc)] == '/') ||
1174 
        (str_length(oldc) == 1) ||
 1180 
        (str_length(oldc) == 1) ||
1175 
        (str_length(oldc) == str_length(newc)))) {
 1181 
        (str_length(oldc) == str_length(newc)))) {
1176 
            /*
 1182 
            /*
1177 
         * oldc is a prefix of newc and either
 1183 
         * oldc is a prefix of newc and either
1178 
         * - newc continues with a / where oldc ends, or
 1184 
         * - newc continues with a / where oldc ends, or
1179 
         * - oldc was / itself, or
 1185 
         * - oldc was / itself, or
1180 
         * - oldc and newc are equal.
 1186 
         * - oldc and newc are equal.
1181 
         */
 1187 
         */
1182 
        ipc_answer_0(rid, EINVAL);
 1188 
        ipc_answer_0(rid, EINVAL);
1183 
        free(old);
 1189 
        free(old);
1184 
        free(new);
 1190 
        free(new);
1185 
        return;
 1191 
        return;
1186 
    }
 1192 
    }
1187 
   
 1193 
   
1188 
    vfs_lookup_res_t old_lr;
 1194 
    vfs_lookup_res_t old_lr;
1189 
    vfs_lookup_res_t new_lr;
 1195 
    vfs_lookup_res_t new_lr;
1190 
    vfs_lookup_res_t new_par_lr;
 1196 
    vfs_lookup_res_t new_par_lr;
1191 
    fibril_rwlock_write_lock(&namespace_rwlock);
 1197 
    fibril_rwlock_write_lock(&namespace_rwlock);
1192 
    /* Lookup the node belonging to the old file name. */
 1198 
    /* Lookup the node belonging to the old file name. */
1193 
    rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
 1199 
    rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
1194 
    if (rc != EOK) {
 1200 
    if (rc != EOK) {
1195 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1201 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1196 
        ipc_answer_0(rid, rc);
 1202 
        ipc_answer_0(rid, rc);
1197 
        free(old);
 1203 
        free(old);
1198 
        free(new);
 1204 
        free(new);
1199 
        return;
 1205 
        return;
1200 
    }
 1206 
    }
1201 
    vfs_node_t *old_node = vfs_node_get(&old_lr);
 1207 
    vfs_node_t *old_node = vfs_node_get(&old_lr);
1202 
    if (!old_node) {
 1208 
    if (!old_node) {
1203 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1209 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1204 
        ipc_answer_0(rid, ENOMEM);
 1210 
        ipc_answer_0(rid, ENOMEM);
1205 
        free(old);
 1211 
        free(old);
1206 
        free(new);
 1212 
        free(new);
1207 
        return;
 1213 
        return;
1208 
    }
 1214 
    }
1209 
    /* Determine the path to the parent of the node with the new name. */
 1215 
    /* Determine the path to the parent of the node with the new name. */
1210 
    char *parentc = str_dup(newc);
 1216 
    char *parentc = str_dup(newc);
1211 
    if (!parentc) {
 1217 
    if (!parentc) {
1212 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1218 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1213 
        ipc_answer_0(rid, rc);
 1219 
        ipc_answer_0(rid, rc);
1214 
        free(old);
 1220 
        free(old);
1215 
        free(new);
 1221 
        free(new);
1216 
        return;
 1222 
        return;
1217 
    }
 1223 
    }
1218 
    char *lastsl = str_rchr(parentc + 1, '/');
 1224 
    char *lastsl = str_rchr(parentc + 1, '/');
1219 
    if (lastsl)
 1225 
    if (lastsl)
1220 
        *lastsl = '\0';
 1226 
        *lastsl = '\0';
1221 
    else
 1227 
    else
1222 
        parentc[1] = '\0';
 1228 
        parentc[1] = '\0';
1223 
    /* Lookup parent of the new file name. */
 1229 
    /* Lookup parent of the new file name. */
1224 
    rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
 1230 
    rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
1225 
    free(parentc);  /* not needed anymore */
 1231 
    free(parentc);  /* not needed anymore */
1226 
    if (rc != EOK) {
 1232 
    if (rc != EOK) {
1227 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1233 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1228 
        ipc_answer_0(rid, rc);
 1234 
        ipc_answer_0(rid, rc);
1229 
        free(old);
 1235 
        free(old);
1230 
        free(new);
 1236 
        free(new);
1231 
        return;
 1237 
        return;
1232 
    }
 1238 
    }
1233 
    /* Check whether linking to the same file system instance. */
 1239 
    /* Check whether linking to the same file system instance. */
1234 
    if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
 1240 
    if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
1235 
        (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
 1241 
        (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
1236 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1242 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1237 
        ipc_answer_0(rid, EXDEV);   /* different file systems */
 1243 
        ipc_answer_0(rid, EXDEV);   /* different file systems */
1238 
        free(old);
 1244 
        free(old);
1239 
        free(new);
 1245 
        free(new);
1240 
        return;
 1246 
        return;
1241 
    }
 1247 
    }
1242 
    /* Destroy the old link for the new name. */
 1248 
    /* Destroy the old link for the new name. */
1243 
    vfs_node_t *new_node = NULL;
 1249 
    vfs_node_t *new_node = NULL;
1244 
    rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
 1250 
    rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
1245 
    switch (rc) {
 1251 
    switch (rc) {
1246 
    case ENOENT:
 1252 
    case ENOENT:
1247 
        /* simply not in our way */
 1253 
        /* simply not in our way */
1248 
        break;
 1254 
        break;
1249 
    case EOK:
 1255 
    case EOK:
1250 
        new_node = vfs_node_get(&new_lr);
 1256 
        new_node = vfs_node_get(&new_lr);
1251 
        if (!new_node) {
 1257 
        if (!new_node) {
1252 
            fibril_rwlock_write_unlock(&namespace_rwlock);
 1258 
            fibril_rwlock_write_unlock(&namespace_rwlock);
1253 
            ipc_answer_0(rid, ENOMEM);
 1259 
            ipc_answer_0(rid, ENOMEM);
1254 
            free(old);
 1260 
            free(old);
1255 
            free(new);
 1261 
            free(new);
1256 
            return;
 1262 
            return;
1257 
        }
 1263 
        }
1258 
        fibril_mutex_lock(&nodes_mutex);
 1264 
        fibril_mutex_lock(&nodes_mutex);
1259 
        new_node->lnkcnt--;
 1265 
        new_node->lnkcnt--;
1260 
        fibril_mutex_unlock(&nodes_mutex);
 1266 
        fibril_mutex_unlock(&nodes_mutex);
1261 
        break;
 1267 
        break;
1262 
    default:
 1268 
    default:
1263 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1269 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1264 
        ipc_answer_0(rid, ENOTEMPTY);
 1270 
        ipc_answer_0(rid, ENOTEMPTY);
1265 
        free(old);
 1271 
        free(old);
1266 
        free(new);
 1272 
        free(new);
1267 
        return;
 1273 
        return;
1268 
    }
 1274 
    }
1269 
    /* Create the new link for the new name. */
 1275 
    /* Create the new link for the new name. */
1270 
    rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
 1276 
    rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
1271 
    if (rc != EOK) {
 1277 
    if (rc != EOK) {
1272 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1278 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1273 
        if (new_node)
 1279 
        if (new_node)
1274 
            vfs_node_put(new_node);
 1280 
            vfs_node_put(new_node);
1275 
        ipc_answer_0(rid, rc);
 1281 
        ipc_answer_0(rid, rc);
1276 
        free(old);
 1282 
        free(old);
1277 
        free(new);
 1283 
        free(new);
1278 
        return;
 1284 
        return;
1279 
    }
 1285 
    }
1280 
    fibril_mutex_lock(&nodes_mutex);
 1286 
    fibril_mutex_lock(&nodes_mutex);
1281 
    old_node->lnkcnt++;
 1287 
    old_node->lnkcnt++;
1282 
    fibril_mutex_unlock(&nodes_mutex);
 1288 
    fibril_mutex_unlock(&nodes_mutex);
1283 
    /* Destroy the link for the old name. */
 1289 
    /* Destroy the link for the old name. */
1284 
    rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
 1290 
    rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
1285 
    if (rc != EOK) {
 1291 
    if (rc != EOK) {
1286 
        fibril_rwlock_write_unlock(&namespace_rwlock);
 1292 
        fibril_rwlock_write_unlock(&namespace_rwlock);
1287 
        vfs_node_put(old_node);
 1293 
        vfs_node_put(old_node);
1288 
        if (new_node)
 1294 
        if (new_node)
1289 
            vfs_node_put(new_node);
 1295 
            vfs_node_put(new_node);
1290 
        ipc_answer_0(rid, rc);
 1296 
        ipc_answer_0(rid, rc);
1291 
        free(old);
 1297 
        free(old);
1292 
        free(new);
 1298 
        free(new);
1293 
        return;
 1299 
        return;
1294 
    }
 1300 
    }
1295 
    fibril_mutex_lock(&nodes_mutex);
 1301 
    fibril_mutex_lock(&nodes_mutex);
1296 
    old_node->lnkcnt--;
 1302 
    old_node->lnkcnt--;
1297 
    fibril_mutex_unlock(&nodes_mutex);
 1303 
    fibril_mutex_unlock(&nodes_mutex);
1298 
    fibril_rwlock_write_unlock(&namespace_rwlock);
 1304 
    fibril_rwlock_write_unlock(&namespace_rwlock);
1299 
    vfs_node_put(old_node);
 1305 
    vfs_node_put(old_node);
1300 
    if (new_node)
 1306 
    if (new_node)
1301 
        vfs_node_put(new_node);
 1307 
        vfs_node_put(new_node);
1302 
    free(old);
 1308 
    free(old);
1303 
    free(new);
 1309 
    free(new);
1304 
    ipc_answer_0(rid, EOK);
 1310 
    ipc_answer_0(rid, EOK);
1305 
}
 1311 
}
1306 
 
 1312 
 
1307 
/**
 1313 
/**
1308 
 * @}
 1314 
 * @}
1309 
 */
 1315 
 */
1310 
 
 1316