Subversion Repositories HelenOS

Rev

Rev 4348 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4348 Rev 4389
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    fat_ops.c
34
 * @file    fat_ops.c
35
 * @brief   Implementation of VFS operations for the FAT file system server.
35
 * @brief   Implementation of VFS operations for the FAT file system server.
36
 */
36
 */
37
 
37
 
38
#include "fat.h"
38
#include "fat.h"
39
#include "fat_dentry.h"
39
#include "fat_dentry.h"
40
#include "fat_fat.h"
40
#include "fat_fat.h"
41
#include "../../vfs/vfs.h"
41
#include "../../vfs/vfs.h"
42
#include <libfs.h>
42
#include <libfs.h>
43
#include <libblock.h>
43
#include <libblock.h>
44
#include <ipc/ipc.h>
44
#include <ipc/ipc.h>
45
#include <ipc/services.h>
45
#include <ipc/services.h>
46
#include <ipc/devmap.h>
46
#include <ipc/devmap.h>
47
#include <async.h>
47
#include <async.h>
48
#include <errno.h>
48
#include <errno.h>
49
#include <string.h>
49
#include <string.h>
50
#include <byteorder.h>
50
#include <byteorder.h>
51
#include <libadt/hash_table.h>
51
#include <libadt/hash_table.h>
52
#include <libadt/list.h>
52
#include <libadt/list.h>
53
#include <assert.h>
53
#include <assert.h>
54
#include <futex.h>
54
#include <futex.h>
55
#include <sys/mman.h>
55
#include <sys/mman.h>
56
#include <align.h>
56
#include <align.h>
57
 
57
 
-
 
58
#define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
-
 
59
#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
-
 
60
 
58
/** Futex protecting the list of cached free FAT nodes. */
61
/** Futex protecting the list of cached free FAT nodes. */
59
static futex_t ffn_futex = FUTEX_INITIALIZER;
62
static futex_t ffn_futex = FUTEX_INITIALIZER;
60
 
63
 
61
/** List of cached free FAT nodes. */
64
/** List of cached free FAT nodes. */
62
static LIST_INITIALIZE(ffn_head);
65
static LIST_INITIALIZE(ffn_head);
63
 
66
 
64
static void fat_node_initialize(fat_node_t *node)
67
static void fat_node_initialize(fat_node_t *node)
65
{
68
{
66
    futex_initialize(&node->lock, 1);
69
    futex_initialize(&node->lock, 1);
-
 
70
    node->bp = NULL;
67
    node->idx = NULL;
71
    node->idx = NULL;
68
    node->type = 0;
72
    node->type = 0;
69
    link_initialize(&node->ffn_link);
73
    link_initialize(&node->ffn_link);
70
    node->size = 0;
74
    node->size = 0;
71
    node->lnkcnt = 0;
75
    node->lnkcnt = 0;
72
    node->refcnt = 0;
76
    node->refcnt = 0;
73
    node->dirty = false;
77
    node->dirty = false;
74
}
78
}
75
 
79
 
76
static void fat_node_sync(fat_node_t *node)
80
static void fat_node_sync(fat_node_t *node)
77
{
81
{
78
    block_t *b;
82
    block_t *b;
79
    fat_bs_t *bs;
83
    fat_bs_t *bs;
80
    fat_dentry_t *d;
84
    fat_dentry_t *d;
81
    uint16_t bps;
85
    uint16_t bps;
82
    unsigned dps;
86
    unsigned dps;
83
   
87
   
84
    assert(node->dirty);
88
    assert(node->dirty);
85
 
89
 
86
    bs = block_bb_get(node->idx->dev_handle);
90
    bs = block_bb_get(node->idx->dev_handle);
87
    bps = uint16_t_le2host(bs->bps);
91
    bps = uint16_t_le2host(bs->bps);
88
    dps = bps / sizeof(fat_dentry_t);
92
    dps = bps / sizeof(fat_dentry_t);
89
   
93
   
90
    /* Read the block that contains the dentry of interest. */
94
    /* Read the block that contains the dentry of interest. */
91
    b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
95
    b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
92
        (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
96
        (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
93
 
97
 
94
    d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
98
    d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
95
 
99
 
96
    d->firstc = host2uint16_t_le(node->firstc);
100
    d->firstc = host2uint16_t_le(node->firstc);
97
    if (node->type == FAT_FILE) {
101
    if (node->type == FAT_FILE) {
98
        d->size = host2uint32_t_le(node->size);
102
        d->size = host2uint32_t_le(node->size);
99
    } else if (node->type == FAT_DIRECTORY) {
103
    } else if (node->type == FAT_DIRECTORY) {
100
        d->attr = FAT_ATTR_SUBDIR;
104
        d->attr = FAT_ATTR_SUBDIR;
101
    }
105
    }
102
   
106
   
103
    /* TODO: update other fields? (e.g time fields) */
107
    /* TODO: update other fields? (e.g time fields) */
104
   
108
   
105
    b->dirty = true;        /* need to sync block */
109
    b->dirty = true;        /* need to sync block */
106
    block_put(b);
110
    block_put(b);
107
}
111
}
108
 
112
 
109
static fat_node_t *fat_node_get_new(void)
113
static fat_node_t *fat_node_get_new(void)
110
{
114
{
-
 
115
    fs_node_t *fn;
111
    fat_node_t *nodep;
116
    fat_node_t *nodep;
112
 
117
 
113
    futex_down(&ffn_futex);
118
    futex_down(&ffn_futex);
114
    if (!list_empty(&ffn_head)) {
119
    if (!list_empty(&ffn_head)) {
115
        /* Try to use a cached free node structure. */
120
        /* Try to use a cached free node structure. */
116
        fat_idx_t *idxp_tmp;
121
        fat_idx_t *idxp_tmp;
117
        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
122
        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
118
        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
123
        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
119
            goto skip_cache;
124
            goto skip_cache;
120
        idxp_tmp = nodep->idx;
125
        idxp_tmp = nodep->idx;
121
        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
126
        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
122
            futex_up(&nodep->lock);
127
            futex_up(&nodep->lock);
123
            goto skip_cache;
128
            goto skip_cache;
124
        }
129
        }
125
        list_remove(&nodep->ffn_link);
130
        list_remove(&nodep->ffn_link);
126
        futex_up(&ffn_futex);
131
        futex_up(&ffn_futex);
127
        if (nodep->dirty)
132
        if (nodep->dirty)
128
            fat_node_sync(nodep);
133
            fat_node_sync(nodep);
129
        idxp_tmp->nodep = NULL;
134
        idxp_tmp->nodep = NULL;
130
        futex_up(&nodep->lock);
135
        futex_up(&nodep->lock);
131
        futex_up(&idxp_tmp->lock);
136
        futex_up(&idxp_tmp->lock);
-
 
137
        fn = FS_NODE(nodep);
132
    } else {
138
    } else {
133
skip_cache:
139
skip_cache:
134
        /* Try to allocate a new node structure. */
140
        /* Try to allocate a new node structure. */
135
        futex_up(&ffn_futex);
141
        futex_up(&ffn_futex);
-
 
142
        fn = (fs_node_t *)malloc(sizeof(fs_node_t));
-
 
143
        if (!fn)
-
 
144
            return NULL;
136
        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
145
        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
137
        if (!nodep)
146
        if (!nodep) {
-
 
147
            free(fn);
138
            return NULL;
148
            return NULL;
139
    }
149
        }
-
 
150
    }
140
    fat_node_initialize(nodep);
151
    fat_node_initialize(nodep);
-
 
152
    fn->data = nodep;
-
 
153
    nodep->bp = fn;
141
   
154
   
142
    return nodep;
155
    return nodep;
143
}
156
}
144
 
157
 
145
/** Internal version of fat_node_get().
158
/** Internal version of fat_node_get().
146
 *
159
 *
147
 * @param idxp      Locked index structure.
160
 * @param idxp      Locked index structure.
148
 */
161
 */
