Changeset beb9336 in mainline for uspace/lib/ext4/libext4_superblock.c
- Timestamp:
- 2012-08-24T14:07:52Z (12 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 041ab64
- Parents:
- bd29f9c9 (diff), db81577 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/ext4/libext4_superblock.c
rbd29f9c9 rbeb9336 29 29 /** @addtogroup libext4 30 30 * @{ 31 */ 31 */ 32 32 33 33 /** 34 * @file 35 * @brief 34 * @file libext4_superblock.c 35 * @brief Ext4 superblock operations. 36 36 */ 37 37 38 38 #include <byteorder.h> 39 39 #include <errno.h> 40 #include < libblock.h>40 #include <block.h> 41 41 #include <malloc.h> 42 42 #include "libext4.h" … … 44 44 /** Get number of i-nodes in the whole filesystem. 45 45 * 46 * @param sb superblock 47 * @return number of i-nodes 46 * @param sb Superblock 47 * 48 * @return Number of i-nodes 49 * 48 50 */ 49 51 uint32_t ext4_superblock_get_inodes_count(ext4_superblock_t *sb) … … 54 56 /** Set number of i-nodes in the whole filesystem. 55 57 * 56 * @param sb superblock 57 * @param count number of i-nodes 58 * @param sb Superblock 59 * @param count Number of i-nodes 60 * 58 61 */ 59 62 void ext4_superblock_set_inodes_count(ext4_superblock_t *sb, uint32_t count) … … 64 67 /** Get number of data blocks in the whole filesystem. 65 68 * 66 * @param sb superblock 67 * @return number of data blocks 69 * @param sb Superblock 70 * 71 * @return Number of data blocks 72 * 68 73 */ 69 74 uint64_t ext4_superblock_get_blocks_count(ext4_superblock_t *sb) 70 75 { 71 return ((uint64_t) uint32_t_le2host(sb->blocks_count_hi) << 32) |72 76 return ((uint64_t) uint32_t_le2host(sb->blocks_count_hi) << 32) | 77 uint32_t_le2host(sb->blocks_count_lo); 73 78 } 74 79 75 80 /** Set number of data blocks in the whole filesystem. 76 81 * 77 * @param sb superblock 78 * @param count number of data blocks 82 * @param sb Superblock 83 * @param count Number of data blocks 84 * 79 85 */ 80 86 void ext4_superblock_set_blocks_count(ext4_superblock_t *sb, uint64_t count) … … 86 92 /** Get number of reserved data blocks in the whole filesystem. 87 93 * 88 * @param sb superblock 89 * @return number of reserved data blocks 94 * @param sb Superblock 95 * 96 * @return Number of reserved data blocks 97 * 90 98 */ 91 99 uint64_t ext4_superblock_get_reserved_blocks_count(ext4_superblock_t *sb) 92 100 { 93 return ((uint64_t)uint32_t_le2host(sb->reserved_blocks_count_hi) << 32) | 94 uint32_t_le2host(sb->reserved_blocks_count_lo); 101 return ((uint64_t) 102 uint32_t_le2host(sb->reserved_blocks_count_hi) << 32) | 103 uint32_t_le2host(sb->reserved_blocks_count_lo); 95 104 } 96 105 97 106 /** Set number of reserved data blocks in the whole filesystem. 98 107 * 99 * @param sb superblock 100 * @param count number of reserved data blocks 101 */ 102 void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *sb, uint64_t count) 108 * @param sb Superblock 109 * @param count Number of reserved data blocks 110 * 111 */ 112 void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *sb, 113 uint64_t count) 103 114 { 104 115 sb->reserved_blocks_count_lo = host2uint32_t_le((count << 32) >> 32); … … 108 119 /** Get number of free data blocks in the whole filesystem. 109 120 * 110 * @param sb superblock 111 * @return number of free data blocks 121 * @param sb Superblock 122 * 123 * @return Number of free data blocks 124 * 112 125 */ 113 126 uint64_t ext4_superblock_get_free_blocks_count(ext4_superblock_t *sb) 114 127 { 115 return ((uint64_t)uint32_t_le2host(sb->free_blocks_count_hi) << 32) | 116 uint32_t_le2host(sb->free_blocks_count_lo); 128 return ((uint64_t) 129 uint32_t_le2host(sb->free_blocks_count_hi) << 32) | 130 uint32_t_le2host(sb->free_blocks_count_lo); 117 131 } 118 132 119 133 /** Set number of free data blocks in the whole filesystem. 120 134 * 121 * @param sb superblock 122 * @param count number of free data blocks 123 */ 124 void ext4_superblock_set_free_blocks_count(ext4_superblock_t *sb, uint64_t count) 135 * @param sb Superblock 136 * @param count Number of free data blocks 137 * 138 */ 139 void ext4_superblock_set_free_blocks_count(ext4_superblock_t *sb, 140 uint64_t count) 125 141 { 126 142 sb->free_blocks_count_lo = host2uint32_t_le((count << 32) >> 32); … … 130 146 /** Get number of free i-nodes in the whole filesystem. 131 147 * 132 * @param sb superblock 133 * @return number of free i-nodes 148 * @param sb Superblock 149 * 150 * @return Number of free i-nodes 151 * 134 152 */ 135 153 uint32_t ext4_superblock_get_free_inodes_count(ext4_superblock_t *sb) … … 140 158 /** Set number of free i-nodes in the whole filesystem. 141 159 * 142 * @param sb superblock 143 * @param count number of free i-nodes 144 */ 145 void ext4_superblock_set_free_inodes_count(ext4_superblock_t *sb, uint32_t count) 160 * @param sb Superblock 161 * @param count Number of free i-nodes 162 * 163 */ 164 void ext4_superblock_set_free_inodes_count(ext4_superblock_t *sb, 165 uint32_t count) 146 166 { 147 167 sb->free_inodes_count = host2uint32_t_le(count); 148 168 } 149 169 150 /** Get index of first data block (block, where is located superblock) 151 * 152 * @param sb superblock 153 * @return index of the first data block 170 /** Get index of first data block (block where the superblock is located) 171 * 172 * @param sb Superblock 173 * 174 * @return Index of the first data block 175 * 154 176 */ 155 177 uint32_t ext4_superblock_get_first_data_block(ext4_superblock_t *sb) … … 158 180 } 159 181 160 /** Set index of first data block (block, where is located superblock) 161 * 162 * @param sb superblock 163 * @param first index of the first data block 164 */ 165 void ext4_superblock_set_first_data_block(ext4_superblock_t *sb, uint32_t first) 182 /** Set index of first data block (block where the superblock is located) 183 * 184 * @param sb Superblock 185 * @param first Index of the first data block 186 * 187 */ 188 void ext4_superblock_set_first_data_block(ext4_superblock_t *sb, 189 uint32_t first) 166 190 { 167 191 sb->first_data_block = host2uint32_t_le(first); … … 170 194 /** Get logarithmic block size (1024 << size == block_size) 171 195 * 172 * @param sb superblock 173 * @return logarithmic block size 196 * @param sb Superblock 197 * 198 * @return Logarithmic block size 199 * 174 200 */ 175 201 uint32_t ext4_superblock_get_log_block_size(ext4_superblock_t *sb) … … 180 206 /** Set logarithmic block size (1024 << size == block_size) 181 207 * 182 * @param sb superblock 183 * @return logarithmic block size 184 */ 185 void ext4_superblock_set_log_block_size(ext4_superblock_t *sb, uint32_t log_size) 208 * @param sb Superblock 209 * 210 * @return Logarithmic block size 211 * 212 */ 213 void ext4_superblock_set_log_block_size(ext4_superblock_t *sb, 214 uint32_t log_size) 186 215 { 187 216 sb->log_block_size = host2uint32_t_le(log_size); … … 190 219 /** Get size of data block (in bytes). 191 220 * 192 * @param sb superblock 193 * @return size of data block 221 * @param sb Superblock 222 * 223 * @return Size of data block 224 * 194 225 */ 195 226 uint32_t ext4_superblock_get_block_size(ext4_superblock_t *sb) … … 200 231 /** Set size of data block (in bytes). 201 232 * 202 * @param sb superblock 203 * @param size size of data block (must be power of 2, at least 1024) 233 * @param sb Superblock 234 * @param size Size of data block (must be power of 2, at least 1024) 235 * 204 236 */ 205 237 void ext4_superblock_set_block_size(ext4_superblock_t *sb, uint32_t size) … … 207 239 uint32_t log = 0; 208 240 uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE; 209 241 210 242 tmp >>= 1; 211 243 while (tmp) { … … 213 245 tmp >>= 1; 214 246 } 215 247 216 248 ext4_superblock_set_log_block_size(sb, log); 217 249 } … … 219 251 /** Get logarithmic fragment size (1024 << size) 220 252 * 221 * @param sb superblock 222 * @return logarithmic fragment size 253 * @param sb Superblock 254 * 255 * @return Logarithmic fragment size 256 * 223 257 */ 224 258 uint32_t ext4_superblock_get_log_frag_size(ext4_superblock_t *sb) … … 229 263 /** Set logarithmic fragment size (1024 << size) 230 264 * 231 * @param sb superblock 232 * @return logarithmic fragment size 233 */ 234 235 void ext4_superblock_set_log_frag_size(ext4_superblock_t *sb, uint32_t frag_size) 265 * @param sb Superblock 266 * @param frag_size Logarithmic fragment size 267 * 268 */ 269 void ext4_superblock_set_log_frag_size(ext4_superblock_t *sb, 270 uint32_t frag_size) 236 271 { 237 272 sb->log_frag_size = host2uint32_t_le(frag_size); … … 240 275 /** Get size of fragment (in bytes). 241 276 * 242 * @param sb superblock 243 * @return size of fragment 277 * @param sb Superblock 278 * 279 * @return Size of fragment 280 * 244 281 */ 245 282 uint32_t ext4_superblock_get_frag_size(ext4_superblock_t *sb) … … 250 287 /** Set size of fragment (in bytes). 251 288 * 252 * @param sb superblock 253 * @param size size of fragment (must be power of 2, at least 1024) 289 * @param sb Superblock 290 * @param size Size of fragment (must be power of 2, at least 1024) 291 * 254 292 */ 255 293 void ext4_superblock_set_frag_size(ext4_superblock_t *sb, uint32_t size) … … 257 295 uint32_t log = 0; 258 296 uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE; 259 297 260 298 tmp >>= 1; 261 299 while (tmp) { … … 263 301 tmp >>= 1; 264 302 } 265 303 266 304 ext4_superblock_set_log_frag_size(sb, log); 267 305 } … … 269 307 /** Get number of data blocks per block group (except last BG) 270 308 * 271 * @param sb superblock 272 * @return data blocks per block group 309 * @param sb Superblock 310 * 311 * @return Data blocks per block group 312 * 273 313 */ 274 314 uint32_t ext4_superblock_get_blocks_per_group(ext4_superblock_t *sb) … … 279 319 /** Set number of data blocks per block group (except last BG) 280 320 * 281 * @param sb superblock 282 * @param blocks data blocks per block group 283 */ 284 void ext4_superblock_set_blocks_per_group(ext4_superblock_t *sb, uint32_t blocks) 321 * @param sb Superblock 322 * @param blocks Data blocks per block group 323 * 324 */ 325 void ext4_superblock_set_blocks_per_group(ext4_superblock_t *sb, 326 uint32_t blocks) 285 327 { 286 328 sb->blocks_per_group = host2uint32_t_le(blocks); … … 289 331 /** Get number of fragments per block group (except last BG) 290 332 * 291 * @param sb superblock 292 * @return fragments per block group 333 * @param sb Superblock 334 * 335 * @return Fragments per block group 336 * 293 337 */ 294 338 uint32_t ext4_superblock_get_frags_per_group(ext4_superblock_t *sb) … … 299 343 /** Set number of fragment per block group (except last BG) 300 344 * 301 * @param sb superblock302 * @param frags fragments per block group345 * @param sb Superblock 346 * @param frags Fragments per block group 303 347 */ 304 348 void ext4_superblock_set_frags_per_group(ext4_superblock_t *sb, uint32_t frags) … … 307 351 } 308 352 309 310 353 /** Get number of i-nodes per block group (except last BG) 311 354 * 312 * @param sb superblock 313 * @return i-nodes per block group 355 * @param sb Superblock 356 * 357 * @return I-nodes per block group 358 * 314 359 */ 315 360 uint32_t ext4_superblock_get_inodes_per_group(ext4_superblock_t *sb) … … 320 365 /** Set number of i-nodes per block group (except last BG) 321 366 * 322 * @param sb superblock 323 * @param inodes i-nodes per block group 324 */ 325 void ext4_superblock_set_inodes_per_group(ext4_superblock_t *sb, uint32_t inodes) 367 * @param sb Superblock 368 * @param inodes I-nodes per block group 369 * 370 */ 371 void ext4_superblock_set_inodes_per_group(ext4_superblock_t *sb, 372 uint32_t inodes) 326 373 { 327 374 sb->inodes_per_group = host2uint32_t_le(inodes); … … 330 377 /** Get time when filesystem was mounted (POSIX time). 331 378 * 332 * @param sb superblock 333 * @return mount time 379 * @param sb Superblock 380 * 381 * @return Mount time 382 * 334 383 */ 335 384 uint32_t ext4_superblock_get_mount_time(ext4_superblock_t *sb) … … 340 389 /** Set time when filesystem was mounted (POSIX time). 341 390 * 342 * @param sb superblock 343 * @param time mount time 391 * @param sb Superblock 392 * @param time Mount time 393 * 344 394 */ 345 395 void ext4_superblock_set_mount_time(ext4_superblock_t *sb, uint32_t time) … … 350 400 /** Get time when filesystem was last accesed by write operation (POSIX time). 351 401 * 352 * @param sb superblock 353 * @return write time 402 * @param sb Superblock 403 * 404 * @return Write time 405 * 354 406 */ 355 407 uint32_t ext4_superblock_get_write_time(ext4_superblock_t *sb) … … 360 412 /** Set time when filesystem was last accesed by write operation (POSIX time). 361 413 * 362 * @param sb superblock 363 * @param time write time 414 * @param sb Superblock 415 * @param time Write time 416 * 364 417 */ 365 418 void ext4_superblock_set_write_time(ext4_superblock_t *sb, uint32_t time) … … 370 423 /** Get number of mount from last filesystem check. 371 424 * 372 * @param sb superblock 373 * @return number of mounts 425 * @param sb Superblock 426 * 427 * @return Number of mounts 428 * 374 429 */ 375 430 uint16_t ext4_superblock_get_mount_count(ext4_superblock_t *sb) … … 380 435 /** Set number of mount from last filesystem check. 381 436 * 382 * @param sb superblock 383 * @param count number of mounts 437 * @param sb Superblock 438 * @param count Number of mounts 439 * 384 440 */ 385 441 void ext4_superblock_set_mount_count(ext4_superblock_t *sb, uint16_t count) … … 390 446 /** Get maximum number of mount from last filesystem check. 391 447 * 392 * @param sb superblock 393 * @return maximum number of mounts 448 * @param sb Superblock 449 * 450 * @return Maximum number of mounts 451 * 394 452 */ 395 453 uint16_t ext4_superblock_get_max_mount_count(ext4_superblock_t *sb) … … 400 458 /** Set maximum number of mount from last filesystem check. 401 459 * 402 * @param sb superblock 403 * @param count maximum number of mounts 460 * @param sb Superblock 461 * @param count Maximum number of mounts 462 * 404 463 */ 405 464 void ext4_superblock_set_max_mount_count(ext4_superblock_t *sb, uint16_t count) … … 410 469 /** Get superblock magic value. 411 470 * 412 * @param sb superblock 413 * @return magic value 471 * @param sb Superblock 472 * 473 * @return Magic value 474 * 414 475 */ 415 476 uint16_t ext4_superblock_get_magic(ext4_superblock_t *sb) … … 420 481 /** Set superblock magic value. 421 482 * 422 * @param sb superblock 423 * @param magic value 483 * @param sb Superblock 484 * @param magic Magic value 485 * 424 486 */ 425 487 void ext4_superblock_set_magic(ext4_superblock_t *sb, uint16_t magic) … … 430 492 /** Get filesystem state. 431 493 * 432 * @param sb superblock 433 * @return filesystem state 494 * @param sb Superblock 495 * 496 * @return Filesystem state 497 * 434 498 */ 435 499 uint16_t ext4_superblock_get_state(ext4_superblock_t *sb) … … 440 504 /** Set filesystem state. 441 505 * 442 * @param sb superblock 443 * @param state filesystem state 506 * @param sb Superblock 507 * @param state Filesystem state 508 * 444 509 */ 445 510 void ext4_superblock_set_state(ext4_superblock_t *sb, uint16_t state) … … 450 515 /** Get behavior code when errors detected. 451 516 * 452 * @param sb superblock 453 * @return behavior code 517 * @param sb Superblock 518 * 519 * @return Behavior code 520 * 454 521 */ 455 522 uint16_t ext4_superblock_get_errors(ext4_superblock_t *sb) … … 460 527 /** Set behavior code when errors detected. 461 528 * 462 * @param sb superblock 463 * @param errors behavior code 529 * @param sb Superblock 530 * @param errors Behavior code 531 * 464 532 */ 465 533 void ext4_superblock_set_errors(ext4_superblock_t *sb, uint16_t errors) … … 470 538 /** Get minor revision level of the filesystem. 471 539 * 472 * @param sb superblock 473 * @return minor revision level 540 * @param sb Superblock 541 * 542 * @return Minor revision level 543 * 474 544 */ 475 545 uint16_t ext4_superblock_get_minor_rev_level(ext4_superblock_t *sb) … … 480 550 /** Set minor revision level of the filesystem. 481 551 * 482 * @param sb superblock 483 * @param level minor revision level 552 * @param sb Superblock 553 * @param level Minor revision level 554 * 484 555 */ 485 556 void ext4_superblock_set_minor_rev_level(ext4_superblock_t *sb, uint16_t level) … … 490 561 /** Get time of the last filesystem check. 491 562 * 492 * @param sb superblock 493 * @return time of the last check (POSIX) 563 * @param sb Superblock 564 * 565 * @return Time of the last check (POSIX) 566 * 494 567 */ 495 568 uint32_t ext4_superblock_get_last_check_time(ext4_superblock_t *sb) … … 500 573 /** Set time of the last filesystem check. 501 574 * 502 * @param sb superblock 503 * @param time time of the last check (POSIX) 575 * @param sb Superblock 576 * @param time Time of the last check (POSIX) 577 * 504 578 */ 505 579 void ext4_superblock_set_last_check_time(ext4_superblock_t *sb, uint32_t time) … … 510 584 /** Get maximum time interval between two filesystem checks. 511 585 * 512 * @param sb superblock 513 * @return time interval between two check (POSIX) 514 */ 515 uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *sb){ 586 * @param sb Superblock 587 * 588 * @return Time interval between two check (POSIX) 589 * 590 */ 591 uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *sb) 592 { 516 593 return uint32_t_le2host(sb->check_interval); 517 594 } … … 519 596 /** Set maximum time interval between two filesystem checks. 520 597 * 521 * @param sb superblock 522 * @param interval time interval between two check (POSIX) 598 * @param sb Superblock 599 * @param interval Time interval between two check (POSIX) 600 * 523 601 */ 524 602 void ext4_superblock_set_check_interval(ext4_superblock_t *sb, uint32_t interval) … … 529 607 /** Get operation system identifier, on which the filesystem was created. 530 608 * 531 * @param sb superblock 532 * @return operation system identifier 609 * @param sb Superblock 610 * 611 * @return Operation system identifier 612 * 533 613 */ 534 614 uint32_t ext4_superblock_get_creator_os(ext4_superblock_t *sb) … … 539 619 /** Set operation system identifier, on which the filesystem was created. 540 620 * 541 * @param sb superblock 542 * @param os operation system identifier 621 * @param sb Superblock 622 * @param os Operation system identifier 623 * 543 624 */ 544 625 void ext4_superblock_set_creator_os(ext4_superblock_t *sb, uint32_t os) … … 549 630 /** Get revision level of the filesystem. 550 631 * 551 * @param sb superblock 552 * @return revision level 632 * @param sb Superblock 633 * 634 * @return Revision level 635 * 553 636 */ 554 637 uint32_t ext4_superblock_get_rev_level(ext4_superblock_t *sb) … … 559 642 /** Set revision level of the filesystem. 560 643 * 561 * @param sb superblock 562 * @param level revision level 644 * @param sb Superblock 645 * @param level Revision level 646 * 563 647 */ 564 648 void ext4_superblock_set_rev_level(ext4_superblock_t *sb, uint32_t level) … … 569 653 /** Get default user id for reserved blocks. 570 654 * 571 * @param sb superblock 572 * @return default user id for reserved blocks. 655 * @param sb Superblock 656 * 657 * @return Default user id for reserved blocks. 658 * 573 659 */ 574 660 uint16_t ext4_superblock_get_def_resuid(ext4_superblock_t *sb) … … 579 665 /** Set default user id for reserved blocks. 580 666 * 581 * @param sb superblock 582 * @param uid default user id for reserved blocks. 667 * @param sb Superblock 668 * @param uid Default user id for reserved blocks. 669 * 583 670 */ 584 671 void ext4_superblock_set_def_resuid(ext4_superblock_t *sb, uint16_t uid) … … 589 676 /** Get default group id for reserved blocks. 590 677 * 591 * @param sb superblock 592 * @return default group id for reserved blocks. 678 * @param sb Superblock 679 * 680 * @return Default group id for reserved blocks. 681 * 593 682 */ 594 683 uint16_t ext4_superblock_get_def_resgid(ext4_superblock_t *sb) … … 599 688 /** Set default group id for reserved blocks. 600 689 * 601 * @param sb superblock 602 * @param gid default group id for reserved blocks. 690 * @param sb Superblock 691 * @param gid Default group id for reserved blocks. 692 * 603 693 */ 604 694 void ext4_superblock_set_def_resgid(ext4_superblock_t *sb, uint16_t gid) … … 609 699 /** Get index of the first i-node, which can be used for allocation. 610 700 * 611 * @param sb superblock 612 * @return i-node index 701 * @param sb Superblock 702 * 703 * @return I-node index 704 * 613 705 */ 614 706 uint32_t ext4_superblock_get_first_inode(ext4_superblock_t *sb) … … 619 711 /** Set index of the first i-node, which can be used for allocation. 620 712 * 621 * @param sb superblock 622 * @param first_inode i-node index 623 */ 624 void ext4_superblock_set_first_inode(ext4_superblock_t *sb, uint32_t first_inode) 713 * @param sb Superblock 714 * @param first_inode I-node index 715 * 716 */ 717 void ext4_superblock_set_first_inode(ext4_superblock_t *sb, 718 uint32_t first_inode) 625 719 { 626 720 sb->first_inode = host2uint32_t_le(first_inode); … … 631 725 * For the oldest revision return constant number. 632 726 * 633 * @param sb superblock 634 * @return size of i-node structure 727 * @param sb Superblock 728 * 729 * @return Size of i-node structure 730 * 635 731 */ 636 732 uint16_t ext4_superblock_get_inode_size(ext4_superblock_t *sb) 637 733 { 638 if (ext4_superblock_get_rev_level(sb) == 0) {734 if (ext4_superblock_get_rev_level(sb) == 0) 639 735 return EXT4_REV0_INODE_SIZE; 640 }736 641 737 return uint16_t_le2host(sb->inode_size); 642 738 } … … 644 740 /** Set size of i-node structure. 645 741 * 646 * @param sb superblock 647 * @param size size of i-node structure 742 * @param sb Superblock 743 * @param size Size of i-node structure 744 * 648 745 */ 649 746 void ext4_superblock_set_inode_size(ext4_superblock_t *sb, uint16_t size) … … 654 751 /** Get index of block group, where superblock copy is located. 655 752 * 656 * @param sb superblock 657 * @return block group index 753 * @param sb Superblock 754 * 755 * @return Block group index 756 * 658 757 */ 659 758 uint16_t ext4_superblock_get_block_group_index(ext4_superblock_t *sb) … … 664 763 /** Set index of block group, where superblock copy is located. 665 764 * 666 * @param sb superblock 667 * @param bgid block group index 765 * @param sb Superblock 766 * @param bgid Block group index 767 * 668 768 */ 669 769 void ext4_superblock_set_block_group_index(ext4_superblock_t *sb, uint16_t bgid) … … 674 774 /** Get compatible features supported by the filesystem. 675 775 * 676 * @param sb superblock 677 * @return compatible features bitmap 776 * @param sb Superblock 777 * 778 * @return Compatible features bitmap 779 * 678 780 */ 679 781 uint32_t ext4_superblock_get_features_compatible(ext4_superblock_t *sb) … … 684 786 /** Set compatible features supported by the filesystem. 685 787 * 686 * @param sb superblock 687 * @param features compatible features bitmap 688 */ 689 void ext4_superblock_set_features_compatible(ext4_superblock_t *sb, uint32_t features) 788 * @param sb Superblock 789 * @param features Compatible features bitmap 790 * 791 */ 792 void ext4_superblock_set_features_compatible(ext4_superblock_t *sb, 793 uint32_t features) 690 794 { 691 795 sb->features_compatible = host2uint32_t_le(features); … … 694 798 /** Get incompatible features supported by the filesystem. 695 799 * 696 * @param sb superblock 697 * @return incompatible features bitmap 800 * @param sb Superblock 801 * 802 * @return Incompatible features bitmap 803 * 698 804 */ 699 805 uint32_t ext4_superblock_get_features_incompatible(ext4_superblock_t *sb) … … 704 810 /** Set incompatible features supported by the filesystem. 705 811 * 706 * @param sb superblock 707 * @param features incompatible features bitmap 708 */ 709 void ext4_superblock_set_features_incompatible(ext4_superblock_t *sb, uint32_t features) 812 * @param sb Superblock 813 * @param features Incompatible features bitmap 814 * 815 */ 816 void ext4_superblock_set_features_incompatible(ext4_superblock_t *sb, 817 uint32_t features) 710 818 { 711 819 sb->features_incompatible = host2uint32_t_le(features); … … 714 822 /** Get compatible features supported by the filesystem. 715 823 * 716 * @param sb superblock 717 * @return read-only compatible features bitmap 824 * @param sb Superblock 825 * 826 * @return Read-only compatible features bitmap 827 * 718 828 */ 719 829 uint32_t ext4_superblock_get_features_read_only(ext4_superblock_t *sb) … … 724 834 /** Set compatible features supported by the filesystem. 725 835 * 726 * @param sb superblock 727 * @param feature read-only compatible features bitmap 728 */ 729 void ext4_superblock_set_features_read_only(ext4_superblock_t *sb, uint32_t features) 836 * @param sb Superblock 837 * @param feature Read-only compatible features bitmap 838 * 839 */ 840 void ext4_superblock_set_features_read_only(ext4_superblock_t *sb, 841 uint32_t features) 730 842 { 731 843 sb->features_read_only = host2uint32_t_le(features); … … 734 846 /** Get UUID of the filesystem. 735 847 * 736 * @param sb superblock 737 * @return pointer to UUID array 738 */ 739 const uint8_t * ext4_superblock_get_uuid(ext4_superblock_t *sb) 848 * @param sb superblock 849 * 850 * @return Pointer to UUID array 851 * 852 */ 853 const uint8_t *ext4_superblock_get_uuid(ext4_superblock_t *sb) 740 854 { 741 855 return sb->uuid; … … 744 858 /** Set UUID of the filesystem. 745 859 * 746 * @param sb superblock 747 * @param uuid pointer to UUID array 860 * @param sb Superblock 861 * @param uuid Pointer to UUID array 862 * 748 863 */ 749 864 void ext4_superblock_set_uuid(ext4_superblock_t *sb, const uint8_t *uuid) … … 754 869 /** Get name of the filesystem volume. 755 870 * 756 * @param sb superblock 757 * @return name of the volume 758 */ 759 const char * ext4_superblock_get_volume_name(ext4_superblock_t *sb) 871 * @param sb Superblock 872 * 873 * @return Name of the volume 874 * 875 */ 876 const char *ext4_superblock_get_volume_name(ext4_superblock_t *sb) 760 877 { 761 878 return sb->volume_name; … … 764 881 /** Set name of the filesystem volume. 765 882 * 766 * @param sb superblock767 * @param name new name of the volume883 * @param sb Superblock 884 * @param name New name of the volume 768 885 */ 769 886 void ext4_superblock_set_volume_name(ext4_superblock_t *sb, const char *name) … … 774 891 /** Get name of the directory, where this filesystem was mounted at last. 775 892 * 776 * @param sb superblock 777 * @return directory name 778 */ 779 const char * ext4_superblock_get_last_mounted(ext4_superblock_t *sb) 893 * @param sb Superblock 894 * 895 * @return Directory name 896 * 897 */ 898 const char *ext4_superblock_get_last_mounted(ext4_superblock_t *sb) 780 899 { 781 900 return sb->last_mounted; … … 784 903 /** Set name of the directory, where this filesystem was mounted at last. 785 904 * 786 * @param sb superblock 787 * @param last directory name 905 * @param sb Superblock 906 * @param last Directory name 907 * 788 908 */ 789 909 void ext4_superblock_set_last_mounted(ext4_superblock_t *sb, const char *last) … … 796 916 * Orphans are stored in linked list. 797 917 * 798 * @param sb superblock 799 * @return last orphaned i-node index 918 * @param sb Superblock 919 * 920 * @return Last orphaned i-node index 921 * 800 922 */ 801 923 uint32_t ext4_superblock_get_last_orphan(ext4_superblock_t *sb) … … 808 930 * Orphans are stored in linked list. 809 931 * 810 * @param sb superblock 811 * @param last_orphan last orphaned i-node index 812 */ 813 void ext4_superblock_set_last_orphan(ext4_superblock_t *sb, uint32_t last_orphan) 932 * @param sb Superblock 933 * @param last_orphan Last orphaned i-node index 934 * 935 */ 936 void ext4_superblock_set_last_orphan(ext4_superblock_t *sb, 937 uint32_t last_orphan) 814 938 { 815 939 sb->last_orphan = host2uint32_t_le(last_orphan); … … 818 942 /** Get hash seed for directory index hash function. 819 943 * 820 * @param sb superblock 821 * @return hash seed pointer 822 */ 823 const uint32_t * ext4_superblock_get_hash_seed(ext4_superblock_t *sb) 944 * @param sb Superblock 945 * 946 * @return Hash seed pointer 947 * 948 */ 949 const uint32_t *ext4_superblock_get_hash_seed(ext4_superblock_t *sb) 824 950 { 825 951 return sb->hash_seed; … … 828 954 /** Set hash seed for directory index hash function. 829 955 * 830 * @param sb superblock 831 * @param seed hash seed pointer 956 * @param sb Superblock 957 * @param seed Hash seed pointer 958 * 832 959 */ 833 960 void ext4_superblock_set_hash_seed(ext4_superblock_t *sb, const uint32_t *seed) … … 838 965 /** Get default version of the hash algorithm version for directory index. 839 966 * 840 * @param sb superblock 841 * @return default hash version 967 * @param sb Superblock 968 * 969 * @return Default hash version 970 * 842 971 */ 843 972 uint8_t ext4_superblock_get_default_hash_version(ext4_superblock_t *sb) … … 848 977 /** Set default version of the hash algorithm version for directory index. 849 978 * 850 * @param sb superblock 851 * @param version default hash version 852 */ 853 void ext4_superblock_set_default_hash_version(ext4_superblock_t *sb, uint8_t version) 979 * @param sb Superblock 980 * @param version Default hash version 981 * 982 */ 983 void ext4_superblock_set_default_hash_version(ext4_superblock_t *sb, 984 uint8_t version) 854 985 { 855 986 sb->default_hash_version = version; … … 860 991 * Output value is checked for minimal size. 861 992 * 862 * @param sb superblock 863 * @return size of block group descriptor 993 * @param sb Superblock 994 * 995 * @return Size of block group descriptor 996 * 864 997 */ 865 998 uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *sb) 866 999 { 867 1000 uint16_t size = uint16_t_le2host(sb->desc_size); 868 869 if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {1001 1002 if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) 870 1003 size = EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE; 871 } 872 1004 873 1005 return size; 874 1006 } … … 878 1010 * Input value is checked for minimal size. 879 1011 * 880 * @param sb superblock 881 * @param size size of block group descriptor 1012 * @param sb Superblock 1013 * @param size Size of block group descriptor 1014 * 882 1015 */ 883 1016 void ext4_superblock_set_desc_size(ext4_superblock_t *sb, uint16_t size) 884 1017 { 885 if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {886 sb->desc_size = host2uint16_t_le(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE);887 }888 1018 if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) 1019 sb->desc_size = 1020 host2uint16_t_le(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE); 1021 889 1022 sb->desc_size = host2uint16_t_le(size); 890 1023 } … … 892 1025 /** Get superblock flags. 893 1026 * 894 * @param sb superblock 895 * @return flags from the superblock 1027 * @param sb Superblock 1028 * 1029 * @return Flags from the superblock 1030 * 896 1031 */ 897 1032 uint32_t ext4_superblock_get_flags(ext4_superblock_t *sb) … … 902 1037 /** Set superblock flags. 903 1038 * 904 * @param sb superblock 905 * @param flags flags for the superblock 1039 * @param sb Superblock 1040 * @param flags Flags for the superblock 1041 * 906 1042 */ 907 1043 void ext4_superblock_set_flags(ext4_superblock_t *sb, uint32_t flags) … … 916 1052 /** Check if superblock has specified flag. 917 1053 * 918 * @param sb superblock 919 * @param flag flag to be checked 920 * @return true, if superblock has the flag 1054 * @param sb Superblock 1055 * @param flag Flag to be checked 1056 * 1057 * @return True, if superblock has the flag 1058 * 921 1059 */ 922 1060 bool ext4_superblock_has_flag(ext4_superblock_t *sb, uint32_t flag) 923 1061 { 924 if (ext4_superblock_get_flags(sb) & flag) {1062 if (ext4_superblock_get_flags(sb) & flag) 925 1063 return true; 926 }1064 927 1065 return false; 928 1066 } … … 930 1068 /** Check if filesystem supports compatible feature. 931 1069 * 932 * @param sb superblock 933 * @param feature feature to be checked 934 * @return true, if filesystem supports the feature 935 */ 936 bool ext4_superblock_has_feature_compatible(ext4_superblock_t *sb, uint32_t feature) 937 { 938 if (ext4_superblock_get_features_compatible(sb) & feature) { 1070 * @param sb Superblock 1071 * @param feature Feature to be checked 1072 * 1073 * @return True, if filesystem supports the feature 1074 * 1075 */ 1076 bool ext4_superblock_has_feature_compatible(ext4_superblock_t *sb, 1077 uint32_t feature) 1078 { 1079 if (ext4_superblock_get_features_compatible(sb) & feature) 939 1080 return true; 940 }1081 941 1082 return false; 942 1083 } … … 944 1085 /** Check if filesystem supports incompatible feature. 945 1086 * 946 * @param sb superblock 947 * @param feature feature to be checked 948 * @return true, if filesystem supports the feature 949 */ 950 bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *sb, uint32_t feature) 951 { 952 if (ext4_superblock_get_features_incompatible(sb) & feature) { 1087 * @param sb Superblock 1088 * @param feature Feature to be checked 1089 * 1090 * @return True, if filesystem supports the feature 1091 * 1092 */ 1093 bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *sb, 1094 uint32_t feature) 1095 { 1096 if (ext4_superblock_get_features_incompatible(sb) & feature) 953 1097 return true; 954 }1098 955 1099 return false; 956 1100 } … … 958 1102 /** Check if filesystem supports read-only compatible feature. 959 1103 * 960 * @param sb superblock 961 * @param feature feature to be checked 962 * @return true, if filesystem supports the feature 963 */ 964 bool ext4_superblock_has_feature_read_only(ext4_superblock_t *sb, uint32_t feature) 965 { 966 if (ext4_superblock_get_features_read_only(sb) & feature) { 1104 * @param sb Superblock 1105 * @param feature Feature to be checked 1106 * 1107 * @return True, if filesystem supports the feature 1108 * 1109 */ 1110 bool ext4_superblock_has_feature_read_only(ext4_superblock_t *sb, 1111 uint32_t feature) 1112 { 1113 if (ext4_superblock_get_features_read_only(sb) & feature) 967 1114 return true; 968 }1115 969 1116 return false; 970 1117 } … … 972 1119 /** Read superblock directly from block device. 973 1120 * 974 * @param service_id block device identifier 975 * @param sb output pointer to memory structure 976 * @return error code. 977 */ 978 int ext4_superblock_read_direct(service_id_t service_id, 979 ext4_superblock_t **sb) 980 { 981 int rc; 982 1121 * @param service_id Block device identifier 1122 * @param sb Output pointer to memory structure 1123 * 1124 * @return Eerror code. 1125 * 1126 */ 1127 int ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb) 1128 { 983 1129 /* Allocated memory for superblock structure */ 984 1130 void *data = malloc(EXT4_SUPERBLOCK_SIZE); 985 if (data == NULL) {1131 if (data == NULL) 986 1132 return ENOMEM; 987 } 988 1133 989 1134 /* Read data from block device */ 990 rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET,1135 int rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET, 991 1136 EXT4_SUPERBLOCK_SIZE, data); 992 1137 993 1138 if (rc != EOK) { 994 1139 free(data); 995 1140 return rc; 996 1141 } 997 1142 998 1143 /* Set output value */ 999 1144 (*sb) = data; 1000 1145 1001 1146 return EOK; 1002 1147 } … … 1004 1149 /** Write superblock structure directly to block device. 1005 1150 * 1006 * @param service_id block device identifier 1007 * @param sb superblock to be written 1008 * @return error code 1009 */ 1010 int ext4_superblock_write_direct(service_id_t service_id, 1011 ext4_superblock_t *sb) 1012 { 1013 int rc; 1151 * @param service_id Block device identifier 1152 * @param sb Superblock to be written 1153 * 1154 * @return Error code 1155 * 1156 */ 1157 int ext4_superblock_write_direct(service_id_t service_id, ext4_superblock_t *sb) 1158 { 1159 /* Load physical block size from block device */ 1014 1160 size_t phys_block_size; 1015 1016 /* Load physical block size from block device */ 1017 rc = block_get_bsize(service_id, &phys_block_size); 1018 if (rc != EOK) { 1161 int rc = block_get_bsize(service_id, &phys_block_size); 1162 if (rc != EOK) 1019 1163 return rc; 1020 } 1021 1164 1022 1165 /* Compute address of the first block */ 1023 1166 uint64_t first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size; 1167 1024 1168 /* Compute number of block to write */ 1025 1169 size_t block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size; 1026 1170 1027 1171 /* Check alignment */ 1028 if (EXT4_SUPERBLOCK_SIZE % phys_block_size) {1172 if (EXT4_SUPERBLOCK_SIZE % phys_block_size) 1029 1173 block_count++; 1030 } 1031 1174 1032 1175 /* Write data */ 1033 1176 return block_write_direct(service_id, first_block, block_count, sb); 1034 1035 1177 } 1036 1178 … … 1040 1182 * Checks are described by one-line comments in the code. 1041 1183 * 1042 * @param sb superblock to check 1043 * @return error code 1184 * @param sb Superblock to check 1185 * 1186 * @return Error code 1187 * 1044 1188 */ 1045 1189 int ext4_superblock_check_sanity(ext4_superblock_t *sb) 1046 1190 { 1047 if (ext4_superblock_get_magic(sb) != EXT4_SUPERBLOCK_MAGIC) {1191 if (ext4_superblock_get_magic(sb) != EXT4_SUPERBLOCK_MAGIC) 1048 1192 return ENOTSUP; 1049 } 1050 1051 if (ext4_superblock_get_inodes_count(sb) == 0) { 1193 1194 if (ext4_superblock_get_inodes_count(sb) == 0) 1052 1195 return ENOTSUP; 1053 } 1054 1055 if (ext4_superblock_get_blocks_count(sb) == 0) { 1196 1197 if (ext4_superblock_get_blocks_count(sb) == 0) 1056 1198 return ENOTSUP; 1057 } 1058 1059 if (ext4_superblock_get_blocks_per_group(sb) == 0) { 1199 1200 if (ext4_superblock_get_blocks_per_group(sb) == 0) 1060 1201 return ENOTSUP; 1061 } 1062 1063 if (ext4_superblock_get_inodes_per_group(sb) == 0) { 1202 1203 if (ext4_superblock_get_inodes_per_group(sb) == 0) 1064 1204 return ENOTSUP; 1065 } 1066 1067 if (ext4_superblock_get_inode_size(sb) < 128) { 1205 1206 if (ext4_superblock_get_inode_size(sb) < 128) 1068 1207 return ENOTSUP; 1069 } 1070 1071 if (ext4_superblock_get_first_inode(sb) < 11) { 1208 1209 if (ext4_superblock_get_first_inode(sb) < 11) 1072 1210 return ENOTSUP; 1073 }1074 1075 if (ext4_superblock_get_desc_size(sb) < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {1211 1212 if (ext4_superblock_get_desc_size(sb) < 1213 EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) 1076 1214 return ENOTSUP; 1077 }1078 1079 if (ext4_superblock_get_desc_size(sb) > EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE) {1215 1216 if (ext4_superblock_get_desc_size(sb) > 1217 EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE) 1080 1218 return ENOTSUP; 1081 } 1082 1219 1083 1220 return EOK; 1084 1221 } … … 1086 1223 /** Compute number of block groups in the filesystem. 1087 1224 * 1088 * @param sb superblock 1089 * @return number of block groups 1225 * @param sb Superblock 1226 * 1227 * @return Number of block groups 1228 * 1090 1229 */ 1091 1230 uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *sb) … … 1093 1232 uint64_t blocks_count = ext4_superblock_get_blocks_count(sb); 1094 1233 uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); 1095 1234 1096 1235 uint32_t block_groups_count = blocks_count / blocks_per_group; 1097 1098 if (blocks_count % blocks_per_group) {1236 1237 if (blocks_count % blocks_per_group) 1099 1238 block_groups_count++; 1100 } 1101 1239 1102 1240 return block_groups_count; 1103 1104 1241 } 1105 1242 1106 1243 /** Compute number of blocks in specified block group. 1107 1244 * 1108 * @param sb superblock 1109 * @param bgid block group index 1110 * @return number of blocks 1245 * @param sb Superblock 1246 * @param bgid Block group index 1247 * 1248 * @return Number of blocks 1249 * 1111 1250 */ 1112 1251 uint32_t ext4_superblock_get_blocks_in_group(ext4_superblock_t *sb, uint32_t bgid) 1113 1252 { 1114 uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); 1115 uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); 1116 uint64_t total_blocks = ext4_superblock_get_blocks_count(sb); 1117 1118 if (bgid < block_group_count - 1) { 1253 uint32_t block_group_count = 1254 ext4_superblock_get_block_group_count(sb); 1255 uint32_t blocks_per_group = 1256 ext4_superblock_get_blocks_per_group(sb); 1257 uint64_t total_blocks = 1258 ext4_superblock_get_blocks_count(sb); 1259 1260 if (bgid < block_group_count - 1) 1119 1261 return blocks_per_group; 1120 } else {1262 else 1121 1263 return (total_blocks - ((block_group_count - 1) * blocks_per_group)); 1122 }1123 1124 1264 } 1125 1265 1126 1266 /** Compute number of i-nodes in specified block group. 1127 1267 * 1128 * @param sb superblock 1129 * @param bgid block group index 1130 * @return number of i-nodes 1268 * @param sb Superblock 1269 * @param bgid Block group index 1270 * 1271 * @return Number of i-nodes 1272 * 1131 1273 */ 1132 1274 uint32_t ext4_superblock_get_inodes_in_group(ext4_superblock_t *sb, uint32_t bgid) 1133 1275 { 1134 uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); 1135 uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); 1136 uint32_t total_inodes = ext4_superblock_get_inodes_count(sb); 1137 1138 if (bgid < block_group_count - 1) { 1276 uint32_t block_group_count = 1277 ext4_superblock_get_block_group_count(sb); 1278 uint32_t inodes_per_group = 1279 ext4_superblock_get_inodes_per_group(sb); 1280 uint32_t total_inodes = 1281 ext4_superblock_get_inodes_count(sb); 1282 1283 if (bgid < block_group_count - 1) 1139 1284 return inodes_per_group; 1140 } else {1285 else 1141 1286 return (total_inodes - ((block_group_count - 1) * inodes_per_group)); 1142 }1143 1144 1287 } 1145 1288 1146 1289 /** 1147 1290 * @} 1148 */ 1291 */
Note:
See TracChangeset
for help on using the changeset viewer.