Changeset 3cfa636 in rtems
- Timestamp:
- 02/26/10 05:54:59 (14 years ago)
- Branches:
- 4.10, 4.11, 5, master
- Children:
- 965dc55
- Parents:
- 28b38f3
- Location:
- cpukit
- Files:
-
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
cpukit/ChangeLog
r28b38f3 r3cfa636 1 2010-02-26 Chris Johns <chrisj@rtems.org> 2 3 * libfs/src/rfs/rtems-rfs-block.c: Reset a buffer handle after 4 moving down an indirection level. 5 6 * libfs/src/rfs/rtems-rfs-dir.c: Move directory entry validation 7 into a macro and use the macro. Fix the range check on the ino so 8 all inodes can be used. 9 10 * libfs/src/rfs/rtems-rfs-file-system.c, 11 libfs/src/rfs/rtems-rfs-file-system.h:: Add a version number to 12 the superblock. Use RTEMS_RFS_INODE_SIZE. 13 14 * libfs/src/rfs/rtems-rfs-file.c: Fix the size offset on partial 15 block lengths. Set the size in the file handle on a truncate to 16 0. 17 18 * libfs/src/rfs/rtems-rfs-format.c: Add a version number to 19 the superblock. Use RTEMS_RFS_INODE_SIZE. A better set of defaults 20 for small disks. 21 22 * libfs/src/rfs/rtems-rfs-inode.c: Use RTEMS_RFS_INODE_SIZE. Free 23 the allocated inode if it cannot be opened. 24 25 * libfs/src/rfs/rtems-rfs-inode.h: Add RTEMS_RFS_INODE_SIZE. 26 27 * libfs/src/rfs/rtems-rfs-rtems-file.c: Move some of the iop 28 acceses inside the fs lock. 29 30 * libfs/src/rfs/rtems-rfs-shell.c: Use RTEMS_RFS_INODE_SIZE. 31 1 32 2010-02-24 Chris Johns <chrisj@rtems.org> 2 33 -
cpukit/libfs/src/rfs/rtems-rfs-block.c
r28b38f3 r3cfa636 627 627 for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 628 628 map->blocks[b] = rtems_rfs_block_get_number (buffer, b); 629 630 rtems_rfs_buffer_handle_reset (buffer); 629 631 } 630 632 else -
cpukit/libfs/src/rfs/rtems-rfs-dir.c
r28b38f3 r3cfa636 33 33 #include <rtems/rfs/rtems-rfs-dir-hash.h> 34 34 35 /** 36 * Validate the directory entry data. 37 */ 38 #define rtems_rfs_dir_entry_valid(_f, _l, _i) \ 39 (((_l) <= RTEMS_RFS_DIR_ENTRY_SIZE) || ((_l) >= rtems_rfs_fs_max_name (_f)) \ 40 || (_i < RTEMS_RFS_ROOT_INO) || (_i > rtems_rfs_fs_inodes (_f))) 41 35 42 int 36 43 rtems_rfs_dir_lookup_ino (rtems_rfs_file_system* fs, … … 137 144 break; 138 145 139 if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE) 140 || (elength >= rtems_rfs_fs_max_name (fs)) 141 || (*ino < RTEMS_RFS_ROOT_INO) 142 || (*ino >= rtems_rfs_fs_inodes (fs))) 146 if (rtems_rfs_dir_entry_valid (fs, elength, *ino)) 143 147 { 144 148 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) … … 332 336 } 333 337 334 if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE) 335 || (elength >= rtems_rfs_fs_max_name (fs)) 336 || (eino < RTEMS_RFS_ROOT_INO) 337 || (eino >= rtems_rfs_fs_inodes (fs))) 338 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 338 339 { 339 340 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) … … 426 427 break; 427 428 428 if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE) 429 || (elength >= rtems_rfs_fs_max_name (fs)) 430 || (eino < RTEMS_RFS_ROOT_INO) 431 || (eino >= rtems_rfs_fs_inodes (fs))) 429 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 432 430 { 433 431 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) … … 573 571 if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 574 572 { 575 if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE) 576 || (elength >= rtems_rfs_fs_max_name (fs)) 577 || (eino < RTEMS_RFS_ROOT_INO) 578 || (eino >= rtems_rfs_fs_inodes (fs))) 573 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 579 574 { 580 575 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) … … 691 686 break; 692 687 693 if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE) 694 || (elength >= rtems_rfs_fs_max_name (fs)) 695 || (eino < RTEMS_RFS_ROOT_INO) 696 || (eino >= rtems_rfs_fs_inodes (fs))) 688 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 697 689 { 698 690 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) -
cpukit/libfs/src/rfs/rtems-rfs-file-system.c
r28b38f3 r3cfa636 55 55 if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC) 56 56 { 57 rtems_rfs_buffer_handle_close (fs, &handle);58 57 if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN)) 59 58 printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n"); 59 rtems_rfs_buffer_handle_close (fs, &handle); 60 60 return EIO; 61 61 } … … 66 66 if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs)) 67 67 { 68 rtems_rfs_buffer_handle_close (fs, &handle);69 68 if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN)) 70 69 printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n"); 71 return EIO; 72 } 73 70 rtems_rfs_buffer_handle_close (fs, &handle); 71 return EIO; 72 } 73 74 if ((read_sb (RTEMS_RFS_SB_OFFSET_VERSION) & RTEMS_RFS_VERSION_MASK) != 75 (RTEMS_RFS_VERSION * RTEMS_RFS_VERSION_MASK)) 76 { 77 if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN)) 78 printf ("rtems-rfs: read-superblock: incompatible version: %08x (%08x)\n", 79 read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK); 80 rtems_rfs_buffer_handle_close (fs, &handle); 81 return EIO; 82 } 83 84 if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE) 85 { 86 if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN)) 87 printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%d target:%d\n", 88 read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK); 89 rtems_rfs_buffer_handle_close (fs, &handle); 90 return EIO; 91 } 92 74 93 fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS); 75 94 fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH); … … 78 97 fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES); 79 98 80 fs->blocks_per_block = rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block); 99 fs->blocks_per_block = 100 rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block); 81 101 82 102 fs->block_map_singly_blocks = … … 87 107 fs->inodes = fs->group_count * fs->group_inodes; 88 108 89 fs->inodes_per_block = fs->block_size / sizeof (rtems_rfs_inode);109 fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE; 90 110 91 111 if (fs->group_blocks > -
cpukit/libfs/src/rfs/rtems-rfs-file-system.h
r28b38f3 r3cfa636 28 28 #define RTEMS_RFS_SB_OFFSET_MAGIC (0) 29 29 #define RTEMS_RFS_SB_MAGIC (0x28092001) 30 #define RTEMS_RFS_SB_OFFSET_BLOCK_SIZE (4) 31 #define RTEMS_RFS_SB_OFFSET_BLOCKS (8) 32 #define RTEMS_RFS_SB_OFFSET_BAD_BLOCKS (12) 33 #define RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH (16) 34 #define RTEMS_RFS_SB_OFFSET_GROUPS (20) 35 #define RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS (24) 36 #define RTEMS_RFS_SB_OFFSET_GROUP_INODES (28) 30 #define RTEMS_RFS_SB_OFFSET_VERSION (RTEMS_RFS_SB_OFFSET_MAGIC + 4) 31 #define RTEMS_RFS_SB_OFFSET_BLOCK_SIZE (RTEMS_RFS_SB_OFFSET_VERSION + 4) 32 #define RTEMS_RFS_SB_OFFSET_BLOCKS (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE + 4) 33 #define RTEMS_RFS_SB_OFFSET_BAD_BLOCKS (RTEMS_RFS_SB_OFFSET_BLOCKS + 4) 34 #define RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS + 4) 35 #define RTEMS_RFS_SB_OFFSET_GROUPS (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH + 4) 36 #define RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS (RTEMS_RFS_SB_OFFSET_GROUPS + 4) 37 #define RTEMS_RFS_SB_OFFSET_GROUP_INODES (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS + 4) 38 #define RTEMS_RFS_SB_OFFSET_INODE_SIZE (RTEMS_RFS_SB_OFFSET_GROUP_INODES + 4) 39 40 /** 41 * RFS Version Number. 42 */ 43 #define RTEMS_RFS_VERSION (0x00000000) 44 45 /** 46 * RFS Version Number Mask. The mask determines which bits of the version 47 * number indicate compatility issues. 48 */ 49 #define RTEMS_RFS_VERSION_MASK (0x00000000) 37 50 38 51 /** -
cpukit/libfs/src/rfs/rtems-rfs-file.c
r28b38f3 r3cfa636 276 276 } 277 277 278 if (read && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))) 278 if (read 279 && rtems_rfs_block_map_last (rtems_rfs_file_map (handle)) 280 && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle))) 279 281 size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)); 280 282 else … … 420 422 rtems_rfs_block_map* map = rtems_rfs_file_map (handle); 421 423 rtems_rfs_pos size; 424 int rc; 422 425 423 426 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) … … 428 431 */ 429 432 if (new_size == 0) 430 return rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map); 433 { 434 rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map); 435 if (rc > 0) 436 return rc; 437 } 438 else 439 { 440 size = rtems_rfs_file_size (handle); 441 442 /* 443 * If the file is same size do nothing else grow or shrink it ? 444 */ 445 if (size != new_size) 446 { 447 if (size < new_size) 448 { 449 /* 450 * Grow. Fill with 0's. 451 */ 452 rtems_rfs_pos count; 453 uint32_t length; 454 bool read_block; 455 456 count = new_size - size; 457 length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 458 read_block = false; 459 460 while (count) 461 { 462 rtems_rfs_buffer_block block; 463 rtems_rfs_block_pos bpos; 464 uint8_t* dst; 465 466 /* 467 * Get the block position for the current end of the file as seen by 468 * the map. If not found and the EOF grow the map then fill the block 469 * with 0. 470 */ 471 rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos); 472 rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle), 473 map, &bpos, &block); 474 if (rc > 0) 475 { 476 /* 477 * Have we reached the EOF ? 478 */ 479 if (rc != ENXIO) 480 return rc; 481 482 rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle), 483 map, 1, &block); 484 if (rc > 0) 485 return rc; 486 } 487 488 if (count < (length - bpos.boff)) 489 { 490 length = count + bpos.boff; 491 read_block = true; 492 rtems_rfs_block_map_set_size_offset (map, length); 493 } 494 else 495 { 496 rtems_rfs_block_map_set_size_offset (map, 0); 497 } 498 499 /* 500 * Only read the block if the length is not the block size. 501 */ 502 rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 503 rtems_rfs_file_buffer (handle), 504 block, read_block); 505 if (rc > 0) 506 return rc; 507 508 dst = rtems_rfs_buffer_data (&handle->buffer); 509 memset (dst + bpos.boff, 0, length - bpos.boff); 510 511 rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); 512 513 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 514 rtems_rfs_file_buffer (handle)); 515 if (rc > 0) 516 return rc; 517 518 count -= length - bpos.boff; 519 } 520 } 521 else 522 { 523 /* 524 * Shrink 525 */ 526 rtems_rfs_block_no blocks; 527 uint32_t offset; 528 529 blocks = 530 rtems_rfs_block_map_count (map) - 531 (((new_size - 1) / 532 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1); 533 534 offset = 535 new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 431 536 432 size = rtems_rfs_file_size (handle); 433 434 /* 435 * If the file is same size do nothing else grow or shrink it ? 436 */ 437 if (size != new_size) 438 { 439 if (size < new_size) 440 { 441 /* 442 * Grow. Fill with 0's. 443 */ 444 rtems_rfs_pos count; 445 uint32_t length; 446 bool read_block; 447 448 count = new_size - size; 449 length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 450 read_block = false; 451 452 while (count) 453 { 454 rtems_rfs_buffer_block block; 455 rtems_rfs_block_pos bpos; 456 uint8_t* dst; 457 int rc; 458 459 /* 460 * Get the block position for the current end of the file as seen by 461 * the map. If not found and the EOF grow the map then fill the block 462 * with 0. 463 */ 464 rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos); 465 rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle), 466 map, &bpos, &block); 467 if (rc > 0) 537 if (blocks) 468 538 { 469 /* 470 * Have we reached the EOF ? 471 */ 472 if (rc != ENXIO) 473 return rc; 474 475 rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle), 476 map, 1, &block); 539 int rc; 540 rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle), 541 rtems_rfs_file_map (handle), 542 blocks); 477 543 if (rc > 0) 478 544 return rc; 479 545 } 480 546 481 if (count < (length - bpos.boff)) 482 { 483 length = count + bpos.boff; 484 read_block = true; 485 rtems_rfs_block_map_set_size_offset (map, length); 486 } 487 else 488 { 489 rtems_rfs_block_map_set_size_offset (map, 0); 490 } 491 492 /* 493 * Only read the block if the length is not the block size. 494 */ 495 rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 496 rtems_rfs_file_buffer (handle), 497 block, read_block); 498 if (rc > 0) 499 return rc; 500 501 dst = rtems_rfs_buffer_data (&handle->buffer); 502 memset (dst + bpos.boff, 0, length - bpos.boff); 503 504 rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); 505 506 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 507 rtems_rfs_file_buffer (handle)); 508 if (rc > 0) 509 return rc; 510 511 count -= length - bpos.boff; 547 rtems_rfs_block_map_set_size_offset (map, offset); 548 549 if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle), 550 rtems_rfs_block_map_size (map))) 551 rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), 552 rtems_rfs_file_bpos (handle)); 512 553 } 513 554 } 514 else 515 { 516 /* 517 * Shrink 518 */ 519 rtems_rfs_block_no blocks; 520 uint32_t offset; 521 522 blocks = 523 rtems_rfs_block_map_count (map) - 524 (((new_size - 1) / 525 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1); 526 527 offset = 528 new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 529 530 if (blocks) 531 { 532 int rc; 533 rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle), 534 rtems_rfs_file_map (handle), 535 blocks); 536 if (rc > 0) 537 return rc; 538 } 539 540 rtems_rfs_block_map_set_size_offset (map, offset); 541 542 if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle), 543 rtems_rfs_block_map_size (map))) 544 rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), 545 rtems_rfs_file_bpos (handle)); 546 } 547 548 handle->shared->size.count = rtems_rfs_block_map_count (map); 549 handle->shared->size.offset = rtems_rfs_block_map_size_offset (map); 550 551 if (rtems_rfs_file_update_mtime (handle)) 552 handle->shared->mtime = time (NULL); 553 } 554 555 } 556 557 handle->shared->size.count = rtems_rfs_block_map_count (map); 558 handle->shared->size.offset = rtems_rfs_block_map_size_offset (map); 559 560 if (rtems_rfs_file_update_mtime (handle)) 561 handle->shared->mtime = time (NULL); 562 555 563 return 0; 556 564 } -
cpukit/libfs/src/rfs/rtems-rfs-format.c
r28b38f3 r3cfa636 62 62 { 63 63 int blocks; 64 blocks = (rtems_rfs_bits_per_block (fs) * percentage) / 100; 65 return blocks * (rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode)); 64 blocks = ((rtems_rfs_fs_blocks (fs) - 65 RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100; 66 blocks = rtems_rfs_rup_quotient (blocks, fs->group_count); 67 return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE); 66 68 } 67 69 … … 73 75 { 74 76 int blocks; 75 blocks = 76 (fs->group_inodes * sizeof (rtems_rfs_inode)) / rtems_rfs_fs_block_size (fs); 77 return ((blocks + 1) * 100 * 10) / rtems_rfs_bits_per_block (fs); 77 int bits_per_block; 78 blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE, 79 rtems_rfs_fs_block_size (fs)); 80 bits_per_block = rtems_rfs_bits_per_block (fs); 81 /* 82 * There could be more bits that there are blocks, eg 512K disk with 512 83 * blocks. 84 */ 85 if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE)) 86 bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE; 87 return ((blocks + 1) * 100 * 10) / bits_per_block; 78 88 } 79 89 … … 87 97 uint64_t total_size = rtems_rfs_fs_media_size (fs); 88 98 89 if (total_size > GIGS (2))99 if (total_size >= GIGS (1)) 90 100 { 91 101 uint32_t gigs = (total_size + GIGS (1)) / GIGS (1); … … 97 107 } 98 108 99 if (fs->block_size < 1024)100 fs->block_size = 1024;109 if (fs->block_size < 512) 110 fs->block_size = 512; 101 111 102 112 if (fs->block_size > (4 * 1024)) … … 127 137 } 128 138 139 fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size; 140 141 /* 142 * The bits per block sets the upper limit for the number of blocks in a 143 * group. The disk will be divided into groups which are the number of bits 144 * per block. 145 */ 146 fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 147 rtems_rfs_bits_per_block (fs)); 148 129 149 fs->group_inodes = config->group_inodes; 130 150 if (!fs->group_inodes) … … 144 164 * Round up to fill a block because the minimum allocation unit is a block. 145 165 */ 146 fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode);166 fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE; 147 167 fs->group_inodes = 148 168 rtems_rfs_rup_quotient (fs->group_inodes, … … 399 419 400 420 write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC); 421 write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION); 401 422 write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs)); 402 423 write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs)); … … 406 427 write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks); 407 428 write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes); 429 write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE); 408 430 409 431 rtems_rfs_buffer_mark_dirty (&handle); … … 549 571 if (!rtems_rfs_check_config (&fs, config)) 550 572 return -1; 551 552 fs.blocks = rtems_rfs_fs_media_size (&fs) / fs.block_size;553 554 /*555 * The bits per block sets the upper limit for the number of blocks in a556 * group. The disk will be divided into groups which are the number of bits557 * per block.558 */559 fs.group_count =560 ((rtems_rfs_fs_blocks (&fs) - 1) / rtems_rfs_bits_per_block (&fs)) + 1;561 573 562 574 if (config->verbose) … … 576 588 printf ("rtems-rfs: format: bits per block = %u\n", 577 589 rtems_rfs_bits_per_block (&fs)); 578 printf ("rtems-rfs: format: inode size = %lu\n", sizeof (rtems_rfs_inode));590 printf ("rtems-rfs: format: inode size = %lu\n", RTEMS_RFS_INODE_SIZE); 579 591 printf ("rtems-rfs: format: inodes = %lu (%d.%d%%)\n", 580 592 fs.group_inodes * fs.group_count, -
cpukit/libfs/src/rfs/rtems-rfs-inode.c
r28b38f3 r3cfa636 212 212 rc = rtems_rfs_inode_open (fs, *ino, &inode, true); 213 213 if (rc > 0) 214 return rc; 215 214 { 215 rtems_rfs_inode_free (fs, *ino); 216 return rc; 217 } 218 216 219 rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid); 217 220 if (rc > 0) … … 224 227 /* 225 228 * Only handle the specifics of a directory. Let caller handle the others. 229 * 230 * The inode delete will free the inode. 226 231 */ 227 232 if (RTEMS_RFS_S_ISDIR (mode)) … … 308 313 if (rc > 0) 309 314 rrc = rc; 310 memset (handle->node, 0xff, sizeof (rtems_rfs_inode));315 memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE); 311 316 rtems_rfs_buffer_mark_dirty (&handle->buffer); 312 317 /* -
cpukit/libfs/src/rfs/rtems-rfs-inode.h
r28b38f3 r3cfa636 170 170 171 171 /** 172 * The size of an inode. 173 */ 174 #define RTEMS_RFS_INODE_SIZE (sizeof (rtems_rfs_inode)) 175 176 /** 172 177 * RFS Inode Handle. 173 178 */ -
cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
r28b38f3 r3cfa636 40 40 { 41 41 rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo); 42 rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);42 rtems_rfs_ino ino; 43 43 rtems_rfs_file_handle* file; 44 44 uint32_t flags; … … 52 52 53 53 rtems_rfs_rtems_lock (fs); 54 55 ino = rtems_rfs_rtems_get_iop_ino (iop); 54 56 55 57 rc = rtems_rfs_file_open (fs, ino, flags, &file); … … 110 112 { 111 113 rtems_rfs_file_handle* file = iop->file_info; 112 rtems_rfs_pos pos = iop->offset;114 rtems_rfs_pos pos; 113 115 uint8_t* data = buffer; 114 116 ssize_t read = 0; … … 120 122 rtems_rfs_rtems_lock (rtems_rfs_file_fs (file)); 121 123 124 pos = iop->offset; 125 122 126 if (pos < rtems_rfs_file_size (file)) 123 127 { … … 173 177 { 174 178 rtems_rfs_file_handle* file = iop->file_info; 175 rtems_rfs_pos pos = iop->offset;179 rtems_rfs_pos pos; 176 180 const uint8_t* data = buffer; 177 181 ssize_t write = 0; … … 183 187 rtems_rfs_rtems_lock (rtems_rfs_file_fs (file)); 184 188 189 pos = iop->offset; 190 185 191 /* 186 192 * If the iop position is past the physical end of the file we need to set the … … 267 273 printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset); 268 274 275 rtems_rfs_rtems_lock (rtems_rfs_file_fs (file)); 276 269 277 pos = iop->offset; 270 271 rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));272 278 273 279 rc = rtems_rfs_file_seek (file, pos, &pos); … … 301 307 302 308 rtems_rfs_rtems_lock (rtems_rfs_file_fs (file)); 303 309 304 310 rc = rtems_rfs_file_set_size (file, length); 305 311 if (rc) -
cpukit/libfs/src/rfs/rtems-rfs-shell.c
r28b38f3 r3cfa636 115 115 int bpcent; 116 116 int ipcent; 117 int g;118 117 119 118 printf ("RFS Filesystem Data\n"); … … 368 367 printf (" %5lu: pos=%06lu:%04lx %c ", 369 368 ino, rtems_rfs_buffer_bnum (&inode.buffer), 370 inode.offset * sizeof (rtems_rfs_inode),369 inode.offset * RTEMS_RFS_INODE_SIZE, 371 370 allocated ? 'A' : 'F'); 372 371
Note: See TracChangeset
for help on using the changeset viewer.