149
static void *fat_node_get_core(fat_idx_t *idxp)
162
static fat_node_t *fat_node_get_core(fat_idx_t *idxp)
150
{
163
{
151
    block_t *b;
164
    block_t *b;
152
    fat_bs_t *bs;
165
    fat_bs_t *bs;
153
    fat_dentry_t *d;
166
    fat_dentry_t *d;
154
    fat_node_t *nodep = NULL;
167
    fat_node_t *nodep = NULL;
155
    unsigned bps;
168
    unsigned bps;
156
    unsigned spc;
169
    unsigned spc;
157
    unsigned dps;
170
    unsigned dps;
158
 
171
 
159
    if (idxp->nodep) {
172
    if (idxp->nodep) {
160
        /*
173
        /*
161
         * We are lucky.
174
         * We are lucky.
162
         * The node is already instantiated in memory.
175
         * The node is already instantiated in memory.
163
         */
176
         */
164
        futex_down(&idxp->nodep->lock);
177
        futex_down(&idxp->nodep->lock);
165
        if (!idxp->nodep->refcnt++)
178
        if (!idxp->nodep->refcnt++)
166
            list_remove(&idxp->nodep->ffn_link);
179
            list_remove(&idxp->nodep->ffn_link);
167
        futex_up(&idxp->nodep->lock);
180
        futex_up(&idxp->nodep->lock);
168
        return idxp->nodep;
181
        return idxp->nodep;
169
    }
182
    }
170
 
183
 
171
    /*
184
    /*
172
     * We must instantiate the node from the file system.
185
     * We must instantiate the node from the file system.
173
     */
186
     */
174
   
187
   
175
    assert(idxp->pfc);
188
    assert(idxp->pfc);
176
 
189
 
177
    nodep = fat_node_get_new();
190
    nodep = fat_node_get_new();
178
    if (!nodep)
191
    if (!nodep)
179
        return NULL;
192
        return NULL;
180
 
193
 
181
    bs = block_bb_get(idxp->dev_handle);
194
    bs = block_bb_get(idxp->dev_handle);
182
    bps = uint16_t_le2host(bs->bps);
195
    bps = uint16_t_le2host(bs->bps);
183
    spc = bs->spc;
196
    spc = bs->spc;
184
    dps = bps / sizeof(fat_dentry_t);
197
    dps = bps / sizeof(fat_dentry_t);
185
 
198
 
186
    /* Read the block that contains the dentry of interest. */
199
    /* Read the block that contains the dentry of interest. */
187
    b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
200
    b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
188
        (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
201
        (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
189
    assert(b);
202
    assert(b);
190
 
203
 
191
    d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
204
    d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
192
    if (d->attr & FAT_ATTR_SUBDIR) {
205
    if (d->attr & FAT_ATTR_SUBDIR) {
193
        /*
206
        /*
194
         * The only directory which does not have this bit set is the
207
         * The only directory which does not have this bit set is the
195
         * root directory itself. The root directory node is handled
208
         * root directory itself. The root directory node is handled
196
         * and initialized elsewhere.
209
         * and initialized elsewhere.
197
         */
210
         */
198
        nodep->type = FAT_DIRECTORY;
211
        nodep->type = FAT_DIRECTORY;
199
        /*
212
        /*
200
         * Unfortunately, the 'size' field of the FAT dentry is not
213
         * Unfortunately, the 'size' field of the FAT dentry is not
201
         * defined for the directory entry type. We must determine the
214
         * defined for the directory entry type. We must determine the
202
         * size of the directory by walking the FAT.
215
         * size of the directory by walking the FAT.
203
         */
216
         */
204
        nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
217
        nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
205
            uint16_t_le2host(d->firstc));
218
            uint16_t_le2host(d->firstc));
206
    } else {
219
    } else {
207
        nodep->type = FAT_FILE;
220
        nodep->type = FAT_FILE;
208
        nodep->size = uint32_t_le2host(d->size);
221
        nodep->size = uint32_t_le2host(d->size);
209
    }
222
    }
210
    nodep->firstc = uint16_t_le2host(d->firstc);
223
    nodep->firstc = uint16_t_le2host(d->firstc);
211
    nodep->lnkcnt = 1;
224
    nodep->lnkcnt = 1;
212
    nodep->refcnt = 1;
225
    nodep->refcnt = 1;
213
 
226
 
214
    block_put(b);
227
    block_put(b);
215
 
228
 
216
    /* Link the idx structure with the node structure. */
229
    /* Link the idx structure with the node structure. */
217
    nodep->idx = idxp;
230
    nodep->idx = idxp;
218
    idxp->nodep = nodep;
231
    idxp->nodep = nodep;
219
 
232
 
220
    return nodep;
233
    return nodep;
221
}
234
}
222
 
235
 
223
/*
236
/*
224
 * Forward declarations of FAT libfs operations.
237
 * Forward declarations of FAT libfs operations.
225
 */
238
 */
226
static void *fat_node_get(dev_handle_t, fs_index_t);
239
static fs_node_t *fat_node_get(dev_handle_t, fs_index_t);
227
static void fat_node_put(void *);
240
static void fat_node_put(fs_node_t *);
228
static void *fat_create_node(dev_handle_t, int);
241
static fs_node_t *fat_create_node(dev_handle_t, int);
229
static int fat_destroy_node(void *);
242
static int fat_destroy_node(fs_node_t *);
230
static int fat_link(void *, void *, const char *);
243
static int fat_link(fs_node_t *, fs_node_t *, const char *);
231
static int fat_unlink(void *, void *);
244
static int fat_unlink(fs_node_t *, fs_node_t *, const char *);
232
static void *fat_match(void *, const char *);
245
static fs_node_t *fat_match(fs_node_t *, const char *);
233
static fs_index_t fat_index_get(void *);
246
static fs_index_t fat_index_get(fs_node_t *);
234
static size_t fat_size_get(void *);
247
static size_t fat_size_get(fs_node_t *);
235
static unsigned fat_lnkcnt_get(void *);
248
static unsigned fat_lnkcnt_get(fs_node_t *);
236
static bool fat_has_children(void *);
249
static bool fat_has_children(fs_node_t *);
237
static void *fat_root_get(dev_handle_t);
250
static fs_node_t *fat_root_get(dev_handle_t);
238
static char fat_plb_get_char(unsigned);
251
static char fat_plb_get_char(unsigned);
239
static bool fat_is_directory(void *);
252
static bool fat_is_directory(fs_node_t *);
240
static bool fat_is_file(void *node);
253
static bool fat_is_file(fs_node_t *node);
241
 
254
 
242
/*
255
/*
243
 * FAT libfs operations.
256
 * FAT libfs operations.
244
 */
257
 */
245
 
258
 
246
/** Instantiate a FAT in-core node. */
259
/** Instantiate a FAT in-core node. */
247
void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
260
fs_node_t *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
248
{
261
{
249
    void *node;
262
    fat_node_t *nodep;
250
    fat_idx_t *idxp;
263
    fat_idx_t *idxp;
251
 
264
 
252
    idxp = fat_idx_get_by_index(dev_handle, index);
265
    idxp = fat_idx_get_by_index(dev_handle, index);
253
    if (!idxp)
266
    if (!idxp)
254
        return NULL;
267
        return NULL;
255
    /* idxp->lock held */
268
    /* idxp->lock held */
256
    node = fat_node_get_core(idxp);
269
    nodep = fat_node_get_core(idxp);
257
    futex_up(&idxp->lock);
270
    futex_up(&idxp->lock);
258
    return node;
271
    return FS_NODE(nodep);
259
}
272
}
260
 
273
 
261
void fat_node_put(void *node)
274
void fat_node_put(fs_node_t *fn)
262
{
275
{
263
    fat_node_t *nodep = (fat_node_t *)node;
276
    fat_node_t *nodep = FAT_NODE(fn);
264
    bool destroy = false;
277
    bool destroy = false;
265
 
278
 
266
    futex_down(&nodep->lock);
279
    futex_down(&nodep->lock);
267
    if (!--nodep->refcnt) {
280
    if (!--nodep->refcnt) {
268
        if (nodep->idx) {
281
        if (nodep->idx) {
269
            futex_down(&ffn_futex);
282
            futex_down(&ffn_futex);
270
            list_append(&nodep->ffn_link, &ffn_head);
283
            list_append(&nodep->ffn_link, &ffn_head);
271
            futex_up(&ffn_futex);
284
            futex_up(&ffn_futex);
272
        } else {
285
        } else {
273
            /*
286
            /*
274
             * The node does not have any index structure associated
287
             * The node does not have any index structure associated
275
             * with itself. This can only mean that we are releasing
288
             * with itself. This can only mean that we are releasing
276
             * the node after a failed attempt to allocate the index
289
             * the node after a failed attempt to allocate the index
277
             * structure for it.
290
             * structure for it.
278
             */
291
             */
279
            destroy = true;
292
            destroy = true;
280
        }
293
        }
281
    }
294
    }
282
    futex_up(&nodep->lock);
295
    futex_up(&nodep->lock);
283
    if (destroy)
296
    if (destroy) {
-
 
297
        free(nodep->bp);
284
        free(node);
298
        free(nodep);
-
 
299
    }
285
}
300
}
286
 
301
 
