Subversion Repositories HelenOS

Rev

Rev 3424 | Rev 3597 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3424 Rev 3425
Line 37... Line 37...
37
 
37
 
38
#include "fat.h"
38
#include "fat.h"
39
#include "../../vfs/vfs.h"
39
#include "../../vfs/vfs.h"
40
#include <libfs.h>
40
#include <libfs.h>
41
#include <ipc/ipc.h>
41
#include <ipc/ipc.h>
-
 
42
#include <ipc/services.h>
-
 
43
#include <ipc/devmap.h>
42
#include <async.h>
44
#include <async.h>
43
#include <errno.h>
45
#include <errno.h>
44
#include <string.h>
46
#include <string.h>
45
#include <byteorder.h>
47
#include <byteorder.h>
46
#include <libadt/hash_table.h>
48
#include <libadt/hash_table.h>
47
#include <libadt/list.h>
49
#include <libadt/list.h>
48
#include <assert.h>
50
#include <assert.h>
49
#include <futex.h>
51
#include <futex.h>
-
 
52
#include <sys/mman.h>
50
 
53
 
51
#define BS_BLOCK        0
54
#define BS_BLOCK        0
-
 
55
#define BS_SIZE         512
52
 
56
 
53
/** Futex protecting the list of cached free FAT nodes. */
57
/** Futex protecting the list of cached free FAT nodes. */
54
static futex_t ffn_futex = FUTEX_INITIALIZER;
58
static futex_t ffn_futex = FUTEX_INITIALIZER;
55
 
59
 
56
/** List of cached free FAT nodes. */
60
/** List of cached free FAT nodes. */
Line 64... Line 68...
64
#define FAT_DENTRY_UNUSED   0x00
68
#define FAT_DENTRY_UNUSED   0x00
65
#define FAT_DENTRY_E5_ESC   0x05
69
#define FAT_DENTRY_E5_ESC   0x05
66
#define FAT_DENTRY_DOT      0x2e
70
#define FAT_DENTRY_DOT      0x2e
67
#define FAT_DENTRY_ERASED   0xe5
71
#define FAT_DENTRY_ERASED   0xe5
68
 
72
 
-
 
73
#define min(a, b)       ((a) < (b) ? (a) : (b))
-
 
74
 
69
static void dentry_name_canonify(fat_dentry_t *d, char *buf)
75
static void dentry_name_canonify(fat_dentry_t *d, char *buf)
70
{
76
{
71
    int i;
77
    int i;
72
 
78
 
73
    for (i = 0; i < FAT_NAME_LEN; i++) {
79
    for (i = 0; i < FAT_NAME_LEN; i++) {
74
        if (d->name[i] == FAT_PAD) {
80
        if (d->name[i] == FAT_PAD)
75
            buf++;
-
 
76
            break;
81
            break;
77
        }
-
 
78
        if (d->name[i] == FAT_DENTRY_E5_ESC)
82
        if (d->name[i] == FAT_DENTRY_E5_ESC)
79
            *buf++ = 0xe5;
83
            *buf++ = 0xe5;
80
        else
84
        else
81
            *buf++ = d->name[i];
85
            *buf++ = d->name[i];
82
    }
86
    }
Line 90... Line 94...
90
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
94
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
91
            *buf++ = 0xe5;
95
            *buf++ = 0xe5;
92
        else
96
        else
93
            *buf++ = d->ext[i];
97
            *buf++ = d->ext[i];
94
    }
98
    }
-
 
99
    *buf = '\0';
95
}
100
}
96
 
101
 
-
 
102
static int dev_phone = -1;      /* FIXME */
-
 
103
static void *dev_buffer = NULL;     /* FIXME */
-
 
104
 
97
/* TODO move somewhere else */
105
/* TODO move somewhere else */
98
typedef struct {
106
typedef struct {
99
    void *data;
107
    void *data;
-
 
108
    size_t size;
100
} block_t;
109
} block_t;
101
 
