Changes in uspace/srv/fs/fat/fat_fat.c [db4ec8d:ed903174] in mainline
- File:
-
- 1 edited
-
uspace/srv/fs/fat/fat_fat.c (modified) (19 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/fs/fat/fat_fat.c
rdb4ec8d red903174 49 49 #include <mem.h> 50 50 51 /*52 * Convenience macros for computing some frequently used values from the53 * primitive boot sector members.54 */55 #define RDS(bs) ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \56 (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0)57 #define SSA(bs) (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs))58 59 #define CLBN2PBN(bs, cl, bn) \60 (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))61 62 51 /** 63 52 * The fat_alloc_lock mutex protects all copies of the File Allocation Table … … 85 74 { 86 75 block_t *b; 76 unsigned bps; 77 unsigned rscnt; /* block address of the first FAT */ 87 78 uint16_t clusters = 0; 88 79 fat_cluster_t clst = firstc; 89 80 int rc; 81 82 bps = uint16_t_le2host(bs->bps); 83 rscnt = uint16_t_le2host(bs->rscnt); 90 84 91 85 if (firstc == FAT_CLST_RES0) { … … 105 99 if (lastc) 106 100 *lastc = clst; /* remember the last cluster number */ 107 fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);108 fidx = clst % ( BPS(bs)/ sizeof(fat_cluster_t));101 fsec = (clst * sizeof(fat_cluster_t)) / bps; 102 fidx = clst % (bps / sizeof(fat_cluster_t)); 109 103 /* read FAT1 */ 110 rc = block_get(&b, dev_handle, RSCNT(bs) + fsec, 111 BLOCK_FLAGS_NONE); 104 rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE); 112 105 if (rc != EOK) 113 106 return rc; … … 132 125 * @param block Pointer to a block pointer for storing result. 133 126 * @param bs Buffer holding the boot sector of the file system. 134 * @param nodep FAT node. 127 * @param dev_handle Device handle of the file system. 128 * @param firstc First cluster used by the file. Can be zero if the file 129 * is empty. 135 130 * @param bn Block number. 136 131 * @param flags Flags passed to libblock. … … 139 134 */ 140 135 int 141 fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,142 aoff64_t bn, int flags)143 {144 fat_cluster_t firstc = nodep->firstc;145 fat_cluster_t currc;146 aoff64_t relbn = bn;147 int rc;148 149 if (!nodep->size)150 return ELIMIT;151 152 if (nodep->firstc == FAT_CLST_ROOT)153 goto fall_through;154 155 if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&156 nodep->lastc_cached_valid) {157 /*158 * This is a request to read a block within the last cluster159 * when fortunately we have the last cluster number cached.160 */161 return block_get(block, nodep->idx->dev_handle,162 CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);163 }164 165 if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {166 /*167 * We can start with the cluster cached by the previous call to168 * fat_block_get().169 */170 firstc = nodep->currc_cached_value;171 relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);172 }173 174 fall_through:175 rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc,176 &currc, relbn, flags);177 if (rc != EOK)178 return rc;179 180 /*181 * Update the "current" cluster cache.182 */183 nodep->currc_cached_valid = true;184 nodep->currc_cached_bn = bn;185 nodep->currc_cached_value = currc;186 187 return rc;188 }189 190 /** Read block from file located on a FAT file system.191 *192 * @param block Pointer to a block pointer for storing result.193 * @param bs Buffer holding the boot sector of the file system.194 * @param dev_handle Device handle of the file system.195 * @param fcl First cluster used by the file. Can be zero if the file196 * is empty.197 * @param clp If not NULL, address where the cluster containing bn198 * will be stored.199 * stored200 * @param bn Block number.201 * @param flags Flags passed to libblock.202 *203 * @return EOK on success or a negative error code.204 */205 int206 136 _fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle, 207 fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags) 208 { 137 fat_cluster_t firstc, aoff64_t bn, int flags) 138 { 139 unsigned bps; 140 unsigned rscnt; /* block address of the first FAT */ 141 unsigned rde; 142 unsigned rds; /* root directory size */ 143 unsigned sf; 144 unsigned ssa; /* size of the system area */ 209 145 uint16_t clusters; 210 146 unsigned max_clusters; 211 fat_cluster_t c;147 fat_cluster_t lastc; 212 148 int rc; 213 149 … … 215 151 * This function can only operate on non-zero length files. 216 152 */ 217 if (f cl== FAT_CLST_RES0)153 if (firstc == FAT_CLST_RES0) 218 154 return ELIMIT; 219 155 220 if (fcl == FAT_CLST_ROOT) { 156 bps = uint16_t_le2host(bs->bps); 157 rscnt = uint16_t_le2host(bs->rscnt); 158 rde = uint16_t_le2host(bs->root_ent_max); 159 sf = uint16_t_le2host(bs->sec_per_fat); 160 161 rds = (sizeof(fat_dentry_t) * rde) / bps; 162 rds += ((sizeof(fat_dentry_t) * rde) % bps != 0); 163 ssa = rscnt + bs->fatcnt * sf + rds; 164 165 if (firstc == FAT_CLST_ROOT) { 221 166 /* root directory special case */ 222 assert(bn < RDS(bs));223 rc = block_get(block, dev_handle, 224 RSCNT(bs) + FATCNT(bs) * SF(bs) + bn,flags);167 assert(bn < rds); 168 rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn, 169 flags); 225 170 return rc; 226 171 } 227 172 228 max_clusters = bn / SPC(bs); 229 rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters); 173 max_clusters = bn / bs->spc; 174 rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters, 175 max_clusters); 230 176 if (rc != EOK) 231 177 return rc; 232 178 assert(clusters == max_clusters); 233 179 234 rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags); 235 236 if (clp) 237 *clp = c; 180 rc = block_get(block, dev_handle, 181 ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags); 238 182 239 183 return rc; … … 254 198 int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos) 255 199 { 200 uint16_t bps; 201 unsigned spc; 256 202 block_t *b; 257 203 aoff64_t o, boundary; 258 204 int rc; 259 205 260 boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs)); 206 bps = uint16_t_le2host(bs->bps); 207 spc = bs->spc; 208 209 boundary = ROUND_UP(nodep->size, bps * spc); 261 210 262 211 /* zero out already allocated space */ 263 212 for (o = nodep->size; o < pos && o < boundary; 264 o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {265 int flags = (o % BPS(bs)== 0) ?213 o = ALIGN_DOWN(o + bps, bps)) { 214 int flags = (o % bps == 0) ? 266 215 BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE; 267 rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);268 if (rc != EOK) 269 return rc; 270 memset(b->data + o % BPS(bs), 0, BPS(bs) - o % BPS(bs));216 rc = fat_block_get(&b, bs, nodep, o / bps, flags); 217 if (rc != EOK) 218 return rc; 219 memset(b->data + o % bps, 0, bps - o % bps); 271 220 b->dirty = true; /* need to sync node */ 272 221 rc = block_put(b); … … 279 228 280 229 /* zero out the initial part of the new cluster chain */ 281 for (o = boundary; o < pos; o += BPS(bs)) {230 for (o = boundary; o < pos; o += bps) { 282 231 rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl, 283 NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);284 if (rc != EOK) 285 return rc; 286 memset(b->data, 0, min( BPS(bs), pos - o));232 (o - boundary) / bps, BLOCK_FLAGS_NOREAD); 233 if (rc != EOK) 234 return rc; 235 memset(b->data, 0, min(bps, pos - o)); 287 236 b->dirty = true; /* need to sync node */ 288 237 rc = block_put(b); … … 308 257 { 309 258 block_t *b; 259 uint16_t bps; 260 uint16_t rscnt; 261 uint16_t sf; 310 262 fat_cluster_t *cp; 311 263 int rc; 312 264 313 rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno + 314 (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); 265 bps = uint16_t_le2host(bs->bps); 266 rscnt = uint16_t_le2host(bs->rscnt); 267 sf = uint16_t_le2host(bs->sec_per_fat); 268 269 rc = block_get(&b, dev_handle, rscnt + sf * fatno + 270 (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE); 315 271 if (rc != EOK) 316 272 return rc; 317 cp = (fat_cluster_t *)b->data + 318 clst % (BPS(bs) / sizeof(fat_cluster_t)); 273 cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t)); 319 274 *value = uint16_t_le2host(*cp); 320 275 rc = block_put(b); … … 338 293 { 339 294 block_t *b; 295 uint16_t bps; 296 uint16_t rscnt; 297 uint16_t sf; 340 298 fat_cluster_t *cp; 341 299 int rc; 342 300 343 assert(fatno < FATCNT(bs)); 344 rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno + 345 (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); 301 bps = uint16_t_le2host(bs->bps); 302 rscnt = uint16_t_le2host(bs->rscnt); 303 sf = uint16_t_le2host(bs->sec_per_fat); 304 305 assert(fatno < bs->fatcnt); 306 rc = block_get(&b, dev_handle, rscnt + sf * fatno + 307 (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE); 346 308 if (rc != EOK) 347 309 return rc; 348 cp = (fat_cluster_t *)b->data + 349 clst % (BPS(bs) / sizeof(fat_cluster_t)); 310 cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t)); 350 311 *cp = host2uint16_t_le(value); 351 312 b->dirty = true; /* need to sync block */ … … 403 364 fat_cluster_t *mcl, fat_cluster_t *lcl) 404 365 { 366 uint16_t bps; 367 uint16_t rscnt; 368 uint16_t sf; 369 uint32_t ts; 370 unsigned rde; 371 unsigned rds; 372 unsigned ssa; 405 373 block_t *blk; 406 374 fat_cluster_t *lifo; /* stack for storing free cluster numbers */ … … 413 381 return ENOMEM; 414 382 383 bps = uint16_t_le2host(bs->bps); 384 rscnt = uint16_t_le2host(bs->rscnt); 385 sf = uint16_t_le2host(bs->sec_per_fat); 386 rde = uint16_t_le2host(bs->root_ent_max); 387 ts = (uint32_t) uint16_t_le2host(bs->totsec16); 388 if (ts == 0) 389 ts = uint32_t_le2host(bs->totsec32); 390 391 rds = (sizeof(fat_dentry_t) * rde) / bps; 392 rds += ((sizeof(fat_dentry_t) * rde) % bps != 0); 393 ssa = rscnt + bs->fatcnt * sf + rds; 394 415 395 /* 416 396 * Search FAT1 for unused clusters. 417 397 */ 418 398 fibril_mutex_lock(&fat_alloc_lock); 419 for (b = 0, cl = 0; b < SF(bs); b++) { 420 rc = block_get(&blk, dev_handle, RSCNT(bs) + b, 421 BLOCK_FLAGS_NONE); 399 for (b = 0, cl = 0; b < sf; b++) { 400 rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE); 422 401 if (rc != EOK) 423 402 goto error; 424 for (c = 0; c < BPS(bs)/ sizeof(fat_cluster_t); c++, cl++) {403 for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) { 425 404 /* 426 * Check if the entire cluster is physically there. 427 * This check becomes necessary when the file system is 428 * created with fewer total sectors than how many is 429 * inferred from the size of the file allocation table 430 * or when the last cluster ends beyond the end of the 431 * device. 405 * Check if the cluster is physically there. This check 406 * becomes necessary when the file system is created 407 * with fewer total sectors than how many is inferred 408 * from the size of the file allocation table. 432 409 */ 433 if ((cl >= FAT_CLST_FIRST) && 434 CLBN2PBN(bs, cl, SPC(bs) - 1) >= TS(bs)) { 410 if ((cl >= 2) && ((cl - 2) * bs->spc + ssa >= ts)) { 435 411 rc = block_put(blk); 436 412 if (rc != EOK) … … 535 511 * @param nodep Node representing the file. 536 512 * @param mcl First cluster of the cluster chain to append. 537 * @param lcl Last cluster of the cluster chain to append.538 513 * 539 514 * @return EOK on success or a negative error code. 540 515 */ 541 int 542 fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, 543 fat_cluster_t lcl) 516 int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl) 544 517 { 545 518 dev_handle_t dev_handle = nodep->idx->dev_handle; 546 fat_cluster_t lastc; 519 fat_cluster_t lcl; 520 uint16_t numc; 547 521 uint8_t fatno; 548 522 int rc; 549 523 550 if (nodep->firstc == FAT_CLST_RES0) { 524 rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc, 525 (uint16_t) -1); 526 if (rc != EOK) 527 return rc; 528 529 if (numc == 0) { 551 530 /* No clusters allocated to the node yet. */ 552 531 nodep->firstc = mcl; 553 nodep->dirty = true; /* need to sync node */ 554 } else { 555 if (nodep->lastc_cached_valid) { 556 lastc = nodep->lastc_cached_value; 557 nodep->lastc_cached_valid = false; 558 } else { 559 rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, 560 &lastc, NULL, (uint16_t) -1); 561 if (rc != EOK) 562 return rc; 563 } 564 565 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 566 rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, 567 lastc, mcl); 568 if (rc != EOK) 569 return rc; 570 } 571 } 572 573 nodep->lastc_cached_valid = true; 574 nodep->lastc_cached_value = lcl; 532 nodep->dirty = true; /* need to sync node */ 533 return EOK; 534 } 535 536 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 537 rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, 538 mcl); 539 if (rc != EOK) 540 return rc; 541 } 575 542 576 543 return EOK; … … 581 548 * @param bs Buffer holding the boot sector of the file system. 582 549 * @param nodep FAT node where the chopping will take place. 583 * @param l clLast cluster which will remain in the node. If this550 * @param lastc Last cluster which will remain in the node. If this 584 551 * argument is FAT_CLST_RES0, then all clusters will 585 552 * be chopped off. … … 587 554 * @return EOK on success or a negative return code. 588 555 */ 589 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl) 590 { 591 int rc; 556 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc) 557 { 558 int rc; 559 592 560 dev_handle_t dev_handle = nodep->idx->dev_handle; 593 594 /* 595 * Invalidate cached cluster numbers. 596 */ 597 nodep->lastc_cached_valid = false; 598 if (nodep->currc_cached_value != lcl) 599 nodep->currc_cached_valid = false; 600 601 if (lcl == FAT_CLST_RES0) { 561 if (lastc == FAT_CLST_RES0) { 602 562 /* The node will have zero size and no clusters allocated. */ 603 563 rc = fat_free_clusters(bs, dev_handle, nodep->firstc); … … 610 570 unsigned fatno; 611 571 612 rc = fat_get_cluster(bs, dev_handle, FAT1, l cl, &nextc);572 rc = fat_get_cluster(bs, dev_handle, FAT1, lastc, &nextc); 613 573 if (rc != EOK) 614 574 return rc; … … 616 576 /* Terminate the cluster chain in all copies of FAT. */ 617 577 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 618 rc = fat_set_cluster(bs, dev_handle, fatno, l cl,578 rc = fat_set_cluster(bs, dev_handle, fatno, lastc, 619 579 FAT_CLST_LAST1); 620 580 if (rc != EOK) … … 628 588 } 629 589 630 /*631 * Update and re-enable the last cluster cache.632 */633 nodep->lastc_cached_valid = true;634 nodep->lastc_cached_value = lcl;635 636 590 return EOK; 637 591 } … … 642 596 int i; 643 597 block_t *b; 644 int rc; 645 646 for (i = 0; i < SPC(bs); i++) { 647 rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i, 598 unsigned bps; 599 int rc; 600 601 bps = uint16_t_le2host(bs->bps); 602 603 for (i = 0; i < bs->spc; i++) { 604 rc = _fat_block_get(&b, bs, dev_handle, c, i, 648 605 BLOCK_FLAGS_NOREAD); 649 606 if (rc != EOK) 650 607 return rc; 651 memset(b->data, 0, BPS(bs));608 memset(b->data, 0, bps); 652 609 b->dirty = true; 653 610 rc = block_put(b);
Note:
See TracChangeset
for help on using the changeset viewer.
