Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2627 jermar 1
/*
2793 jermar 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"
2793 jermar 40
#include <libfs.h>
2627 jermar 41
#include <ipc/ipc.h>
42
#include <async.h>
43
#include <errno.h>
2793 jermar 44
#include <string.h>
2798 jermar 45
#include <byteorder.h>
2831 jermar 46
#include <libadt/hash_table.h>
47
#include <libadt/list.h>
48
#include <assert.h>
2856 jermar 49
#include <futex.h>
2627 jermar 50
 
2843 jermar 51
#define BS_BLOCK        0
52
 
2951 jermar 53
/** Futex protecting the list of cached free FAT nodes. */
54
static futex_t ffn_futex = FUTEX_INITIALIZER;
2843 jermar 55
 
2951 jermar 56
/** List of cached free FAT nodes. */
57
static LIST_INITIALIZE(ffn_head);
58
 
2638 jermar 59
#define FAT_NAME_LEN        8
60
#define FAT_EXT_LEN     3
61
 
62
#define FAT_PAD         ' ' 
63
 
64
#define FAT_DENTRY_UNUSED   0x00
65
#define FAT_DENTRY_E5_ESC   0x05
66
#define FAT_DENTRY_DOT      0x2e
67
#define FAT_DENTRY_ERASED   0xe5
68
 
2793 jermar 69
static void dentry_name_canonify(fat_dentry_t *d, char *buf)
2638 jermar 70
{
2793 jermar 71
    int i;
2639 jermar 72
 
2793 jermar 73
    for (i = 0; i < FAT_NAME_LEN; i++) {
74
        if (d->name[i] == FAT_PAD) {
75
            buf++;
76
            break;
2639 jermar 77
        }
2793 jermar 78
        if (d->name[i] == FAT_DENTRY_E5_ESC)
79
            *buf++ = 0xe5;
80
        else
81
            *buf++ = d->name[i];
82
    }
83
    if (d->ext[0] != FAT_PAD)
84
        *buf++ = '.';
85
    for (i = 0; i < FAT_EXT_LEN; i++) {
86
        if (d->ext[i] == FAT_PAD) {
87
            *buf = '\0';
88
            return;
89
        }
90
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
91
            *buf++ = 0xe5;
92
        else
93
            *buf++ = d->ext[i];
94
    }
95
}
96
 
2910 jermar 97
/* TODO move somewhere else */
2822 jermar 98
typedef struct {
99
    void *data;
100
} block_t;
101
 
102
static block_t *block_get(dev_handle_t dev_handle, off_t offset)
2793 jermar 103
{
104
    return NULL;    /* TODO */
105
}
106
 
2822 jermar 107
static void block_put(block_t *block)
2793 jermar 108
{
109
    /* TODO */
110
}
111
 
2859 jermar 112
#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
113
 
2864 jermar 114
#define FAT_CLST_RES0   0x0000
115
#define FAT_CLST_RES1   0x0001  /* internally used to mark root directory */
2859 jermar 116
#define FAT_CLST_FIRST  0x0002
117
#define FAT_CLST_BAD    0xfff7
118
#define FAT_CLST_LAST1  0xfff8
119
#define FAT_CLST_LAST8  0xffff
120
 
2891 jermar 121
#define fat_block_get(np, off) \
122
    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
123
 
