Changes in uspace/srv/fs/fat/fat_fat.c [7ece4247:15f3c3f] in mainline
- File:
-
- 1 edited
-
uspace/srv/fs/fat/fat_fat.c (modified) (29 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/fs/fat/fat_fat.c
r7ece4247 r15f3c3f 1 1 /* 2 2 * Copyright (c) 2008 Jakub Jermar 3 * Copyright (c) 2011 Oleg Romanenko4 3 * All rights reserved. 5 4 * … … 30 29 /** @addtogroup fs 31 30 * @{ 32 */ 31 */ 33 32 34 33 /** … … 51 50 #include <mem.h> 52 51 53 #define IS_ODD(number) (number & 0x1) 52 /* 53 * Convenience macros for computing some frequently used values from the 54 * primitive boot sector members. 55 */ 56 #define RDS(bs) ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \ 57 (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0) 58 #define SSA(bs) (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs)) 59 60 #define CLBN2PBN(bs, cl, bn) \ 61 (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs))) 54 62 55 63 /** … … 57 65 * during allocation of clusters. The lock does not have to be held durring 58 66 * deallocation of clusters. 59 */ 67 */ 60 68 static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock); 61 69 … … 69 77 * @param numc If non-NULL, output argument holding the number of 70 78 * clusters seen during the walk. 71 * @param max_clusters Maximum number of clusters to visit. 79 * @param max_clusters Maximum number of clusters to visit. 72 80 * 73 81 * @return EOK on success or a negative error code. 74 82 */ 75 int 83 int 76 84 fat_cluster_walk(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc, 77 fat_cluster_t *lastc, uint 32_t *numc, uint32_t max_clusters)78 { 79 uint32_t clusters = 0;80 fat_cluster_t clst = firstc, clst_last1 = FAT_CLST_LAST1(bs);81 fat_cluster_t clst _bad = FAT_CLST_BAD(bs);85 fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters) 86 { 87 block_t *b; 88 uint16_t clusters = 0; 89 fat_cluster_t clst = firstc; 82 90 int rc; 83 91 … … 91 99 } 92 100 93 while (clst < clst_last1 && clusters < max_clusters) { 101 while (clst < FAT_CLST_LAST1 && clusters < max_clusters) { 102 aoff64_t fsec; /* sector offset relative to FAT1 */ 103 unsigned fidx; /* FAT1 entry index */ 104 94 105 assert(clst >= FAT_CLST_FIRST); 95 106 if (lastc) 96 107 *lastc = clst; /* remember the last cluster number */ 97 108 fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs); 109 fidx = clst % (BPS(bs) / sizeof(fat_cluster_t)); 98 110 /* read FAT1 */ 99 rc = fat_get_cluster(bs, service_id, FAT1, clst, &clst); 100 if (rc != EOK) 101 return rc; 102 103 assert(clst != clst_bad); 111 rc = block_get(&b, service_id, RSCNT(bs) + fsec, 112 BLOCK_FLAGS_NONE); 113 if (rc != EOK) 114 return rc; 115 clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]); 116 assert(clst != FAT_CLST_BAD); 117 rc = block_put(b); 118 if (rc != EOK) 119 return rc; 104 120 clusters++; 105 121 } 106 122 107 if (lastc && clst < clst_last1)123 if (lastc && clst < FAT_CLST_LAST1) 108 124 *lastc = clst; 109 125 if (numc) … … 135 151 return ELIMIT; 136 152 137 if ( !FAT_IS_FAT32(bs) && nodep->firstc == FAT_CLST_ROOT)153 if (nodep->firstc == FAT_CLST_ROOT) 138 154 goto fall_through; 139 155 … … 162 178 if (rc != EOK) 163 179 return rc; 164 180 165 181 /* 166 182 * Update the "current" cluster cache. … … 182 198 * @param clp If not NULL, address where the cluster containing bn 183 199 * will be stored. 184 * stored 200 * stored 185 201 * @param bn Block number. 186 202 * @param flags Flags passed to libblock. … … 192 208 fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags) 193 209 { 194 uint 32_t clusters;195 u int32_tmax_clusters;210 uint16_t clusters; 211 unsigned max_clusters; 196 212 fat_cluster_t c; 197 213 int rc; … … 203 219 return ELIMIT; 204 220 205 if ( !FAT_IS_FAT32(bs) &&fcl == FAT_CLST_ROOT) {221 if (fcl == FAT_CLST_ROOT) { 206 222 /* root directory special case */ 207 223 assert(bn < RDS(bs)); … … 237 253 * @return EOK on success or a negative error code. 238 254 */ 239 int 240 fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos) 255 int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos) 241 256 { 242 257 block_t *b; … … 260 275 return rc; 261 276 } 262 277 263 278 if (o >= pos) 264 279 return EOK; 265 280 266 281 /* zero out the initial part of the new cluster chain */ 267 282 for (o = boundary; o < pos; o += BPS(bs)) { … … 289 304 * @return EOK or a negative error code. 290 305 */ 291 static int292 fat_get_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno,293 fat_cluster_t clst, fat_cluster_t *value)294 {295 block_t *b, *b1;296 uint16_t byte1, byte2;297 aoff64_t offset;298 int rc;299 300 offset = (clst + clst / 2);301 if (offset / BPS(bs) >= SF(bs))302 return ERANGE;303 304 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +305 offset / BPS(bs), BLOCK_FLAGS_NONE);306 if (rc != EOK)307 return rc;308 309 byte1 = ((uint8_t *) b->data)[offset % BPS(bs)];310 /* This cluster access spans a sector boundary. Check only for FAT12 */311 if ((offset % BPS(bs)) + 1 == BPS(bs)) {312 /* Is this the last sector of FAT? */313 if (offset / BPS(bs) < SF(bs)) {314 /* No, read the next sector */315 rc = block_get(&b1, service_id, 1 + RSCNT(bs) +316 SF(bs) * fatno + offset / BPS(bs),317 BLOCK_FLAGS_NONE);318 if (rc != EOK) {319 block_put(b);320 return rc;321 }322 /*323 * Combining value with last byte of current sector and324 * first byte of next sector325 */326 byte2 = ((uint8_t*) b1->data)[0];327 328 rc = block_put(b1);329 if (rc != EOK) {330 block_put(b);331 return rc;332 }333 } else {334 /* Yes. This is the last sector of FAT */335 block_put(b);336 return ERANGE;337 }338 } else339 byte2 = ((uint8_t *) b->data)[(offset % BPS(bs)) + 1];340 341 *value = uint16_t_le2host(byte1 | (byte2 << 8));342 if (IS_ODD(clst))343 *value = (*value) >> 4;344 else345 *value = (*value) & FAT12_MASK;346 347 rc = block_put(b);348 349 return rc;350 }351 352 /** Get cluster from the first FAT.353 *354 * @param bs Buffer holding the boot sector for the file system.355 * @param service_id Service ID for the file system.356 * @param clst Cluster which to get.357 * @param value Output argument holding the value of the cluster.358 *359 * @return EOK or a negative error code.360 */361 static int362 fat_get_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno,363 fat_cluster_t clst, fat_cluster_t *value)364 {365 block_t *b;366 aoff64_t offset;367 int rc;368 369 offset = (clst * FAT16_CLST_SIZE);370 371 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +372 offset / BPS(bs), BLOCK_FLAGS_NONE);373 if (rc != EOK)374 return rc;375 376 *value = uint16_t_le2host(*(uint16_t *)(b->data + offset % BPS(bs)));377 378 rc = block_put(b);379 380 return rc;381 }382 383 /** Get cluster from the first FAT.384 *385 * @param bs Buffer holding the boot sector for the file system.386 * @param service_id Service ID for the file system.387 * @param clst Cluster which to get.388 * @param value Output argument holding the value of the cluster.389 *390 * @return EOK or a negative error code.391 */392 static int393 fat_get_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno,394 fat_cluster_t clst, fat_cluster_t *value)395 {396 block_t *b;397 aoff64_t offset;398 int rc;399 400 offset = (clst * FAT32_CLST_SIZE);401 402 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +403 offset / BPS(bs), BLOCK_FLAGS_NONE);404 if (rc != EOK)405 return rc;406 407 *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) &408 FAT32_MASK;409 410 rc = block_put(b);411 412 return rc;413 }414 415 416 /** Get cluster from the first FAT.417 *418 * @param bs Buffer holding the boot sector for the file system.419 * @param service_id Service ID for the file system.420 * @param clst Cluster which to get.421 * @param value Output argument holding the value of the cluster.422 *423 * @return EOK or a negative error code.424 */425 306 int 426 307 fat_get_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno, 427 308 fat_cluster_t clst, fat_cluster_t *value) 428 309 { 429 int rc; 430 431 assert(fatno < FATCNT(bs)); 432 433 if (FAT_IS_FAT12(bs)) 434 rc = fat_get_cluster_fat12(bs, service_id, fatno, clst, value); 435 else if (FAT_IS_FAT16(bs)) 436 rc = fat_get_cluster_fat16(bs, service_id, fatno, clst, value); 437 else 438 rc = fat_get_cluster_fat32(bs, service_id, fatno, clst, value); 439 440 return rc; 441 } 442 443 /** Set cluster in one instance of FAT. 444 * 445 * @param bs Buffer holding the boot sector for the file system. 446 * @param service_id Service ID for the file system. 447 * @param fatno Number of the FAT instance where to make the change. 448 * @param clst Cluster which is to be set. 449 * @param value Value to set the cluster with. 450 * 451 * @return EOK on success or a negative error code. 452 */ 453 static int 454 fat_set_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno, 455 fat_cluster_t clst, fat_cluster_t value) 456 { 457 block_t *b, *b1 = NULL; 458 aoff64_t offset; 459 uint16_t byte1, byte2; 460 int rc; 461 462 offset = (clst + clst / 2); 463 if (offset / BPS(bs) >= SF(bs)) 464 return ERANGE; 465 310 block_t *b; 311 fat_cluster_t *cp; 312 int rc; 313 466 314 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + 467 offset/ BPS(bs), BLOCK_FLAGS_NONE);315 (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); 468 316 if (rc != EOK) 469 317 return rc; 470 471 byte1 = ((uint8_t*) b->data)[offset % BPS(bs)]; 472 bool border = false; 473 /* This cluster access spans a sector boundary. */ 474 if ((offset % BPS(bs)) + 1 == BPS(bs)) { 475 /* Is it the last sector of FAT? */ 476 if (offset / BPS(bs) < SF(bs)) { 477 /* No, read the next sector */ 478 rc = block_get(&b1, service_id, 1 + RSCNT(bs) + 479 SF(bs) * fatno + offset / BPS(bs), 480 BLOCK_FLAGS_NONE); 481 if (rc != EOK) { 482 block_put(b); 483 return rc; 484 } 485 /* 486 * Combining value with last byte of current sector and 487 * first byte of next sector 488 */ 489 byte2 = ((uint8_t *) b1->data)[0]; 490 border = true; 491 } else { 492 /* Yes. This is the last sector of FAT */ 493 block_put(b); 494 return ERANGE; 495 } 496 } else 497 byte2 = ((uint8_t*) b->data)[(offset % BPS(bs)) + 1]; 498 499 if (IS_ODD(clst)) { 500 byte1 &= 0x0f; 501 byte2 = 0; 502 value = (value << 4); 503 } else { 504 byte1 = 0; 505 byte2 &= 0xf0; 506 value &= FAT12_MASK; 507 } 508 509 byte1 = byte1 | (value & 0xff); 510 byte2 = byte2 | (value >> 8); 511 512 ((uint8_t *) b->data)[(offset % BPS(bs))] = byte1; 513 if (border) { 514 ((uint8_t *) b1->data)[0] = byte2; 515 516 b1->dirty = true; 517 rc = block_put(b1); 518 if (rc != EOK) { 519 block_put(b); 520 return rc; 521 } 522 } else 523 ((uint8_t *) b->data)[(offset % BPS(bs)) + 1] = byte2; 524 525 b->dirty = true; /* need to sync block */ 318 cp = (fat_cluster_t *)b->data + 319 clst % (BPS(bs) / sizeof(fat_cluster_t)); 320 *value = uint16_t_le2host(*cp); 526 321 rc = block_put(b); 527 528 return rc; 529 } 530 531 /** Set cluster in one instance of FAT. 532 * 533 * @param bs Buffer holding the boot sector for the file system. 534 * @param service_id Service ID for the file system. 535 * @param fatno Number of the FAT instance where to make the change. 536 * @param clst Cluster which is to be set. 537 * @param value Value to set the cluster with. 538 * 539 * @return EOK on success or a negative error code. 540 */ 541 static int 542 fat_set_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno, 543 fat_cluster_t clst, fat_cluster_t value) 544 { 545 block_t *b; 546 aoff64_t offset; 547 int rc; 548 549 offset = (clst * FAT16_CLST_SIZE); 550 551 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + 552 offset / BPS(bs), BLOCK_FLAGS_NONE); 553 if (rc != EOK) 554 return rc; 555 556 *(uint16_t *)(b->data + offset % BPS(bs)) = host2uint16_t_le(value); 557 558 b->dirty = true; /* need to sync block */ 559 rc = block_put(b); 560 561 return rc; 562 } 563 564 /** Set cluster in one instance of FAT. 565 * 566 * @param bs Buffer holding the boot sector for the file system. 567 * @param service_id Service ID for the file system. 568 * @param fatno Number of the FAT instance where to make the change. 569 * @param clst Cluster which is to be set. 570 * @param value Value to set the cluster with. 571 * 572 * @return EOK on success or a negative error code. 573 */ 574 static int 575 fat_set_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno, 576 fat_cluster_t clst, fat_cluster_t value) 577 { 578 block_t *b; 579 aoff64_t offset; 580 int rc; 581 fat_cluster_t temp; 582 583 offset = (clst * FAT32_CLST_SIZE); 584 585 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + 586 offset / BPS(bs), BLOCK_FLAGS_NONE); 587 if (rc != EOK) 588 return rc; 589 590 temp = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))); 591 temp &= 0xf0000000; 592 temp |= (value & FAT32_MASK); 593 *(uint32_t *)(b->data + offset % BPS(bs)) = host2uint32_t_le(temp); 594 595 b->dirty = true; /* need to sync block */ 596 rc = block_put(b); 597 322 598 323 return rc; 599 324 } … … 613 338 fat_cluster_t clst, fat_cluster_t value) 614 339 { 340 block_t *b; 341 fat_cluster_t *cp; 615 342 int rc; 616 343 617 344 assert(fatno < FATCNT(bs)); 618 619 if (FAT_IS_FAT12(bs)) 620 rc = fat_set_cluster_fat12(bs, service_id, fatno, clst, value); 621 else if (FAT_IS_FAT16(bs)) 622 rc = fat_set_cluster_fat16(bs, service_id, fatno, clst, value); 623 else 624 rc = fat_set_cluster_fat32(bs, service_id, fatno, clst, value); 625 345 rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + 346 (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); 347 if (rc != EOK) 348 return rc; 349 cp = (fat_cluster_t *)b->data + 350 clst % (BPS(bs) / sizeof(fat_cluster_t)); 351 *cp = host2uint16_t_le(value); 352 b->dirty = true; /* need to sync block */ 353 rc = block_put(b); 626 354 return rc; 627 355 } … … 641 369 uint8_t fatno; 642 370 unsigned c; 643 fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs); 644 int rc; 645 646 for (fatno = FAT1 + 1; fatno < FATCNT(bs); fatno++) { 371 int rc; 372 373 for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) { 647 374 for (c = 0; c < nclsts; c++) { 648 375 rc = fat_set_cluster(bs, service_id, fatno, lifo[c], 649 c == 0 ? clst_last1 : lifo[c - 1]);376 c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]); 650 377 if (rc != EOK) 651 378 return rc; … … 677 404 fat_cluster_t *mcl, fat_cluster_t *lcl) 678 405 { 679 fat_cluster_t *lifo; /* stack for storing free cluster numbers */ 680 unsigned found = 0; /* top of the free cluster number stack */ 681 fat_cluster_t clst, value, clst_last1 = FAT_CLST_LAST1(bs); 682 int rc = EOK; 406 block_t *blk; 407 fat_cluster_t *lifo; /* stack for storing free cluster numbers */ 408 unsigned found = 0; /* top of the free cluster number stack */ 409 unsigned b, c, cl; 410 int rc; 683 411 684 412 lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t)); 685 413 if (!lifo) 686 414 return ENOMEM; 415 687 416 /* 688 417 * Search FAT1 for unused clusters. 689 418 */ 690 419 fibril_mutex_lock(&fat_alloc_lock); 691 for (clst = FAT_CLST_FIRST; clst < CC(bs) + 2 && found < nclsts; 692 clst++) { 693 rc = fat_get_cluster(bs, service_id, FAT1, clst, &value); 694 if (rc != EOK) 695 break; 696 697 if (value == FAT_CLST_RES0) { 420 for (b = 0, cl = 0; b < SF(bs); b++) { 421 rc = block_get(&blk, service_id, RSCNT(bs) + b, 422 BLOCK_FLAGS_NONE); 423 if (rc != EOK) 424 goto error; 425 for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) { 698 426 /* 699 * The cluster is free. Put it into our stack 700 * of found clusters and mark it as non-free. 427 * Check if the entire cluster is physically there. 428 * This check becomes necessary when the file system is 429 * created with fewer total sectors than how many is 430 * inferred from the size of the file allocation table 431 * or when the last cluster ends beyond the end of the 432 * device. 701 433 */ 702 lifo[found] = clst; 703 rc = fat_set_cluster(bs, service_id, FAT1, clst, 704 (found == 0) ? clst_last1 : lifo[found - 1]); 705 if (rc != EOK) 706 break; 707 708 found++; 434 if ((cl >= FAT_CLST_FIRST) && 435 CLBN2PBN(bs, cl, SPC(bs) - 1) >= TS(bs)) { 436 rc = block_put(blk); 437 if (rc != EOK) 438 goto error; 439 goto out; 440 } 441 442 fat_cluster_t *clst = (fat_cluster_t *)blk->data + c; 443 if (uint16_t_le2host(*clst) == FAT_CLST_RES0) { 444 /* 445 * The cluster is free. Put it into our stack 446 * of found clusters and mark it as non-free. 447 */ 448 lifo[found] = cl; 449 *clst = (found == 0) ? 450 host2uint16_t_le(FAT_CLST_LAST1) : 451 host2uint16_t_le(lifo[found - 1]); 452 blk->dirty = true; /* need to sync block */ 453 if (++found == nclsts) { 454 /* we are almost done */ 455 rc = block_put(blk); 456 if (rc != EOK) 457 goto error; 458 /* update the shadow copies of FAT */ 459 rc = fat_alloc_shadow_clusters(bs, 460 service_id, lifo, nclsts); 461 if (rc != EOK) 462 goto error; 463 *mcl = lifo[found - 1]; 464 *lcl = lifo[0]; 465 free(lifo); 466 fibril_mutex_unlock(&fat_alloc_lock); 467 return EOK; 468 } 469 } 709 470 } 710 } 711 712 if (rc == EOK && found == nclsts) { 713 rc = fat_alloc_shadow_clusters(bs, service_id, lifo, nclsts); 714 if (rc == EOK) { 715 *mcl = lifo[found - 1]; 716 *lcl = lifo[0]; 471 rc = block_put(blk); 472 if (rc != EOK) { 473 error: 474 fibril_mutex_unlock(&fat_alloc_lock); 717 475 free(lifo); 718 fibril_mutex_unlock(&fat_alloc_lock); 719 return EOK; 476 return rc; 720 477 } 721 478 } 722 723 /* If something wrong - free the clusters */ 479 out: 480 fibril_mutex_unlock(&fat_alloc_lock); 481 482 /* 483 * We could not find enough clusters. Now we need to free the clusters 484 * we have allocated so far. 485 */ 724 486 while (found--) { 725 (void)fat_set_cluster(bs, service_id, FAT1, lifo[found],487 rc = fat_set_cluster(bs, service_id, FAT1, lifo[found], 726 488 FAT_CLST_RES0); 727 } 728 489 if (rc != EOK) { 490 free(lifo); 491 return rc; 492 } 493 } 494 729 495 free(lifo); 730 fibril_mutex_unlock(&fat_alloc_lock);731 732 496 return ENOSPC; 733 497 } … … 745 509 { 746 510 unsigned fatno; 747 fat_cluster_t nextc , clst_bad = FAT_CLST_BAD(bs);511 fat_cluster_t nextc; 748 512 int rc; 749 513 750 514 /* Mark all clusters in the chain as free in all copies of FAT. */ 751 while (firstc < FAT_CLST_LAST1(bs)) { 752 assert(firstc >= FAT_CLST_FIRST && firstc < clst_bad); 753 515 while (firstc < FAT_CLST_LAST1) { 516 assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD); 754 517 rc = fat_get_cluster(bs, service_id, FAT1, firstc, &nextc); 755 518 if (rc != EOK) 756 519 return rc; 757 758 for (fatno = FAT1; fatno < FATCNT(bs); fatno++) { 520 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 759 521 rc = fat_set_cluster(bs, service_id, fatno, firstc, 760 522 FAT_CLST_RES0); … … 762 524 return rc; 763 525 } 526 764 527 firstc = nextc; 765 528 } … … 777 540 * @return EOK on success or a negative error code. 778 541 */ 779 int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, 542 int 543 fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, 780 544 fat_cluster_t lcl) 781 545 { … … 795 559 } else { 796 560 rc = fat_cluster_walk(bs, service_id, nodep->firstc, 797 &lastc, NULL, (uint 32_t) -1);561 &lastc, NULL, (uint16_t) -1); 798 562 if (rc != EOK) 799 563 return rc; 800 564 } 801 565 802 for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {803 rc = fat_set_cluster(bs, nodep->idx->service_id, 804 fatno,lastc, mcl);566 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 567 rc = fat_set_cluster(bs, nodep->idx->service_id, fatno, 568 lastc, mcl); 805 569 if (rc != EOK) 806 570 return rc; … … 826 590 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl) 827 591 { 828 fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);829 592 int rc; 830 593 service_id_t service_id = nodep->idx->service_id; … … 853 616 854 617 /* Terminate the cluster chain in all copies of FAT. */ 855 for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {618 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { 856 619 rc = fat_set_cluster(bs, service_id, fatno, lcl, 857 clst_last1);620 FAT_CLST_LAST1); 858 621 if (rc != EOK) 859 622 return rc; … … 910 673 911 674 /* Check number of FATs. */ 912 if ( FATCNT(bs)== 0)675 if (bs->fatcnt == 0) 913 676 return ENOTSUP; 914 677 915 678 /* Check total number of sectors. */ 916 if (TS(bs) == 0) 679 680 if (bs->totsec16 == 0 && bs->totsec32 == 0) 917 681 return ENOTSUP; 918 682 919 683 if (bs->totsec16 != 0 && bs->totsec32 != 0 && 920 bs->totsec16 != bs->totsec32) 684 bs->totsec16 != bs->totsec32) 921 685 return ENOTSUP; 922 686 … … 926 690 927 691 /* Check number of sectors per FAT. */ 928 if ( SF(bs)== 0)692 if (bs->sec_per_fat == 0) 929 693 return ENOTSUP; 930 694 … … 936 700 * sanitized to support file systems with this property. 937 701 */ 938 if ( !FAT_IS_FAT32(bs) &&939 (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)702 if ((uint16_t_le2host(bs->root_ent_max) * sizeof(fat_dentry_t)) % 703 uint16_t_le2host(bs->bps) != 0) 940 704 return ENOTSUP; 941 705 942 706 /* Check signature of each FAT. */ 943 for (fat_no = 0; fat_no < FATCNT(bs); fat_no++) { 707 708 for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) { 944 709 rc = fat_get_cluster(bs, service_id, fat_no, 0, &e0); 945 710 if (rc != EOK) … … 950 715 return EIO; 951 716 952 /* 953 * Check that first byte of FAT contains the media descriptor. 954 */ 717 /* Check that first byte of FAT contains the media descriptor. */ 955 718 if ((e0 & 0xff) != bs->mdesc) 956 719 return ENOTSUP; … … 960 723 * set to one. 961 724 */ 962 if (!FAT_IS_FAT12(bs) && 963 ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs))) 725 if ((e0 >> 8) != 0xff || e1 != 0xffff) 964 726 return ENOTSUP; 965 727 } … … 970 732 /** 971 733 * @} 972 */ 734 */
Note:
See TracChangeset
for help on using the changeset viewer.