287
void *fat_create_node(dev_handle_t dev_handle, int flags)
302
fs_node_t *fat_create_node(dev_handle_t dev_handle, int flags)
288
{
303
{
289
    fat_idx_t *idxp;
304
    fat_idx_t *idxp;
290
    fat_node_t *nodep;
305
    fat_node_t *nodep;
291
    fat_bs_t *bs;
306
    fat_bs_t *bs;
292
    fat_cluster_t mcl, lcl;
307
    fat_cluster_t mcl, lcl;
293
    uint16_t bps;
308
    uint16_t bps;
294
    int rc;
309
    int rc;
295
 
310
 
296
    bs = block_bb_get(dev_handle);
311
    bs = block_bb_get(dev_handle);
297
    bps = uint16_t_le2host(bs->bps);
312
    bps = uint16_t_le2host(bs->bps);
298
    if (flags & L_DIRECTORY) {
313
    if (flags & L_DIRECTORY) {
299
        /* allocate a cluster */
314
        /* allocate a cluster */
300
        rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
315
        rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
301
        if (rc != EOK)
316
        if (rc != EOK)
302
            return NULL;
317
            return NULL;
303
    }
318
    }
304
 
319
 
305
    nodep = fat_node_get_new();
320
    nodep = fat_node_get_new();
306
    if (!nodep) {
321
    if (!nodep) {
307
        fat_free_clusters(bs, dev_handle, mcl);
322
        fat_free_clusters(bs, dev_handle, mcl);
308
        return NULL;
323
        return NULL;
309
    }
324
    }
310
    idxp = fat_idx_get_new(dev_handle);
325
    idxp = fat_idx_get_new(dev_handle);
311
    if (!idxp) {
326
    if (!idxp) {
312
        fat_free_clusters(bs, dev_handle, mcl);
327
        fat_free_clusters(bs, dev_handle, mcl);
313
        fat_node_put(nodep);
328
        fat_node_put(FS_NODE(nodep));
314
        return NULL;
329
        return NULL;
315
    }
330
    }
316
    /* idxp->lock held */
331
    /* idxp->lock held */
317
    if (flags & L_DIRECTORY) {
332
    if (flags & L_DIRECTORY) {
318
        int i;
333
        int i;
319
        block_t *b;
334
        block_t *b;
320
 
335
 
321
        /*
336
        /*
322
         * Populate the new cluster with unused dentries.
337
         * Populate the new cluster with unused dentries.
323
         */
338
         */
324
        for (i = 0; i < bs->spc; i++) {
339
        for (i = 0; i < bs->spc; i++) {
325
            b = _fat_block_get(bs, dev_handle, mcl, i,
340
            b = _fat_block_get(bs, dev_handle, mcl, i,
326
                BLOCK_FLAGS_NOREAD);
341
                BLOCK_FLAGS_NOREAD);
327
            /* mark all dentries as never-used */
342
            /* mark all dentries as never-used */
328
            memset(b->data, 0, bps);
343
            memset(b->data, 0, bps);
329
            b->dirty = false;
344
            b->dirty = false;
330
            block_put(b);
345
            block_put(b);
331
        }
346
        }
332
        nodep->type = FAT_DIRECTORY;
347
        nodep->type = FAT_DIRECTORY;
333
        nodep->firstc = mcl;
348
        nodep->firstc = mcl;
334
        nodep->size = bps * bs->spc;
349
        nodep->size = bps * bs->spc;
335
    } else {
350
    } else {
336
        nodep->type = FAT_FILE;
351
        nodep->type = FAT_FILE;
337
        nodep->firstc = FAT_CLST_RES0;
352
        nodep->firstc = FAT_CLST_RES0;
338
        nodep->size = 0;
353
        nodep->size = 0;
339
    }
354
    }
340
    nodep->lnkcnt = 0;  /* not linked anywhere */
355
    nodep->lnkcnt = 0;  /* not linked anywhere */
341
    nodep->refcnt = 1;
356
    nodep->refcnt = 1;
342
    nodep->dirty = true;
357
    nodep->dirty = true;
343
 
358
 
344
    nodep->idx = idxp;
359
    nodep->idx = idxp;
345
    idxp->nodep = nodep;
360
    idxp->nodep = nodep;
346
 
361
 
347
    futex_up(&idxp->lock);
362
    futex_up(&idxp->lock);
348
    return nodep;
363
    return FS_NODE(nodep);
349
}
364
}
350
 
365
 
351
int fat_destroy_node(void *node)
366
int fat_destroy_node(fs_node_t *fn)
352
{
367
{
353
    fat_node_t *nodep = (fat_node_t *)node;
368
    fat_node_t *nodep = FAT_NODE(fn);
354
    fat_bs_t *bs;
369
    fat_bs_t *bs;
355
 
370
 
356
    /*
371
    /*
357
     * The node is not reachable from the file system. This means that the
372
     * The node is not reachable from the file system. This means that the
358
     * link count should be zero and that the index structure cannot be
373
     * link count should be zero and that the index structure cannot be
359
     * found in the position hash. Obviously, we don't need to lock the node
374
     * found in the position hash. Obviously, we don't need to lock the node
360
     * nor its index structure.
375
     * nor its index structure.
361
     */
376
     */
362
    assert(nodep->lnkcnt == 0);
377
    assert(nodep->lnkcnt == 0);
363
 
378
 
364
    /*
379
    /*
365
     * The node may not have any children.
380
     * The node may not have any children.
366
     */
381
     */
367
    assert(fat_has_children(node) == false);
382
    assert(fat_has_children(fn) == false);
368
 
383
 
369
    bs = block_bb_get(nodep->idx->dev_handle);
384
    bs = block_bb_get(nodep->idx->dev_handle);
370
    if (nodep->firstc != FAT_CLST_RES0) {
385
    if (nodep->firstc != FAT_CLST_RES0) {
371
        assert(nodep->size);
386
        assert(nodep->size);
372
        /* Free all clusters allocated to the node. */
387
        /* Free all clusters allocated to the node. */
373
        fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
388
        fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
374
    }
389
    }
375
 
390
 
376
    fat_idx_destroy(nodep->idx);
391
    fat_idx_destroy(nodep->idx);
-
 
392
    free(nodep->bp);
377
    free(nodep);
393
    free(nodep);
378
    return EOK;
394
    return EOK;
379
}
395
}
380
 
396
 
381
int fat_link(void *prnt, void *chld, const char *name)
397
int fat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
382
{
398
{
383
    fat_node_t *parentp = (fat_node_t *)prnt;
399
    fat_node_t *parentp = FAT_NODE(pfn);
384
    fat_node_t *childp = (fat_node_t *)chld;
400
    fat_node_t *childp = FAT_NODE(cfn);
385
    fat_dentry_t *d;
401
    fat_dentry_t *d;
386
    fat_bs_t *bs;
402
    fat_bs_t *bs;
387
    block_t *b;
403
    block_t *b;
388
    int i, j;
404
    int i, j;
389
    uint16_t bps;
405
    uint16_t bps;
390
    unsigned dps;
406
    unsigned dps;
391
    unsigned blocks;
407
    unsigned blocks;
392
    fat_cluster_t mcl, lcl;
408
    fat_cluster_t mcl, lcl;
393
    int rc;
409
    int rc;
394
 
410
 
395
    futex_down(&childp->lock);
411
    futex_down(&childp->lock);
396
    if (childp->lnkcnt == 1) {
412
    if (childp->lnkcnt == 1) {
397
        /*
413
        /*
398
         * On FAT, we don't support multiple hard links.
414
         * On FAT, we don't support multiple hard links.
399
         */
415
         */
400
        futex_up(&childp->lock);
416
        futex_up(&childp->lock);
401
        return EMLINK;
417
        return EMLINK;
402
    }
418
    }
403
    assert(childp->lnkcnt == 0);
419
    assert(childp->lnkcnt == 0);
404
    futex_up(&childp->lock);
420
    futex_up(&childp->lock);
405
 
421
 
406
    if (!fat_dentry_name_verify(name)) {
422
    if (!fat_dentry_name_verify(name)) {
407
        /*
423
        /*
408
         * Attempt to create unsupported name.
424
         * Attempt to create unsupported name.
409
         */
425
         */
410
        return ENOTSUP;
426
        return ENOTSUP;
411
    }
427
    }
412
 
428
 
413
    /*
429
    /*
414
     * Get us an unused parent node's dentry or grow the parent and allocate
430
     * Get us an unused parent node's dentry or grow the parent and allocate
415
     * a new one.
431
     * a new one.
416
     */
432
     */
417
   
433
   
418
    futex_down(&parentp->idx->lock);
434
    futex_down(&parentp->idx->lock);
419
    bs = block_bb_get(parentp->idx->dev_handle);
435
    bs = block_bb_get(parentp->idx->dev_handle);
420
    bps = uint16_t_le2host(bs->bps);
436
    bps = uint16_t_le2host(bs->bps);
421
    dps = bps / sizeof(fat_dentry_t);
437
    dps = bps / sizeof(fat_dentry_t);
422
 
438
 
423
    blocks = parentp->size / bps;
439
    blocks = parentp->size / bps;
424
 
440
 
425
    for (i = 0; i < blocks; i++) {
441
    for (i = 0; i < blocks; i++) {
426
        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
442
        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
427
        for (j = 0; j < dps; j++) {
443
        for (j = 0; j < dps; j++) {
428
            d = ((fat_dentry_t *)b->data) + j;
444
            d = ((fat_dentry_t *)b->data) + j;
429
            switch (fat_classify_dentry(d)) {
445
            switch (fat_classify_dentry(d)) {
430
            case FAT_DENTRY_SKIP:
446
            case FAT_DENTRY_SKIP:
431
            case FAT_DENTRY_VALID:
447
            case FAT_DENTRY_VALID:
432
                /* skipping used and meta entries */
448
                /* skipping used and meta entries */
433
                continue;
449
                continue;
434
            case FAT_DENTRY_FREE:
450
            case FAT_DENTRY_FREE:
435
            case FAT_DENTRY_LAST:
451
            case FAT_DENTRY_LAST:
436
                /* found an empty slot */
452
                /* found an empty slot */
437
                goto hit;
453
                goto hit;
438
            }
454
            }
439
        }
455
        }
440
        block_put(b);
456
        block_put(b);
441
    }
457
    }
442
    j = 0;
458
    j = 0;
443
   
459
   
444
    /*
460
    /*
445
     * We need to grow the parent in order to create a new unused dentry.
461
     * We need to grow the parent in order to create a new unused dentry.
446
     */
462
     */
447
    if (parentp->idx->pfc == FAT_CLST_ROOT) {
463
    if (parentp->idx->pfc == FAT_CLST_ROOT) {
448
        /* Can't grow the root directory. */
464
        /* Can't grow the root directory. */
449
        futex_up(&parentp->idx->lock);
465
        futex_up(&parentp->idx->lock);
450
        return ENOSPC;
466
        return ENOSPC;
451
    }
467
    }
452
    rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
468
    rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
453
    if (rc != EOK) {
469
    if (rc != EOK) {
454
        futex_up(&parentp->idx->lock);
470
        futex_up(&parentp->idx->lock);
455
        return rc;
471
        return rc;
456
    }
472
    }
457
    fat_append_clusters(bs, parentp, mcl);
473
    fat_append_clusters(bs, parentp, mcl);
458
    b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
474
    b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
459
    d = (fat_dentry_t *)b->data;
475
    d = (fat_dentry_t *)b->data;
460
    /*
476
    /*
461
     * Clear all dentries in the block except for the first one (the first
477
     * Clear all dentries in the block except for the first one (the first
462
     * dentry will be cleared in the next step).
478
     * dentry will be cleared in the next step).
463
     */
479
     */
464
    memset(d + 1, 0, bps - sizeof(fat_dentry_t));
480
    memset(d + 1, 0, bps - sizeof(fat_dentry_t));
465
 
481
 
466
hit:
482
hit:
467
    /*
483
    /*
468
     * At this point we only establish the link between the parent and the
484
     * At this point we only establish the link between the parent and the
469
     * child.  The dentry, except of the name and the extension, will remain
485
     * child.  The dentry, except of the name and the extension, will remain
470
     * uninitialized until the corresponding node is synced. Thus the valid
486
     * uninitialized until the corresponding node is synced. Thus the valid
471
     * dentry data is kept in the child node structure.
487
     * dentry data is kept in the child node structure.
472
     */
488
     */
473
    memset(d, 0, sizeof(fat_dentry_t));
489
    memset(d, 0, sizeof(fat_dentry_t));
474
    fat_dentry_name_set(d, name);
490
    fat_dentry_name_set(d, name);
475
    b->dirty = true;        /* need to sync block */
491
    b->dirty = true;        /* need to sync block */
476
    block_put(b);
492
    block_put(b);
477
    futex_up(&parentp->idx->lock);
493
    futex_up(&parentp->idx->lock);
478
 
494
 
479
    futex_down(&childp->idx->lock);
495
    futex_down(&childp->idx->lock);
480
   
496
   
481
    /*
497
    /*
482
     * If possible, create the Sub-directory Identifier Entry and the
498
     * If possible, create the Sub-directory Identifier Entry and the
483
     * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
499
     * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
484
     * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
500
     * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
485
     * not use them anyway, so this is rather a sign of our good will.
501
     * not use them anyway, so this is rather a sign of our good will.
486
     */
502
     */
487
    b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
503
    b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
488
    d = (fat_dentry_t *)b->data;
504
    d = (fat_dentry_t *)b->data;
489
    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
505
    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
490
        str_cmp(d->name, FAT_NAME_DOT) == 0) {
506
        str_cmp(d->name, FAT_NAME_DOT) == 0) {
491
        memset(d, 0, sizeof(fat_dentry_t));
507
        memset(d, 0, sizeof(fat_dentry_t));
492
        str_cpy(d->name, 8, FAT_NAME_DOT);
508
        str_cpy(d->name, 8, FAT_NAME_DOT);
493
        str_cpy(d->ext, 3, FAT_EXT_PAD);
509
        str_cpy(d->ext, 3, FAT_EXT_PAD);
494
        d->attr = FAT_ATTR_SUBDIR;
510
        d->attr = FAT_ATTR_SUBDIR;
495
        d->firstc = host2uint16_t_le(childp->firstc);
511
        d->firstc = host2uint16_t_le(childp->firstc);
496
        /* TODO: initialize also the date/time members. */
512
        /* TODO: initialize also the date/time members. */
497
    }
513
    }