124
static block_t *
2893 jermar 125
_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
2859 jermar 126
{
127
    block_t *bb;
128
    block_t *b;
129
    unsigned bps;
130
    unsigned spc;
131
    unsigned rscnt;     /* block address of the first FAT */
132
    unsigned fatcnt;
133
    unsigned rde;
134
    unsigned rds;       /* root directory size */
135
    unsigned sf;
136
    unsigned ssa;       /* size of the system area */
137
    unsigned clusters;
2893 jermar 138
    fat_cluster_t clst = firstc;
2859 jermar 139
    unsigned i;
140
 
2891 jermar 141
    bb = block_get(dev_handle, BS_BLOCK);
2859 jermar 142
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
143
    spc = FAT_BS(bb)->spc;
144
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
145
    fatcnt = FAT_BS(bb)->fatcnt;
146
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
147
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
148
    block_put(bb);
149
 
150
    rds = (sizeof(fat_dentry_t) * rde) / bps;
151
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
152
    ssa = rscnt + fatcnt * sf + rds;
153
 
2893 jermar 154
    if (firstc == FAT_CLST_RES1) {
2859 jermar 155
        /* root directory special case */
156
        assert(offset < rds);
2891 jermar 157
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
2859 jermar 158
        return b;
159
    }
160
 
161
    clusters = offset / spc;
162
    for (i = 0; i < clusters; i++) {
163
        unsigned fsec;  /* sector offset relative to FAT1 */
164
        unsigned fidx;  /* FAT1 entry index */
165
 
166
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
2864 jermar 167
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
168
        fidx = clst % (bps / sizeof(fat_cluster_t));
2859 jermar 169
        /* read FAT1 */
2891 jermar 170
        b = block_get(dev_handle, rscnt + fsec);
2864 jermar 171
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
2859 jermar 172
        assert(clst != FAT_CLST_BAD);
173
        assert(clst < FAT_CLST_LAST1);
174
        block_put(b);
175
    }
176
 
2891 jermar 177
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
178
        offset % spc);
2859 jermar 179
 
180
    return b;
181
}
182
 
2831 jermar 183
static void fat_node_initialize(fat_node_t *node)
2793 jermar 184
{
2951 jermar 185
    futex_initialize(&node->lock, 1);
2864 jermar 186
    node->idx = NULL;
2831 jermar 187
    node->type = 0;
188
    link_initialize(&node->ffn_link);
189
    node->size = 0;
190
    node->lnkcnt = 0;
191
    node->refcnt = 0;
192
    node->dirty = false;
2793 jermar 193
}
194
 
2843 jermar 195
static uint16_t fat_bps_get(dev_handle_t dev_handle)
196
{
197
    block_t *bb;
198
    uint16_t bps;
199
 
200
    bb = block_get(dev_handle, BS_BLOCK);
201
    assert(bb != NULL);
2859 jermar 202
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
2843 jermar 203
    block_put(bb);
204
 
205
    return bps;
206
}
207
 
2845 jermar 208
typedef enum {
209
    FAT_DENTRY_SKIP,
210
    FAT_DENTRY_LAST,
211
    FAT_DENTRY_VALID
212
} fat_dentry_clsf_t;
213
 
214
static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)
215
{
216
    if (d->attr & FAT_ATTR_VOLLABEL) {
217
        /* volume label entry */
218
        return FAT_DENTRY_SKIP;
219
    }
220
    if (d->name[0] == FAT_DENTRY_ERASED) {
221
        /* not-currently-used entry */
222
        return FAT_DENTRY_SKIP;
223
    }
224
    if (d->name[0] == FAT_DENTRY_UNUSED) {
225
        /* never used entry */
226
        return FAT_DENTRY_LAST;
227
    }
228
    if (d->name[0] == FAT_DENTRY_DOT) {
229
        /*
230
         * Most likely '.' or '..'.
231
         * It cannot occur in a regular file name.
232
         */
233
        return FAT_DENTRY_SKIP;
234
    }
235
    return FAT_DENTRY_VALID;
236
}
237
 
2893 jermar 238
static void fat_node_sync(fat_node_t *node)
2831 jermar 239
{
240
    /* TODO */
241
}
242
 
2951 jermar 243
/** Internal version of fat_node_get().
244
 *
245
 * @param idxp      Locked index structure.
246
 */
