Subversion Repositories HelenOS

Rev

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

Rev 3551 Rev 3571
Line 57... Line 57...
57 
/** Walk the cluster chain.
 57 
/** Walk the cluster chain.
58 
 *
 58 
 *
59 
 * @param bs        Buffer holding the boot sector for the file.
 59 
 * @param bs        Buffer holding the boot sector for the file.
60 
 * @param dev_handle    Device handle of the device with the file.
 60 
 * @param dev_handle    Device handle of the device with the file.
61 
 * @param firstc    First cluster to start the walk with.
 61 
 * @param firstc    First cluster to start the walk with.
62 
 * @param penult    If non-NULL, output argument hodling the
 62 
 * @param lastc     If non-NULL, output argument hodling the last cluster number visited.
63 
 *          the penultimate cluster visited.
 - 
 
64 
 * @param ult       If non-NULL, output argument holding the
 - 
 
65 
 *          ultimate cluster visited.
 - 
 
66 
 * @param max_clusters  Maximum number of clusters to visit.   
 63 
 * @param max_clusters  Maximum number of clusters to visit.   
67 
 *
 64 
 *
68 
 * @return      Number of clusters seen during the walk.
 65 
 * @return      Number of clusters seen during the walk.
69 
 */
 66 
 */
70 
uint16_t
 67 
uint16_t
71 
fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
 68 
fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
72 
    fat_cluster_t *penult, fat_cluster_t *ult, uint16_t max_clusters)
 69 
    fat_cluster_t *lastc, uint16_t max_clusters)
73 
{
 70 
{
74 
    block_t *b;
 71 
    block_t *b;
75 
    unsigned bps;
 72 
    unsigned bps;
76 
    unsigned rscnt;     /* block address of the first FAT */
 73 
    unsigned rscnt;     /* block address of the first FAT */
77 
    uint16_t clusters = 0;
 74 
    uint16_t clusters = 0;
Line 80... Line 77...
80 
    bps = uint16_t_le2host(bs->bps);
 77 
    bps = uint16_t_le2host(bs->bps);
81 
    rscnt = uint16_t_le2host(bs->rscnt);
 78 
    rscnt = uint16_t_le2host(bs->rscnt);
82 
 
 79 
 
83 
    if (firstc == FAT_CLST_RES0) {
 80 
    if (firstc == FAT_CLST_RES0) {
84 
        /* No space allocated to the file. */
 81 
        /* No space allocated to the file. */
85 
        if (ult)
 82 
        if (lastc)
86 
            *ult = firstc;
 83 
            *lastc = firstc;
87 
        return 0;
 84 
        return 0;
88 
    }
 85 
    }
89 
 
 86 
 
90 
    /* At this point, the meaning of penult is not well-defined. */
 - 
 
91 
    if (penult)
 - 
 
92 
        *penult = FAT_CLST_RES0;
 - 
 
93 
 
 - 
 
94 
    while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
 87 
    while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
95 
        unsigned fsec;  /* sector offset relative to FAT1 */
 88 
        bn_t fsec;  /* sector offset relative to FAT1 */
96 
        unsigned fidx;  /* FAT1 entry index */
 89 
        unsigned fidx;  /* FAT1 entry index */
97 
 
 90 
 
98 
        assert(clst >= FAT_CLST_FIRST);
 91 
        assert(clst >= FAT_CLST_FIRST);
99 
        if (penult)
 92 
        if (lastc)
100 
            *penult = clst; /* remember the penultimate cluster */
 93 
            *lastc = clst;  /* remember the last cluster number */
101 
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
 94 
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
102 
        fidx = clst % (bps / sizeof(fat_cluster_t));
 95 
        fidx = clst % (bps / sizeof(fat_cluster_t));
103 
        /* read FAT1 */
 96 
        /* read FAT1 */
104 
        b = block_get(dev_handle, rscnt + fsec);
 97 
        b = block_get(dev_handle, rscnt + fsec);
105 
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
 98 
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
106 
        assert(clst != FAT_CLST_BAD);
 99 
        assert(clst != FAT_CLST_BAD);
107 
        block_put(b);
 100 
        block_put(b);
108 
        clusters++;
 101 
        clusters++;
109 
    }
 102 
    }
110 
 
 103 
 
111 
    if (ult)
 104 
    if (lastc && clst < FAT_CLST_LAST1)
