Changeset 23 for trunk/kernel/vfs/vfs.c
- Timestamp:
- Jun 18, 2017, 10:06:41 PM (7 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/kernel/vfs/vfs.c
r14 r23 35 35 #include <slist.h> 36 36 #include <xhtab.h> 37 #include <rpc.h> 37 38 #include <errno.h> 38 39 #include <kmem.h> … … 40 41 #include <thread.h> 41 42 #include <process.h> 43 #include <vfs.h> 42 44 #include <fatfs.h> 43 45 #include <ramfs.h> 44 #include <vfs.h> 46 #include <devfs.h> 47 #include <syscalls.h> 45 48 46 49 … … 49 52 ////////////////////////////////////////////////////////////////////////////////////////// 50 53 51 // array of supported FS contexts (indexed by the FS type)54 // array of supported FS contexts 52 55 vfs_ctx_t fs_context[FS_TYPES_NR]; 53 56 … … 56 59 ////////////////////////////////////////////////////////////////////////////////////////// 57 60 58 //////////////////////////////////////////// /////61 //////////////////////////////////////////// 59 62 error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx, 60 63 uint32_t * inum ) … … 64 67 65 68 // get lid from local inum allocator 66 uint32_t lid = bitmap_ffc( ctx-> inum, CONFIG_VFS_MAX_INODES );69 uint32_t lid = bitmap_ffc( ctx->bitmap , CONFIG_VFS_MAX_INODES ); 67 70 68 71 if( lid == -1 ) // no more free slot => error … … 77 80 { 78 81 // set slot allocated 79 bitmap_set( ctx-> inum, lid );82 bitmap_set( ctx->bitmap , lid ); 80 83 81 84 // release lock … … 92 95 uint32_t inum ) 93 96 { 94 bitmap_clear( ctx-> inum, inum & 0xFFFF );97 bitmap_clear( ctx->bitmap , inum & 0xFFFF ); 95 98 } 96 99 … … 99 102 ////////////////////////////////////////////////////////////////////////////////////////// 100 103 101 //////////////////////////////////////////////// 102 error_t vfs_inode_create( xptr_t dentry_xp, 103 uint32_t type, 104 uint32_t attr, 105 uint32_t mode, 106 uid_t uid, 107 gid_t gid, 108 xptr_t * inode_xp ) 104 ////////////////////////////////////////////////////// 105 106 error_t vfs_inode_create( xptr_t dentry_xp, 107 vfs_fs_type_t fs_type, 108 vfs_inode_type_t inode_type, 109 uint32_t attr, 110 uint32_t rights, 111 uid_t uid, 112 gid_t gid, 113 xptr_t * inode_xp ) 109 114 { 110 115 mapper_t * mapper; // associated mapper( to be allocated) … … 115 120 error_t error; 116 121 117 // check type and get pointer on context 118 if ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS]; 119 else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS]; 122 // check fs type and get pointer on context 123 if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS]; 124 else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS]; 125 else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS]; 120 126 else 121 127 { … … 144 150 } 145 151 146 // allocate memory for inode descriptor152 // allocate memory for VFS inode descriptor 147 153 req.type = KMEM_VFS_INODE; 148 154 req.size = sizeof(vfs_inode_t); … … 160 166 // initialize inode descriptor 161 167 inode->gc = 0; 168 inode->type = inode_type; 162 169 inode->inum = inum; 163 170 inode->attr = attr; 164 inode-> mode = mode;171 inode->rights = rights; 165 172 inode->uid = uid; 166 173 inode->gid = gid; … … 174 181 175 182 // initialize dentries hash table, if new inode is a directory 176 if( attr & INODE_ATTR_DIR )xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );183 if( inode_type == INODE_TYPE_DIR ) xhtab_init( &inode->children , XHTAB_DENTRY_TYPE ); 177 184 178 185 // initialize inode locks 179 186 remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ) ); 180 187 remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) ); 181 182 // create FS specific inode183 if ( ctx->type == FS_TYPE_FATFS ) fatfs_inode_create( inode );184 else if( ctx->type == FS_TYPE_RAMFS ) ramfs_inode_create( inode );185 188 186 189 // return extended pointer on inode … … 284 287 ////////////////////////////////////////////////////////////////////////////////////////// 285 288 286 ////////////////////////////////////////////// 287 error_t vfs_dentry_create( uint32_ttype,288 char * name,289 vfs_inode_t * parent,290 xptr_t * dentry_xp )289 /////////////////////////////////////////////////// 290 error_t vfs_dentry_create( vfs_fs_type_t fs_type, 291 char * name, 292 vfs_inode_t * parent, 293 xptr_t * dentry_xp ) 291 294 { 292 295 vfs_ctx_t * ctx; // context descriptor 293 296 vfs_dentry_t * dentry; // dentry descriptor (to be allocated) 294 297 kmem_req_t req; // request to kernel memory allocator 295 xptr_t xhtab_xp; // extended pointer on xhtab_t embedded in inode 296 xptr_t xlist_xp; // extended pointer on xlist_entry_t in dentry 298 299 printk("\n @@@ dentry_create : 0 / name = %s\n", name ); 297 300 298 301 // check type and get pointer on context 299 if ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS]; 300 else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS]; 302 if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS]; 303 else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS]; 304 else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS]; 301 305 else 302 306 { … … 309 313 uint32_t length = strlen( name ); 310 314 311 if( length > (CONFIG_VFS_MAX_NAME_LENGTH - 1))315 if( length >= CONFIG_VFS_MAX_NAME_LENGTH ) 312 316 { 313 317 printk("\n[ERROR] in %s : name too long\n", __FUNCTION__ ); 314 318 return EINVAL; 315 319 } 320 321 printk("\n @@@ dentry_create : 1 / name = %s\n", name ); 316 322 317 323 // allocate memory for dentry descriptor … … 328 334 329 335 // initialize dentry descriptor 336 330 337 dentry->ctx = ctx; 331 338 dentry->length = length; … … 333 340 strcpy( dentry->name , name ); 334 341 335 // return extended pointer on dentry to caller 342 printk("\n @@@ dentry_create : 2 / name = %s\n", name ); 343 344 // register dentry in hash table rooted in parent inode 345 xhtab_insert( XPTR( local_cxy , &parent->children ), 346 name, 347 XPTR( local_cxy , &dentry->xlist ) ); 348 349 printk("\n @@@ dentry_create : 3 / name = %s\n", name ); 350 351 // return extended pointer on dentry 336 352 *dentry_xp = XPTR( local_cxy , dentry ); 337 353 338 // register dentry in hash table rooted in parent inode339 xhtab_xp = XPTR( local_cxy , &parent->children );340 xlist_xp = XPTR( local_cxy , &dentry->xlist );341 xhtab_register( xhtab_xp , name , xlist_xp );342 343 354 return 0; 344 355 … … 365 376 ////////////////////////////////////////////////////////////////////////////////////////// 366 377 367 //////////////////////////////////////// 368 void vfs_file_count_up( xptr_t file_xp ) 369 { 370 // get file cluster and local pointer 371 cxy_t file_cxy = GET_CXY( file_xp ); 372 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 373 374 // atomically increment count 375 hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 ); 376 } 377 378 ////////////////////////////////////////// 379 void vfs_file_count_down( xptr_t file_xp ) 380 { 381 // get file cluster and local pointer 382 cxy_t file_cxy = GET_CXY( file_xp ); 383 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 384 385 // atomically decrement count 386 hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 ); 387 } 388 389 //////////////////////////////////////////////// 390 error_t vfs_file_create( xptr_t inode_xp, 391 uint32_t type, 378 ///////////////////////////////////////////// 379 error_t vfs_file_create( vfs_inode_t * inode, 392 380 uint32_t attr, 393 xptr_t * file_xp ) 394 { 395 vfs_file_t * file _ptr;381 xptr_t * file_xp ) 382 { 383 vfs_file_t * file; 396 384 kmem_req_t req; 397 398 // get inode cluster and local pointer399 cxy_t inode_cxy = GET_CXY( inode_xp );400 vfs_inode_t * inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );401 402 // check cluster identifier403 if( inode_cxy != local_cxy )404 {405 printk("\n[PANIC] in %s : local cluster is not the inode owner\n", __FUNCTION__ );406 hal_core_sleep();407 }408 385 409 386 // allocate memory for new file descriptor … … 411 388 req.size = sizeof(vfs_file_t); 412 389 req.flags = AF_KERNEL | AF_ZERO; 413 file_ptr = (vfs_file_t *)kmem_alloc( &req ); 414 415 if( file_ptr == NULL ) return ENOMEM; 416 417 // get inode local pointer 390 file = (vfs_file_t *)kmem_alloc( &req ); 391 392 if( file == NULL ) return ENOMEM; 393 418 394 // initializes new file descriptor 419 file_ptr->gc = 0; 420 file_ptr->type = type; 421 file_ptr->attr = attr; 422 file_ptr->offset = 0; 423 file_ptr->refcount = 0; 424 file_ptr->inode = inode_ptr; 425 file_ptr->ctx = inode_ptr->ctx; 426 file_ptr->mapper = inode_ptr->mapper; 427 428 remote_rwlock_init( XPTR( local_cxy , &file_ptr->lock ) ); 429 430 *file_xp = XPTR( local_cxy , file_ptr ); 431 return 0; 432 } 433 434 //////////////////////////////////////// 435 void vfs_file_destroy( xptr_t file_xp ) 436 { 437 // get file cluster and local pointer 438 cxy_t file_cxy = GET_CXY( file_xp ); 439 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 440 441 if( file_cxy != local_cxy ) 442 { 443 printk("\n[PANIC] in %s : file descriptor not in local cluster\n", __FUNCTION__ ); 444 hal_core_sleep(); 445 } 446 447 if( file_ptr->refcount ) 395 file->gc = 0; 396 file->type = inode->type; 397 file->attr = attr; 398 file->offset = 0; 399 file->refcount = 0; 400 file->inode = inode; 401 file->ctx = inode->ctx; 402 file->mapper = inode->mapper; 403 404 remote_rwlock_init( XPTR( local_cxy , &file->lock ) ); 405 406 *file_xp = XPTR( local_cxy , file ); 407 return 0; 408 409 } // end vfs_file_create() 410 411 /////////////////////////////////////////// 412 void vfs_file_destroy( vfs_file_t * file ) 413 { 414 if( file->refcount ) 448 415 { 449 416 printk("\n[PANIC] in %s : file refcount non zero\n", __FUNCTION__ ); … … 452 419 453 420 kmem_req_t req; 454 req.ptr = file _ptr;421 req.ptr = file; 455 422 req.type = KMEM_VFS_FILE; 456 423 kmem_free( &req ); 457 } 458 459 ////////////////////////////////////////////////////////////////////////////////////////// 460 // File related functions 424 425 } // end vfs_file_destroy() 426 427 428 //////////////////////////////////////// 429 void vfs_file_count_up( xptr_t file_xp ) 430 { 431 // get file cluster and local pointer 432 cxy_t file_cxy = GET_CXY( file_xp ); 433 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 434 435 // atomically increment count 436 hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 ); 437 } 438 439 ////////////////////////////////////////// 440 void vfs_file_count_down( xptr_t file_xp ) 441 { 442 // get file cluster and local pointer 443 cxy_t file_cxy = GET_CXY( file_xp ); 444 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 445 446 // atomically decrement count 447 hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 ); 448 } 449 450 ////////////////////////////////////////////////////////////////////////////////////////// 451 // File access related functions 461 452 ////////////////////////////////////////////////////////////////////////////////////////// 462 453 … … 465 456 char * path, 466 457 uint32_t flags, 467 xptr_t * file_xp ) 468 { 469 return 0; 470 } 471 472 /////////////////////////////////// 473 uint32_t vfs_read( xptr_t file_xp, 474 void * buffer, 475 uint32_t size ) 476 { 477 return 0; 478 } 479 480 //////////////////////////////////// 481 uint32_t vfs_write( xptr_t file_xp, 482 void * buffer, 483 uint32_t size ) 484 { 485 return 0; 486 } 458 uint32_t mode, 459 xptr_t * new_file_xp, 460 uint32_t * new_file_id ) 461 { 462 error_t error; 463 xptr_t inode_xp; // extended pointer on target inode 464 cxy_t inode_cxy; // inode cluster identifier 465 vfs_inode_t * inode_ptr; // inode local pointer 466 uint32_t file_attr; // file descriptor attributes 467 uint32_t lookup_mode; // lookup working mode 468 xptr_t file_xp; // extended pointer on created file descriptor 469 uint32_t file_id; // created file descriptor index in reference fd_array 470 471 // compute lookup working mode 472 lookup_mode = VFS_LOOKUP_OPEN; 473 if( (flags & O_DIR ) ) lookup_mode |= VFS_LOOKUP_DIR; 474 if( (flags & O_CREAT ) ) lookup_mode |= VFS_LOOKUP_CREATE; 475 if( (flags & O_EXCL ) ) lookup_mode |= VFS_LOOKUP_EXCL; 476 477 // compute attributes for the created file 478 file_attr = 0; 479 if( (flags & O_RDONLY ) == 0 ) file_attr |= FD_ATTR_READ_ENABLE; 480 if( (flags & O_WRONLY ) == 0 ) file_attr |= FD_ATTR_WRITE_ENABLE; 481 if( (flags & O_SYNC ) ) file_attr |= FD_ATTR_SYNC; 482 if( (flags & O_APPEND ) ) file_attr |= FD_ATTR_APPEND; 483 if( (flags & O_CLOEXEC) ) file_attr |= FD_ATTR_CLOSE_EXEC; 484 485 // get extended pointer on target inode 486 error = vfs_lookup( cwd_xp , path , lookup_mode , &inode_xp ); 487 488 if( error ) return error; 489 490 // get target inode cluster and local pointer 491 inode_cxy = GET_CXY( inode_xp ); 492 inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp ); 493 494 // create a new file descriptor in cluster containing inode 495 if( inode_cxy == local_cxy ) // target cluster is local 496 { 497 error = vfs_file_create( inode_ptr , file_attr , &file_xp ); 498 } 499 else // target cluster is remote 500 { 501 rpc_vfs_file_create_client( inode_cxy , inode_ptr , file_attr , &file_xp , &error ); 502 } 503 504 if( error ) return error; 505 506 // allocate and register a new file descriptor index in reference cluster fd_array 507 error = process_fd_register( file_xp , &file_id ); 508 509 if( error ) return error; 510 511 // success 512 *new_file_xp = file_xp; 513 *new_file_id = file_id; 514 return 0; 515 516 } // end vfs_open() 517 518 ///////////////////////////////////// 519 error_t vfs_move( bool_t to_buffer, 520 xptr_t file_xp, 521 void * buffer, 522 uint32_t size ) 523 { 524 assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" ); 525 526 cxy_t file_cxy; // remote file descriptor cluster 527 vfs_file_t * file_ptr; // remote file descriptor local pointer 528 vfs_inode_type_t inode_type; 529 uint32_t file_offset; // current offset in file 530 mapper_t * mapper; 531 error_t error; 532 533 // get cluster and local pointer on remote file descriptor 534 file_cxy = GET_CXY( file_xp ); 535 file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 536 537 // get inode type from remote file descriptor 538 inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) ); 539 540 // action depends on inode type 541 if( inode_type == INODE_TYPE_FILE ) 542 { 543 // get mapper pointer and file offset from file descriptor 544 file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) ); 545 mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) ); 546 547 // move data between mapper and buffer 548 if( file_cxy == local_cxy ) 549 { 550 error = mapper_move( mapper, 551 to_buffer, 552 file_offset, 553 buffer, 554 size ); 555 } 556 else 557 { 558 rpc_mapper_move_client( file_cxy, 559 mapper, 560 to_buffer, 561 file_offset, 562 buffer, 563 size, 564 &error ); 565 } 566 567 return error; 568 } 569 else if (inode_type == INODE_TYPE_DIR ) 570 { 571 printk("\n[ERROR] in %s : inode is a directory", __FUNCTION__ ); 572 return EINVAL; 573 } 574 else if (inode_type == INODE_TYPE_DEV ) 575 { 576 // TODO 577 return 0; 578 } 579 else 580 { 581 printk("\n[PANIC] in %s : illegal inode type\n", __FUNCTION__ ); 582 hal_core_sleep(); 583 return -1; 584 } 585 } // end vfs_access() 487 586 488 587 ////////////////////////////////////// … … 492 591 uint32_t * new_offset ) 493 592 { 494 return 0; 495 } 496 497 ////////////////////////////////////// 498 error_t vfs_close( xptr_t file_xp, 499 uint32_t * refcount ) 500 { 501 return 0; 502 } 593 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 594 hal_core_sleep(); 595 return 0; 596 597 assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" ); 598 599 } // vfs_lseek() 600 601 /////////////////////////////////// 602 error_t vfs_close( xptr_t file_xp, 603 uint32_t file_id ) 604 { 605 assert( (file_xp != XPTR_NULL) , __FUNCTION__ , "file_xp == XPTR_NULL" ); 606 607 assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , __FUNCTION__ , "illegal file_id" ); 608 609 thread_t * this = CURRENT_THREAD; 610 process_t * process = this->process; 611 612 // get cluster and local pointer on remote file descriptor 613 cxy_t file_cxy = GET_CXY( file_xp ); 614 vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp ); 615 616 // get local pointer on local cluster manager 617 cluster_t * cluster = LOCAL_CLUSTER; 618 619 // get owner process cluster and lpid 620 cxy_t owner_cxy = CXY_FROM_PID( process->pid ); 621 lpid_t lpid = LPID_FROM_PID( process->pid ); 622 623 // get extended pointers on copies root and lock 624 xptr_t root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] ); 625 xptr_t lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] ); 626 627 // take the lock protecting the copies 628 remote_spinlock_lock( lock_xp ); 629 630 // 1) loop on the process descriptor copies to cancel all fd_array[file_id] entries 631 xptr_t iter_xp; 632 XLIST_FOREACH( root_xp , iter_xp ) 633 { 634 xptr_t process_xp = XLIST_ELEMENT( iter_xp , process_t , copies_list ); 635 cxy_t process_cxy = GET_CXY( process_xp ); 636 process_t * process_ptr = (process_t *)GET_PTR( process_xp ); 637 638 xptr_t lock_xp = XPTR( process_cxy , &process_ptr->fd_array.lock ); 639 xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] ); 640 641 // lock is required for atomic write of a 64 bits word 642 remote_rwlock_wr_lock( lock_xp ); 643 hal_remote_swd( entry_xp , XPTR_NULL ); 644 remote_rwlock_wr_unlock( lock_xp ); 645 646 hal_wbflush(); 647 } 648 649 // 2) release memory allocated to file descriptor in remote cluster 650 if( file_cxy == local_cxy ) // file cluster is local 651 { 652 vfs_file_destroy( file_ptr ); 653 } 654 else // file cluster is local 655 { 656 rpc_vfs_file_destroy_client( file_cxy , file_ptr ); 657 } 658 659 return 0; 660 661 } // end vfs_close() 503 662 504 663 //////////////////////////////////// … … 506 665 char * path ) 507 666 { 667 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 668 hal_core_sleep(); 669 return 0; 670 } // vfs_unlink() 671 672 /////////////////////////////////////// 673 error_t vfs_stat( xptr_t file_xp, 674 vfs_stat_t * k_stat ) 675 { 676 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 677 hal_core_sleep(); 678 return 0; 679 } 680 681 //////////////////////////////////////////// 682 error_t vfs_readdir( xptr_t file_xp, 683 vfs_dirent_t * k_dirent ) 684 { 685 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 686 hal_core_sleep(); 508 687 return 0; 509 688 } 510 689 511 690 ////////////////////////////////////// 512 error_t vfs_stat( xptr_t file_xp, 513 vfs_stat_t * stat ) 514 { 515 return 0; 516 } 517 518 ////////////////////////////////////////////////////////////////////////////////////////// 519 // Directory related functions 520 ////////////////////////////////////////////////////////////////////////////////////////// 521 522 523 524 525 526 ////////////////////////////////////////////////////////////////////////////////////////// 691 error_t vfs_mkdir( xptr_t file_xp, 692 char * path, 693 uint32_t mode ) 694 { 695 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 696 hal_core_sleep(); 697 return 0; 698 } 699 700 //////////////////////////////////// 701 error_t vfs_rmdir( xptr_t file_xp, 702 char * path ) 703 { 704 printk("\n[PANIC] %s non implemented\n", __FUNCTION__ ); 705 hal_core_sleep(); 706 return 0; 707 } 708 709 /////////////////////////////////// 710 error_t vfs_chdir( xptr_t cwd_xp, 711 char * path ) 712 { 713 error_t error; 714 xptr_t inode_xp; // extended pointer on target inode 715 cxy_t inode_cxy; // target inode cluster identifier 716 vfs_inode_t * inode_ptr; // target inode local pointer 717 uint32_t mode; // lookup working mode 718 vfs_inode_type_t inode_type; // target inode type 719 720 // set lookup working mode 721 mode = 0; 722 723 // get extended pointer on target inode 724 error = vfs_lookup( cwd_xp , path , mode , &inode_xp ); 725 726 if( error ) return error; 727 728 // get inode cluster and local pointer 729 inode_cxy = GET_CXY( inode_xp ); 730 inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp ); 731 732 // get inode type from remote file 733 inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) ); 734 735 if( inode_type != INODE_TYPE_DIR ) 736 { 737 CURRENT_THREAD->errno = ENOTDIR; 738 return -1; 739 } 740 741 printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ ); 742 hal_core_sleep(); 743 return 0; 744 } 745 746 /////////////////////////////////// 747 error_t vfs_chmod( xptr_t cwd_xp, 748 char * path, 749 uint32_t rights ) 750 { 751 error_t error; 752 xptr_t inode_xp; // extended pointer on target inode 753 cxy_t inode_cxy; // inode cluster identifier 754 vfs_inode_t * inode_ptr; // inode local pointer 755 uint32_t mode; // lookup working mode 756 vfs_inode_type_t inode_type; // target inode type 757 758 // set lookup working mode 759 mode = 0; 760 761 // get extended pointer on target inode 762 error = vfs_lookup( cwd_xp , path , mode , &inode_xp ); 763 764 if( error ) return error; 765 766 // get inode cluster and local pointer 767 inode_cxy = GET_CXY( inode_xp ); 768 inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp ); 769 770 // get inode type from remote inode 771 inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) ); 772 773 774 printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ ); 775 hal_core_sleep(); 776 return 0; 777 } 778 779 /////////////////////////////////// 780 error_t vfs_mkfifo( xptr_t cwd_xp, 781 char * path, 782 uint32_t rights ) 783 { 784 printk("\n[PANIC] in %s : not implemented yet\n", __FUNCTION__ ); 785 hal_core_sleep(); 786 return 0; 787 } 788 789 790 791 /////////////////////////////////////////////////////////////////////////////////////////r 527 792 // Inode Tree functions 528 793 ////////////////////////////////////////////////////////////////////////////////////////// 529 794 530 795 ////////////////////////////////////////////////////////////////////////////////////////// 531 // This staticfunction is used by the vfs_lookup() function.796 // This function is used by the vfs_lookup() function. 532 797 // It takes an extended pointer on a remote inode (parent directory inode), 533 798 // and check access_rights violation for the calling thread. … … 641 906 } 642 907 643 //////////////////////////////////////// 644 error_t vfs_lookup( xptr_t cwd_xp, 645 char * pathname, 646 uint32_t client_uid, 647 uint32_t client_gid, 648 xptr_t * inode_xp, 649 xptr_t * ctx_xp ) 908 ////////////////////////////////////////////// 909 error_t vfs_lookup( xptr_t cwd_xp, 910 char * pathname, 911 uint32_t mode, 912 xptr_t * inode_xp ) 650 913 { 651 914 char name[CONFIG_VFS_MAX_NAME_LENGTH]; // one name in path 652 915 653 xptr_t parent_xp; // extended pointer on parent inode 654 cxy_t parent_cxy; // cluster for parentc inode 655 vfs_inode_t * parent_ptr; // local pointer on parent inode 656 xptr_t child_xp; // extended pointer on child inode 657 cxy_t child_cxy; // cluster for child inode 658 vfs_inode_t * child_ptr; // local pointer on child inode 659 char * current; // current pointer on path 660 char * next; // next value for current pointer 661 bool_t last; // true when the name is the last in path 662 bool_t found; // true when a child has been found 663 thread_t * this; // pointer on calling thread descriptor 664 process_t * process; // pointer on calling process descriptor 665 vfs_ctx_t * ctx; // parent inode context 666 uint32_t type; // file system type of parent inode 667 error_t error; 916 xptr_t parent_xp; // extended pointer on parent inode 917 cxy_t parent_cxy; // cluster for parent inode 918 vfs_inode_t * parent_ptr; // local pointer on parent inode 919 xptr_t child_xp; // extended pointer on child inode 920 cxy_t child_cxy; // cluster for child inode 921 vfs_inode_t * child_ptr; // local pointer on child inode 922 vfs_inode_type_t inode_type; // child inode type 923 vfs_fs_type_t fs_type; // File system type 924 vfs_ctx_t * ctx_ptr; // local pointer on FS context 925 char * current; // current pointer on path 926 char * next; // next value for current pointer 927 bool_t last; // true when the name is the last in path 928 bool_t found; // true when a child has been found 929 thread_t * this; // pointer on calling thread descriptor 930 process_t * process; // pointer on calling process descriptor 931 error_t error; 668 932 669 933 this = CURRENT_THREAD; … … 687 951 do 688 952 { 689 // get cluster and local pointer for parent inode 690 parent_cxy = GET_CXY( parent_xp ); 691 parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp ); 692 693 // get parent inode FS type 694 ctx = (vfs_ctx_t *)(intptr_t)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) ); 695 type = ctx->type; 696 697 // get one name from path 953 // get one name from path and the last flag 698 954 vfs_get_name_from_path( current , name , &next , &last ); 699 955 … … 708 964 vfs_inode_remote_unlock( parent_xp ); 709 965 710 // insert a new dentry/inode in parent inode 711 error = vfs_add_child_in_parent( type , parent_xp , name , &child_xp ); 966 // get cluster and local pointer on parent inode 967 parent_cxy = GET_CXY( parent_xp ); 968 parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp ); 969 970 // get parent inode FS type 971 ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) ); 972 fs_type = ctx_ptr->type; 973 974 // get child inode type 975 if( (last == false) || (mode & VFS_LOOKUP_DIR) ) inode_type = INODE_TYPE_DIR; 976 else inode_type = INODE_TYPE_FILE; 977 978 // insert a child dentry/inode in parent inode 979 error = vfs_add_child_in_parent( inode_type, 980 fs_type, 981 parent_xp, 982 name, 983 &child_xp ); 712 984 713 985 if( error ) … … 723 995 724 996 // check access rights 725 error = vfs_access_denied( child_xp,726 client_uid,727 client_gid );728 if( error )729 {730 printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name );731 return EACCES;732 }997 // error = vfs_access_denied( child_xp, 998 // client_uid, 999 // client_gid ); 1000 // if( error ) 1001 // { 1002 // printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name ); 1003 // return EACCES; 1004 // } 733 1005 734 1006 // take lock on child inode if not last … … 753 1025 // return searched pointers 754 1026 *inode_xp = child_xp; 755 *ctx_xp = (xptr_t)hal_remote_lwd( XPTR( child_cxy , &child_ptr->ctx ) );756 1027 757 1028 return 0; … … 770 1041 uint32_t count; // number of characters written in buffer 771 1042 uint32_t index; // slot index in buffer 772 xptr_t inode_xp; // extended pointer on1043 xptr_t inode_xp; // extended pointer on 773 1044 774 1045 // implementation note: … … 829 1100 } // end vfs_get_path() 830 1101 831 /////////////////////////////////////////////// 832 error_t vfs_add_child_in_parent( uint32_t type, 833 xptr_t parent_xp, 834 char * name, 835 xptr_t * child_xp ) 836 { 837 xptr_t dentry_xp; // extended pointer on created dentry 838 xptr_t inode_xp; // extended pointer on created inode 839 error_t error; 1102 /////////////////////////////////////////////////////////////// 1103 error_t vfs_add_child_in_parent( vfs_inode_type_t inode_type, 1104 vfs_fs_type_t fs_type, 1105 xptr_t parent_xp, 1106 char * name, 1107 xptr_t * child_xp ) 1108 { 1109 error_t error; 1110 xptr_t dentry_xp; // extended pointer on created dentry 1111 xptr_t inode_xp; // extended pointer on created inode 1112 cxy_t parent_cxy; // parent inode cluster identifier 1113 vfs_inode_t * parent_ptr; // parent inode local pointer 1114 vfs_ctx_t * parent_ctx; // parent inode context local pointer 840 1115 841 1116 // get parent inode cluster and local pointer 842 cxy_t parent_cxy = GET_CXY( parent_xp ); 843 vfs_inode_t * parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp ); 1117 parent_cxy = GET_CXY( parent_xp ); 1118 parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp ); 1119 1120 // get parent inode context local pointer 1121 parent_ctx = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) ); 844 1122 845 1123 // create dentry 846 1124 if( parent_cxy == local_cxy ) // parent cluster is the local cluster 847 1125 { 848 error = vfs_dentry_create( type,1126 error = vfs_dentry_create( fs_type, 849 1127 name, 850 1128 parent_ptr, … … 854 1132 { 855 1133 rpc_vfs_dentry_create_client( parent_cxy, 856 type,1134 fs_type, 857 1135 name, 858 1136 parent_ptr, … … 887 1165 { 888 1166 error = vfs_inode_create( dentry_xp, 889 type, 1167 fs_type, 1168 inode_type, 890 1169 attr, 891 1170 mode, … … 898 1177 rpc_vfs_inode_create_client( child_cxy, 899 1178 dentry_xp, 900 type, 1179 fs_type, 1180 inode_type, 901 1181 attr, 902 1182 mode, … … 925 1205 926 1206 1207 1208 1209 ////////////////////////////////////////////////////////////////////////////////////////// 1210 // Mapper related functions 1211 ////////////////////////////////////////////////////////////////////////////////////////// 1212 1213 //////////////////////////////////////////////// 1214 error_t vfs_move_page_to_mapper( page_t * page ) 1215 { 1216 error_t error = 0; 1217 1218 assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" ); 1219 1220 mapper_t * mapper = page->mapper; 1221 1222 assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" ); 1223 1224 // get FS type 1225 vfs_fs_type_t fs_type = mapper->inode->ctx->type; 1226 1227 // update mapper if permitted by file system type 1228 if( fs_type == FS_TYPE_FATFS ) 1229 { 1230 // get mapper lock in WRITE_MODE 1231 rwlock_wr_lock( &mapper->lock ); 1232 1233 error = fatfs_read_page( page ); 1234 1235 // release mapper lock 1236 rwlock_wr_unlock( &mapper->lock ); 1237 } 1238 else if( fs_type == FS_TYPE_RAMFS ) 1239 { 1240 assert( false , __FUNCTION__ , "should not be called for RAMFS\n" ); 1241 } 1242 else if( fs_type == FS_TYPE_DEVFS ) 1243 { 1244 assert( false , __FUNCTION__ , "should not be called for DEVFS\n" ); 1245 } 1246 else 1247 { 1248 assert( false , __FUNCTION__ , "undefined file system type\n" ); 1249 } 1250 1251 return error; 1252 1253 } // end vfs_move_page_to_mapper() 1254 1255 ////////////////////////////////////////////////// 1256 error_t vfs_move_page_from_mapper( page_t * page ) 1257 { 1258 error_t error = 0; 1259 1260 assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" ); 1261 1262 mapper_t * mapper = page->mapper; 1263 1264 assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" ); 1265 1266 // get FS type 1267 vfs_fs_type_t fs_type = mapper->inode->ctx->type; 1268 1269 // update file system if permitted by file system type 1270 if( fs_type == FS_TYPE_FATFS ) 1271 { 1272 if( page_is_flag( page , PG_DIRTY ) ) 1273 { 1274 // get mapper lock in READ_MODE 1275 rwlock_rd_lock( &mapper->lock ); 1276 1277 error = fatfs_write_page( page ); 1278 1279 // release mapper lock from READ_MODE 1280 rwlock_rd_unlock( &mapper->lock ); 1281 1282 // clear dirty bit if success 1283 if( error == 0 ) page_undo_dirty( page ); 1284 } 1285 } 1286 else if( fs_type == FS_TYPE_RAMFS ) 1287 { 1288 assert( false , __FUNCTION__ , "should not be called for RAMFS\n" ); 1289 } 1290 else if( fs_type == FS_TYPE_DEVFS ) 1291 { 1292 assert( false , __FUNCTION__ , "should not be called for DEVFS\n" ); 1293 } 1294 else 1295 { 1296 assert( false , __FUNCTION__ , "undefined file system type\n" ); 1297 } 1298 1299 return error; 1300 1301 } // end vfs_move_page_from_mapper() 1302 1303
Note: See TracChangeset
for help on using the changeset viewer.