498
    d++;
514
    d++;
499
    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
515
    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
500
        str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
516
        str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
501
        memset(d, 0, sizeof(fat_dentry_t));
517
        memset(d, 0, sizeof(fat_dentry_t));
502
        str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
518
        str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
503
        str_cpy(d->ext, 3, FAT_EXT_PAD);
519
        str_cpy(d->ext, 3, FAT_EXT_PAD);
504
        d->attr = FAT_ATTR_SUBDIR;
520
        d->attr = FAT_ATTR_SUBDIR;
505
        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
521
        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
506
            host2uint16_t_le(FAT_CLST_RES0) :
522
            host2uint16_t_le(FAT_CLST_RES0) :
507
            host2uint16_t_le(parentp->firstc);
523
            host2uint16_t_le(parentp->firstc);
508
        /* TODO: initialize also the date/time members. */
524
        /* TODO: initialize also the date/time members. */
509
    }
525
    }
510
    b->dirty = true;        /* need to sync block */
526
    b->dirty = true;        /* need to sync block */
511
    block_put(b);
527
    block_put(b);
512
 
528
 
513
    childp->idx->pfc = parentp->firstc;
529
    childp->idx->pfc = parentp->firstc;
514
    childp->idx->pdi = i * dps + j;
530
    childp->idx->pdi = i * dps + j;
515
    futex_up(&childp->idx->lock);
531
    futex_up(&childp->idx->lock);
516
 
532
 
517
    futex_down(&childp->lock);
533
    futex_down(&childp->lock);
518
    childp->lnkcnt = 1;
534
    childp->lnkcnt = 1;
519
    childp->dirty = true;       /* need to sync node */
535
    childp->dirty = true;       /* need to sync node */
520
    futex_up(&childp->lock);
536
    futex_up(&childp->lock);
521
 
537
 
522
    /*
538
    /*
523
     * Hash in the index structure into the position hash.
539
     * Hash in the index structure into the position hash.
524
     */
540
     */
525
    fat_idx_hashin(childp->idx);
541
    fat_idx_hashin(childp->idx);
526
 
542
 
527
    return EOK;
543
    return EOK;
528
}
544
}
529
 
545
 
