Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2627 jermar 1
/*
2925 svoboda 2
 * Copyright (c) 2008 Jakub Jermar
2627 jermar 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup fs
30
 * @{
31
 */
32
 
33
/**
34
 * @file    fat_ops.c
35
 * @brief   Implementation of VFS operations for the FAT file system server.
36
 */
37
 
38
#include "fat.h"
2638 jermar 39
#include "../../vfs/vfs.h"
2925 svoboda 40
#include <libfs.h>
2627 jermar 41
#include <ipc/ipc.h>
42
#include <async.h>
43
#include <errno.h>
2925 svoboda 44
#include <string.h>
45
#include <byteorder.h>
46
#include <libadt/hash_table.h>
47
#include <libadt/list.h>
48
#include <assert.h>
49
#include <futex.h>
2627 jermar 50
 
2925 svoboda 51
#define BS_BLOCK        0
2638 jermar 52
 
2925 svoboda 53
/** List of free FAT nodes that still contain valid data. */
54
LIST_INITIALIZE(ffn_head);
55
 
2638 jermar 56
#define FAT_NAME_LEN        8
57
#define FAT_EXT_LEN     3
58
 
59
#define FAT_PAD         ' ' 
60
 
61
#define FAT_DENTRY_UNUSED   0x00
62
#define FAT_DENTRY_E5_ESC   0x05
63
#define FAT_DENTRY_DOT      0x2e
64
#define FAT_DENTRY_ERASED   0xe5
65
 
2925 svoboda 66
static void dentry_name_canonify(fat_dentry_t *d, char *buf)
2638 jermar 67
{
2925 svoboda 68
    int i;
2639 jermar 69
 
2925 svoboda 70
    for (i = 0; i < FAT_NAME_LEN; i++) {
71
        if (d->name[i] == FAT_PAD) {
72
            buf++;
73
            break;
2639 jermar 74
        }
2925 svoboda 75
        if (d->name[i] == FAT_DENTRY_E5_ESC)
76
            *buf++ = 0xe5;
77
        else
78
            *buf++ = d->name[i];
79
    }
80
    if (d->ext[0] != FAT_PAD)
81
        *buf++ = '.';
82
    for (i = 0; i < FAT_EXT_LEN; i++) {
83
        if (d->ext[i] == FAT_PAD) {
84
            *buf = '\0';
85
            return;
2639 jermar 86
        }
2925 svoboda 87
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
88
            *buf++ = 0xe5;
89
        else
90
            *buf++ = d->ext[i];
91
    }
92
}
93
 
94
/* TODO move somewhere else */
95
typedef struct {
96
    void *data;
97
} block_t;
98
 
99
static block_t *block_get(dev_handle_t dev_handle, off_t offset)
100
{
101
    return NULL;    /* TODO */
102
}
103
 
104
static void block_put(block_t *block)
105
{
106
    /* TODO */
107
}
108
 
109
#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
110
 
111
#define FAT_CLST_RES0   0x0000
112
#define FAT_CLST_RES1   0x0001  /* internally used to mark root directory */
113
#define FAT_CLST_FIRST  0x0002
114
#define FAT_CLST_BAD    0xfff7
115
#define FAT_CLST_LAST1  0xfff8
116
#define FAT_CLST_LAST8  0xffff
117
 
118
#define fat_block_get(np, off) \
119
    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
120
 