110
 
102
static block_t *block_get(dev_handle_t dev_handle, off_t offset)
111
static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
103
{
112
{
-
 
113
    /* FIXME */
-
 
114
    block_t *b;
-
 
115
    off_t bufpos = 0;
-
 
116
    size_t buflen = 0;
-
 
117
    off_t pos = offset * bs;
-
 
118
 
-
 
119
    assert(dev_phone != -1);
-
 
120
    assert(dev_buffer);
-
 
121
 
-
 
122
    b = malloc(sizeof(block_t));
-
 
123
    if (!b)
104
    return NULL;    /* TODO */
124
        return NULL;
-
 
125
   
-
 
126
    b->data = malloc(bs);
-
 
127
    if (!b->data) {
-
 
128
        free(b);
-
 
129
        return NULL;
-
 
130
    }
-
 
131
    b->size = bs;
-
 
132
 
-
 
133
    if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,
-
 
134
        b->data, bs, bs)) {
-
 
135
        free(b->data);
-
 
136
        free(b);
-
 
137
        return NULL;
-
 
138
    }
-
 
139
 
-
 
140
    return b;
105
}
141
}
106
 
142
 
107
static void block_put(block_t *block)
143
static void block_put(block_t *block)
108
{
144
{
109
    /* TODO */
145
    /* FIXME */
-
 
146
    free(block->data);
-
 
147
    free(block);
110
}
148
}
111
 
149
 
112
#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
150
#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
113
 
151
 
114
#define FAT_CLST_RES0   0x0000
152
#define FAT_CLST_RES0   0x0000
Line 141... Line 179...
141
    unsigned ssa;       /* size of the system area */
179
    unsigned ssa;       /* size of the system area */
142
    unsigned clusters;
180
    unsigned clusters;
143
    fat_cluster_t clst = firstc;
181
    fat_cluster_t clst = firstc;
144
    unsigned i;
182
    unsigned i;
145
 
183
 
146
    bb = block_get(dev_handle, BS_BLOCK);
184
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
147
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
185
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
148
    spc = FAT_BS(bb)->spc;
186
    spc = FAT_BS(bb)->spc;
149
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
187
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
150
    fatcnt = FAT_BS(bb)->fatcnt;
188
    fatcnt = FAT_BS(bb)->fatcnt;
151
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
189
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
Line 157... Line 195...
157
    ssa = rscnt + fatcnt * sf + rds;
195
    ssa = rscnt + fatcnt * sf + rds;
158
 
196
 
159
    if (firstc == FAT_CLST_ROOT) {
197
    if (firstc == FAT_CLST_ROOT) {
160
        /* root directory special case */
198
        /* root directory special case */
161
        assert(offset < rds);
199
        assert(offset < rds);
162
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
200
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
163
        return b;
201
        return b;
164
    }
202
    }
165
 
203
 
166
    clusters = offset / spc;
204
    clusters = offset / spc;
167
    for (i = 0; i < clusters; i++) {
205
    for (i = 0; i < clusters; i++) {
Line 170... Line 208...
170
 
208
 
171
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
209
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
172
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
210
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
173
        fidx = clst % (bps / sizeof(fat_cluster_t));
211
        fidx = clst % (bps / sizeof(fat_cluster_t));
174
        /* read FAT1 */
212
        /* read FAT1 */
175
        b = block_get(dev_handle, rscnt + fsec);
213
        b = block_get(dev_handle, rscnt + fsec, bps);
176
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
214
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
177
        assert(clst != FAT_CLST_BAD);
215
        assert(clst != FAT_CLST_BAD);
178
        assert(clst < FAT_CLST_LAST1);
216
        assert(clst < FAT_CLST_LAST1);
179
        block_put(b);
217
        block_put(b);
180
    }
218
    }
181
 
219
 
182
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
220
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
183
        offset % spc);
221
        offset % spc, bps);
184
 
222
 
185
    return b;
223
    return b;
