source: mainline/uspace/srv/fs/fat/fat_fat.c@ a429bfb

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a429bfb was a429bfb, checked in by Jakub Jermar <jakub@…>, 17 years ago

Make sure that data are converted from / to the native endianity when writing them
out to / reading them in from the file system.
  • Property mode set to 100644
File size: 8.9 KB
Line 
1/*
2 * Copyright (c) 2008 Jakub 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_fat.c
35 * @brief Functions that manipulate the file allocation tables.
36 */
37
38#include "fat_fat.h"
39#include "fat_dentry.h"
40#include "fat.h"
41#include "../../vfs/vfs.h"
42#include <libfs.h>
43#include <errno.h>
44#include <byteorder.h>
45#include <align.h>
46#include <assert.h>
47
48block_t *
49_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
50{
51 block_t *bb;
52 block_t *b;
53 unsigned bps;
54 unsigned spc;
55 unsigned rscnt; /* block address of the first FAT */
56 unsigned fatcnt;
57 unsigned rde;
58 unsigned rds; /* root directory size */
59 unsigned sf;
60 unsigned ssa; /* size of the system area */
61 unsigned clusters;
62 fat_cluster_t clst = firstc;
63 unsigned i;
64
65 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
66 bps = uint16_t_le2host(FAT_BS(bb)->bps);
67 spc = FAT_BS(bb)->spc;
68 rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
69 fatcnt = FAT_BS(bb)->fatcnt;
70 rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
71 sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
72 block_put(bb);
73
74 rds = (sizeof(fat_dentry_t) * rde) / bps;
75 rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
76 ssa = rscnt + fatcnt * sf + rds;
77
78 if (firstc == FAT_CLST_ROOT) {
79 /* root directory special case */
80 assert(offset < rds);
81 b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
82 return b;
83 }
84
85 clusters = offset / spc;
86 for (i = 0; i < clusters; i++) {
87 unsigned fsec; /* sector offset relative to FAT1 */
88 unsigned fidx; /* FAT1 entry index */
89
90 assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
91 fsec = (clst * sizeof(fat_cluster_t)) / bps;
92 fidx = clst % (bps / sizeof(fat_cluster_t));
93 /* read FAT1 */
94 b = block_get(dev_handle, rscnt + fsec, bps);
95 clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
96 assert(clst != FAT_CLST_BAD);
97 assert(clst < FAT_CLST_LAST1);
98 block_put(b);
99 }
100
101 b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
102 offset % spc, bps);
103
104 return b;
105}
106
107/** Return number of blocks allocated to a file.
108 *
109 * @param dev_handle Device handle of the device with the file.
110 * @param firstc First cluster of the file.
111 *
112 * @return Number of blocks allocated to the file.
113 */
114uint16_t
115_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
116{
117 block_t *bb;
118 block_t *b;
119 unsigned bps;
120 unsigned spc;
121 unsigned rscnt; /* block address of the first FAT */
122 unsigned clusters = 0;
123 fat_cluster_t clst = firstc;
124
125 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
126 bps = uint16_t_le2host(FAT_BS(bb)->bps);
127 spc = FAT_BS(bb)->spc;
128 rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
129 block_put(bb);
130
131 if (firstc == FAT_CLST_RES0) {
132 /* No space allocated to the file. */
133 return 0;
134 }
135
136 while (clst < FAT_CLST_LAST1) {
137 unsigned fsec; /* sector offset relative to FAT1 */
138 unsigned fidx; /* FAT1 entry index */
139
140 assert(clst >= FAT_CLST_FIRST);
141 fsec = (clst * sizeof(fat_cluster_t)) / bps;
142 fidx = clst % (bps / sizeof(fat_cluster_t));
143 /* read FAT1 */
144 b = block_get(dev_handle, rscnt + fsec, bps);
145 clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
146 assert(clst != FAT_CLST_BAD);
147 block_put(b);
148 clusters++;
149 }
150
151 return clusters * spc;
152}
153
154uint16_t fat_bps_get(dev_handle_t dev_handle)
155{
156 block_t *bb;
157 uint16_t bps;
158
159 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
160 assert(bb != NULL);
161 bps = uint16_t_le2host(FAT_BS(bb)->bps);
162 block_put(bb);
163
164 return bps;
165}
166
167/** Fill the gap between EOF and a new file position.
168 *
169 * @param nodep FAT node with the gap.
170 * @param mcl First cluster in an independent cluster chain that will
171 * be later appended to the end of the node's own cluster
172 * chain. If pos is still in the last allocated cluster,
173 * this argument is ignored.
174 * @param pos Position in the last node block.
175 */
176void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
177{
178 uint16_t bps;
179 unsigned spc;
180 block_t *bb, *b;
181 off_t o, boundary;
182
183 bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
184 bps = uint16_t_le2host(FAT_BS(bb)->bps);
185 spc = FAT_BS(bb)->spc;
186 block_put(bb);
187
188 boundary = ROUND_UP(nodep->size, bps * spc);
189
190 /* zero out already allocated space */
191 for (o = nodep->size - 1; o < pos && o < boundary;
192 o = ALIGN_DOWN(o + bps, bps)) {
193 b = fat_block_get(nodep, o / bps);
194 memset(b->data + o % bps, 0, bps - o % bps);
195 b->dirty = true; /* need to sync node */
196 block_put(b);
197 }
198
199 if (o >= pos)
200 return;
201
202 /* zero out the initial part of the new cluster chain */
203 for (o = boundary; o < pos; o += bps) {
204 b = _fat_block_get(nodep->idx->dev_handle, mcl,
205 (o - boundary) / bps);
206 memset(b->data, 0, min(bps, pos - o));
207 b->dirty = true; /* need to sync node */
208 block_put(b);
209 }
210}
211
212void
213fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,
214 fat_cluster_t value)
215{
216 block_t *bb, *blk;
217 uint16_t bps;
218 uint16_t rscnt;
219 uint16_t sf;
220 uint8_t fatcnt;
221 fat_cluster_t *cp;
222
223 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
224 bps = uint16_t_le2host(FAT_BS(bb)->bps);
225 rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
226 sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
227 fatcnt = FAT_BS(bb)->fatcnt;
228 block_put(bb);
229
230 assert(fatno < fatcnt);
231 blk = block_get(dev_handle, rscnt + sf * fatno +
232 (clst * sizeof(fat_cluster_t)) / bps, bps);
233 cp = (fat_cluster_t *)blk->data + clst % (bps / sizeof(fat_cluster_t));
234 *cp = host2uint16_t_le(value);
235 blk->dirty = true; /* need to sync block */
236 block_put(blk);
237}
238
239void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
240 unsigned nclsts)
241{
242 uint8_t fatcnt;
243 uint8_t fatno;
244 unsigned c;
245 block_t *bb;
246
247 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
248 fatcnt = FAT_BS(bb)->fatcnt;
249 block_put(bb);
250
251 for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {
252 for (c = 0; c < nclsts; c++) {
253 fat_mark_cluster(dev_handle, fatno, lifo[c],
254 c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
255 }
256 }
257}
258
259int
260fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
261 fat_cluster_t *lcl)
262{
263 uint16_t bps;
264 uint16_t rscnt;
265 uint16_t sf;
266 block_t *bb, *blk;
267 fat_cluster_t *lifo; /* stack for storing free cluster numbers */
268 unsigned found = 0; /* top of the free cluster number stack */
269 unsigned b, c, cl;
270
271 lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
272 if (lifo)
273 return ENOMEM;
274
275 bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
276 bps = uint16_t_le2host(FAT_BS(bb)->bps);
277 rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
278 sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
279 block_put(bb);
280
281 /*
282 * Search FAT1 for unused clusters.
283 */
284 for (b = 0, cl = 0; b < sf; blk++) {
285 blk = block_get(dev_handle, rscnt + b, bps);
286 for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
287 fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
288 if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {
289 /*
290 * The cluster is free. Put it into our stack
291 * of found clusters and mark it as non-free.
292 */
293 lifo[found] = cl;
294 *clst = (found == 0) ?
295 host2uint16_t_le(FAT_CLST_LAST1) :
296 host2uint16_t_le(lifo[found - 1]);
297 blk->dirty = true; /* need to sync block */
298 if (++found == nclsts) {
299 /* we are almost done */
300 block_put(blk);
301 /* update the shadow copies of FAT */
302 fat_alloc_shadow_clusters(dev_handle,
303 lifo, nclsts);
304 *mcl = lifo[found - 1];
305 *lcl = lifo[0];
306 free(lifo);
307 return EOK;
308 }
309 }
310 }
311 block_put(blk);
312 }
313
314 /*
315 * We could not find enough clusters. Now we need to free the clusters
316 * we have allocated so far.
317 */
318 while (found--)
319 fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
320
321 free(lifo);
322 return ENOSPC;
323}
324
325void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
326{
327}
328
329/**
330 * @}
331 */
Note: See TracBrowser for help on using the repository browser.