121
static block_t *
122
_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
123
{
124
    block_t *bb;
125
    block_t *b;
126
    unsigned bps;
127
    unsigned spc;
128
    unsigned rscnt;     /* block address of the first FAT */
129
    unsigned fatcnt;
130
    unsigned rde;
131
    unsigned rds;       /* root directory size */
132
    unsigned sf;
133
    unsigned ssa;       /* size of the system area */
134
    unsigned clusters;
135
    fat_cluster_t clst = firstc;
136
    unsigned i;
137
 
138
    bb = block_get(dev_handle, BS_BLOCK);
139
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
140
    spc = FAT_BS(bb)->spc;
141
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
142
    fatcnt = FAT_BS(bb)->fatcnt;
143
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
144
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
145
    block_put(bb);
146
 
147
    rds = (sizeof(fat_dentry_t) * rde) / bps;
148
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
149
    ssa = rscnt + fatcnt * sf + rds;
150
 
151
    if (firstc == FAT_CLST_RES1) {
152
        /* root directory special case */
153
        assert(offset < rds);
154
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
155
        return b;
156
    }
157
 
158
    clusters = offset / spc;
159
    for (i = 0; i < clusters; i++) {
160
        unsigned fsec;  /* sector offset relative to FAT1 */
161
        unsigned fidx;  /* FAT1 entry index */
162
 
163
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
164
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
165
        fidx = clst % (bps / sizeof(fat_cluster_t));
166
        /* read FAT1 */
167
        b = block_get(dev_handle, rscnt + fsec);
168
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
169
        assert(clst != FAT_CLST_BAD);
170
        assert(clst < FAT_CLST_LAST1);
171
        block_put(b);
172
    }
173
 
174
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
175
        offset % spc);
176
 
177
    return b;
178
}
179
 
180
static void fat_node_initialize(fat_node_t *node)
181
{
182
    node->idx = NULL;
183
    node->type = 0;
184
    link_initialize(&node->ffn_link);
185
    node->size = 0;
186
    node->lnkcnt = 0;
187
    node->refcnt = 0;
188
    node->dirty = false;
189
}
190
 
191
static uint16_t fat_bps_get(dev_handle_t dev_handle)
192
{
193
    block_t *bb;
194
    uint16_t bps;
195
 
196
    bb = block_get(dev_handle, BS_BLOCK);
197
    assert(bb != NULL);
198
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
199
    block_put(bb);
200
 
201
    return bps;
202
}
203
 
204
typedef enum {
205
    FAT_DENTRY_SKIP,
206
    FAT_DENTRY_LAST,
207
    FAT_DENTRY_VALID
208
} fat_dentry_clsf_t;
209
 
210
static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)
211
{
212
    if (d->attr & FAT_ATTR_VOLLABEL) {
213
        /* volume label entry */
214
        return FAT_DENTRY_SKIP;
215
    }
216
    if (d->name[0] == FAT_DENTRY_ERASED) {
217
        /* not-currently-used entry */
218
        return FAT_DENTRY_SKIP;
219
    }
220
    if (d->name[0] == FAT_DENTRY_UNUSED) {
221
        /* never used entry */
222
        return FAT_DENTRY_LAST;
223
    }
224
    if (d->name[0] == FAT_DENTRY_DOT) {
225
        /*
226
         * Most likely '.' or '..'.
227
         * It cannot occur in a regular file name.
228
         */
229
        return FAT_DENTRY_SKIP;
230
    }
231
    return FAT_DENTRY_VALID;
232
}
233
 
234
static void fat_node_sync(fat_node_t *node)
235
{
236
    /* TODO */
237
}
238
 