530
int fat_unlink(void *prnt, void *chld)
546
int fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
531
{
547
{
532
    fat_node_t *parentp = (fat_node_t *)prnt;
548
    fat_node_t *parentp = FAT_NODE(pfn);
533
    fat_node_t *childp = (fat_node_t *)chld;
549
    fat_node_t *childp = FAT_NODE(cfn);
534
    fat_bs_t *bs;
550
    fat_bs_t *bs;
535
    fat_dentry_t *d;
551
    fat_dentry_t *d;
536
    uint16_t bps;
552
    uint16_t bps;
537
    block_t *b;
553
    block_t *b;
538
 
554
 
-
 
555
    if (!parentp)
-
 
556
        return EBUSY;
-
 
557
   
-
 
558
    if (fat_has_children(cfn))
-
 
559
        return ENOTEMPTY;
-
 
560
 
539
    futex_down(&parentp->lock);
561
    futex_down(&parentp->lock);
540
    futex_down(&childp->lock);
562
    futex_down(&childp->lock);
541
    assert(childp->lnkcnt == 1);
563
    assert(childp->lnkcnt == 1);
542
    futex_down(&childp->idx->lock);
564
    futex_down(&childp->idx->lock);
543
    bs = block_bb_get(childp->idx->dev_handle);
565
    bs = block_bb_get(childp->idx->dev_handle);
544
    bps = uint16_t_le2host(bs->bps);
566
    bps = uint16_t_le2host(bs->bps);
545
 
567
 
546
    b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
568
    b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
547
        (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
569
        (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
548
        BLOCK_FLAGS_NONE);
570
        BLOCK_FLAGS_NONE);
549
    d = (fat_dentry_t *)b->data +
571
    d = (fat_dentry_t *)b->data +
550
        (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
572
        (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
551
    /* mark the dentry as not-currently-used */
573
    /* mark the dentry as not-currently-used */
552
    d->name[0] = FAT_DENTRY_ERASED;
574
    d->name[0] = FAT_DENTRY_ERASED;
553
    b->dirty = true;        /* need to sync block */
575
    b->dirty = true;        /* need to sync block */
554
    block_put(b);
576
    block_put(b);
555
 
577
 
556
    /* remove the index structure from the position hash */
578
    /* remove the index structure from the position hash */
557
    fat_idx_hashout(childp->idx);
579
    fat_idx_hashout(childp->idx);
558
    /* clear position information */
580
    /* clear position information */
559
    childp->idx->pfc = FAT_CLST_RES0;
581
    childp->idx->pfc = FAT_CLST_RES0;
560
    childp->idx->pdi = 0;
582
    childp->idx->pdi = 0;
561
    futex_up(&childp->idx->lock);
583
    futex_up(&childp->idx->lock);
562
    childp->lnkcnt = 0;
584
    childp->lnkcnt = 0;
563
    childp->dirty = true;
585
    childp->dirty = true;
564
    futex_up(&childp->lock);
586
    futex_up(&childp->lock);
565
    futex_up(&parentp->lock);
587
    futex_up(&parentp->lock);
566
 
588
 
567
    return EOK;
589
    return EOK;
568
}
590
}
569
 
591
 
570
void *fat_match(void *prnt, const char *component)
592
fs_node_t *fat_match(fs_node_t *pfn, const char *component)
571
{
593
{
572
    fat_bs_t *bs;
594
    fat_bs_t *bs;
573
    fat_node_t *parentp = (fat_node_t *)prnt;
595
    fat_node_t *parentp = FAT_NODE(pfn);
574
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
596
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
575
    unsigned i, j;
597
    unsigned i, j;
576
    unsigned bps;       /* bytes per sector */
598
    unsigned bps;       /* bytes per sector */
577
    unsigned dps;       /* dentries per sector */
599
    unsigned dps;       /* dentries per sector */
578
    unsigned blocks;
600
    unsigned blocks;
579
    fat_dentry_t *d;
601
    fat_dentry_t *d;
580
    block_t *b;
602
    block_t *b;
581
 
603
 
582
    futex_down(&parentp->idx->lock);
604
    futex_down(&parentp->idx->lock);
583
    bs = block_bb_get(parentp->idx->dev_handle);
605
    bs = block_bb_get(parentp->idx->dev_handle);
584
    bps = uint16_t_le2host(bs->bps);
606
    bps = uint16_t_le2host(bs->bps);
585
    dps = bps / sizeof(fat_dentry_t);
607
    dps = bps / sizeof(fat_dentry_t);
586
    blocks = parentp->size / bps;
608
    blocks = parentp->size / bps;
587
    for (i = 0; i < blocks; i++) {
609
    for (i = 0; i < blocks; i++) {
588
        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
610
        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
589
        for (j = 0; j < dps; j++) {
611
        for (j = 0; j < dps; j++) {
590
            d = ((fat_dentry_t *)b->data) + j;
612
            d = ((fat_dentry_t *)b->data) + j;
591
            switch (fat_classify_dentry(d)) {
613
            switch (fat_classify_dentry(d)) {
592
            case FAT_DENTRY_SKIP:
614
            case FAT_DENTRY_SKIP:
593
            case FAT_DENTRY_FREE:
615
            case FAT_DENTRY_FREE:
594
                continue;
616
                continue;
595
            case FAT_DENTRY_LAST:
617
            case FAT_DENTRY_LAST:
596
                block_put(b);
618
                block_put(b);
597
                futex_up(&parentp->idx->lock);
619
                futex_up(&parentp->idx->lock);
598
                return NULL;
620
                return NULL;
599
            default:
621
            default:
600
            case FAT_DENTRY_VALID:
622
            case FAT_DENTRY_VALID:
601
                fat_dentry_name_get(d, name);
623
                fat_dentry_name_get(d, name);
602
                break;
624
                break;
603
            }
625
            }
604
            if (fat_dentry_namecmp(name, component) == 0) {
626
            if (fat_dentry_namecmp(name, component) == 0) {
605
                /* hit */
627
                /* hit */
606
                void *node;
628
                fat_node_t *nodep;
607
                /*
629
                /*
608
                 * Assume tree hierarchy for locking.  We
630
                 * Assume tree hierarchy for locking.  We
609
                 * already have the parent and now we are going
631
                 * already have the parent and now we are going
610
                 * to lock the child.  Never lock in the oposite
632
                 * to lock the child.  Never lock in the oposite
611
                 * order.
633
                 * order.
612
                 */
634
                 */
613
                fat_idx_t *idx = fat_idx_get_by_pos(
635
                fat_idx_t *idx = fat_idx_get_by_pos(
614
                    parentp->idx->dev_handle, parentp->firstc,
636
                    parentp->idx->dev_handle, parentp->firstc,
615
                    i * dps + j);
637
                    i * dps + j);
616
                futex_up(&parentp->idx->lock);
638
                futex_up(&parentp->idx->lock);
617
                if (!idx) {
639
                if (!idx) {
618
                    /*
640
                    /*
619
                     * Can happen if memory is low or if we
641
                     * Can happen if memory is low or if we
620
                     * run out of 32-bit indices.
642
                     * run out of 32-bit indices.
621
                     */
643
                     */
622
                    block_put(b);
644
                    block_put(b);
623
                    return NULL;
645
                    return NULL;
624
                }
646
                }
625
                node = fat_node_get_core(idx);
647
                nodep = fat_node_get_core(idx);
626
                futex_up(&idx->lock);
648
                futex_up(&idx->lock);
627
                block_put(b);
649
                block_put(b);
628
                return node;
650
                return FS_NODE(nodep);
629
            }
651
            }
630
        }
652
        }
631
        block_put(b);
653
        block_put(b);
632
    }
654
    }
633
 
655
 
634
    futex_up(&parentp->idx->lock);
656
    futex_up(&parentp->idx->lock);
635
    return NULL;
657
    return NULL;
636
}
658
}
637
 
659
 
638
fs_index_t fat_index_get(void *node)
660
fs_index_t fat_index_get(fs_node_t *fn)
639
{
661
{
640
    fat_node_t *fnodep = (fat_node_t *)node;
-
 
641
    if (!fnodep)
-
 
642
        return 0;
-
 
643
    return fnodep->idx->index;
662
    return FAT_NODE(fn)->idx->index;
644
}
663
}
645
 
664
 
646
size_t fat_size_get(void *node)
665
size_t fat_size_get(fs_node_t *fn)
647
{
666
{
648
    return ((fat_node_t *)node)->size;
667
    return FAT_NODE(fn)->size;
649
}
668
}
650
 
669
 
651
unsigned fat_lnkcnt_get(void *node)
670
unsigned fat_lnkcnt_get(fs_node_t *fn)
652
{
671
{
653
    return ((fat_node_t *)node)->lnkcnt;
672
    return FAT_NODE(fn)->lnkcnt;
654
}
673
}
655
 
674
 
656
bool fat_has_children(void *node)
675
bool fat_has_children(fs_node_t *fn)
657
{
676
{
658
    fat_bs_t *bs;
677
    fat_bs_t *bs;
659
    fat_node_t *nodep = (fat_node_t *)node;
678
    fat_node_t *nodep = FAT_NODE(fn);
660
    unsigned bps;
679
    unsigned bps;
661
    unsigned dps;
680
    unsigned dps;
662
    unsigned blocks;
681
    unsigned blocks;
663
    block_t *b;
682
    block_t *b;
664
    unsigned i, j;
683
    unsigned i, j;
665
 
684
 
666
    if (nodep->type != FAT_DIRECTORY)
685
    if (nodep->type != FAT_DIRECTORY)
667
        return false;
686
        return false;
668
   
687
   
669
    futex_down(&nodep->idx->lock);
688
    futex_down(&nodep->idx->lock);
670
    bs = block_bb_get(nodep->idx->dev_handle);
689
    bs = block_bb_get(nodep->idx->dev_handle);
671
    bps = uint16_t_le2host(bs->bps);
690
    bps = uint16_t_le2host(bs->bps);
672
    dps = bps / sizeof(fat_dentry_t);
691
    dps = bps / sizeof(fat_dentry_t);
673
 
692
 
674
    blocks = nodep->size / bps;
693
    blocks = nodep->size / bps;
675
 
694
 
676
    for (i = 0; i < blocks; i++) {
695
    for (i = 0; i < blocks; i++) {
677
        fat_dentry_t *d;
696
        fat_dentry_t *d;
678
   
697
   
679
        b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
698
        b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
680
        for (j = 0; j < dps; j++) {
699
        for (j = 0; j < dps; j++) {
681
            d = ((fat_dentry_t *)b->data) + j;
700
            d = ((fat_dentry_t *)b->data) + j;
682
            switch (fat_classify_dentry(d)) {
701
            switch (fat_classify_dentry(d)) {
683
            case FAT_DENTRY_SKIP:
702
            case FAT_DENTRY_SKIP:
684
            case FAT_DENTRY_FREE:
703
            case FAT_DENTRY_FREE:
685
                continue;
704
                continue;
686
            case FAT_DENTRY_LAST:
705
            case FAT_DENTRY_LAST:
687
                block_put(b);
706
                block_put(b);
688
                futex_up(&nodep->idx->lock);
707
                futex_up(&nodep->idx->lock);
689
                return false;
708
                return false;
690
            default:
709
            default:
691
            case FAT_DENTRY_VALID:
710
            case FAT_DENTRY_VALID:
692
                block_put(b);
711
                block_put(b);
693
                futex_up(&nodep->idx->lock);
712
                futex_up(&nodep->idx->lock);
694
                return true;
713
                return true;
695
            }
714
            }
696
            block_put(b);
715
            block_put(b);
697
            futex_up(&nodep->idx->lock);
716
            futex_up(&nodep->idx->lock);
698
            return true;
717
            return true;
699
        }
718
        }
700
        block_put(b);
719
        block_put(b);
701
    }
720
    }
702
 
721
 
703
    futex_up(&nodep->idx->lock);
722
    futex_up(&nodep->idx->lock);
704
    return false;
723
    return false;
705
}
724
}
706
 
725
 
707
void *fat_root_get(dev_handle_t dev_handle)
726
fs_node_t *fat_root_get(dev_handle_t dev_handle)
708
{
727
{
709
    return fat_node_get(dev_handle, 0);
728
    return fat_node_get(dev_handle, 0);
710
}
729
}
711
 
730
 
712
char fat_plb_get_char(unsigned pos)
731
char fat_plb_get_char(unsigned pos)
713
{
732
{
714
    return fat_reg.plb_ro[pos % PLB_SIZE];
733
    return fat_reg.plb_ro[pos % PLB_SIZE];
715
}
734
}
716
 
735
 
717
bool fat_is_directory(void *node)
736
bool fat_is_directory(fs_node_t *fn)
718
{
737
{
719
    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
738
    return FAT_NODE(fn)->type == FAT_DIRECTORY;
720
}
739
}
721
 
740
 
722
bool fat_is_file(void *node)
741
bool fat_is_file(fs_node_t *fn)
723
{
742
{
724
    return ((fat_node_t *)node)->type == FAT_FILE;
743
    return FAT_NODE(fn)->type == FAT_FILE;
725
}
744
}
726
 
745
 
727
/** libfs operations */
746
/** libfs operations */
728
libfs_ops_t fat_libfs_ops = {
747
libfs_ops_t fat_libfs_ops = {
729
    .match = fat_match,
748
    .match = fat_match,
730
    .node_get = fat_node_get,
749
    .node_get = fat_node_get,
731
    .node_put = fat_node_put,
750
    .node_put = fat_node_put,
732
    .create = fat_create_node,
751
    .create = fat_create_node,
733
    .destroy = fat_destroy_node,
752
    .destroy = fat_destroy_node,
734
    .link = fat_link,
753
    .link = fat_link,
735
    .unlink = fat_unlink,
754
    .unlink = fat_unlink,
736
    .index_get = fat_index_get,
755
    .index_get = fat_index_get,
737
    .size_get = fat_size_get,
756
    .size_get = fat_size_get,
738
    .lnkcnt_get = fat_lnkcnt_get,
757
    .lnkcnt_get = fat_lnkcnt_get,
739
    .has_children = fat_has_children,
758
    .has_children = fat_has_children,
740
    .root_get = fat_root_get,
759
    .root_get = fat_root_get,
741
    .plb_get_char = fat_plb_get_char,
760
    .plb_get_char = fat_plb_get_char,
742
    .is_directory = fat_is_directory,
761
    .is_directory = fat_is_directory,
743
    .is_file = fat_is_file
762
    .is_file = fat_is_file
744
};
763
};
745
 
764
 
746
/*
765
/*
747
 * VFS operations.
766
 * VFS operations.
748
 */
767
 */
749
 
768
 
750
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
769
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
751
{
770
{
752
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
771
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
753
    fat_bs_t *bs;
772
    fat_bs_t *bs;
754
    uint16_t bps;
773
    uint16_t bps;
755
    uint16_t rde;
774
    uint16_t rde;
756
    int rc;
775
    int rc;
757
 
776
 
758
    /* accept the mount options */
777
    /* accept the mount options */
759
    ipc_callid_t callid;
778
    ipc_callid_t callid;
760
    size_t size;
779
    size_t size;
761
    if (!ipc_data_write_receive(&callid, &size)) {
780
    if (!ipc_data_write_receive(&callid, &size)) {
762
        ipc_answer_0(callid, EINVAL);
781
        ipc_answer_0(callid, EINVAL);
763
        ipc_answer_0(rid, EINVAL);
782
        ipc_answer_0(rid, EINVAL);
764
        return;
783
        return;
765
    }
784
    }
766
    char *opts = malloc(size + 1);
785
    char *opts = malloc(size + 1);
767
    if (!opts) {
786
    if (!opts) {
768
        ipc_answer_0(callid, ENOMEM);
787
        ipc_answer_0(callid, ENOMEM);
769
        ipc_answer_0(rid, ENOMEM);
788
        ipc_answer_0(rid, ENOMEM);
770
        return;
789
        return;
771
    }
790
    }
772
    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
791
    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
773
    if (retval != EOK) {
792
    if (retval != EOK) {
774
        ipc_answer_0(rid, retval);
793
        ipc_answer_0(rid, retval);
775
        free(opts);
794
        free(opts);
776
        return;
795
        return;
777
    }
796
    }
778
    opts[size] = '\0';
797
    opts[size] = '\0';
779
 
798
 
780
    /* initialize libblock */
799
    /* initialize libblock */
781
    rc = block_init(dev_handle, BS_SIZE);
800
    rc = block_init(dev_handle, BS_SIZE);
782
    if (rc != EOK) {
801
    if (rc != EOK) {
783
        ipc_answer_0(rid, rc);
802
        ipc_answer_0(rid, rc);
784
        return;
803
        return;
785
    }
804
    }
786
 
805
 
787
    /* prepare the boot block */
806
    /* prepare the boot block */
788
    rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
807
    rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
789
    if (rc != EOK) {
808
    if (rc != EOK) {
790
        block_fini(dev_handle);
809
        block_fini(dev_handle);
791
        ipc_answer_0(rid, rc);
810
        ipc_answer_0(rid, rc);
792
        return;
811
        return;
793
    }
812
    }
794
 
813
 
795
    /* get the buffer with the boot sector */
814
    /* get the buffer with the boot sector */
796
    bs = block_bb_get(dev_handle);
815
    bs = block_bb_get(dev_handle);
797
   
816
   
798
    /* Read the number of root directory entries. */
817
    /* Read the number of root directory entries. */
799
    bps = uint16_t_le2host(bs->bps);
818
    bps = uint16_t_le2host(bs->bps);
800
    rde = uint16_t_le2host(bs->root_ent_max);
819
    rde = uint16_t_le2host(bs->root_ent_max);
801
 
820
 
802
    if (bps != BS_SIZE) {
821
    if (bps != BS_SIZE) {
803
        block_fini(dev_handle);
822
        block_fini(dev_handle);
804
        ipc_answer_0(rid, ENOTSUP);
823
        ipc_answer_0(rid, ENOTSUP);
805
        return;
824
        return;
806
    }
825
    }
807
 
826
 
808
    /* Initialize the block cache */
827
    /* Initialize the block cache */
809
    rc = block_cache_init(dev_handle, bps, 0 /* XXX */);
828
    rc = block_cache_init(dev_handle, bps, 0 /* XXX */);
810
    if (rc != EOK) {
829
    if (rc != EOK) {
811
        block_fini(dev_handle);
830
        block_fini(dev_handle);
812
        ipc_answer_0(rid, rc);
831
        ipc_answer_0(rid, rc);
813
        return;
832
        return;
814
    }
833
    }
815
 
834
 
816
    rc = fat_idx_init_by_dev_handle(dev_handle);
835
    rc = fat_idx_init_by_dev_handle(dev_handle);
817
    if (rc != EOK) {
836
    if (rc != EOK) {
818
        block_fini(dev_handle);
837
        block_fini(dev_handle);
819
        ipc_answer_0(rid, rc);
838
        ipc_answer_0(rid, rc);
820
        return;
839
        return;
821
    }
840
    }
822
 
841
 
823
    /* Initialize the root node. */
842
    /* Initialize the root node. */
-
 
843
    fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
-
 
844
    if (!rfn) {
-
 
845
        block_fini(dev_handle);
-
 
846
        fat_idx_fini_by_dev_handle(dev_handle);
-
 
847
        ipc_answer_0(rid, ENOMEM);
-
 
848
        return;
-
 
849
    }
824
    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
850
    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
825
    if (!rootp) {
851
    if (!rootp) {
-
 
852
        free(rfn);
826
        block_fini(dev_handle);
853
        block_fini(dev_handle);
827
        fat_idx_fini_by_dev_handle(dev_handle);
854
        fat_idx_fini_by_dev_handle(dev_handle);
828
        ipc_answer_0(rid, ENOMEM);
855
        ipc_answer_0(rid, ENOMEM);
829
        return;
856
        return;
830
    }
857
    }
831
    fat_node_initialize(rootp);
858
    fat_node_initialize(rootp);
832
 
859
 
833
    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
860
    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
834
    if (!ridxp) {
861
    if (!ridxp) {
835
        block_fini(dev_handle);
862
        free(rfn);
836
        free(rootp);
863
        free(rootp);
-
 
864
        block_fini(dev_handle);
837
        fat_idx_fini_by_dev_handle(dev_handle);
865
        fat_idx_fini_by_dev_handle(dev_handle);
838
        ipc_answer_0(rid, ENOMEM);
866
        ipc_answer_0(rid, ENOMEM);
839
        return;
867
        return;
840
    }
868
    }
841
    assert(ridxp->index == 0);
869
    assert(ridxp->index == 0);
842
    /* ridxp->lock held */
870
    /* ridxp->lock held */
843
 
871
 
844
    rootp->type = FAT_DIRECTORY;
872
    rootp->type = FAT_DIRECTORY;
845
    rootp->firstc = FAT_CLST_ROOT;
873
    rootp->firstc = FAT_CLST_ROOT;
846
    rootp->refcnt = 1;
874
    rootp->refcnt = 1;
847
    rootp->lnkcnt = 0;  /* FS root is not linked */
875
    rootp->lnkcnt = 0;  /* FS root is not linked */
848
    rootp->size = rde * sizeof(fat_dentry_t);
876
    rootp->size = rde * sizeof(fat_dentry_t);
849
    rootp->idx = ridxp;
877
    rootp->idx = ridxp;
850
    ridxp->nodep = rootp;
878
    ridxp->nodep = rootp;
-
 
879
    rootp->bp = rfn;
-
 
880
    rfn->data = rootp;
851
   
881
   
852
    futex_up(&ridxp->lock);
882
    futex_up(&ridxp->lock);
853
 
883
 
854
    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
884
    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
855
}
885
}
856
 
886
 
857
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
887
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
858
{
888
{
859
    ipc_answer_0(rid, ENOTSUP);
889
    ipc_answer_0(rid, ENOTSUP);
860
}
890
}
861
 
891
 
862
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
892
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
863
{
893
{
864
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
894
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
865
}
895
}
866
 
896
 
867
void fat_read(ipc_callid_t rid, ipc_call_t *request)
897
void fat_read(ipc_callid_t rid, ipc_call_t *request)
868
{
898
{
869
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
899
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
870
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
900
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
871
    off_t pos = (off_t)IPC_GET_ARG3(*request);
901
    off_t pos = (off_t)IPC_GET_ARG3(*request);
872
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
902
    fs_node_t *fn = fat_node_get(dev_handle, index);
-
 
903
    fat_node_t *nodep;
873
    fat_bs_t *bs;
904
    fat_bs_t *bs;
874
    uint16_t bps;
905
    uint16_t bps;
875
    size_t bytes;
906
    size_t bytes;
876
    block_t *b;
907
    block_t *b;
877
 
908
 
878
    if (!nodep) {
909
    if (!fn) {
879
        ipc_answer_0(rid, ENOENT);
910
        ipc_answer_0(rid, ENOENT);
880
        return;
911
        return;
881
    }
912
    }
-
 
913
    nodep = FAT_NODE(fn);
882
 
914
 
883
    ipc_callid_t callid;
915
    ipc_callid_t callid;
884
    size_t len;
916
    size_t len;
885
    if (!ipc_data_read_receive(&callid, &len)) {
917
    if (!ipc_data_read_receive(&callid, &len)) {
886
        fat_node_put(nodep);
918
        fat_node_put(fn);
887
        ipc_answer_0(callid, EINVAL);
919
        ipc_answer_0(callid, EINVAL);
888
        ipc_answer_0(rid, EINVAL);
920
        ipc_answer_0(rid, EINVAL);
889
        return;
921
        return;
890
    }
922
    }
891
 
923
 
892
    bs = block_bb_get(dev_handle);
924
    bs = block_bb_get(dev_handle);
893
    bps = uint16_t_le2host(bs->bps);
925
    bps = uint16_t_le2host(bs->bps);
894
 
926
 
895
    if (nodep->type == FAT_FILE) {
927
    if (nodep->type == FAT_FILE) {
896
        /*
928
        /*
897
         * Our strategy for regular file reads is to read one block at
929
         * Our strategy for regular file reads is to read one block at
898
         * most and make use of the possibility to return less data than
930
         * most and make use of the possibility to return less data than
899
         * requested. This keeps the code very simple.
931
         * requested. This keeps the code very simple.
900
         */
932
         */
901
        if (pos >= nodep->size) {
933
        if (pos >= nodep->size) {
902
            /* reading beyond the EOF */
934
            /* reading beyond the EOF */
903
            bytes = 0;
935
            bytes = 0;
904
            (void) ipc_data_read_finalize(callid, NULL, 0);
936
            (void) ipc_data_read_finalize(callid, NULL, 0);
905
        } else {
937
        } else {
906
            bytes = min(len, bps - pos % bps);
938
            bytes = min(len, bps - pos % bps);
907
            bytes = min(bytes, nodep->size - pos);
939
            bytes = min(bytes, nodep->size - pos);
908
            b = fat_block_get(bs, nodep, pos / bps,
940
            b = fat_block_get(bs, nodep, pos / bps,
909
                BLOCK_FLAGS_NONE);
941
                BLOCK_FLAGS_NONE);
910
            (void) ipc_data_read_finalize(callid, b->data + pos % bps,
942
            (void) ipc_data_read_finalize(callid, b->data + pos % bps,
911
                bytes);
943
                bytes);
912
            block_put(b);
944
            block_put(b);
913
        }
945
        }
914
    } else {
946
    } else {
915
        unsigned bnum;
947
        unsigned bnum;
916
        off_t spos = pos;
948
        off_t spos = pos;
917
        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
949
        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
918
        fat_dentry_t *d;
950
        fat_dentry_t *d;
919
 
951
 
920
        assert(nodep->type == FAT_DIRECTORY);
952
        assert(nodep->type == FAT_DIRECTORY);
921
        assert(nodep->size % bps == 0);
953
        assert(nodep->size % bps == 0);
922
        assert(bps % sizeof(fat_dentry_t) == 0);
954
        assert(bps % sizeof(fat_dentry_t) == 0);
923
 
955
 
924
        /*
956
        /*
925
         * Our strategy for readdir() is to use the position pointer as
957
         * Our strategy for readdir() is to use the position pointer as
926
         * an index into the array of all dentries. On entry, it points
958
         * an index into the array of all dentries. On entry, it points
927
         * to the first unread dentry. If we skip any dentries, we bump
959
         * to the first unread dentry. If we skip any dentries, we bump
928
         * the position pointer accordingly.
960
         * the position pointer accordingly.
929
         */
961
         */
930
        bnum = (pos * sizeof(fat_dentry_t)) / bps;
962
        bnum = (pos * sizeof(fat_dentry_t)) / bps;
931
        while (bnum < nodep->size / bps) {
963
        while (bnum < nodep->size / bps) {
932
            off_t o;
964
            off_t o;
933
 
965
 
934
            b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
966
            b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
935
            for (o = pos % (bps / sizeof(fat_dentry_t));
967
            for (o = pos % (bps / sizeof(fat_dentry_t));
936
                o < bps / sizeof(fat_dentry_t);
968
                o < bps / sizeof(fat_dentry_t);
937
                o++, pos++) {
969
                o++, pos++) {
938
                d = ((fat_dentry_t *)b->data) + o;
970
                d = ((fat_dentry_t *)b->data) + o;
939
                switch (fat_classify_dentry(d)) {
971
                switch (fat_classify_dentry(d)) {
940
                case FAT_DENTRY_SKIP:
972
                case FAT_DENTRY_SKIP:
941
                case FAT_DENTRY_FREE:
973
                case FAT_DENTRY_FREE:
942
                    continue;
974
                    continue;
943
                case FAT_DENTRY_LAST:
975
                case FAT_DENTRY_LAST:
944
                    block_put(b);
976
                    block_put(b);
945
                    goto miss;
977
                    goto miss;
946
                default:
978
                default:
947
                case FAT_DENTRY_VALID:
979
                case FAT_DENTRY_VALID:
948
                    fat_dentry_name_get(d, name);
980
                    fat_dentry_name_get(d, name);
949
                    block_put(b);
981
                    block_put(b);
950
                    goto hit;
982
                    goto hit;
951
                }
983
                }
952
            }
984
            }
953
            block_put(b);
985
            block_put(b);
954
            bnum++;
986
            bnum++;
955
        }
987
        }
956
miss:
988
miss:
957
        fat_node_put(nodep);
989
        fat_node_put(fn);
958
        ipc_answer_0(callid, ENOENT);
990
        ipc_answer_0(callid, ENOENT);
959
        ipc_answer_1(rid, ENOENT, 0);
991
        ipc_answer_1(rid, ENOENT, 0);
960
        return;
992
        return;
961
hit:
993
hit:
962
        (void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
994
        (void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
963
        bytes = (pos - spos) + 1;
995
        bytes = (pos - spos) + 1;
964
    }
996
    }
965
 
997
 
966
    fat_node_put(nodep);
998
    fat_node_put(fn);
967
    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
999
    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
968
}
1000
}
969
 
1001
 
970
void fat_write(ipc_callid_t rid, ipc_call_t *request)
1002
void fat_write(ipc_callid_t rid, ipc_call_t *request)
971
{
1003
{
972
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
1004
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
973
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
1005
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
974
    off_t pos = (off_t)IPC_GET_ARG3(*request);
1006
    off_t pos = (off_t)IPC_GET_ARG3(*request);
975
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
1007
    fs_node_t *fn = fat_node_get(dev_handle, index);
-
 
1008
    fat_node_t *nodep;
976
    fat_bs_t *bs;
1009
    fat_bs_t *bs;
977
    size_t bytes;
1010
    size_t bytes;
978
    block_t *b;
1011
    block_t *b;
979
    uint16_t bps;
1012
    uint16_t bps;
980
    unsigned spc;
1013
    unsigned spc;
981
    unsigned bpc;       /* bytes per cluster */
1014
    unsigned bpc;       /* bytes per cluster */
982
    off_t boundary;
1015
    off_t boundary;
983
    int flags = BLOCK_FLAGS_NONE;
1016
    int flags = BLOCK_FLAGS_NONE;
984
   
1017
   
985
    if (!nodep) {
1018
    if (!fn) {
986
        ipc_answer_0(rid, ENOENT);
1019
        ipc_answer_0(rid, ENOENT);
987
        return;
1020
        return;
988
    }
1021
    }
-
 
1022
    nodep = FAT_NODE(fn);
989
   
1023
   
990
    ipc_callid_t callid;
1024
    ipc_callid_t callid;
991
    size_t len;
1025
    size_t len;
992
    if (!ipc_data_write_receive(&callid, &len)) {
1026
    if (!ipc_data_write_receive(&callid, &len)) {
993
        fat_node_put(nodep);
1027
        fat_node_put(fn);
994
        ipc_answer_0(callid, EINVAL);
1028
        ipc_answer_0(callid, EINVAL);
995
        ipc_answer_0(rid, EINVAL);
1029
        ipc_answer_0(rid, EINVAL);
996
        return;
1030
        return;
997
    }
1031
    }
998
 
1032
 
999
    bs = block_bb_get(dev_handle);
1033
    bs = block_bb_get(dev_handle);
1000
    bps = uint16_t_le2host(bs->bps);
1034
    bps = uint16_t_le2host(bs->bps);
1001
    spc = bs->spc;
1035
    spc = bs->spc;
1002
    bpc = bps * spc;
1036
    bpc = bps * spc;
1003
 
1037
 
1004
    /*
1038
    /*
1005
     * In all scenarios, we will attempt to write out only one block worth
1039
     * In all scenarios, we will attempt to write out only one block worth
1006
     * of data at maximum. There might be some more efficient approaches,
1040
     * of data at maximum. There might be some more efficient approaches,
1007
     * but this one greatly simplifies fat_write(). Note that we can afford
1041
     * but this one greatly simplifies fat_write(). Note that we can afford
1008
     * to do this because the client must be ready to handle the return
1042
     * to do this because the client must be ready to handle the return
1009
     * value signalizing a smaller number of bytes written.
1043
     * value signalizing a smaller number of bytes written.
1010
     */
1044
     */
1011
    bytes = min(len, bps - pos % bps);
1045
    bytes = min(len, bps - pos % bps);
1012
    if (bytes == bps)
1046
    if (bytes == bps)
1013
        flags |= BLOCK_FLAGS_NOREAD;
1047
        flags |= BLOCK_FLAGS_NOREAD;
1014
   
1048
   
1015
    boundary = ROUND_UP(nodep->size, bpc);
1049
    boundary = ROUND_UP(nodep->size, bpc);
1016
    if (pos < boundary) {
1050
    if (pos < boundary) {
1017
        /*
1051
        /*
1018
         * This is the easier case - we are either overwriting already
1052
         * This is the easier case - we are either overwriting already
1019
         * existing contents or writing behind the EOF, but still within
1053
         * existing contents or writing behind the EOF, but still within
1020
         * the limits of the last cluster. The node size may grow to the
1054
         * the limits of the last cluster. The node size may grow to the
1021
         * next block size boundary.
1055
         * next block size boundary.
1022
         */
1056
         */
1023
        fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
1057
        fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
1024
        b = fat_block_get(bs, nodep, pos / bps, flags);
1058
        b = fat_block_get(bs, nodep, pos / bps, flags);
1025
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
1059
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
1026
            bytes);
1060
            bytes);
1027
        b->dirty = true;        /* need to sync block */
1061
        b->dirty = true;        /* need to sync block */
1028
        block_put(b);
1062
        block_put(b);
1029
        if (pos + bytes > nodep->size) {
1063
        if (pos + bytes > nodep->size) {
1030
            nodep->size = pos + bytes;
1064
            nodep->size = pos + bytes;
1031
            nodep->dirty = true;    /* need to sync node */
1065
            nodep->dirty = true;    /* need to sync node */
1032
        }
1066
        }
1033
        ipc_answer_2(rid, EOK, bytes, nodep->size);
1067
        ipc_answer_2(rid, EOK, bytes, nodep->size);
1034
        fat_node_put(nodep);
1068
        fat_node_put(fn);
1035
        return;
1069
        return;
1036
    } else {
1070
    } else {
1037
        /*
1071
        /*
1038
         * This is the more difficult case. We must allocate new
1072
         * This is the more difficult case. We must allocate new
1039
         * clusters for the node and zero them out.
1073
         * clusters for the node and zero them out.
1040
         */
1074
         */
1041
        int status;
1075
        int status;
1042
        unsigned nclsts;
1076
        unsigned nclsts;
1043
        fat_cluster_t mcl, lcl;
1077
        fat_cluster_t mcl, lcl;
1044
 
1078
 
1045
        nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
1079
        nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
1046
        /* create an independent chain of nclsts clusters in all FATs */
1080
        /* create an independent chain of nclsts clusters in all FATs */
1047
        status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
1081
        status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
1048
        if (status != EOK) {
1082
        if (status != EOK) {
1049
            /* could not allocate a chain of nclsts clusters */
1083
            /* could not allocate a chain of nclsts clusters */
1050
            fat_node_put(nodep);
1084
            fat_node_put(fn);
1051
            ipc_answer_0(callid, status);
1085
            ipc_answer_0(callid, status);
1052
            ipc_answer_0(rid, status);
1086
            ipc_answer_0(rid, status);
1053
            return;
1087
            return;
1054
        }
1088
        }
1055
        /* zero fill any gaps */
1089
        /* zero fill any gaps */
1056
        fat_fill_gap(bs, nodep, mcl, pos);
1090
        fat_fill_gap(bs, nodep, mcl, pos);
1057
        b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
1091
        b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
1058
            flags);
1092
            flags);
1059
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
1093
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
1060
            bytes);
1094
            bytes);
1061
        b->dirty = true;        /* need to sync block */
1095
        b->dirty = true;        /* need to sync block */
1062
        block_put(b);
1096
        block_put(b);
1063
        /*
1097
        /*
1064
         * Append the cluster chain starting in mcl to the end of the
1098
         * Append the cluster chain starting in mcl to the end of the
1065
         * node's cluster chain.
1099
         * node's cluster chain.
1066
         */
1100
         */
1067
        fat_append_clusters(bs, nodep, mcl);
1101
        fat_append_clusters(bs, nodep, mcl);
1068
        nodep->size = pos + bytes;
1102
        nodep->size = pos + bytes;
1069
        nodep->dirty = true;        /* need to sync node */
1103
        nodep->dirty = true;        /* need to sync node */
1070
        ipc_answer_2(rid, EOK, bytes, nodep->size);
1104
        ipc_answer_2(rid, EOK, bytes, nodep->size);
1071
        fat_node_put(nodep);
1105
        fat_node_put(fn);
1072
        return;
1106
        return;
1073
    }
1107
    }