112 
        *ult = clst;
 105 
        *lastc = clst;
113 
 
 106 
 
114 
    return clusters;
 107 
    return clusters;
115 
}
 108 
}
116 
 
 109 
 
117 
/** Read block from file located on a FAT file system.
 110 
/** Read block from file located on a FAT file system.
118 
 *
 111 
 *
119 
 * @param bs        Buffer holding the boot sector of the file system.
 112 
 * @param bs        Buffer holding the boot sector of the file system.
120 
 * @param dev_handle    Device handle of the file system.
 113 
 * @param dev_handle    Device handle of the file system.
121 
 * @param firstc    First cluster used by the file. Can be zero if the file
 114 
 * @param firstc    First cluster used by the file. Can be zero if the file
122 
 *          is empty.
 115 
 *          is empty.
123 
 * @param offset    Offset in blocks.
 116 
 * @param bn        Block number.
124 
 *
 117 
 *
125 
 * @return      Block structure holding the requested block.
 118 
 * @return      Block structure holding the requested block.
126 
 */
 119 
 */
127 
block_t *
 120 
block_t *
128 
_fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
 121 
_fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
129 
    off_t offset)
 122 
    bn_t bn)
130 
{
 123 
{
131 
    block_t *b;
 124 
    block_t *b;
132 
    unsigned bps;
 125 
    unsigned bps;
133 
    unsigned rscnt;     /* block address of the first FAT */
 126 
    unsigned rscnt;     /* block address of the first FAT */
134 
    unsigned rde;
 127 
    unsigned rde;
Line 147... Line 140...
147 
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
 140 
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
148 
    ssa = rscnt + bs->fatcnt * sf + rds;
 141 
    ssa = rscnt + bs->fatcnt * sf + rds;
149 
 
 142 
 
150 
    if (firstc == FAT_CLST_ROOT) {
 143 
    if (firstc == FAT_CLST_ROOT) {
151 
        /* root directory special case */
 144 
        /* root directory special case */
152 
        assert(offset < rds);
 145 
        assert(bn < rds);
153 
        b = block_get(dev_handle, rscnt + bs->fatcnt * sf + offset);
 146 
        b = block_get(dev_handle, rscnt + bs->fatcnt * sf + bn);
154 
        return b;
 147 
        return b;
155 
    }
 148 
    }
156 
 
 149 
 
157 
    max_clusters = offset / bs->spc;
 150 
    max_clusters = bn / bs->spc;
158 
    clusters = fat_cluster_walk(bs, dev_handle, firstc, NULL, &lastc,
 151 
    clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
159 
        max_clusters);
 152 
        max_clusters);
160 
    assert(clusters == max_clusters);
 153 
    assert(clusters == max_clusters);
161 
 
 154 
 
162 
    b = block_get(dev_handle, ssa + (lastc - FAT_CLST_FIRST) * bs->spc +
 155 
    b = block_get(dev_handle, ssa + (lastc - FAT_CLST_FIRST) * bs->spc +
163 
        offset % bs->spc);
 156 
        bn % bs->spc);
164 
 
 157 
 
165 
    return b;
 158 
    return b;
166 
}
 159 
}
167 
 
 160 
 
168 
 
 161 
 
Line 359... Line 352...
359 
    dev_handle_t dev_handle = nodep->idx->dev_handle;
 352 
    dev_handle_t dev_handle = nodep->idx->dev_handle;
360 
    fat_cluster_t lcl;
 353 
    fat_cluster_t lcl;
361 
    uint8_t fatno;
 354 
    uint8_t fatno;
362 
 
 355 
 
363 
    if (fat_cluster_walk(bs, nodep->idx->dev_handle, nodep->firstc, &lcl,
 356 
    if (fat_cluster_walk(bs, nodep->idx->dev_handle, nodep->firstc, &lcl,
364 
        NULL, (uint16_t) -1) == 0) {
 357 
        (uint16_t) -1) == 0) {
365 
        /* No clusters allocated to the node yet. */
 358 
        /* No clusters allocated to the node yet. */
366 
        nodep->firstc = host2uint16_t_le(mcl);
 359 
        nodep->firstc = host2uint16_t_le(mcl);
367 
        nodep->dirty = true;        /* need to sync node */
 360 
        nodep->dirty = true;        /* need to sync node */
368 
        return;
 361 
        return;
369 
    }
 362 
    }