186
}
224
}
187
 
225
 
-
 
226
/** Return number of blocks allocated to a file.
-
 
227
 *
-
 
228
 * @param dev_handle    Device handle of the device with the file.
-
 
229
 * @param firstc    First cluster of the file.
-
 
230
 *
-
 
231
 * @return      Number of blocks allocated to the file.
-
 
232
 */
-
 
233
static uint16_t
-
 
234
_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
-
 
235
{
-
 
236
    block_t *bb;
-
 
237
    block_t *b;
-
 
238
    unsigned bps;
-
 
239
    unsigned spc;
-
 
240
    unsigned rscnt;     /* block address of the first FAT */
-
 
241
    unsigned clusters = 0;
-
 
242
    fat_cluster_t clst = firstc;
-
 
243
 
-
 
244
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-
 
245
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-
 
246
    spc = FAT_BS(bb)->spc;
-
 
247
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-
 
248
    block_put(bb);
-
 
249
 
-
 
250
    if (firstc == FAT_CLST_RES0) {
-
 
251
        /* No space allocated to the file. */
-
 
252
        return 0;
-
 
253
    }
-
 
254
 
-
 
255
    while (clst < FAT_CLST_LAST1) {
-
 
256
        unsigned fsec;  /* sector offset relative to FAT1 */
-
 
257
        unsigned fidx;  /* FAT1 entry index */
-
 
258
 
-
 
259
        assert(clst >= FAT_CLST_FIRST);
-
 
260
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
-
 
261
        fidx = clst % (bps / sizeof(fat_cluster_t));
-
 
262
        /* read FAT1 */
-
 
263
        b = block_get(dev_handle, rscnt + fsec, bps);
-
 
264
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-
 
265
        assert(clst != FAT_CLST_BAD);
-
 
266
        block_put(b);
-
 
267
        clusters++;
-
 
268
    }
-
 
269
 
-
 
270
    return clusters * spc;
-
 
271
}
-
 
272
 
