/* * IMFS_memfile_addblock * * This routine adds a single block to the specified in-memory file. */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { block_p memory; block_p *block_entry_ptr; IMFS_assert( the_jnode ); IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE ); /* * Obtain the pointer for the specified block number */ block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); if ( !block_entry_ptr ) return 1; if ( *block_entry_ptr ) return 0; /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); if ( !memory ) return 1; *block_entry_ptr = memory; return 0; }
/* * IMFS_memfile_extend * * This routine insures that the in-memory file is of the length * specified. If necessary, it will allocate memory blocks to * extend the file. */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { unsigned int block; unsigned int new_blocks; unsigned int old_blocks; /* * Perform internal consistency checks */ IMFS_assert( the_jnode ); IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) rtems_set_errno_and_return_minus_one( EINVAL ); /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); } } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; IMFS_update_ctime(the_jnode); IMFS_update_mtime(the_jnode); return 0; }
/* * memfile_free_blocks_in_table * * This is a support routine for IMFS_memfile_remove. It frees all the * blocks in one of the indirection tables. */ static void memfile_free_blocks_in_table( block_p **block_table, int entries ) { int i; block_p *b; /* * Perform internal consistency checks */ IMFS_assert( block_table ); /* * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i<entries ; i++ ) { if ( b[i] ) { memfile_free_block( b[i] ); b[i] = 0; } } /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); *block_table = 0; }
int IMFS_initialize_support( rtems_filesystem_mount_table_entry_t *mt_entry, const void *data ) { const IMFS_mount_data *mount_data = data; IMFS_fs_info_t *fs_info = mount_data->fs_info; IMFS_jnode_t *root_node; fs_info->mknod_controls = mount_data->mknod_controls; root_node = IMFS_initialize_node( &fs_info->Root_directory.Node, &fs_info->mknod_controls->directory->node_control, "", 0, (S_IFDIR | 0755), NULL ); IMFS_assert( root_node != NULL ); mt_entry->fs_info = fs_info; mt_entry->ops = mount_data->ops; mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS; mt_entry->mt_fs_root->location.node_access = root_node; IMFS_Set_handlers( &mt_entry->mt_fs_root->location ); IMFS_determine_bytes_per_block( &imfs_memfile_bytes_per_block, imfs_rq_memfile_bytes_per_block, IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK ); return 0; }
IMFS_jnode_t *IMFS_create_node_with_control( const rtems_filesystem_location_info_t *parentloc, const IMFS_node_control *node_control, const char *name, size_t namelen, mode_t mode, const IMFS_types_union *info ) { IMFS_fs_info_t *fs_info = parentloc->mt_entry->fs_info; IMFS_jnode_t *node = IMFS_allocate_node( fs_info, node_control, name, namelen, mode, info ); if ( node != NULL ) { IMFS_jnode_t *parent = parentloc->node_access; /* * This node MUST have a parent, so put it in that directory list. */ IMFS_assert( parent != NULL ); IMFS_add_to_directory( parent, node ); } return node; }
/* * IMFS_memfile_addblock * * This routine adds a single block to the specified in-memory file. */ static int IMFS_memfile_addblock( IMFS_memfile_t *memfile, unsigned int block ) { block_p memory; block_p *block_entry_ptr; IMFS_assert( memfile ); /* * Obtain the pointer for the specified block number */ block_entry_ptr = IMFS_memfile_get_block_pointer( memfile, block, 1 ); if ( !block_entry_ptr ) return 1; if ( *block_entry_ptr ) return 0; /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); if ( !memory ) return 1; *block_entry_ptr = memory; return 0; }
void IMFS_node_destroy( IMFS_jnode_t *node ) { IMFS_assert( node->reference_count == 0 ); node = (*node->control->node_destroy)( node ); free( node ); }
int IMFS_mknod( const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { IMFS_token_types type = 0; IMFS_jnode_t *new_node; int result; char new_name[ IMFS_NAME_MAX + 1 ]; IMFS_types_union info; IMFS_get_token( token, strlen( token ), new_name, &result ); /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else if (S_ISFIFO(mode)) type = IMFS_FIFO; else IMFS_assert( 0 ); /* * Allocate and fill in an IMFS jnode * * NOTE: Coverity Id 21 reports this as a leak. * While technically not a leak, it indicated that IMFS_create_node * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( pathloc, type, new_name, mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); IMFS_update_ctime(new_node->Parent); IMFS_update_mtime(new_node->Parent); return 0; }
/* * IMFS_memfile_remove_block * * This routine removes the specified block from the in-memory file. * * NOTE: This is a support routine and is called only to remove * the last block or set of blocks in a file. Removing a * block from the middle of a file would be exceptionally * dangerous and the results unpredictable. */ MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { block_p *block_ptr; block_p ptr; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); IMFS_assert( block_ptr ); ptr = *block_ptr; *block_ptr = 0; memfile_free_block( ptr ); return 1; }
ssize_t IMFS_readlink( const rtems_filesystem_location_info_t *loc, char *buf, size_t bufsize ) { IMFS_jnode_t *node; ssize_t i; node = loc->node_access; IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK ); for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ ) buf[i] = node->info.sym_link.name[i]; return i; }
static void get_type_and_info_by_mode_and_dev( mode_t mode, dev_t dev, IMFS_jnode_types_t *type, IMFS_types_union *info ) { if ( S_ISDIR( mode ) ) { *type = IMFS_DIRECTORY; } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) { *type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info->device.major, info->device.minor ); } else if (S_ISFIFO( mode )) { *type = IMFS_FIFO; } else { IMFS_assert( S_ISREG( mode ) ); *type = IMFS_MEMORY_FILE; } }
/* * IMFS_memfile_destroy * * This routine frees all memory associated with an in memory file. * * NOTE: This is an exceptionally conservative implementation. * It will check EVERY pointer which is non-NULL and insure * any child non-NULL pointers are freed. Optimistically, all that * is necessary is to scan until a NULL pointer is found. There * should be no allocated data past that point. * * In experimentation on the powerpc simulator, it was noted * that using blocks which held 128 slots versus 16 slots made * a significant difference in the performance of this routine. * * Regardless until the IMFS implementation is proven, it * is better to stick to simple, easy to understand algorithms. */ static void IMFS_memfile_destroy( IMFS_jnode_t *the_jnode ) { IMFS_memfile_t *memfile; int i; int j; unsigned int to_free; block_p *p; memfile = (IMFS_memfile_t *) the_jnode; /* * Perform internal consistency checks */ IMFS_assert( memfile ); /* * Eventually this could be set smarter at each call to * memfile_free_blocks_in_table to greatly speed this up. */ to_free = IMFS_MEMFILE_BLOCK_SLOTS; /* * Now start freeing blocks in this order: * + indirect * + doubly indirect * + triply indirect */ if ( memfile->indirect ) { memfile_free_blocks_in_table( &memfile->indirect, to_free ); } if ( memfile->doubly_indirect ) { for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) { if ( memfile->doubly_indirect[i] ) { memfile_free_blocks_in_table( (block_p **)&memfile->doubly_indirect[i], to_free ); } } memfile_free_blocks_in_table( &memfile->doubly_indirect, to_free ); } if ( memfile->triply_indirect ) { for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) { p = (block_p *) memfile->triply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) { if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( (block_p **)&memfile->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( (block_p **)&memfile->triply_indirect, to_free ); } IMFS_node_destroy_default( the_jnode ); }
/* * IMFS_memfile_remove * * This routine frees all memory associated with an in memory file. * * NOTE: This is an exceptionally conservative implementation. * It will check EVERY pointer which is non-NULL and insure * any child non-NULL pointers are freed. Optimistically, all that * is necessary is to scan until a NULL pointer is found. There * should be no allocated data past that point. * * In experimentation on the powerpc simulator, it was noted * that using blocks which held 128 slots versus 16 slots made * a significant difference in the performance of this routine. * * Regardless until the IMFS implementation is proven, it * is better to stick to simple, easy to understand algorithms. */ IMFS_jnode_t *IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { IMFS_memfile_t *info; int i; int j; unsigned int to_free; block_p *p; /* * Perform internal consistency checks */ IMFS_assert( the_jnode ); IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE ); /* * Eventually this could be set smarter at each call to * memfile_free_blocks_in_table to greatly speed this up. */ to_free = IMFS_MEMFILE_BLOCK_SLOTS; /* * Now start freeing blocks in this order: * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) { if ( info->doubly_indirect[i] ) { memfile_free_blocks_in_table( (block_p **)&info->doubly_indirect[i], to_free ); } } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) { p = (block_p *) info->triply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) { if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect, to_free ); } return the_jnode; }
block_p *IMFS_memfile_get_block_pointer( #endif IMFS_memfile_t *memfile, unsigned int block, int malloc_it ) { unsigned int my_block; unsigned int singly; unsigned int doubly; unsigned int triply; block_p *p; block_p *p1; block_p *p2; /* * Perform internal consistency checks */ IMFS_assert( memfile ); my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { p = memfile->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) return 0; memfile->indirect = p; } return &memfile->indirect[ my_block ]; } if ( !p ) return 0; return &memfile->indirect[ my_block ]; } /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { my_block -= FIRST_DOUBLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = memfile->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) return 0; memfile->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) return 0; p[ doubly ] = (block_p) p1; } return (block_p *)&p1[ singly ]; } if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) return 0; return (block_p *)&p[ singly ]; } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = memfile->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) return 0; memfile->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) return 0; p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; p2 = (block_p *)p1[ doubly ]; if ( !p2 ) return 0; return (block_p *)&p2[ singly ]; } /* * This means the requested block number is out of range. */ return 0; }
/* * IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by memfile. The file is extended as needed. */ ssize_t IMFS_memfile_write( IMFS_memfile_t *memfile, off_t start, const unsigned char *source, unsigned int length ) { block_p *block_ptr; unsigned int block; int status; unsigned int my_length; unsigned int to_copy = 0; unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; /* * Perform internal consistency checks */ IMFS_assert( source ); IMFS_assert( memfile ); my_length = length; /* * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + my_length; if ( last_byte > memfile->File.size ) { bool zero_fill = start > memfile->File.size; status = IMFS_memfile_extend( memfile, zero_fill, last_byte ); if ( status ) return status; } copied = 0; /* * Three phases to the write: * + possibly the last part of one block * + all of zero of more blocks * + possibly the first part of one block */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 ); if ( !block_ptr ) return copied; #if 0 fprintf( stderr, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); src += to_copy; block++; my_length -= to_copy; copied += to_copy; } /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 ); if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); src += to_copy; block++; my_length -= to_copy; copied += to_copy; } /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 ); if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); my_length = 0; copied += to_copy; } IMFS_mtime_ctime_update( &memfile->File.Node ); return copied; }
/* * IMFS_memfile_read * * This routine read from memory file pointed to by the_jnode into * the specified data buffer specified by destination. The file * is NOT extended. An offset greater than the length of the file * is considered an error. Read from an offset for more bytes than * are between the offset and the end of the file will result in * reading the data between offset and the end of the file (truncated * read). */ static ssize_t IMFS_memfile_read( IMFS_file_t *file, off_t start, unsigned char *destination, unsigned int length ) { block_p *block_ptr; unsigned int block; unsigned int my_length; unsigned int to_copy = 0; unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; /* * Perform internal consistency checks */ IMFS_assert( file ); IMFS_assert( dest ); /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; /* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > file->Memfile.File.size ) my_length = file->Memfile.File.size - start; copied = 0; /* * Three phases to the read: * + possibly the last part of one block * + all of zero of more blocks * + possibly the first part of one block */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( &file->Memfile, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); dest += to_copy; block++; my_length -= to_copy; copied += to_copy; } /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( &file->Memfile, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); dest += to_copy; block++; my_length -= to_copy; copied += to_copy; } /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( &file->Memfile, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( &file->Node ); return copied; }
/* * IMFS_memfile_extend * * This routine insures that the in-memory file is of the length * specified. If necessary, it will allocate memory blocks to * extend the file. */ static int IMFS_memfile_extend( IMFS_memfile_t *memfile, bool zero_fill, off_t new_length ) { unsigned int block; unsigned int new_blocks; unsigned int old_blocks; unsigned int offset; /* * Perform internal consistency checks */ IMFS_assert( memfile ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) rtems_set_errno_and_return_minus_one( EFBIG ); /* * Verify new file size is actually larger than current size */ if ( new_length <= memfile->File.size ) return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; old_blocks = memfile->File.size / IMFS_MEMFILE_BYTES_PER_BLOCK; offset = memfile->File.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK; /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( !IMFS_memfile_addblock( memfile, block ) ) { if ( zero_fill ) { size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset; block_p *block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 ); memset( &(*block_ptr) [offset], 0, count); offset = 0; } } else { for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( memfile, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); } } /* * Set the new length of the file. */ memfile->File.size = new_length; IMFS_mtime_ctime_update( &memfile->File.Node ); return 0; }