1074
}
1108
}
1075
 
1109
 
1076
void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
1110
void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
1077
{
1111
{
1078
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
1112
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
1079
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
1113
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
1080
    size_t size = (off_t)IPC_GET_ARG3(*request);
1114
    size_t size = (off_t)IPC_GET_ARG3(*request);
1081
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
1115
    fs_node_t *fn = fat_node_get(dev_handle, index);
-
 
1116
    fat_node_t *nodep;
1082
    fat_bs_t *bs;
1117
    fat_bs_t *bs;
1083
    uint16_t bps;
1118
    uint16_t bps;
1084
    uint8_t spc;
1119
    uint8_t spc;
1085
    unsigned bpc;   /* bytes per cluster */
1120
    unsigned bpc;   /* bytes per cluster */
1086
    int rc;
1121
    int rc;
1087
 
1122
 
1088
    if (!nodep) {
1123
    if (!fn) {
1089
        ipc_answer_0(rid, ENOENT);
1124
        ipc_answer_0(rid, ENOENT);
1090
        return;
1125
        return;
1091
    }
1126
    }
-
 
1127
    nodep = FAT_NODE(fn);
1092
 
1128
 
1093
    bs = block_bb_get(dev_handle);
1129
    bs = block_bb_get(dev_handle);
1094
    bps = uint16_t_le2host(bs->bps);
1130
    bps = uint16_t_le2host(bs->bps);
1095
    spc = bs->spc;
1131
    spc = bs->spc;
1096
    bpc = bps * spc;
1132
    bpc = bps * spc;
1097
 
1133
 
1098
    if (nodep->size == size) {
1134
    if (nodep->size == size) {
1099
        rc = EOK;
1135
        rc = EOK;
1100
    } else if (nodep->size < size) {
1136
    } else if (nodep->size < size) {
1101
        /*
1137
        /*
1102
         * The standard says we have the freedom to grow the node.
1138
         * The standard says we have the freedom to grow the node.
1103
         * For now, we simply return an error.
1139
         * For now, we simply return an error.
1104
         */
1140
         */
1105
        rc = EINVAL;
1141
        rc = EINVAL;
1106
    } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
1142
    } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
1107
        /*
1143
        /*
1108
         * The node will be shrunk, but no clusters will be deallocated.
1144
         * The node will be shrunk, but no clusters will be deallocated.
1109
         */
1145
         */
1110
        nodep->size = size;
1146
        nodep->size = size;
1111
        nodep->dirty = true;        /* need to sync node */
1147
        nodep->dirty = true;        /* need to sync node */
1112
        rc = EOK;  
1148
        rc = EOK;  
1113
    } else {
1149
    } else {
1114
        /*
1150
        /*
1115
         * The node will be shrunk, clusters will be deallocated.
1151
         * The node will be shrunk, clusters will be deallocated.
1116
         */
1152
         */
1117
        if (size == 0) {
1153
        if (size == 0) {
1118
            fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
1154
            fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
1119
        } else {
1155
        } else {
1120
            fat_cluster_t lastc;
1156
            fat_cluster_t lastc;
1121
            (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
1157
            (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
1122
                &lastc, (size - 1) / bpc);
1158
                &lastc, (size - 1) / bpc);
1123
            fat_chop_clusters(bs, nodep, lastc);
1159
            fat_chop_clusters(bs, nodep, lastc);
1124
        }
1160
        }
1125
        nodep->size = size;
1161
        nodep->size = size;
1126
        nodep->dirty = true;        /* need to sync node */
1162
        nodep->dirty = true;        /* need to sync node */
1127
        rc = EOK;  
1163
        rc = EOK;  
1128
    }
1164
    }
1129
    fat_node_put(nodep);
1165
    fat_node_put(fn);
1130
    ipc_answer_0(rid, rc);
1166
    ipc_answer_0(rid, rc);
1131
    return;
1167
    return;
1132
}
1168
}
1133
 
1169
 
1134
void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
1170
void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
1135
{
1171
{
1136
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
1172
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
1137
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
1173
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
1138
    int rc;
1174
    int rc;
1139
 
1175
 
1140
    fat_node_t *nodep = fat_node_get(dev_handle, index);
1176
    fs_node_t *fn = fat_node_get(dev_handle, index);
1141
    if (!nodep) {
1177
    if (!fn) {
1142
        ipc_answer_0(rid, ENOENT);
1178
        ipc_answer_0(rid, ENOENT);
1143
        return;
1179
        return;
1144
    }
1180
    }
1145
 
1181
 
1146
    rc = fat_destroy_node(nodep);
1182
    rc = fat_destroy_node(fn);
1147
    ipc_answer_0(rid, rc);
1183
    ipc_answer_0(rid, rc);
1148
}
1184
}
1149
 
1185
 
1150
/**
1186
/**
1151
 * @}
1187
 * @}
1152
 */
1188
 */
1153
 
1189