188
static void fat_node_initialize(fat_node_t *node)
273
static void fat_node_initialize(fat_node_t *node)
189
{
274
{
190
    futex_initialize(&node->lock, 1);
275
    futex_initialize(&node->lock, 1);
191
    node->idx = NULL;
276
    node->idx = NULL;
192
    node->type = 0;
277
    node->type = 0;
Line 200... Line 285...
200
static uint16_t fat_bps_get(dev_handle_t dev_handle)
285
static uint16_t fat_bps_get(dev_handle_t dev_handle)
201
{
286
{
202
    block_t *bb;
287
    block_t *bb;
203
    uint16_t bps;
288
    uint16_t bps;
204
   
289
   
205
    bb = block_get(dev_handle, BS_BLOCK);
290
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
206
    assert(bb != NULL);
291
    assert(bb != NULL);
207
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
292
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
208
    block_put(bb);
293
    block_put(bb);
209
 
294
 
210
    return bps;
295
    return bps;
Line 251... Line 336...
251
 */
336
 */
252
static void *fat_node_get_core(fat_idx_t *idxp)
337
static void *fat_node_get_core(fat_idx_t *idxp)
253
{
338
{
254
    block_t *b;
339
    block_t *b;
255
    fat_dentry_t *d;
340
    fat_dentry_t *d;
256
    fat_node_t *nodep;
341
    fat_node_t *nodep = NULL;
257
    unsigned bps;
342
    unsigned bps;
258
    unsigned dps;
343
    unsigned dps;
259
 
344
 
260
    if (idxp->nodep) {
345
    if (idxp->nodep) {
261
        /*
346
        /*
262
         * We are lucky.
347
         * We are lucky.
263
         * The node is already instantiated in memory.
348
         * The node is already instantiated in memory.
264
         */
349
         */
265
        futex_down(&idxp->nodep->lock);
350
        futex_down(&idxp->nodep->lock);
266
        if (!idxp->nodep->refcnt++)
351
        if (!idxp->nodep->refcnt++)
267
            list_remove(&nodep->ffn_link);
352
            list_remove(&idxp->nodep->ffn_link);
268
        futex_up(&idxp->nodep->lock);
353
        futex_up(&idxp->nodep->lock);
269
        return idxp->nodep;
354
        return idxp->nodep;
270
    }
355
    }
271
 
356
 
272
    /*
357
    /*
Line 318... Line 403...
318
         * The only directory which does not have this bit set is the
403
         * The only directory which does not have this bit set is the
319
         * root directory itself. The root directory node is handled
404
         * root directory itself. The root directory node is handled
320
         * and initialized elsewhere.
405
         * and initialized elsewhere.
321
         */
406
         */
322
        nodep->type = FAT_DIRECTORY;
407
        nodep->type = FAT_DIRECTORY;
-
 
408
        /*
-
 
409
         * Unfortunately, the 'size' field of the FAT dentry is not
-
 
410
         * defined for the directory entry type. We must determine the
-
 
411
         * size of the directory by walking the FAT.
-
 
412
         */
-
 
413
        nodep->size = bps * _fat_blcks_get(idxp->dev_handle,
-
 
414
            uint16_t_le2host(d->firstc));
323
    } else {
415
    } else {
324
        nodep->type = FAT_FILE;
416
        nodep->type = FAT_FILE;
-
 
417
        nodep->size = uint32_t_le2host(d->size);
325
    }
418
    }
326
    nodep->firstc = uint16_t_le2host(d->firstc);
419
    nodep->firstc = uint16_t_le2host(d->firstc);
327
    nodep->size = uint32_t_le2host(d->size);
-
 
328
    nodep->lnkcnt = 1;
420
    nodep->lnkcnt = 1;
329
    nodep->refcnt = 1;
421
    nodep->refcnt = 1;
330
 
422
 
331
    block_put(b);
423
    block_put(b);
332
 
424
 
Line 419... Line 511...
419
            default:
511
            default:
420
            case FAT_DENTRY_VALID:
512
            case FAT_DENTRY_VALID:
421
                dentry_name_canonify(d, name);
513
                dentry_name_canonify(d, name);
422
                break;
514
                break;
423
            }
515
            }
424
            if (strcmp(name, component) == 0) {
516
            if (stricmp(name, component) == 0) {
425
                /* hit */
517
                /* hit */
426
                void *node;
518
                void *node;
427
                /*
519
                /*
428
                 * Assume tree hierarchy for locking.  We
520
                 * Assume tree hierarchy for locking.  We
429
                 * already have the parent and now we are going
521
                 * already have the parent and now we are going
Line 565... Line 657...
565
 
657
 
566
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
658
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
567
{
659
{
568
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
660
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
569
    block_t *bb;
661
    block_t *bb;
-
 
662
    uint16_t bps;
570
    uint16_t rde;
663
    uint16_t rde;
571
    int rc;
664
    int rc;
572
 
665
 
-
 
666
    /*
-
 
667
     * For now, we don't bother to remember dev_handle, dev_phone or
-
 
668
     * dev_buffer in some data structure. We use global variables because we
-
 
669
     * know there will be at most one mount on this file system.
-
 
670
     * Of course, this is a huge TODO item.
-
 
671
     */
-
 
672
    dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE,
-
 
673
        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-
 
674
   
-
 
675
    if (!dev_buffer) {
-
 
676
        ipc_answer_0(rid, ENOMEM);
-
 
677
        return;
-
 
678
    }
-
 
679
 
-
 
680
    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-
 
681
        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
-
 
682
 
-
 
683
    if (dev_phone < 0) {
-
 
684
        munmap(dev_buffer, BS_SIZE);
-
 
685
        ipc_answer_0(rid, dev_phone);
-
 
686
        return;
-
 
687
    }
-
 
688
 
-
 
689
    rc = ipc_share_out_start(dev_phone, dev_buffer,
-
 
690
        AS_AREA_READ | AS_AREA_WRITE);
-
 
691
    if (rc != EOK) {
-
 
692
            munmap(dev_buffer, BS_SIZE);
-
 
693
        ipc_answer_0(rid, rc);
-
 
694
        return;
-
 
695
    }
-
 
696
 
573
    /* Read the number of root directory entries. */
697
    /* Read the number of root directory entries. */
574
    bb = block_get(dev_handle, BS_BLOCK);
698
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-
 
699
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
575
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
700
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
576
    block_put(bb);
701
    block_put(bb);
577
 
702
 
-
 
703
    if (bps != BS_SIZE) {
-
 
704
        munmap(dev_buffer, BS_SIZE);
-
 
705
        ipc_answer_0(rid, ENOTSUP);
-
 
706
        return;
-
 
707
    }
-
 
708
 
578
    rc = fat_idx_init_by_dev_handle(dev_handle);
709
    rc = fat_idx_init_by_dev_handle(dev_handle);
579
    if (rc != EOK) {
710
    if (rc != EOK) {
-
 
711
            munmap(dev_buffer, BS_SIZE);
580
        ipc_answer_0(rid, rc);
712
        ipc_answer_0(rid, rc);
581
        return;
713
        return;
582
    }
714
    }
583
 
715
 
584
    /* Initialize the root node. */
716
    /* Initialize the root node. */
585
    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
717
    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
586
    if (!rootp) {
718
    if (!rootp) {
-
 
719
            munmap(dev_buffer, BS_SIZE);
587
        fat_idx_fini_by_dev_handle(dev_handle);
720
        fat_idx_fini_by_dev_handle(dev_handle);
588
        ipc_answer_0(rid, ENOMEM);
721
        ipc_answer_0(rid, ENOMEM);
589
        return;
722
        return;
590
    }
723
    }
591
    fat_node_initialize(rootp);
724
    fat_node_initialize(rootp);
592
 
725
 
593
    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
726
    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
594
    if (!ridxp) {
727
    if (!ridxp) {
-
 
728
            munmap(dev_buffer, BS_SIZE);
595
        free(rootp);
729
        free(rootp);
596
        fat_idx_fini_by_dev_handle(dev_handle);
730
        fat_idx_fini_by_dev_handle(dev_handle);
597
        ipc_answer_0(rid, ENOMEM);
731
        ipc_answer_0(rid, ENOMEM);
598
        return;
732
        return;
599
    }
733
    }
Line 601... Line 735...
601
    /* ridxp->lock held */
735
    /* ridxp->lock held */
602
 
736
 
603
    rootp->type = FAT_DIRECTORY;
737
    rootp->type = FAT_DIRECTORY;
604
    rootp->firstc = FAT_CLST_ROOT;
738
    rootp->firstc = FAT_CLST_ROOT;
605
    rootp->refcnt = 1;
739
    rootp->refcnt = 1;
-
 
740
    rootp->lnkcnt = 0;  /* FS root is not linked */
606
    rootp->size = rde * sizeof(fat_dentry_t);
741
    rootp->size = rde * sizeof(fat_dentry_t);
607
    rootp->idx = ridxp;
742
    rootp->idx = ridxp;
608
    ridxp->nodep = rootp;
743
    ridxp->nodep = rootp;
609
   
744
   
610
    futex_up(&ridxp->lock);
745
    futex_up(&ridxp->lock);
611
 
746
 
612
    ipc_answer_0(rid, EOK);
747
    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
613
}
748
}
614
 
749
 
615
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
750
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
616
{
751
{
617
    ipc_answer_0(rid, ENOTSUP);
752
    ipc_answer_0(rid, ENOTSUP);
Line 620... Line 755...
620
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
755
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
621
{
756
{
622
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
757
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
623
}
758
}
624
 
759
 
-
 
760
void fat_read(ipc_callid_t rid, ipc_call_t *request)
-
 
761
{
-
 
762
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-
 
763
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-
 
764
    off_t pos = (off_t)IPC_GET_ARG3(*request);
-
 
765
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
-
 
766
    uint16_t bps = fat_bps_get(dev_handle);
-
 
767
    size_t bytes;
-
 
768
    block_t *b;
-
 
769
 
-
 
770
    if (!nodep) {
-
 
771
        ipc_answer_0(rid, ENOENT);
-
 
772
        return;
-
 
773
    }
-
 
774
 
-
 
775
    ipc_callid_t callid;
-
 
776
    size_t len;
-
 
777
    if (!ipc_data_read_receive(&callid, &len)) {
-
 
778
        fat_node_put(nodep);
-
 
779
        ipc_answer_0(callid, EINVAL);
-
 
780
        ipc_answer_0(rid, EINVAL);
-
 
781
        return;
-
 
782
    }
-
 
783
 
-
 
784
    if (nodep->type == FAT_FILE) {
-
 
785
        /*
-
 
786
         * Our strategy for regular file reads is to read one block at
-
 
787
         * most and make use of the possibility to return less data than
-
 
788
         * requested. This keeps the code very simple.
-
 
789
         */
-
 
790
        bytes = min(len, bps - pos % bps);
-
 
791
        b = fat_block_get(nodep, pos / bps);
-
 
792
        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
-
 
793
            bytes);
-
 
794
        block_put(b);
-
 
795
    } else {
-
 
796
        unsigned bnum;
-
 
797
        off_t spos = pos;
-
 
798
        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
-
 
799
        fat_dentry_t *d;
-
 
800
 
-
 
801
        assert(nodep->type == FAT_DIRECTORY);
-
 
802
        assert(nodep->size % bps == 0);
-
 
803
        assert(bps % sizeof(fat_dentry_t) == 0);
-
 
804
 
-
 
805
        /*
-
 
806
         * Our strategy for readdir() is to use the position pointer as
-
 
807
         * an index into the array of all dentries. On entry, it points
-
 
808
         * to the first unread dentry. If we skip any dentries, we bump
-
 
809
         * the position pointer accordingly.
-
 
810
         */
-
 
811
        bnum = (pos * sizeof(fat_dentry_t)) / bps;
-
 
812
        while (bnum < nodep->size / bps) {
-
 
813
            off_t o;
-
 
814
 
-
 
815
            b = fat_block_get(nodep, bnum);
-
 
816
            for (o = pos % (bps / sizeof(fat_dentry_t));
-
 
817
                o < bps / sizeof(fat_dentry_t);
-
 
818
                o++, pos++) {
-
 
819
                d = ((fat_dentry_t *)b->data) + o;
-
 
820
                switch (fat_classify_dentry(d)) {
-
 
821
                case FAT_DENTRY_SKIP:
-
 
822
                    continue;
-
 
823
                case FAT_DENTRY_LAST:
-
 
824
                    block_put(b);
-
 
825
                    goto miss;
-
 
826
                default:
-
 
827
                case FAT_DENTRY_VALID:
-
 
828
                    dentry_name_canonify(d, name);
-
 
829
                    block_put(b);
-
 
830
                    goto hit;
-
 
831
                }
-
 
832
            }
-
 
833
            block_put(b);
-
 
834
            bnum++;
-
 
835
        }
-
 
836
miss:
-
 
837
        fat_node_put(nodep);
-
 
838
        ipc_answer_0(callid, ENOENT);
-
 
839
        ipc_answer_1(rid, ENOENT, 0);
-
 
840
        return;
-
 
841
hit:
-
 
842
        (void) ipc_data_read_finalize(callid, name, strlen(name) + 1);
-
 
843
        bytes = (pos - spos) + 1;
-
 
844
    }
-
 
845
 
-
 
846
    fat_node_put(nodep);
-
 
847
    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
-
 
848
}
-
 
849
 
625
/**
850
/**
626
 * @}
851
 * @}
627
 */
852
 */