247
static void *fat_node_get_core(fat_idx_t *idxp)
2831 jermar 248
{
2891 jermar 249
    block_t *b;
250
    fat_dentry_t *d;
251
    fat_node_t *nodep;
252
    unsigned bps;
253
    unsigned dps;
254
 
2951 jermar 255
    if (idxp->nodep) {
2891 jermar 256
        /*
257
         * We are lucky.
258
         * The node is already instantiated in memory.
259
         */
2951 jermar 260
        futex_down(&idxp->nodep->lock);
261
        if (!idxp->nodep->refcnt++)
2910 jermar 262
            list_remove(&nodep->ffn_link);
2951 jermar 263
        futex_up(&idxp->nodep->lock);
264
        return idxp->nodep;
2891 jermar 265
    }
266
 
267
    /*
268
     * We must instantiate the node from the file system.
269
     */
270
 
2951 jermar 271
    assert(idxp->pfc);
2891 jermar 272
 
2951 jermar 273
    futex_down(&ffn_futex);
2893 jermar 274
    if (!list_empty(&ffn_head)) {
2951 jermar 275
        /* Try to use a cached free node structure. */
276
        fat_idx_t *idxp_tmp;
2893 jermar 277
        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
2951 jermar 278
        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
279
            goto skip_cache;
280
        idxp_tmp = nodep->idx;
281
        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
282
            futex_up(&nodep->lock);
283
            goto skip_cache;
284
        }
285
        list_remove(&nodep->ffn_link);
286
        futex_up(&ffn_futex);
2893 jermar 287
        if (nodep->dirty)
288
            fat_node_sync(nodep);
2951 jermar 289
        idxp_tmp->nodep = NULL;
290
        futex_up(&nodep->lock);
291
        futex_up(&idxp_tmp->lock);
2893 jermar 292
    } else {
2951 jermar 293
skip_cache:
2893 jermar 294
        /* Try to allocate a new node structure. */
2951 jermar 295
        futex_up(&ffn_futex);
2893 jermar 296
        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
297
        if (!nodep)
298
            return NULL;
299
    }
2891 jermar 300
    fat_node_initialize(nodep);
301
 
2951 jermar 302
    bps = fat_bps_get(idxp->dev_handle);
2891 jermar 303
    dps = bps / sizeof(fat_dentry_t);
304
 
2893 jermar 305
    /* Read the block that contains the dentry of interest. */
2951 jermar 306
    b = _fat_block_get(idxp->dev_handle, idxp->pfc,
307
        (idxp->pdi * sizeof(fat_dentry_t)) / bps);
2891 jermar 308
    assert(b);
309
 
2951 jermar 310
    d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
2893 jermar 311
    if (d->attr & FAT_ATTR_SUBDIR) {
312
        /*
313
         * The only directory which does not have this bit set is the
314
         * root directory itself. The root directory node is handled
315
         * and initialized elsewhere.
316
         */
317
        nodep->type = FAT_DIRECTORY;
318
    } else {
319
        nodep->type = FAT_FILE;
320
    }
321
    nodep->firstc = uint16_t_le2host(d->firstc);
322
    nodep->size = uint32_t_le2host(d->size);
323
    nodep->lnkcnt = 1;
324
    nodep->refcnt = 1;
325
 
326
    block_put(b);
327
 
328
    /* Link the idx structure with the node structure. */
2951 jermar 329
    nodep->idx = idxp;
330
    idxp->nodep = nodep;
2893 jermar 331
 
332
    return nodep;
2831 jermar 333
}
334
 
2951 jermar 335
/** Instantiate a FAT in-core node. */
336
static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
337
{
338
    void *node;
339
    fat_idx_t *idxp;
340
 
341
    idxp = fat_idx_get_by_index(dev_handle, index);
342
    if (!idxp)
343
        return NULL;
344
    /* idxp->lock held */
345
    node = fat_node_get_core(idxp);
346
    futex_up(&idxp->lock);
347
    return node;
348
}
349
 
2852 jermar 350
static void fat_node_put(void *node)
351
{
2910 jermar 352
    fat_node_t *nodep = (fat_node_t *)node;
353
 
2951 jermar 354
    futex_down(&nodep->lock);
2910 jermar 355
    if (!--nodep->refcnt) {
2951 jermar 356
        futex_down(&ffn_futex);
2910 jermar 357
        list_append(&nodep->ffn_link, &ffn_head);
2951 jermar 358
        futex_up(&ffn_futex);
2910 jermar 359
    }
2951 jermar 360
    futex_up(&nodep->lock);
2852 jermar 361
}
362
 
2857 jermar 363
static void *fat_create(int flags)
364
{
365
    return NULL;    /* not supported at the moment */
366
}
367
 
