bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { rtems_chain_control *chain = &filesystem_chain; const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( node = rtems_chain_first( chain ); !rtems_chain_is_tail( chain, node ) && !stop; node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); } rtems_libio_unlock(); } return stop; }
static int pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { sc = rtems_semaphore_create( rtems_build_name('P', 'I', 'P', 'E'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &pipe_semaphore ); } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); } if (sc == RTEMS_SUCCESSFUL) { return 0; } else { return -ENOMEM; } }
void rtems_libio_free( rtems_libio_t *iop ) { rtems_filesystem_location_free( &iop->pathinfo ); rtems_libio_lock(); iop->flags = 0; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_libio_unlock(); }
void rtems_libio_free( rtems_libio_t *iop ) { rtems_filesystem_location_free( &iop->pathinfo ); rtems_libio_lock(); iop = memset( iop, 0, sizeof( *iop ) ); *rtems_libio_iop_free_tail = iop; rtems_libio_iop_free_tail = &iop->data1; rtems_libio_unlock(); }
static bool rtems_rap_data_init (void) { /* * Lock the RAP. We only create a lock if a call is made. First we test if a * lock is present. If one is present we lock it. If not the libio lock is * locked and we then test the lock again. If not present we create the lock * then release libio lock. */ if (!rap_.lock) { rtems_libio_lock (); if (!rap_.lock) { rtems_status_code sc; rtems_id lock; /* * Create the RAP lock. */ sc = rtems_semaphore_create (rtems_build_name ('R', 'A', 'P', '_'), 1, RTEMS_MUTEX_ATTRIBS, RTEMS_NO_PRIORITY, &lock); if (sc != RTEMS_SUCCESSFUL) return false; sc = rtems_semaphore_obtain (lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { rtems_semaphore_delete (lock); return false; } rap_.lock = lock; /* * Initialise the objects list and create any required services. */ rtems_chain_initialize_empty (&rap_.apps); } rtems_libio_unlock (); rtems_rap_unlock (); } return true; }
rtems_libio_t *rtems_libio_allocate( void ) { rtems_libio_t *iop = NULL; rtems_libio_lock(); if (rtems_libio_iop_freelist) { iop = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop->data1; memset( iop, 0, sizeof(*iop) ); iop->flags = LIBIO_FLAGS_OPEN; } rtems_libio_unlock(); return iop; }
static int open_files(void) { int free_count = 0; rtems_libio_t *iop; rtems_libio_lock(); iop = rtems_libio_iop_freelist; while (iop != NULL) { ++free_count; iop = iop->data1; } rtems_libio_unlock(); return (int) rtems_libio_number_iops - free_count; }
rtems_libio_t *rtems_libio_allocate( void ) { rtems_libio_t *iop; rtems_libio_lock(); iop = rtems_libio_iop_free_head; if ( iop != NULL ) { void *next; next = iop->data1; rtems_libio_iop_free_head = next; if ( next == NULL ) { rtems_libio_iop_free_tail = &rtems_libio_iop_free_head; } } rtems_libio_unlock(); return iop; }
bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; node = rtems_chain_next( node ) ) { const rtems_filesystem_mount_table_entry_t *mt_entry = (rtems_filesystem_mount_table_entry_t *) node; stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; }
void rtems_filesystem_default_lock( const rtems_filesystem_mount_table_entry_t *mt_entry ) { rtems_libio_lock(); }
int mount( const char *source, const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { rtems_filesystem_fsmount_me_t mount_h = NULL; rtems_filesystem_location_info_t loc; rtems_filesystem_mount_table_entry_t *mt_entry = NULL; rtems_filesystem_location_info_t *loc_to_free = NULL; bool has_target = target != NULL; size_t target_length = 0; /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && options != RTEMS_FILESYSTEM_READ_WRITE ) rtems_set_errno_and_return_minus_one( EINVAL ); /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); if ( !mount_h ) rtems_set_errno_and_return_minus_one( EINVAL ); /* * Allocate a mount table entry */ mt_entry = alloc_mount_table_entry( source, target, filesystemtype, &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); mt_entry->mt_fs_root.mt_entry = mt_entry; mt_entry->options = options; mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf; /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( has_target ) { if ( rtems_filesystem_evaluate_path( target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 ) goto cleanup_and_bail; loc_to_free = &loc; /* * Test for node_type_h */ if (!loc.ops->node_type_h) { errno = ENOTSUP; goto cleanup_and_bail; } /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { errno = ENOTDIR; goto cleanup_and_bail; } /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { errno = EBUSY; goto cleanup_and_bail; } /* * This must be a good mount point, so move the location information * into the allocated mount entry. Note: the information that * may have been allocated in loc should not be sent to freenode * until the system is unmounted. It may be needed to correctly * traverse the tree. */ mt_entry->mt_point_node.node_access = loc.node_access; mt_entry->mt_point_node.handlers = loc.handlers; mt_entry->mt_point_node.ops = loc.ops; mt_entry->mt_point_node.mt_entry = loc.mt_entry; /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ errno = ENOTSUP; goto cleanup_and_bail; } if ( loc.ops->mount_h( mt_entry ) ) { goto cleanup_and_bail; } } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { errno = EINVAL; goto cleanup_and_bail; } /* * This is a mount of the base file system --> The * mt_point_node.node_access will be left to null to indicate that this * is the root of the entire file system. */ } if ( (*mount_h)( mt_entry, data ) ) { /* * Try to undo the mount operation */ if ( loc.ops->unmount_h ) { loc.ops->unmount_h( mt_entry ); } goto cleanup_and_bail; } /* * Add the mount table entry to the mount table chain */ rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) rtems_filesystem_root = mt_entry->mt_fs_root; return 0; cleanup_and_bail: free( mt_entry ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; }
int unmount( const char *path ) { rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *fs_root_loc; rtems_filesystem_location_info_t *fs_mount_loc; rtems_filesystem_mount_table_entry_t *mt_entry; /* * Get * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; fs_mount_loc = &mt_entry->mt_point_node; fs_root_loc = &mt_entry->mt_fs_root; /* * Verify this is the root node for the file system to be unmounted. */ if ( fs_root_loc->node_access != loc.node_access ) { rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EACCES ); } /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); /* * Verify the current node is not in this filesystem. * XXX - Joel I have a question here wasn't code added * that made the current node thread based instead * of system based? I thought it was but it doesn't * look like it in this version. */ if ( rtems_filesystem_current.mt_entry == mt_entry ) rtems_set_errno_and_return_minus_one( EBUSY ); /* * Verify there are no file systems below the path specified */ if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point, fs_root_loc->mt_entry ) ) rtems_set_errno_and_return_minus_one( EBUSY ); /* * Run the file descriptor table to determine if there are any file * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) rtems_set_errno_and_return_minus_one( EBUSY ); /* * Allow the file system being unmounted on to do its cleanup. * If it fails it will set the errno to the approprate value * and the fileystem will not be modified. */ if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 ) return -1; /* * Allow the mounted filesystem to unmark the use of the root node. * * Run the unmount function for the subordinate file system. * * If we fail to unmount the filesystem remount it on the base filesystems * directory node. * * NOTE: Fatal error is called in a case which should never happen * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0) { if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) rtems_fatal_error_occurred( 0 ); return -1; } /* * Extract the mount table entry from the chain */ rtems_libio_lock(); rtems_chain_extract( &mt_entry->Node ); rtems_libio_unlock(); /* * Free the memory node that was allocated in mount * Free the memory associated with the extracted mount table entry. */ rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; }