239
/** Instantiate a FAT in-core node. */
240
static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
241
{
242
    fat_idx_t *idx;
243
    block_t *b;
244
    fat_dentry_t *d;
245
    fat_node_t *nodep;
246
    unsigned bps;
247
    unsigned dps;
248
 
249
    idx = fat_idx_get_by_index(dev_handle, index);
250
    if (!idx)
251
        return NULL;
252
 
253
    if (idx->nodep) {
254
        /*
255
         * We are lucky.
256
         * The node is already instantiated in memory.
257
         */
258
        if (!idx->nodep->refcnt++)
259
            list_remove(&nodep->ffn_link);
260
        return idx->nodep;
261
    }
262
 
263
    /*
264
     * We must instantiate the node from the file system.
265
     */
266
 
267
    assert(idx->pfc);
268
 
269
    if (!list_empty(&ffn_head)) {
270
        /* Try to use a cached unused node structure. */
271
        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
272
        if (nodep->dirty)
273
            fat_node_sync(nodep);
274
        list_remove(&nodep->ffn_link);
275
        nodep->idx->nodep = NULL;
276
    } else {
277
        /* Try to allocate a new node structure. */
278
        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
279
        if (!nodep)
280
            return NULL;
281
    }
282
    fat_node_initialize(nodep);
283
 
284
    bps = fat_bps_get(dev_handle);
285
    dps = bps / sizeof(fat_dentry_t);
286
 
287
    /* Read the block that contains the dentry of interest. */
288
    b = _fat_block_get(dev_handle, idx->pfc,
289
        (idx->pdi * sizeof(fat_dentry_t)) / bps);
290
    assert(b);
291
 
292
    d = ((fat_dentry_t *)b->data) + (idx->pdi % dps);
293
    if (d->attr & FAT_ATTR_SUBDIR) {
294
        /*
295
         * The only directory which does not have this bit set is the
296
         * root directory itself. The root directory node is handled
297
         * and initialized elsewhere.
298
         */
299
        nodep->type = FAT_DIRECTORY;
300
    } else {
301
        nodep->type = FAT_FILE;
302
    }
303
    nodep->firstc = uint16_t_le2host(d->firstc);
304
    nodep->size = uint32_t_le2host(d->size);
305
    nodep->lnkcnt = 1;
306
    nodep->refcnt = 1;
307
 
308
    block_put(b);
309
 
310
    /* Link the idx structure with the node structure. */
311
    nodep->idx = idx;
312
    idx->nodep = nodep;
313
 
314
    return nodep;
315
}
316
 
317
static void fat_node_put(void *node)
318
{
319
    fat_node_t *nodep = (fat_node_t *)node;
320
 
321
    if (!--nodep->refcnt) {
322
        list_append(&nodep->ffn_link, &ffn_head);
323
    }
324
}
325
 
326
static void *fat_create(int flags)
327
{
328
    return NULL;    /* not supported at the moment */
329
}
330
 
331
static int fat_destroy(void *node)
332
{
333
    return ENOTSUP; /* not supported at the moment */
334
}
335
 
336
static bool fat_link(void *prnt, void *chld, const char *name)
337
{
338
    return false;   /* not supported at the moment */
339
}
340
 
341
static int fat_unlink(void *prnt, void *chld)
342
{
343
    return ENOTSUP; /* not supported at the moment */
344
}
345
 
346
static void *fat_match(void *prnt, const char *component)
347
{
348
    fat_node_t *parentp = (fat_node_t *)prnt;
349
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
350
    unsigned i, j;
351
    unsigned bps;       /* bytes per sector */
352
    unsigned dps;       /* dentries per sector */
353
    unsigned blocks;
354
    fat_dentry_t *d;
355
    block_t *b;
356
 
357
    bps = fat_bps_get(parentp->idx->dev_handle);
358
    dps = bps / sizeof(fat_dentry_t);
359
    blocks = parentp->size / bps + (parentp->size % bps != 0);
360
    for (i = 0; i < blocks; i++) {
361
        unsigned dentries;
362
 
363
        b = fat_block_get(parentp, i);
364
        dentries = (i == blocks - 1) ?
365
            parentp->size % sizeof(fat_dentry_t) :
366
            dps;
367
        for (j = 0; j < dentries; j++) {
368
            d = ((fat_dentry_t *)b->data) + j;
369
            switch (fat_classify_dentry(d)) {
370
            case FAT_DENTRY_SKIP:
2639 jermar 371
                continue;
2925 svoboda 372
            case FAT_DENTRY_LAST:
373
                block_put(b);
374
                return NULL;
375
            default:
376
            case FAT_DENTRY_VALID:
377
                dentry_name_canonify(d, name);
378
                break;
2639 jermar 379
            }
2925 svoboda 380
            if (strcmp(name, component) == 0) {
381
                /* hit */
382
                fat_idx_t *idx = fat_idx_get_by_pos(
383
                    parentp->idx->dev_handle, parentp->firstc,
384
                    i * dps + j);
385
                if (!idx) {
386
                    /*
387
                     * Can happen if memory is low or if we
388
                     * run out of 32-bit indices.
389
                     */
390
                    block_put(b);
391
                    return NULL;
392
                }
393
                void *node = fat_node_get(idx->dev_handle,
394
                    idx->index);
395
                block_put(b);
396
                return node;
397
            }
2639 jermar 398
        }
2925 svoboda 399
        block_put(b);
2639 jermar 400
    }
2925 svoboda 401
 
402
    return NULL;
403
}
404
 