2858 jermar 368
static int fat_destroy(void *node)
2857 jermar 369
{
2858 jermar 370
    return ENOTSUP; /* not supported at the moment */
2857 jermar 371
}
372
 
373
static bool fat_link(void *prnt, void *chld, const char *name)
374
{
375
    return false;   /* not supported at the moment */
376
}
377
 
378
static int fat_unlink(void *prnt, void *chld)
379
{
380
    return ENOTSUP; /* not supported at the moment */
381
}
382
 
2793 jermar 383
static void *fat_match(void *prnt, const char *component)
384
{
385
    fat_node_t *parentp = (fat_node_t *)prnt;
386
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
2822 jermar 387
    unsigned i, j;
2828 jermar 388
    unsigned bps;       /* bytes per sector */
2822 jermar 389
    unsigned dps;       /* dentries per sector */
390
    unsigned blocks;
2793 jermar 391
    fat_dentry_t *d;
2822 jermar 392
    block_t *b;
2793 jermar 393
 
2953 jermar 394
    futex_down(&parentp->idx->lock);
2864 jermar 395
    bps = fat_bps_get(parentp->idx->dev_handle);
2828 jermar 396
    dps = bps / sizeof(fat_dentry_t);
397
    blocks = parentp->size / bps + (parentp->size % bps != 0);
2822 jermar 398
    for (i = 0; i < blocks; i++) {
399
        unsigned dentries;
2793 jermar 400
 
2864 jermar 401
        b = fat_block_get(parentp, i);
2822 jermar 402
        dentries = (i == blocks - 1) ?
403
            parentp->size % sizeof(fat_dentry_t) :
404
            dps;
405
        for (j = 0; j < dentries; j++) {
406
            d = ((fat_dentry_t *)b->data) + j;
2845 jermar 407
            switch (fat_classify_dentry(d)) {
408
            case FAT_DENTRY_SKIP:
2822 jermar 409
                continue;
2845 jermar 410
            case FAT_DENTRY_LAST:
2822 jermar 411
                block_put(b);
2953 jermar 412
                futex_up(&parentp->idx->lock);
2822 jermar 413
                return NULL;
2845 jermar 414
            default:
415
            case FAT_DENTRY_VALID:
416
                dentry_name_canonify(d, name);
417
                break;
2822 jermar 418
            }
419
            if (strcmp(name, component) == 0) {
420
                /* hit */
2951 jermar 421
                void *node;
2953 jermar 422
                /*
423
                 * Assume tree hierarchy for locking.  We
424
                 * already have the parent and now we are going
425
                 * to lock the child.  Never lock in the oposite
426
                 * order.
427
                 */
2890 jermar 428
                fat_idx_t *idx = fat_idx_get_by_pos(
2881 jermar 429
                    parentp->idx->dev_handle, parentp->firstc,
2864 jermar 430
                    i * dps + j);
2953 jermar 431
                futex_up(&parentp->idx->lock);
2890 jermar 432
                if (!idx) {
433
                    /*
434
                     * Can happen if memory is low or if we
435
                     * run out of 32-bit indices.
436
                     */
437
                    block_put(b);
438
                    return NULL;
439
                }
2951 jermar 440
                node = fat_node_get_core(idx);
441
                futex_up(&idx->lock);
2822 jermar 442
                block_put(b);
443
                return node;
444
            }
2793 jermar 445
        }
2822 jermar 446
        block_put(b);
2639 jermar 447
    }
2953 jermar 448
    futex_up(&parentp->idx->lock);
2793 jermar 449
    return NULL;
2638 jermar 450
}
451
 
2831 jermar 452
static fs_index_t fat_index_get(void *node)
453
{
454
    fat_node_t *fnodep = (fat_node_t *)node;
455
    if (!fnodep)
456
        return 0;
2864 jermar 457
    return fnodep->idx->index;
2831 jermar 458
}
459
 
460
static size_t fat_size_get(void *node)
461
{
462
    return ((fat_node_t *)node)->size;
463
}
464
 
