Changeset 8434594 in rtems


Ignore:
Timestamp:
May 17, 2011, 4:45:52 AM (9 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10
Children:
37834667
Parents:
64a31017
Message:

2011-05-17 Chris Johns <chrisj@…>

PR 1774/filesystem

  • libfs/src/imfs/imfs_eval.c: The previous change broke some of the tests. This has been fixed.
Location:
cpukit
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r64a31017 r8434594  
     12011-05-17      Chris Johns <chrisj@rtems.org>
     2
     3        PR 1774/filesystem
     4        * libfs/src/imfs/imfs_eval.c: The previous change broke some of
     5        the tests. This has been fixed.
     6       
    172011-05-11      Sebastian Huber <sebastian.huber@embedded-brains.de>
    28
  • cpukit/libfs/src/imfs/imfs_eval.c

    r64a31017 r8434594  
    271271}
    272272
     273/*
     274 * IMFS_skip_separator
     275 *
     276 * Skip the separator in the path.
     277 */
     278static void IMFS_skip_separator (
     279   const char *path,       /* IN     */
     280   size_t     *len,        /* IN/OUT */
     281   int        *index       /* IN/OUT */
     282)
     283{
     284  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
     285    ++(*index);
     286    --(*len);
     287  }
     288}
    273289
    274290/*
     
    282298
    283299int IMFS_evaluate_for_make(
    284    const char                         *path,       /* IN     */
    285    rtems_filesystem_location_info_t   *pathloc,    /* IN/OUT */
    286    const char                        **name        /* OUT    */
    287 )
     300  const char                         *path,       /* IN     */
     301  rtems_filesystem_location_info_t   *pathloc,    /* IN/OUT */
     302  const char                        **name        /* OUT    */
     303                           )
    288304{
    289   int                                 i = 0;
    290   int                                 len;
    291   IMFS_token_types                    type;
    292   char                                token[ IMFS_NAME_MAX + 1 ];
    293   rtems_filesystem_location_info_t    newloc;
    294   IMFS_jnode_t                       *node;
    295   bool                                done = false;
    296   int                                 pathlen;
    297   int                                 result;
     305  int               i = 0;
     306  int               len;
     307  IMFS_token_types  type;
     308  char              token[ IMFS_NAME_MAX + 1 ];
     309  IMFS_jnode_t     *node;
     310  bool              done = false;
     311  size_t            pathlen;
     312  int               result;
    298313
    299314  /*
     
    347362        */
    348363
    349         if (pathloc->node_access ==
    350             pathloc->mt_entry->mt_fs_root.node_access){
     364        if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
    351365
    352366          /*
     
    356370          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
    357371            break;
     372
    358373          } else {
    359             newloc = pathloc->mt_entry->mt_point_node;
    360             *pathloc = newloc;
    361             return (*pathloc->ops->evalformake_h)( &path[i], pathloc, name );
     374            *pathloc = pathloc->mt_entry->mt_point_node;
     375            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
    362376          }
    363377        } else {
     
    402416
    403417        /*
    404          * Otherwise find the token name in the present location.
     418         * Find the token name in the present location.
    405419         */
    406420
     
    415429          done = true;
    416430        else {
    417           /*
    418            * If we are at a node that is a mount point. Set loc to the
    419            * new fs root node and let them finish evaluating the path.
    420            */
    421 
    422           if ( node->info.directory.mt_fs != NULL ) {
    423             newloc  = node->info.directory.mt_fs->mt_fs_root;
    424             *pathloc = newloc;
    425             return (*pathloc->ops->evalformake_h)( &path[i], pathloc, name );
     431        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
     432            IMFS_skip_separator( path, &pathlen, &i);
     433            if ((path[i] != '.') || (path[i + 1] != '.')) {
     434              *pathloc = node->info.directory.mt_fs->mt_fs_root;
     435              return (*pathloc->ops->evalformake_h)( &path[i],
     436                                                     pathloc,
     437                                                     name );
     438            }
     439            i += 2;
     440            pathlen -= 2;
     441            node = node->Parent;
    426442          }
    427443         
     
    494510                   )
    495511{
    496   int                                 i = 0;
    497   int                                 len;
    498   IMFS_token_types                    type = IMFS_CURRENT_DIR;
    499   char                                token[ IMFS_NAME_MAX + 1 ];
    500   rtems_filesystem_location_info_t    newloc;
    501   IMFS_jnode_t                       *node;
    502   int                                 result;
     512  int               i = 0;
     513  int               len;
     514  IMFS_token_types  type = IMFS_CURRENT_DIR;
     515  char              token[ IMFS_NAME_MAX + 1 ];
     516  IMFS_jnode_t     *node;
     517  int               result;
    503518
    504519  if ( !rtems_libio_is_valid_perms( flags ) ) {
     
    560575            break;       /* Throw out the .. in this case */
    561576          } else {
    562             newloc = pathloc->mt_entry->mt_point_node;
    563             *pathloc = newloc;
    564             return (*pathloc->ops->evalpath_h)(&(pathname[i]),
    565                                                pathnamelen,
     577            *pathloc = pathloc->mt_entry->mt_point_node;
     578            return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
     579                                               pathnamelen+len,
    566580                                               flags,pathloc);
    567581          }
     
    606620
    607621        /*
    608          *  Otherwise find the token name in the present location.
     622         *  Find the token name in the current node.
    609623         */
    610624
     
    614628          rtems_set_errno_and_return_minus_one( ENOENT );
    615629
     630        /*
     631         *  If we are at a node that is a mount point so current directory
     632         *  actually exists on the mounted file system and not in the node that
     633         *  contains the mount point node. For example a stat of the mount
     634         *  point should return the details of the root of the mounted file
     635         *  system not the mount point node of parent file system.
     636         *
     637         *  If the node we have just moved to is a mount point do not loop and
     638         *  get the token because the token may be suitable for the mounted
     639         *  file system and not the IMFS. For example the IMFS length is
     640         *  limited. If the token is a parent directory move back up otherwise
     641         *  set loc to the new fs root node and let them finish evaluating the
     642         *  path.
     643         */
     644        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
     645          IMFS_skip_separator( pathname, &pathnamelen, &i);
     646          if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
     647            *pathloc = node->info.directory.mt_fs->mt_fs_root;
     648            return (*pathloc->ops->evalpath_h)( &pathname[i],
     649                                                pathnamelen,
     650                                                flags, pathloc );
     651          }
     652          i += 2;
     653          pathnamelen -= 2;
     654          node = node->Parent;
     655        }
    616656
    617657        /*
     
    620660
    621661        pathloc->node_access = node;
    622        
    623         /*
    624          *  If we are at a node that is a mount point. Set loc to the
    625          *  new fs root node and let them finish evaluating the path.
    626          */
    627 
    628         if ( node->info.directory.mt_fs != NULL ) {
    629           newloc   = node->info.directory.mt_fs->mt_fs_root;
    630           *pathloc = newloc;
    631           return (*pathloc->ops->evalpath_h)( &pathname[i],
    632                                               pathnamelen,
    633                                               flags, pathloc );
    634         }
    635662        break;
    636663
     
    657684  if ( node->type == IMFS_DIRECTORY ) {
    658685    if ( node->info.directory.mt_fs != NULL ) {
    659       newloc   = node->info.directory.mt_fs->mt_fs_root;
    660       *pathloc = newloc;
     686      *pathloc = node->info.directory.mt_fs->mt_fs_root;
    661687      return (*pathloc->ops->evalpath_h)( &pathname[i-len],
    662688                                          pathnamelen+len,
Note: See TracChangeset for help on using the changeset viewer.