405
static fs_index_t fat_index_get(void *node)
406
{
407
    fat_node_t *fnodep = (fat_node_t *)node;
408
    if (!fnodep)
2639 jermar 409
        return 0;
2925 svoboda 410
    return fnodep->idx->index;
2638 jermar 411
}
412
 
2925 svoboda 413
static size_t fat_size_get(void *node)
2627 jermar 414
{
2925 svoboda 415
    return ((fat_node_t *)node)->size;
416
}
2627 jermar 417
 
2925 svoboda 418
static unsigned fat_lnkcnt_get(void *node)
419
{
420
    return ((fat_node_t *)node)->lnkcnt;
421
}
422
 
423
static bool fat_has_children(void *node)
424
{
425
    fat_node_t *nodep = (fat_node_t *)node;
426
    unsigned bps;
427
    unsigned dps;
428
    unsigned blocks;
429
    block_t *b;
430
    unsigned i, j;
431
 
432
    if (nodep->type != FAT_DIRECTORY)
433
        return false;
434
 
435
    bps = fat_bps_get(nodep->idx->dev_handle);
436
    dps = bps / sizeof(fat_dentry_t);
437
 
438
    blocks = nodep->size / bps + (nodep->size % bps != 0);
439
 
440
    for (i = 0; i < blocks; i++) {
441
        unsigned dentries;
442
        fat_dentry_t *d;
2627 jermar 443
 
2925 svoboda 444
        b = fat_block_get(nodep, i);
445
        dentries = (i == blocks - 1) ?
446
            nodep->size % sizeof(fat_dentry_t) :
447
            dps;
448
        for (j = 0; j < dentries; j++) {
449
            d = ((fat_dentry_t *)b->data) + j;
450
            switch (fat_classify_dentry(d)) {
451
            case FAT_DENTRY_SKIP:
452
                continue;
453
            case FAT_DENTRY_LAST:
454
                block_put(b);
455
                return false;
456
            default:
457
            case FAT_DENTRY_VALID:
458
                block_put(b);
459
                return true;
460
            }
461
            block_put(b);
462
            return true;
463
        }
464
        block_put(b);
465
    }
466
 
467
    return false;
2627 jermar 468
}
469
 
2925 svoboda 470
static void *fat_root_get(dev_handle_t dev_handle)
471
{
472
    return NULL;    /* TODO */
473
}
474
 
475
static char fat_plb_get_char(unsigned pos)
476
{
477
    return fat_reg.plb_ro[pos % PLB_SIZE];
478
}
479
 
480
static bool fat_is_directory(void *node)
481
{
482
    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
483
}
484
 
485
static bool fat_is_file(void *node)
486
{
487
    return ((fat_node_t *)node)->type == FAT_FILE;
488
}
489
 
490
/** libfs operations */
491
libfs_ops_t fat_libfs_ops = {
492
    .match = fat_match,
493
    .node_get = fat_node_get,
494
    .node_put = fat_node_put,
495
    .create = fat_create,
496
    .destroy = fat_destroy,
497
    .link = fat_link,
498
    .unlink = fat_unlink,
499
    .index_get = fat_index_get,
500
    .size_get = fat_size_get,
501
    .lnkcnt_get = fat_lnkcnt_get,
502
    .has_children = fat_has_children,
503
    .root_get = fat_root_get,
504
    .plb_get_char = fat_plb_get_char,
505
    .is_directory = fat_is_directory,
506
    .is_file = fat_is_file
507
};
508
 
509
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
510
{
511
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
512
}
513
 
2627 jermar 514
/**
515
 * @}
516
 */