465
static unsigned fat_lnkcnt_get(void *node)
466
{
467
    return ((fat_node_t *)node)->lnkcnt;
468
}
469
 
2845 jermar 470
static bool fat_has_children(void *node)
471
{
472
    fat_node_t *nodep = (fat_node_t *)node;
473
    unsigned bps;
474
    unsigned dps;
475
    unsigned blocks;
476
    block_t *b;
477
    unsigned i, j;
478
 
479
    if (nodep->type != FAT_DIRECTORY)
480
        return false;
481
 
2951 jermar 482
    futex_down(&nodep->idx->lock);
2864 jermar 483
    bps = fat_bps_get(nodep->idx->dev_handle);
2845 jermar 484
    dps = bps / sizeof(fat_dentry_t);
485
 
486
    blocks = nodep->size / bps + (nodep->size % bps != 0);
487
 
488
    for (i = 0; i < blocks; i++) {
489
        unsigned dentries;
490
        fat_dentry_t *d;
491
 
2864 jermar 492
        b = fat_block_get(nodep, i);
2845 jermar 493
        dentries = (i == blocks - 1) ?
494
            nodep->size % sizeof(fat_dentry_t) :
495
            dps;
496
        for (j = 0; j < dentries; j++) {
497
            d = ((fat_dentry_t *)b->data) + j;
498
            switch (fat_classify_dentry(d)) {
499
            case FAT_DENTRY_SKIP:
500
                continue;
501
            case FAT_DENTRY_LAST:
502
                block_put(b);
2951 jermar 503
                futex_up(&nodep->idx->lock);
2845 jermar 504
                return false;
505
            default:
506
            case FAT_DENTRY_VALID:
507
                block_put(b);
2951 jermar 508
                futex_up(&nodep->idx->lock);
2845 jermar 509
                return true;
510
            }
511
            block_put(b);
2951 jermar 512
            futex_up(&nodep->idx->lock);
2845 jermar 513
            return true;
514
        }
515
        block_put(b);
516
    }
517
 
2951 jermar 518
    futex_up(&nodep->idx->lock);
2845 jermar 519
    return false;
520
}
521
 
2844 jermar 522
static void *fat_root_get(dev_handle_t dev_handle)
523
{
2893 jermar 524
    return NULL;    /* TODO */
2844 jermar 525
}
526
 
527
static char fat_plb_get_char(unsigned pos)
528
{
529
    return fat_reg.plb_ro[pos % PLB_SIZE];
530
}
531
 
2831 jermar 532
static bool fat_is_directory(void *node)
533
{
534
    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
535
}
536
 
537
static bool fat_is_file(void *node)
538
{
539
    return ((fat_node_t *)node)->type == FAT_FILE;
540
}
541
 
2793 jermar 542
/** libfs operations */
543
libfs_ops_t fat_libfs_ops = {
544
    .match = fat_match,
545
    .node_get = fat_node_get,
2852 jermar 546
    .node_put = fat_node_put,
2857 jermar 547
    .create = fat_create,
548
    .destroy = fat_destroy,
549
    .link = fat_link,
550
    .unlink = fat_unlink,
2831 jermar 551
    .index_get = fat_index_get,
552
    .size_get = fat_size_get,
553
    .lnkcnt_get = fat_lnkcnt_get,
2845 jermar 554
    .has_children = fat_has_children,
2844 jermar 555
    .root_get = fat_root_get,
556
    .plb_get_char = fat_plb_get_char,
2831 jermar 557
    .is_directory = fat_is_directory,
558
    .is_file = fat_is_file
2793 jermar 559
};
560
 
3110 jermar 561
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
562
{
563
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
564
    int rc;
565
 
566
    rc = fat_idx_init_by_dev_handle(dev_handle);
567
    if (rc != EOK) {
568
        ipc_answer_0(rid, rc);
569
        return;
570
    }
571
 
572
    ipc_answer_0(rid, EOK);
573
}
574
 
575
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
576
{
577
    ipc_answer_0(rid, ENOTSUP);
578
}
579
 
2627 jermar 580
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
581
{
2793 jermar 582
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
2627 jermar 583
}
584
 
585
/**
586
 * @}
587
 */