Changeset 626 for trunk/kernel/fs/fatfs.c
- Timestamp:
- Apr 29, 2019, 7:25:09 PM (5 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/kernel/fs/fatfs.c
r625 r626 37 37 #include <fatfs.h> 38 38 39 #define LITTLE_ENDIAN 1 39 40 40 41 ////////////////////////////////////////////////////////////////////////////////////////// … … 72 73 73 74 ////////////////////////////////////////////////////////////////////////////////////////// 74 // This function return an integer record value (one, two, or four bytes) 75 // from a memory buffer, taking into account endianness.76 // ////////////////////////////////////////////////////////////////////////////////////////77 // @ offset : first byte of record in buffer.78 // @ size : record length in bytes (1/2/4).79 // @ buffer : pointer on buffer base.80 // @ little endian : the most significant byte has the highest address when true.75 // This function return an integer record value (one, two, or four bytes) from a local 76 // array of bytes, taking into account the global LITTLE_ENDIAN parameter: 77 // if LITTLE_ENDIAN is true, the most significant byte has the highest address. 78 ////////////////////////////////////////////////////////////////////////////////////////// 79 // @ offset : first byte in array. 80 // @ nbytes : record length in bytes (1/2/4). 81 // @ buffer : local pointer on byte array. 81 82 // @ return the integer value in a 32 bits word. 82 83 ////////////////////////////////////////////////////////////////////////////////////////// 83 84 static uint32_t fatfs_get_record( uint32_t offset, 84 uint32_t size, 85 uint8_t * buffer, 86 uint32_t little_endian ) 87 { 88 uint32_t n; 89 uint32_t res = 0; 90 91 if ( little_endian ) 92 { 93 for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1]; 94 } 95 else // big_endian 96 { 97 for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n]; 85 uint32_t nbytes, 86 uint8_t * buffer ) 87 { 88 uint32_t i; 89 uint32_t res = 0; 90 91 if ( LITTLE_ENDIAN ) 92 { 93 for( i = nbytes ; i > 0 ; i-- ) res = (res<<8) | buffer[offset+i-1]; 94 } 95 else 96 { 97 for( i = 0 ; i < nbytes ; i++ ) res = (res<<8) | buffer[offset+i]; 98 98 } 99 99 return res; … … 102 102 103 103 ////////////////////////////////////////////////////////////////////////////////////////// 104 // This function writes one, two, or four bytes from a 32 bits integer to a memory buffer,105 // taking into account endianness.106 // ////////////////////////////////////////////////////////////////////////////////////////107 // @ offset : first byte of record in buffer.108 // @ size : record length in bytes (1/2/4).109 // @ buffer : pointer on buffer base.110 // @ little endian : the most significant byte has the highest address when true.104 // This function return an integer record value (one, two, or four bytes) from a remote 105 // array of bytes, taking into account the global LITTLE_ENDIAN parameter: 106 // if LITTLE_ENDIAN is true, the most significant byte has the highest address. 107 ////////////////////////////////////////////////////////////////////////////////////////// 108 // @ offset : first byte in array. 109 // @ nbytes : record length in bytes (1/2/4). 110 // @ buffer_xp : extended pointer on byte array. 111 111 // @ return the integer value in a 32 bits word. 112 112 ////////////////////////////////////////////////////////////////////////////////////////// 113 static uint32_t fatfs_get_remote_record( uint32_t offset, 114 uint32_t nbytes, 115 xptr_t buffer_xp ) 116 { 117 uint32_t i; 118 uint32_t res = 0; 119 120 if ( LITTLE_ENDIAN ) 121 { 122 for( i = nbytes ; i > 0 ; i-- ) 123 { 124 res = (res<<8) | hal_remote_lb( buffer_xp+offset+i-1 ); 125 } 126 } 127 else 128 { 129 for( i = 0 ; i < nbytes ; i++ ) 130 { 131 res = (res<<8) | hal_remote_lb( buffer_xp+offset+i ); 132 } 133 } 134 return res; 135 136 } // end fatfs_get_remote_record() 137 138 ////////////////////////////////////////////////////////////////////////////////////////// 139 // This function writes one, two, or four bytes from a 32 bits integer to a local 140 // array of bytes, taking into account the global LITTLE_ENDIAN parameter: 141 // if LITTLE_ENDIAN is true, the most significant byte has the highest address. 142 ////////////////////////////////////////////////////////////////////////////////////////// 143 // @ offset : first byte in array. 144 // @ nbytes : record length in bytes (1/2/4). 145 // @ buffer : local pointer on byte array. 146 // @ value : 32 bits integer value. 147 ////////////////////////////////////////////////////////////////////////////////////////// 113 148 static void fatfs_set_record( uint32_t offset, 114 uint32_t size,149 uint32_t nbytes, 115 150 uint8_t * buffer, 116 uint32_t little_endian,117 151 uint32_t value ) 118 152 { 119 uint32_t n; 120 121 if ( little_endian ) 122 { 123 for( n = size ; n > 0 ; n-- ) buffer[offset+n-1] = (uint8_t)(value>>((n-1)<<3)); 124 } 125 else // big_endian 126 { 127 for( n = 0 ; n < size ; n++ ) buffer[offset+n] = (uint8_t)(value>>((size-1-n)<<3)); 153 uint32_t i; 154 155 if ( LITTLE_ENDIAN ) 156 { 157 for( i = nbytes ; i > 0 ; i-- ) buffer[offset+i-1] = (uint8_t)(value>>((i-1)<<3)); 158 } 159 else 160 { 161 for( i = 0 ; i < nbytes ; i++ ) buffer[offset+i] = (uint8_t)(value>>((nbytes-1-i)<<3)); 162 } 163 164 } // end fatfs_set_record() 165 166 ////////////////////////////////////////////////////////////////////////////////////////// 167 // This function writes one, two, or four bytes from a 32 bits integer to a remote 168 // array of bytes, taking into account the global LITTLE_ENDIAN parameter: 169 // if LITTLE_ENDIAN is true, the most significant byte has the highest address. 170 ////////////////////////////////////////////////////////////////////////////////////////// 171 // @ offset : first byte in array. 172 // @ nbytes : record length in bytes (1/2/4). 173 // @ buffer_xp : extended pointer on byte array. 174 // @ value : 32 bits integer value. 175 ////////////////////////////////////////////////////////////////////////////////////////// 176 static void fatfs_set_remote_record( uint32_t offset, 177 uint32_t nbytes, 178 xptr_t buffer_xp, 179 uint32_t value ) 180 { 181 uint32_t i; 182 183 if ( LITTLE_ENDIAN ) 184 { 185 for( i = nbytes ; i > 0 ; i-- ) 186 { 187 hal_remote_sb( (buffer_xp+offset+i-1) , (uint8_t)(value>>((i-1)<<3)) ); 188 } 189 } 190 else 191 { 192 for( i = 0 ; i < nbytes ; i++ ) 193 { 194 hal_remote_sb( (buffer_xp+offset+i) , (uint8_t)(value>>((nbytes-1-i)<<3)) ); 195 } 128 196 } 129 197 … … 374 442 375 443 ////////////////////////////////////////////////////////////////////////////////////////// 444 // This static function is called by both the fatfs_free_clusters_increment(), 445 // and the fatfs_free_cluster_decrement() functions defined below. 446 // It synchronously updates the "free_clusters" and "free_cluster_hint" variables 447 // in FS_INFO sector on the IOC device, each times these variables are modified. 448 ////////////////////////////////////////////////////////////////////////////////////////// 449 // @ fatfs_ctx_xp : extended pointer on fatfs context in FAT cluster. 450 // @ free_clusters : new free_clusters value. 451 // @ free_cluster_hint : new free_cluster_hint value. 452 // @ return 0 if success, return -1 if the FS_INFO sector cannot be updated. 453 ////////////////////////////////////////////////////////////////////////////////////////// 454 static error_t fatfs_free_clusters_update_ioc( xptr_t fatfs_ctx_xp, 455 uint32_t free_clusters, 456 uint32_t free_cluster_hint ) 457 { 458 cxy_t fat_cxy; // FAT cluster identifier 459 fatfs_ctx_t * fatfs_ctx_ptr; // local pointer on fatfs context in FAT cluster 460 uint8_t * fs_info_buffer_ptr; // local pointer on FS_INFO buffer in FAT cluster 461 xptr_t fs_info_buffer_xp; // extended pointer on FS_INFO buffer in FAT cluster 462 uint32_t fs_info_lba; // FS_INFO sector lba on IOC device 463 464 // get cluster and local pointer on FAT cluster context 465 fat_cxy = GET_CXY( fatfs_ctx_xp ); 466 fatfs_ctx_ptr = GET_PTR( fatfs_ctx_xp ); 467 468 // get pointers on FS_INFO buffer in FAT cluster 469 fs_info_buffer_ptr = hal_remote_lpt( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_buffer ) ); 470 fs_info_buffer_xp = XPTR( fat_cxy , fs_info_buffer_ptr ); 471 472 // get lba of FS_INFO sector on IOC device from fatfs context 473 fs_info_lba = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_lba ) ); 474 475 // update the FS_INFO buffer in FAT cluster 476 fatfs_set_remote_record( FS_FREE_CLUSTERS , fs_info_buffer_xp , free_clusters ); 477 fatfs_set_remote_record( FS_FREE_CLUSTER_HINT , fs_info_buffer_xp , free_cluster_hint ); 478 479 // update the FS_INFO sector on IOC device 480 return dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 ); 481 482 } // fatfs_free_clusters_update_ioc() 483 484 ////////////////////////////////////////////////////////////////////////////////////////// 376 485 // This static function decrements the "free_clusters" variable, and updates the 377 // "free_cluster_hint" variable in the FATFS context , identified by the <fat_ctx_cxy>378 // and <fat_ctx_ptr> arguments (cluster containing the FAT mapper).486 // "free_cluster_hint" variable in the FATFS context in FAT cluster, identified 487 // by the <fat_ctx_xp> argument, when a new <cluster> has been allocated from FAT. 379 488 // It scan all slots in the FAT mapper seen as an array of 32 bits words, looking for the 380 489 // first free slot larger than the <cluster> argument, to update "free_cluster_hint". 490 // It calls the fatfs_free_clusters_update_ioc() function to synchronously update the 491 // FS_INFO sector on the IOC device. It can be called by a thead running in any cluster. 381 492 // 382 493 // WARNING : The free_lock protecting exclusive access to these variables 383 494 // must be taken by the calling function. 384 495 ////////////////////////////////////////////////////////////////////////////////////////// 385 // @ fat_ctx_cxy : FAT mapper cluster identifier. 386 // @ fat_ctx_ptr : local pointer on FATFS context. 387 // @ cluster : recently allocated cluster index in FAT. 388 ////////////////////////////////////////////////////////////////////////////////////////// 389 static error_t fatfs_free_clusters_decrement( cxy_t fat_ctx_cxy, 390 fatfs_ctx_t * fat_ctx_ptr, 391 uint32_t cluster ) 392 { 496 // @ fatfs_ctx_xp : extended pointer on FATFS context in FAT cluster. 497 // @ cluster : recently allocated cluster index in FAT. 498 // @ return 0 if success, return -1 if the FS_INFO sector cannot be updated. 499 ////////////////////////////////////////////////////////////////////////////////////////// 500 static error_t fatfs_free_clusters_decrement( xptr_t fatfs_ctx_xp, 501 uint32_t cluster ) 502 { 503 error_t error; 504 cxy_t fat_cxy; // FAT cluster identifier 505 fatfs_ctx_t * fat_ctx_ptr; // local pointer on fatfs context in FAT cluster 393 506 xptr_t mapper_xp; // extended pointer on FAT mapper 394 507 xptr_t hint_xp; // extended pointer on "free_cluster_hint" shared variable 395 508 xptr_t numb_xp; // extended pointer on "free_clusters" shared variable 396 509 uint32_t numb; // "free_clusters" variable current value 510 uint32_t hint; // "free_cluster_hint" variable current value 397 511 uint32_t page_id; // page index in FAT mapper 398 512 uint32_t slot_id; // slot index in one page of FAT (1024 slots per page) … … 405 519 uint32_t cycle = (uint32_t)hal_get_cycles(); 406 520 thread_t * this = CURRENT_THREAD; 407 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles())521 if( DEBUG_FATFS_FREE_CLUSTERS < cycle ) 408 522 printk("\n[%s] thread[%x,%x] enter for allocated cluster %x / cycle %d\n", 409 523 __FUNCTION__, this->process->pid, this->trdid, cluster , cycle ); 410 524 #endif 411 525 412 // build extended pointers on free_clusters, and free_cluster_hint 413 hint_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_cluster_hint ); 414 numb_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_clusters ); 415 416 // update "free_clusters" 417 numb = hal_remote_l32( numb_xp ); 418 hal_remote_s32( numb_xp , numb - 1 ); 526 // get FAT cluster an local pointer on fatfs context in FAT cluster 527 fat_cxy = GET_CXY( fatfs_ctx_xp ); 528 fat_ctx_ptr = GET_PTR( fatfs_ctx_xp ); 529 530 // build extended pointers on free_clusters, and free_cluster_hint in fatfs context 531 hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint ); 532 numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters ); 533 534 // update "free_clusters" value 535 numb = hal_remote_l32( numb_xp ) - 1; 536 hal_remote_s32( numb_xp , numb ); 419 537 420 538 // get extended pointer on FAT mapper 421 mapper_xp = hal_remote_l64( XPTR( fat_c tx_cxy , &fat_ctx_ptr->fat_mapper_xp ) );539 mapper_xp = hal_remote_l64( XPTR( fat_cxy , &fat_ctx_ptr->fat_mapper_xp ) ); 422 540 423 541 // initialise variables to scan the FAT mapper … … 425 543 page_id = (cluster + 1) >> 10; 426 544 slot_id = (cluster + 1) & 0x3FF; 427 page_max = hal_remote_l32( XPTR( fat_c tx_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3;545 page_max = hal_remote_l32( XPTR( fat_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3; 428 546 429 547 // scan FAT mapper / loop on pages … … 451 569 if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER ) 452 570 { 453 // update "free_cluster_hint" 454 hal_remote_s32( hint_xp , (page_id << 10) + slot_id - 1 ); 571 // update "free_cluster_hint" value 572 hint = (page_id << 10) + slot_id - 1; 573 hal_remote_s32( hint_xp , hint ); 574 575 // update FS_INFO sector on IOC device 576 error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint ); 577 578 if( error ) 579 { 580 printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ ); 581 return -1; 582 } 455 583 456 584 #if DEBUG_FATFS_FREE_CLUSTERS 457 585 cycle = (uint32_t)hal_get_cycles(); 458 586 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() ) 459 printk("\n[%s] thread[%x,%x] exit / hint %x / free_clusters %x / cycle %d\n",460 __FUNCTION__, this->process->pid, this->trdid, 461 hal_remote_l32(hint_xp), hal_remote_l32(numb_xp) , cycle);587 printk("\n[%s] thread[%x,%x] updated free cluster info / hint %x / number %x\n", 588 __FUNCTION__, this->process->pid, this->trdid, 589 hal_remote_l32(hint_xp), hal_remote_l32(numb_xp) ); 462 590 #endif 463 591 return 0; … … 469 597 } // end loop on slots 470 598 471 // update (page_id,slot_id)variables599 // update page_id & slot_id variables 472 600 page_id++; 473 601 slot_id = 0; … … 483 611 ////////////////////////////////////////////////////////////////////////////////////////// 484 612 // This static function increments the "free_clusters" variable, and updates the 485 // "free_cluster_hint" variables in the FATFS context , identified by the <fat_ctx_cxy>486 // and <fat_ctx_ptr> argument (cluster containing the FAT mapper).613 // "free_cluster_hint" variables in the FATFS context in FAT cluster, identified 614 // by the <fat_ctx_xp> argument, when a cluster is released to FAT. 487 615 // If the released cluster index is smaller than the current (hint) value, 488 616 // it set "free_cluster_hint" <= cluster. 617 // It calls the fatfs_free_clusters_update_ioc() function to synchronously update the 618 // FS_INFO sector on the IOC device. It can be called by a thead running in any cluster. 489 619 // 490 620 // WARNING : The free_lock protecting exclusive access to these variables 491 621 // must be taken by the calling function. 492 622 ////////////////////////////////////////////////////////////////////////////////////////// 493 // @ fat_ctx_cxy : FAT mapper cluster identifier. 494 // @ fat_ctx_ptr : local pointer on FATFS context. 495 // @ cluster : recently released cluster index in FAT. 496 ////////////////////////////////////////////////////////////////////////////////////////// 497 static void fatfs_free_clusters_increment( cxy_t fat_ctx_cxy, 498 fatfs_ctx_t * fat_ctx_ptr, 499 uint32_t cluster ) 500 { 623 // @ fatfs_ctx_xp : extended pointer on FATFS context in FAT cluster. 624 // @ cluster : recently released cluster index in FAT. 625 // @ return 0 if success, return -1 if the FS_INFO sector cannot be updated. 626 ////////////////////////////////////////////////////////////////////////////////////////// 627 static error_t fatfs_free_clusters_increment( xptr_t fatfs_ctx_xp, 628 uint32_t cluster ) 629 { 630 error_t error; 631 cxy_t fat_cxy; // FAT cluster identifier 632 fatfs_ctx_t * fat_ctx_ptr; // local pointer on fatfs context in FAT cluster 501 633 xptr_t hint_xp; // extended pointer on "free_cluster_hint" shared variable 502 634 xptr_t numb_xp; // extended pointer on "free_clusters" shared variable … … 504 636 uint32_t numb; // "free_clusters" variable current value 505 637 638 #if DEBUG_FATFS_FREE_CLUSTERS 639 uint32_t cycle = (uint32_t)hal_get_cycles(); 640 thread_t * this = CURRENT_THREAD; 641 if( DEBUG_FATFS_FREE_CLUSTERS < cycle ) 642 printk("\n[%s] thread[%x,%x] enter for released cluster %x / cycle %d\n", 643 __FUNCTION__, this->process->pid, this->trdid, cluster , cycle ); 644 #endif 645 646 // get FAT cluster an local pointer on fatfs context in FAT cluster 647 fat_cxy = GET_CXY( fatfs_ctx_xp ); 648 fat_ctx_ptr = GET_PTR( fatfs_ctx_xp ); 649 506 650 // build extended pointers on free_clusters, and free_cluster_hint 507 hint_xp = XPTR( fat_c tx_cxy , &fat_ctx_ptr->free_cluster_hint );508 numb_xp = XPTR( fat_c tx_cxy , &fat_ctx_ptr->free_clusters );651 hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint ); 652 numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters ); 509 653 510 654 // get current value of free_cluster_hint and free_clusters … … 512 656 numb = hal_remote_l32( numb_xp ); 513 657 514 // update free_cluster_hint if required 515 if ( (cluster - 1) < hint ) hal_remote_s32( hint_xp , (cluster - 1) ); 658 // update "numb" and "hint" variables as required 659 numb++; 660 if ( (cluster - 1) < hint ) hint = cluster - 1; 516 661 517 662 // update free_clusters 518 hal_remote_s32( numb_xp , numb + 1 ); 663 hal_remote_s32( numb_xp , numb ); 664 hal_remote_s32( hint_xp , hint ); 665 666 // update FS_INFO sector on IOC device 667 error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint ); 668 669 if( error ) 670 { 671 printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ ); 672 return -1; 673 } 519 674 520 675 #if DEBUG_FATFS_FREE_CLUSTERS 521 676 thread_t * this = CURRENT_THREAD; 522 677 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() ) 523 printk("\n[%s] thread[%x,%x] update sfree cluster info : hint %x / number %x\n",678 printk("\n[%s] thread[%x,%x] updated free cluster info : hint %x / number %x\n", 524 679 __FUNCTION__, this->process->pid, this->trdid, 525 680 hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ) ); 526 681 #endif 682 683 return 0; 527 684 528 685 } // end fatfs_free_clusters_increment() … … 576 733 FREE_CLUSTER ) ) return -1; 577 734 578 // Update free_cluster_hint and free_clusters in FAT context 579 fatfs_free_clusters_increment( mapper_cxy, 580 fatfs_ctx, 581 cluster ); 582 583 return 0; 735 // Update free_cluster info in FATFS context and in FS_INFO sector 736 return fatfs_free_clusters_increment( XPTR( mapper_cxy , fatfs_ctx ) , cluster ); 584 737 585 738 } // end fatfs_recursive_release() … … 590 743 ////////////////////////////////////////////////////////////////////////////////////////// 591 744 592 /////////////////////////////////////////// 593 void fatfs_ctx_display( fatfs_ctx_t * ctx ) 594 { 595 printk("\n*** FAT context ***\n" 745 /////////////////////////////////// 746 void fatfs_display_ctx( cxy_t cxy ) 747 { 748 // get pointer on local FATFS context 749 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS]; 750 fatfs_ctx_t * ctx = hal_remote_lpt( XPTR( cxy , &vfs_ctx->extend ) ); 751 752 uint32_t fat_sectors = hal_remote_l32( XPTR( cxy , &ctx->fat_sectors_count ) ); 753 uint32_t sector_size = hal_remote_l32( XPTR( cxy , &ctx->bytes_per_sector ) ); 754 uint32_t sec_per_clus = hal_remote_l32( XPTR( cxy , &ctx->sectors_per_cluster ) ); 755 uint32_t fat_lba = hal_remote_l32( XPTR( cxy , &ctx->fat_begin_lba ) ); 756 uint32_t data_lba = hal_remote_l32( XPTR( cxy , &ctx->cluster_begin_lba ) ); 757 uint32_t fsinfo_lba = hal_remote_l32( XPTR( cxy , &ctx->fs_info_lba ) ); 758 uint32_t root_dir_clus = hal_remote_l32( XPTR( cxy , &ctx->root_dir_cluster ) ); 759 uint32_t free_clusters = hal_remote_l32( XPTR( cxy , &ctx->free_clusters ) ); 760 uint32_t free_cluster_hint = hal_remote_l32( XPTR( cxy , &ctx->free_cluster_hint ) ); 761 xptr_t mapper_xp = hal_remote_l64( XPTR( cxy , &ctx->fat_mapper_xp ) ); 762 void * fs_info_buffer = hal_remote_lpt( XPTR( cxy , &ctx->fs_info_buffer ) ); 763 764 printk("\n*** FAT context in cluster %x\n" 596 765 "- fat_sectors = %d\n" 597 766 "- sector size = %d\n" 598 767 "- cluster size = %d\n" 599 "- fat_first_lba = %d\n" 600 "- data_first_lba = %d\n" 601 "- root_dir_cluster = %d\n" 602 "- free_clusters = %d\n" 603 "- free_cluster_hint = %d\n" 604 "- fat_mapper_xp = %l\n", 605 ctx->fat_sectors_count, 606 ctx->bytes_per_sector, 607 ctx->sectors_per_cluster * ctx->bytes_per_sector, 608 ctx->fat_begin_lba, 609 ctx->cluster_begin_lba, 610 ctx->root_dir_cluster, 611 ctx->free_clusters, 612 ctx->free_cluster_hint, 613 ctx->fat_mapper_xp ); 614 615 } // end ctx_display() 768 "- fat_lba = %x\n" 769 "- data_lba = %x\n" 770 "- fsinfo_lba = %x\n" 771 "- root_dir_cluster = %x\n" 772 "- free_clusters = %x\n" 773 "- free_cluster_hint = %x\n" 774 "- fat_mapper_ptr = %x\n" 775 "- fs_info_buffer = %x\n", 776 cxy, 777 fat_sectors, 778 sector_size, 779 sector_size * sec_per_clus, 780 fat_lba, 781 data_lba, 782 fsinfo_lba, 783 root_dir_clus, 784 free_clusters, 785 free_cluster_hint, 786 GET_PTR( mapper_xp ), 787 fs_info_buffer ); 788 789 } // end fatfs_ctx_display() 616 790 617 791 ////////////////////////////////////////// … … 622 796 uint32_t maxline; 623 797 624 // co pute numner of lines to display798 // compute number of lines to display 625 799 maxline = nentries >> 3; 626 800 if( nentries & 0x7 ) maxline++; 627 801 628 802 // get pointer on local FATFS context 629 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];630 fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;803 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS]; 804 fatfs_ctx_t * loc_fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend; 631 805 632 806 // get extended pointer on FAT mapper 633 xptr_t fat_mapper_xp = fatfs_ctx->fat_mapper_xp; 634 635 // get extended pointer and cluster of FAT mapper requested page 807 xptr_t fat_mapper_xp = loc_fatfs_ctx->fat_mapper_xp; 808 809 // get FAT cluster identifier 810 cxy_t fat_cxy = GET_CXY( fat_mapper_xp ); 811 812 // get pointer on FATFS context in FAT cluster 813 fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) ); 814 815 // get current value of hint and free_clusters 816 uint32_t hint = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint ) ); 817 uint32_t free = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_clusters ) ); 818 819 // get extended pointer on requested page in FAT mapper 636 820 xptr_t page_xp = mapper_remote_get_page( fat_mapper_xp , page_id ); 637 821 638 822 // get extended pointer on requested page base 639 823 xptr_t base_xp = ppm_page2base( page_xp ); 640 641 printk("\n***** FAT content / page %d *****\n", page_id ); 824 void * base = GET_PTR( base_xp ); 825 826 printk("\n***** FAT mapper / cxy %x / page_id %d / base %x / free_clusters %x / hint %x\n", 827 fat_cxy, page_id, base, free, hint ); 828 642 829 for( line = 0 ; line < maxline ; line++ ) 643 830 { … … 766 953 kmem_req_t req; 767 954 uint8_t * buffer; 955 xptr_t buffer_xp; 768 956 769 957 #if DEBUG_FATFS_CTX_INIT … … 778 966 assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL" ); 779 967 780 // check only cluster 0 does FATFS init 968 // check only cluster 0 does FATFS initialization 781 969 assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS"); 782 970 783 // allocate a 512 bytes buffer to store the boot record 971 // allocate a permanent 512 bytes buffer to store 972 // - temporarily the BOOT sector 973 // - permanently the FS_INFO sector 784 974 req.type = KMEM_512_BYTES; 785 975 req.flags = AF_KERNEL | AF_ZERO; 786 976 buffer = (uint8_t *)kmem_alloc( &req ); 977 buffer_xp = XPTR( local_cxy , buffer ); 787 978 788 979 if( buffer == NULL ) … … 793 984 794 985 // load the BOOT record from device 795 error = dev_ioc_sync_read( buffer , 0 , 1 );986 error = dev_ioc_sync_read( buffer_xp , 0 , 1 ); 796 987 797 988 if ( error ) … … 807 998 808 999 // get sector size from boot record 809 uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1);1000 uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer ); 810 1001 if ( sector_size != 512 ) 811 1002 { … … 815 1006 816 1007 // get cluster size from boot record 817 uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1);1008 uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer ); 818 1009 if ( nb_sectors != 8 ) 819 1010 { … … 823 1014 824 1015 // get number of FAT copies from boot record 825 uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1);1016 uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer ); 826 1017 if ( nb_fats != 1 ) 827 1018 { … … 831 1022 832 1023 // get number of sectors in FAT from boot record 833 uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1);1024 uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer ); 834 1025 if ( (fat_sectors & 0xF) != 0 ) 835 1026 { … … 839 1030 840 1031 // get root cluster from boot record 841 uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1);1032 uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer ); 842 1033 if ( root_cluster != 2 ) 843 1034 { … … 847 1038 848 1039 // get FAT lba from boot record 849 uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1);1040 uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer ); 850 1041 851 1042 // get FS_INFO sector lba from boot record 852 uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer , 1);1043 uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer ); 853 1044 854 1045 // load the FS_INFO record from device 855 error = dev_ioc_sync_read( buffer , fs_info_lba , 1 );1046 error = dev_ioc_sync_read( buffer_xp , fs_info_lba , 1 ); 856 1047 857 1048 if ( error ) … … 861 1052 } 862 1053 863 // get free 864 uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer , 1);1054 // get free_clusters number from FS_INFO record 1055 uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer ); 865 1056 if ( free_clusters >= fat_sectors << 7 ) 866 1057 { … … 869 1060 } 870 1061 871 // get cluster hint from FS_INFO record 872 uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer , 1 ); 1062 // get free_cluster_hint from FS_INFO record 1063 uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer ); 1064 873 1065 if ( free_cluster_hint >= fat_sectors << 7 ) 874 1066 { … … 876 1068 hal_core_sleep(); 877 1069 } 878 879 // release the 512 bytes buffer880 req.type = KMEM_512_BYTES;881 req.ptr = buffer;882 kmem_free( &req );883 1070 884 1071 // allocate a mapper for the FAT itself … … 890 1077 } 891 1078 892 // WARNING : the inode field MUST beNULL for the FAT mapper1079 // the inode field is NULL for the FAT mapper 893 1080 fat_mapper->inode = NULL; 894 895 1081 896 1082 // initialize the FATFS context … … 902 1088 fatfs_ctx->root_dir_cluster = 2; 903 1089 fatfs_ctx->fat_mapper_xp = XPTR( local_cxy , fat_mapper ); 1090 fatfs_ctx->fs_info_lba = fs_info_lba; 904 1091 fatfs_ctx->free_clusters = free_clusters; 905 1092 fatfs_ctx->free_cluster_hint = free_cluster_hint; 1093 fatfs_ctx->fs_info_buffer = buffer; 906 1094 907 1095 remote_queuelock_init( XPTR( local_cxy , &fatfs_ctx->free_lock ) , LOCK_FATFS_FREE ); … … 1019 1207 while ( (offset < 4096) && (found == 0) ) 1020 1208 { 1021 if ( fatfs_get_record( LDIR_ORD, (base + offset) , 0) == NO_MORE_ENTRY )1209 if ( fatfs_get_record( LDIR_ORD, (base + offset) ) == NO_MORE_ENTRY ) 1022 1210 { 1023 1211 found = 1; … … 1335 1523 1336 1524 // check for LFN entry 1337 assert( (fatfs_get_record( DIR_ATTR, base + offset , 0) == ATTR_LONG_NAME_MASK ),1525 assert( (fatfs_get_record( DIR_ATTR, base + offset ) == ATTR_LONG_NAME_MASK ), 1338 1526 "this directory entry must be a LFN\n"); 1339 1527 … … 1439 1627 while( (offset < 4096) && (found == 0) ) 1440 1628 { 1441 attr = fatfs_get_record( DIR_ATTR , base + offset , 0);1442 ord = fatfs_get_record( LDIR_ORD , base + offset , 0);1629 attr = fatfs_get_record( DIR_ATTR , base + offset ); 1630 ord = fatfs_get_record( LDIR_ORD , base + offset ); 1443 1631 1444 1632 if (ord == NO_MORE_ENTRY) // no more entry => break … … 1559 1747 1560 1748 // check arguments 1561 assert( (parent_inode != NULL) , "parent_inode is NULL\n" ); 1562 assert( (name != NULL) , "name is NULL\n" ); 1563 assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" ); 1749 assert( (parent_inode != NULL) , "parent_inode is NULL\n" ); 1750 assert( (name != NULL) , "name is NULL\n" ); 1751 assert( (child_inode_xp != XPTR_NULL ) , "child_inode is NULL\n" ); 1752 1753 // get child inode cluster and local pointer 1754 child_inode_cxy = GET_CXY( child_inode_xp ); 1755 child_inode_ptr = GET_PTR( child_inode_xp ); 1756 1757 // build extended pointer on root of list of parent dentries 1758 root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents ); 1759 1760 // check child inode has at least one parent 1761 assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n"); 1564 1762 1565 1763 #if DEBUG_FATFS_GET_DENTRY … … 1578 1776 error = fatfs_scan_directory( mapper, name , &entry , &index ); 1579 1777 1580 if( error ) 1581 { 1582 vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name ); 1583 printk("\n[ERROR] in %s : cannot find <%s> in parent mapper <%s>\n", 1584 __FUNCTION__, name , dir_name ); 1585 return -1; 1586 } 1778 // return non fatal error if not found 1779 if( error ) return -1; 1587 1780 1588 1781 // get relevant infos from FAT32 directory entry 1589 cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry , 1 ) << 16) | 1590 (fatfs_get_record( DIR_FST_CLUS_LO , entry , 1 ) ) ; 1591 is_dir = (fatfs_get_record( DIR_ATTR , entry , 1 ) & ATTR_DIRECTORY); 1592 size = fatfs_get_record( DIR_FILE_SIZE , entry , 1 ); 1593 1594 // get child inode cluster and local pointer 1595 child_inode_cxy = GET_CXY( child_inode_xp ); 1596 child_inode_ptr = GET_PTR( child_inode_xp ); 1597 1598 // build extended pointer on root of list of parent dentries 1599 root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents ); 1600 1601 // check child inode has at least one parent 1602 assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n"); 1782 cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry ) << 16) | 1783 (fatfs_get_record( DIR_FST_CLUS_LO , entry ) ) ; 1784 is_dir = (fatfs_get_record( DIR_ATTR , entry ) & ATTR_DIRECTORY); 1785 size = fatfs_get_record( DIR_FILE_SIZE , entry ); 1603 1786 1604 1787 // scan list of parent dentries to search the parent_inode … … 1692 1875 1693 1876 // set size in FAT32 directory entry 1694 fatfs_set_record( DIR_FILE_SIZE , entry , 1 ,size );1877 fatfs_set_record( DIR_FILE_SIZE , entry , size ); 1695 1878 1696 1879 // get local pointer on modified page base … … 1795 1978 bool_t valid = (dentry_id >= min_dentry) && (dirent_id < max_dirent ); 1796 1979 1797 attr = fatfs_get_record( DIR_ATTR , base + offset , 0);1798 ord = fatfs_get_record( LDIR_ORD , base + offset , 0);1980 attr = fatfs_get_record( DIR_ATTR , base + offset ); 1981 ord = fatfs_get_record( LDIR_ORD , base + offset ); 1799 1982 1800 1983 if (ord == NO_MORE_ENTRY) // no more entry => break … … 2033 2216 error_t fatfs_sync_free_info( void ) 2034 2217 { 2218 error_t error; 2219 fatfs_ctx_t * fatfs_ctx_ptr; // local pointer on fatfs context in cluster 0 2220 uint32_t ctx_free_clusters; // number of free clusters from fatfs context 2221 uint32_t ctx_free_cluster_hint; // free cluster hint from fatfs context 2222 uint32_t ioc_free_clusters; // number of free clusters from fatfs context 2223 uint32_t ioc_free_cluster_hint; // free cluster hint from fatfs context 2224 uint32_t fs_info_lba; // lba of FS_INFO sector on IOC device 2225 uint8_t * fs_info_buffer; // local pointer on FS_INFO buffer in cluster 0 2226 xptr_t fs_info_buffer_xp; // extended pointer on FS_INFO buffer in cluster 0 2227 uint8_t tmp_buf[512]; // 512 bytes temporary buffer 2228 xptr_t tmp_buf_xp; // extended pointer on temporary buffer 2035 2229 2036 2230 #if DEBUG_FATFS_SYNC_FSINFO … … 2042 2236 #endif 2043 2237 2044 uint8_t * buffer; // dynamically allocated aligned 512 bytes buffer 2045 kmem_req_t req; 2046 error_t error; 2047 2048 // get FS_INFO lba, free_ from FATFS context 2049 fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend; 2050 uint32_t lba = fatfs_ctx->fs_info_lba; 2051 uint32_t hint = fatfs_ctx->free_cluster_hint; 2052 uint32_t number = fatfs_ctx->free_clusters; 2053 2054 // allocate buffer to store the FS_INFO sector 2055 req.type = KMEM_512_BYTES; 2056 req.flags = AF_KERNEL | AF_ZERO; 2057 buffer = (uint8_t *)kmem_alloc( &req ); 2058 if( buffer == NULL ) 2059 { 2060 printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ ); 2061 return ENOMEM; 2062 } 2063 2064 // load the FS_INFO sector from device to buffer 2065 error = dev_ioc_read( buffer , lba , 1 ); 2238 // get pointer on fatfs context in cluster 0 2239 fatfs_ctx_ptr = hal_remote_lpt( XPTR( 0 , &fs_context[FS_TYPE_FATFS].extend ) ); 2240 2241 // get "free_clusters" and "free_cluster_hint" from fatfs context in cluster 0 2242 ctx_free_clusters = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_clusters ) ); 2243 ctx_free_cluster_hint = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_cluster_hint ) ); 2244 2245 // get fs_info_lba 2246 fs_info_lba = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->fs_info_lba ) ); 2247 2248 // build extended pointer on temporary buffer 2249 tmp_buf_xp = XPTR( local_cxy , tmp_buf ); 2250 2251 // copy FS_INFO sector from IOC to local buffer 2252 error = dev_ioc_sync_read( tmp_buf_xp , fs_info_lba , 1 ); 2253 2066 2254 if ( error ) 2067 2255 { 2068 printk("\n[PANIC] in %s : cannot read FS_INFO record\n", __FUNCTION__ ); 2069 return EIO; 2070 } 2071 2072 // update buffer 2073 fatfs_set_record( FS_FREE_CLUSTERS , buffer , 1 , number ); 2074 fatfs_set_record( FS_FREE_CLUSTER_HINT , buffer , 1 , hint ); 2075 2076 // write modified FS_INFO sector from buffer to device 2077 error = dev_ioc_write( buffer , lba , 1 ); 2078 if ( error ) 2079 { 2080 printk("\n[PANIC] in %s : cannot write FS_INFO record\n", __FUNCTION__ ); 2081 return EIO; 2082 } 2083 2084 // release the 512 bytes buffer 2085 req.type = KMEM_512_BYTES; 2086 req.ptr = buffer; 2087 kmem_free( &req ); 2256 printk("\n[ERROR] in %s : cannot access FS_INFO on IOC device\n", __FUNCTION__ ); 2257 return -1; 2258 } 2259 2260 // get current values of "free_clusters" and "free_cluster_hint" from FS_INFO on IOC 2261 ioc_free_clusters = fatfs_get_remote_record( FS_FREE_CLUSTERS , tmp_buf_xp ); 2262 ioc_free_cluster_hint = fatfs_get_remote_record( FS_FREE_CLUSTER_HINT , tmp_buf_xp ); 2263 2264 // check values 2265 if( (ioc_free_clusters != ctx_free_clusters) || 2266 (ioc_free_cluster_hint != ctx_free_cluster_hint) ) 2267 { 2268 printk("\n[WARNING] in %s : unconsistent free clusters info\n" 2269 " ioc_free %x / ctx_free %x / ioc_hint %x / ctx_hint %x\n", 2270 __FUNCTION__, ioc_free_clusters, ctx_free_clusters, 2271 ioc_free_cluster_hint, ctx_free_cluster_hint ); 2272 2273 // get pointers on FS_INFO buffer in cluster 0 2274 fs_info_buffer = hal_remote_lpt( XPTR( 0 , &fatfs_ctx_ptr->fs_info_buffer ) ); 2275 fs_info_buffer_xp = XPTR( 0 , fs_info_buffer ); 2276 2277 // update FS_INFO buffer in cluster 0 2278 fatfs_set_remote_record(FS_FREE_CLUSTERS ,fs_info_buffer_xp,ctx_free_clusters ); 2279 fatfs_set_remote_record(FS_FREE_CLUSTER_HINT,fs_info_buffer_xp,ctx_free_cluster_hint); 2280 2281 // update the FS_INFO sector on IOC device 2282 error = dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 ); 2283 2284 if ( error ) 2285 { 2286 printk("\n[ERROR] in %s : cannot update FS_INFO on IOC device\n", __FUNCTION__ ); 2287 return -1; 2288 } 2289 } 2088 2290 2089 2291 #if DEBUG_FATFS_SYNC_FSINFO … … 2096 2298 return 0; 2097 2299 2098 } // end fatfs_sync_f s_info()2300 } // end fatfs_sync_free_info() 2099 2301 2100 2302 ////////////////////////////////////////////////////////// 2101 2303 error_t fatfs_cluster_alloc( uint32_t * searched_cluster ) 2102 2304 { 2305 error_t error; 2103 2306 uint32_t page_id; // page index in FAT mapper 2104 2307 uint32_t slot_id; // slot index in page (1024 slots per page) … … 2109 2312 fatfs_ctx_t * fat_fatfs_ctx; // local pointer on FATFS context in FAT cluster 2110 2313 xptr_t mapper_xp; // extended pointer on FAT mapper 2111 cxy_t mapper_cxy;// Fat mapper cluster identifier2314 cxy_t fat_cxy; // Fat mapper cluster identifier 2112 2315 xptr_t page_xp; // extended pointer on current page descriptor in mapper 2113 2316 xptr_t slot_xp; // extended pointer on FAT slot defined by hint 2114 2317 xptr_t lock_xp; // extended pointer on lock protecting free clusters info 2115 2318 xptr_t hint_xp; // extended pointer on free_cluster_hint in FAT cluster 2116 xptr_t numb_xp; // extended pointer on free_clusters_number in FAT cluster2319 xptr_t free_xp; // extended pointer on free_clusters_number in FAT cluster 2117 2320 2118 2321 #if DEBUG_FATFS_CLUSTER_ALLOC … … 2130 2333 loc_fatfs_ctx = vfs_ctx->extend; 2131 2334 2132 // get extended pointer and clusteron FAT mapper2335 // get extended pointer on FAT mapper 2133 2336 mapper_xp = loc_fatfs_ctx->fat_mapper_xp; 2134 mapper_cxy = GET_CXY( mapper_xp ); 2337 2338 // get FAT cluster 2339 fat_cxy = GET_CXY( mapper_xp ); 2135 2340 2136 2341 // get local pointer on FATFS context in FAT cluster 2137 fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );2342 fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) ); 2138 2343 2139 2344 // build relevant extended pointers on free clusters info in mapper cluster 2140 lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );2141 hint_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_cluster_hint );2142 numb_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_clusters );2345 lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_lock ); 2346 hint_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint ); 2347 free_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_clusters ); 2143 2348 2144 2349 // take the lock protecting free clusters 2145 2350 remote_queuelock_acquire( lock_xp ); 2146 2351 2147 // get hint and free_clusters values from FATFS context 2352 // get hint and free_clusters values from FATFS context in FAT cluster 2148 2353 cluster = hal_remote_l32( hint_xp ) + 1; 2149 free_clusters = hal_remote_l32( numb_xp );2354 free_clusters = hal_remote_l32( free_xp ); 2150 2355 2151 2356 #if (DEBUG_FATFS_CLUSTER_ALLOC & 1) … … 2168 2373 } 2169 2374 2170 2171 2172 2375 // get page index & slot index for selected cluster 2173 2376 page_id = cluster >> 10; 2174 2377 slot_id = cluster & 0x3FF; 2175 2378 2176 // get relevant page descriptor from mapper2379 // get relevant page descriptor from FAT mapper 2177 2380 page_xp = mapper_remote_get_page( mapper_xp , page_id ); 2178 2381 … … 2194 2397 } 2195 2398 2196 // update free cluster info in FATFS context 2197 fatfs_free_clusters_decrement( mapper_cxy , fat_fatfs_ctx , cluster ); 2399 // update free cluster info in FATFS context and in FS_INFO sector 2400 error = fatfs_free_clusters_decrement( XPTR( fat_cxy , fat_fatfs_ctx ) , cluster ); 2401 2402 if( error ) 2403 { 2404 printk("\n[ERROR] in %s : cannot update free cluster info\n", __FUNCTION__ ); 2405 remote_queuelock_acquire( lock_xp ); 2406 return -1; 2407 } 2408 2409 // update FAT mapper 2410 hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX ); 2411 2412 // synchronously update FAT on device 2413 error = fatfs_move_page( page_xp , IOC_SYNC_WRITE ); 2414 2415 if( error ) 2416 { 2417 printk("\n[ERROR] in %s : cannot update FAT on IOC device\n", __FUNCTION__ ); 2418 remote_queuelock_acquire( lock_xp ); 2419 return -1; 2420 } 2198 2421 2199 2422 // release free clusters busylock 2200 2423 remote_queuelock_release( lock_xp ); 2201 2202 // update FAT mapper2203 hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );2204 2205 // synchronously update FAT on device2206 fatfs_move_page( page_xp , IOC_SYNC_WRITE );2207 2424 2208 2425 #if DEBUG_FATFS_CLUSTER_ALLOC 2209 2426 cycle = (uint32_t)hal_get_cycles(); 2210 2427 if( DEBUG_FATFS_CLUSTER_ALLOC < cycle ) 2211 printk("\n[%s] thread[%x,%x] exit / updated cluster %x in FAT / cycle %d\n",2428 printk("\n[%s] thread[%x,%x] exit / allocated cluster %x in FAT / cycle %d\n", 2212 2429 __FUNCTION__, this->process->pid, this->trdid, cluster, cycle ); 2213 2430 #endif … … 2230 2447 xptr_t first_xp; // extended pointer on inode extension 2231 2448 uint32_t first_cluster; // first cluster index for released inode 2232 vfs_inode_t * inode_ptr; 2233 cxy_t inode_cxy; 2449 vfs_inode_t * inode_ptr; // local pointer on target inode 2450 cxy_t inode_cxy; // target inode cluster identifier 2234 2451 2235 2452 // check inode pointer … … 2357 2574 2358 2575 // get page base address 2359 xptr_t b ase_xp= ppm_page2base( page_xp );2360 uint8_t * buffer = (uint8_t *)GET_PTR( base_xp );2576 xptr_t buffer_xp = ppm_page2base( page_xp ); 2577 uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp ); 2361 2578 2362 2579 // get inode pointer from mapper 2363 2580 inode_ptr = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) ); 2364 2581 2365 ////////////////////////////// it is the FAT mapper 2582 #if DEBUG_FATFS_MOVE_PAGE 2583 if( DEBUG_FATFS_MOVE_PAGE < cycle ) 2584 printk("\n[%s] thread[%x,%x] enters : %s / cxy %x / mapper %x / inode %x / page %x\n", 2585 __FUNCTION__, this->process->pid, this->trdid, 2586 dev_ioc_cmd_str( cmd_type ), page_cxy, mapper_ptr, inode_ptr, buffer_ptr ); 2587 #endif 2588 2589 ////////////////////////////// FAT mapper 2366 2590 if( inode_ptr == NULL ) 2367 2591 { … … 2370 2594 2371 2595 // access device 2372 if ( cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer , lba , 8 ); 2373 else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 ); 2374 else if( cmd_type == IOC_READ ) error = dev_ioc_read ( buffer , lba , 8 ); 2375 else if( cmd_type == IOC_WRITE ) error = dev_ioc_write ( buffer , lba , 8 ); 2376 else error = -1; 2377 2378 if( error ) return EIO; 2596 if (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp , lba , 8 ); 2597 else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp , lba , 8 ); 2598 else if(cmd_type == IOC_READ ) error = dev_ioc_read ( buffer_ptr , lba , 8 ); 2599 else if(cmd_type == IOC_WRITE ) error = dev_ioc_write ( buffer_ptr , lba , 8 ); 2600 else error = -1; 2601 2602 if( error ) 2603 { 2604 printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ ); 2605 return -1; 2606 } 2379 2607 2380 2608 #if DEBUG_FATFS_MOVE_PAGE … … 2382 2610 { 2383 2611 if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) ) 2384 printk("\n[%s] thread[%x,%x] load page %d of FAT/ cycle %d\n",2385 2612 printk("\n[%s] thread[%x,%x] load FAT mapper page %d from IOC / cycle %d\n", 2613 __FUNCTION__, this->process->pid, this->trdid, page_id, cycle ); 2386 2614 else 2387 printk("\n[%s] thread[%x,%x] sync page %d of FAT/ cycle %d\n",2615 printk("\n[%s] thread[%x,%x] sync FAT mapper page %d to IOC / cycle %d\n", 2388 2616 __FUNCTION__, this->process->pid, this->trdid, page_id, cycle ); 2389 2617 } … … 2391 2619 2392 2620 } 2393 ///////////////////////// it is aninode mapper2621 ///////////////////////// inode mapper 2394 2622 else 2395 2623 { … … 2425 2653 } 2426 2654 2427 // get lba f romsearched_cluster2655 // get lba for searched_cluster 2428 2656 uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster ); 2657 2658 // access device 2659 if (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp , lba , 8 ); 2660 else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp , lba , 8 ); 2661 else if(cmd_type == IOC_READ ) error = dev_ioc_read ( buffer_ptr , lba , 8 ); 2662 else if(cmd_type == IOC_WRITE ) error = dev_ioc_write ( buffer_ptr , lba , 8 ); 2663 else error = -1; 2664 2665 if( error ) 2666 { 2667 printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ ); 2668 return -1; 2669 } 2429 2670 2430 2671 #if DEBUG_FATFS_MOVE_PAGE … … 2440 2681 #endif 2441 2682 2442 // access device2443 if ( cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer , lba , 8 );2444 else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );2445 else if( cmd_type == IOC_READ ) error = dev_ioc_read ( buffer , lba , 8 );2446 else if( cmd_type == IOC_WRITE ) error = dev_ioc_write ( buffer , lba , 8 );2447 else error = -1;2448 2449 if( error )2450 {2451 printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );2452 return -1;2453 }2454 2683 } 2455 2684
Note: See TracChangeset
for help on using the changeset viewer.