Changeset d0fcd0b in rtems


Ignore:
Timestamp:
Mar 15, 2011, 5:02:34 AM (9 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.11, master
Children:
ecfeb16b
Parents:
03b5096
Message:

2011-03-15 Chris Johns <chrisj@…>

PR 1763/shell

  • libmisc/shell/hexdump-conv.c: Remove debug hacks.

PR 1757/filesystem

  • libfs/src/rfs/rtems-rfs-block-pos.h, libfs/src/rfs/rtems-rfs-block.h, libfs/src/rfs/rtems-rfs-file.c, libfs/src/rfs/rtems-rfs-rtems-file.c: Set the file size in iop-size when a file is open. Fix lseek to end of file then write for sizes less than half the file system block size.
  • libfs/src/rfs/rtems-rfs-rtems-dev.c, libfs/src/rfs/rtems-rfs-rtems-dir.c, libfs/src/rfs/rtems-rfs-rtems.c, libfs/src/rfs/rtems-rfs-rtems.h: Fix the fstat and fchmod calls due to the change in the iop struct where pathinfo went away. The node_access field in pathinfo was overloaded.
Location:
cpukit
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r03b5096 rd0fcd0b  
     12011-03-15      Chris Johns <chrisj@rtems.org>
     2
     3        PR 1763/shell
     4        * libmisc/shell/hexdump-conv.c: Remove debug hacks.
     5
     6        PR 1757/filesystem
     7        * libfs/src/rfs/rtems-rfs-block-pos.h,
     8        libfs/src/rfs/rtems-rfs-block.h, libfs/src/rfs/rtems-rfs-file.c,
     9        libfs/src/rfs/rtems-rfs-rtems-file.c: Set the file size in
     10        iop-size when a file is open. Fix lseek to end of file then write
     11        for sizes less than half the file system block size.
     12        * libfs/src/rfs/rtems-rfs-rtems-dev.c,
     13        libfs/src/rfs/rtems-rfs-rtems-dir.c,
     14        libfs/src/rfs/rtems-rfs-rtems.c, libfs/src/rfs/rtems-rfs-rtems.h:
     15        Fix the fstat and fchmod calls due to the change in the iop struct
     16        where pathinfo went away. The node_access field in pathinfo was
     17        overloaded.
     18
    1192011-03-14      Joel Sherrill <joel.sherrill@oarcorp.com>
    220
  • cpukit/libfs/src/rfs/rtems-rfs-block-pos.h

    r03b5096 rd0fcd0b  
    194194
    195195/**
     196 * Do the sizes match ?
     197 */
     198#define rtems_rfs_block_size_equal(_lhs, _rhs) \
     199  (((_lhs)->count == (_rhs)->count) && ((_lhs)->offset == (_rhs)->count))
     200
     201/**
    196202 * Zero a block size.
    197203 *
  • cpukit/libfs/src/rfs/rtems-rfs-block.h

    r03b5096 rd0fcd0b  
    164164
    165165/**
    166  * Set the size offset for the map.
    167  */
    168 #define rtems_rfs_block_map_set_size_offset(_m, _o) ((_m)->size.offset = (_o))
    169 
    170 /**
    171166 * Are we at the last block in the map ?
    172167 */
     
    196191#define rtems_rfs_block_map_block_offset(_m) ((_m)->bpos.boff)
    197192
     193/**
     194 * Set the size offset for the map. The map is tagged as dirty.
     195 *
     196 * @param map Pointer to the open map to set the offset in.
     197 * @param offset The offset to set in the map's size.
     198 */
     199static inline void
     200rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
     201                                     rtems_rfs_block_off  offset)
     202{
     203  map->size.offset = offset;
     204  map->dirty = true;
     205}
     206
     207/**
     208 * Set the map's size. The map is tagged as dirty.
     209 *
     210 * @param map Pointer to the open map to set the offset in.
     211 * @param size The size to set in the map's size.
     212 */
     213static inline void
     214rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,
     215                              rtems_rfs_block_size* size)
     216{
     217  rtems_rfs_block_copy_size (&map->size, size);
     218  map->dirty = true;
     219}
    198220/**
    199221 * Open a block map. The block map data in the inode is copied into the
  • cpukit/libfs/src/rfs/rtems-rfs-file.c

    r03b5096 rd0fcd0b  
    173173      rtems_rfs_inode_set_ctime (&handle->shared->inode,
    174174                                 handle->shared->ctime);
    175       handle->shared->map.size.count = handle->shared->size.count;
    176       handle->shared->map.size.offset = handle->shared->size.offset;
     175      if (!rtems_rfs_block_size_equal (&handle->shared->size,
     176                                       &handle->shared->map.size))
     177        rtems_rfs_block_map_set_size (&handle->shared->map,
     178                                      &handle->shared->size);
    177179    }
    178180   
     
    421423   * write occurs.
    422424   */
    423   if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
    424                                              handle->shared))
     425  if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
     426                                            handle->shared))
    425427    rtems_rfs_file_set_bpos (handle, pos);
    426428 
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c

    r03b5096 rd0fcd0b  
    261261  .ioctl_h     = rtems_rfs_rtems_device_ioctl,
    262262  .lseek_h     = rtems_rfs_rtems_device_lseek,
    263   .fstat_h     = rtems_rfs_rtems_stat,
     263  .fstat_h     = rtems_rfs_rtems_fstat,
    264264  .fchmod_h    = rtems_rfs_rtems_fchmod,
    265265  .ftruncate_h = rtems_rfs_rtems_device_ftruncate,
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c

    r03b5096 rd0fcd0b  
    235235  .ioctl_h     = rtems_filesystem_default_ioctl,
    236236  .lseek_h     = rtems_rfs_rtems_dir_lseek,
    237   .fstat_h     = rtems_rfs_rtems_stat,
     237  .fstat_h     = rtems_rfs_rtems_fstat,
    238238  .fchmod_h    = rtems_rfs_rtems_fchmod,
    239239  .ftruncate_h = rtems_filesystem_default_ftruncate,
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c

    r03b5096 rd0fcd0b  
    7171    printf("rtems-rfs: file-open: handle:%p\n", file);
    7272 
     73  iop->size = rtems_rfs_file_size (file);
    7374  iop->pathinfo.node_access = file;
    7475 
     
    112113 * @return int
    113114 */
    114 ssize_t
     115static ssize_t
    115116rtems_rfs_rtems_file_read (rtems_libio_t* iop,
    116117                           void*          buffer,
     
    177178 * @return ssize_t
    178179 */
    179 ssize_t
     180static ssize_t
    180181rtems_rfs_rtems_file_write (rtems_libio_t* iop,
    181182                            const void*    buffer,
     
    196197 
    197198  /*
    198    * If the iop position is past the physical end of the file we need to set the
    199    * file size to the new length before writing.
     199   * If the iop position is past the physical end of the file we need to set
     200   * the file size to the new length before writing. If the position equals the
     201   * size of file we are still past the end of the file as positions number
     202   * from 0. For a specific position we need a file that has a length of one
     203   * more.
    200204   */
    201205 
    202   if (pos > rtems_rfs_file_size (file))
     206  if (pos >= rtems_rfs_file_size (file))
    203207  {
    204     rc = rtems_rfs_file_set_size (file, pos);
     208    rc = rtems_rfs_file_set_size (file, pos + 1);
    205209    if (rc)
    206210    {
     
    208212      return rtems_rfs_rtems_error ("file-write: write extend", rc);
    209213    }
    210     rtems_rfs_file_set_bpos (file, pos);
    211214  }
     215 
     216  rtems_rfs_file_set_bpos (file, pos);
    212217 
    213218  while (count)
     
    256261 */
    257262
    258 int
     263static int
    259264rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
    260265{
     
    270275 * @return rtems_off64_t
    271276 */
    272 rtems_off64_t
     277static rtems_off64_t
    273278rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
    274279                            rtems_off64_t  offset,
     
    299304
    300305/**
     306 * Stat the file.
     307 *
     308 * @param iop
     309 * @param buf
     310 * @return int
     311 */
     312static int
     313rtems_rfs_rtems_file_fstat (rtems_filesystem_location_info_t* pathloc,
     314                            struct stat*                      buf)
     315{
     316  rtems_rfs_file_handle* file = pathloc->node_access;
     317  int                    rc;
     318
     319  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
     320    printf ("rtems-rfs: file-fstat: handle:%p\n", file);
     321
     322  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
     323
     324  rc = rtems_rfs_rtems_stat_inode (rtems_rfs_file_fs (file),
     325                                   rtems_rfs_file_inode (file),
     326                                   buf);
     327
     328  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
     329
     330  return rc;
     331}
     332
     333/**
     334 * File change mode routine.
     335 *
     336 * @param iop
     337 * @param mode
     338 * @return int
     339 */
     340static int
     341rtems_rfs_rtems_file_fchmod (rtems_filesystem_location_info_t* pathloc,
     342                             mode_t                            mode)
     343{
     344  rtems_rfs_file_handle* file = pathloc->node_access;
     345  int                    rc;
     346
     347  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
     348    printf ("rtems-rfs: file-fchmod: handle:%p\n", file);
     349
     350  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
     351
     352  rc = rtems_rfs_rtems_fchmod_inode (rtems_rfs_file_fs (file),
     353                                     rtems_rfs_file_inode (file),
     354                                     mode);
     355
     356  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
     357
     358  return rc;
     359}
     360
     361/**
    301362 * This routine processes the ftruncate() system call.
    302363 *
     
    305366 * @return int
    306367 */
    307 int
     368static int
    308369rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
    309370                                rtems_off64_t  length)
     
    339400  .ioctl_h     = rtems_rfs_rtems_file_ioctl,
    340401  .lseek_h     = rtems_rfs_rtems_file_lseek,
    341   .fstat_h     = rtems_rfs_rtems_stat,
    342   .fchmod_h    = rtems_rfs_rtems_fchmod,
     402  .fstat_h     = rtems_rfs_rtems_file_fstat,
     403  .fchmod_h    = rtems_rfs_rtems_file_fchmod,
    343404  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,
    344405  .fpathconf_h = rtems_filesystem_default_fpathconf,
  • cpukit/libfs/src/rfs/rtems-rfs-rtems.c

    r03b5096 rd0fcd0b  
    6666 * @param pathloc
    6767 */
    68 int
     68static int
    6969rtems_rfs_rtems_eval_path (const char*                       path,
    7070                           size_t                            pathlen,
     
    247247 * @return int
    248248 */
    249 int
     249static int
    250250rtems_rfs_rtems_eval_for_make (const char*                       path,
    251251                               rtems_filesystem_location_info_t* pathloc,
     
    482482 * @return int
    483483 */
    484 int
     484static int
    485485rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
    486486                      rtems_filesystem_location_info_t* parent_loc,
     
    518518 */
    519519
    520 int
     520static int
    521521rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
    522522                        rtems_filesystem_location_info_t* loc)
     
    554554 */
    555555
    556 rtems_filesystem_node_types_t
     556static rtems_filesystem_node_types_t
    557557rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
    558558{
     
    678678 */
    679679
    680 int
     680static int
    681681rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
    682682                      time_t                            atime,
     
    722722 */
    723723
    724 int
     724static int
    725725rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
    726726                         const char*                       link_name,
     
    766766 */
    767767
    768 ssize_t
     768static ssize_t
    769769rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
    770770                          char*                             buf,
     
    793793}
    794794
    795 /**
    796  * File change mode routine.
    797  *
    798  * @param pathloc
    799  * @param mode
    800  * @return int
    801  */
    802795int
    803 rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
    804                         mode_t                            mode)
    805 {
    806   rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc);
    807   rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
    808   rtems_rfs_inode_handle  inode;
    809   uint16_t                imode;
     796rtems_rfs_rtems_fchmod_inode (rtems_rfs_file_system*  fs,
     797                              rtems_rfs_inode_handle* inode,
     798                              mode_t                  mode)
     799{
     800  uint16_t imode;
    810801#if defined (RTEMS_POSIX_API)
    811   uid_t                   uid;
     802  uid_t     uid;
    812803#endif
    813   int                     rc;
    814804
    815805  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
    816     printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
    817             ino, mode);
    818  
    819   rtems_rfs_rtems_lock (fs);
    820  
    821   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    822   if (rc)
    823   {
    824     rtems_rfs_rtems_unlock (fs);
    825     return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
    826   }
    827 
    828   imode = rtems_rfs_inode_get_mode (&inode);
     806    printf ("rtems-rfs-rtems: fchmod indo: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
     807            rtems_rfs_inode_ino (inode), mode);
     808 
     809  imode = rtems_rfs_inode_get_mode (inode);
    829810 
    830811  /*
     
    834815  uid = geteuid();
    835816
    836   if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
    837   {
    838     rtems_rfs_inode_close (fs, &inode);
    839     rtems_rfs_rtems_unlock (fs);
    840     return rtems_rfs_rtems_error ("fchmod: not owner", EPERM);
    841   }
     817  if ((uid != rtems_rfs_inode_get_uid (inode)) && (uid != 0))
     818    return EPERM;
    842819#endif
    843820
     
    845822  imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
    846823
    847   rtems_rfs_inode_set_mode (&inode, imode);
    848  
    849   rc = rtems_rfs_inode_close (fs, &inode);
    850   if (rc > 0)
    851   {
    852     rtems_rfs_rtems_unlock (fs);
    853     return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
    854   }
    855  
    856   rtems_rfs_rtems_unlock (fs);
     824  rtems_rfs_inode_set_mode (inode, imode);
    857825 
    858826  return 0;
    859827}
    860828
    861 /**
    862  * The following routine does a stat on a node.
    863  *
    864  * @param pathloc
    865  * @param buf
    866  * @return int
    867  */
    868 
    869829int
    870 rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
    871                       struct stat*                      buf)
     830rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
     831                        mode_t                            mode)
    872832{
    873833  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc);
    874834  rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
    875835  rtems_rfs_inode_handle  inode;
    876   rtems_rfs_file_shared*  shared;
    877   uint16_t                mode;
    878836  int                     rc;
    879837
    880   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
    881     printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
    882 
     838  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
     839    printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
     840            ino, mode);
     841 
    883842  rtems_rfs_rtems_lock (fs);
    884843 
     
    887846  {
    888847    rtems_rfs_rtems_unlock (fs);
    889     return rtems_rfs_rtems_error ("stat: opening inode", rc);
    890   }
    891 
    892   mode = rtems_rfs_inode_get_mode (&inode);
     848    return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
     849  }
     850
     851  rc = rtems_rfs_rtems_fchmod_inode (fs, &inode, mode);
     852  if (rc > 0)
     853  {
     854    rtems_rfs_inode_close (fs, &inode);
     855    rtems_rfs_rtems_unlock (fs);
     856    return rtems_rfs_rtems_error ("fchmod: fchmod inode", EPERM);
     857  }
     858 
     859  rc = rtems_rfs_inode_close (fs, &inode);
     860  if (rc > 0)
     861  {
     862    rtems_rfs_rtems_unlock (fs);
     863    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
     864  }
     865 
     866  rtems_rfs_rtems_unlock (fs);
     867 
     868  return 0;
     869}
     870
     871int
     872rtems_rfs_rtems_stat_inode (rtems_rfs_file_system*  fs,
     873                            rtems_rfs_inode_handle* inode,
     874                            struct stat*            buf)
     875{
     876  rtems_rfs_file_shared* shared;
     877  uint16_t               mode;
     878
     879  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
     880    printf ("rtems-rfs-rtems: stat-inode: in: ino:%" PRId32 "\n",
     881            rtems_rfs_inode_ino (inode));
     882
     883  mode = rtems_rfs_inode_get_mode (inode);
    893884 
    894885  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
    895886  {
    896887    buf->st_rdev =
    897       rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
    898                                    rtems_rfs_inode_get_block (&inode, 1));
     888      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (inode, 0),
     889                                   rtems_rfs_inode_get_block (inode, 1));
    899890  }
    900891 
    901892  buf->st_dev     = rtems_rfs_fs_device (fs);
    902   buf->st_ino     = ino;
     893  buf->st_ino     = rtems_rfs_inode_ino (inode);
    903894  buf->st_mode    = rtems_rfs_rtems_mode (mode);
    904   buf->st_nlink   = rtems_rfs_inode_get_links (&inode);
    905   buf->st_uid     = rtems_rfs_inode_get_uid (&inode);
    906   buf->st_gid     = rtems_rfs_inode_get_gid (&inode);
     895  buf->st_nlink   = rtems_rfs_inode_get_links (inode);
     896  buf->st_uid     = rtems_rfs_inode_get_uid (inode);
     897  buf->st_gid     = rtems_rfs_inode_get_gid (inode);
    907898
    908899  /*
     
    910901   * the open file rather than the inode.
    911902   */
    912   shared = rtems_rfs_file_get_shared (fs, ino);
     903  shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (inode));
    913904
    914905  if (shared)
     
    926917  else
    927918  {
    928     buf->st_atime   = rtems_rfs_inode_get_atime (&inode);
    929     buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);
    930     buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);
    931     buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);
     919    buf->st_atime   = rtems_rfs_inode_get_atime (inode);
     920    buf->st_mtime   = rtems_rfs_inode_get_mtime (inode);
     921    buf->st_ctime   = rtems_rfs_inode_get_ctime (inode);
     922    buf->st_blocks  = rtems_rfs_inode_get_block_count (inode);
    932923
    933924    if (S_ISLNK (buf->st_mode))
    934       buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
     925      buf->st_size = rtems_rfs_inode_get_block_offset (inode);
    935926    else
    936       buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
     927      buf->st_size = rtems_rfs_inode_get_size (fs, inode);
    937928  }
    938929 
    939930  buf->st_blksize = rtems_rfs_fs_block_size (fs);
    940931 
     932  return 0;
     933}
     934
     935int
     936rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
     937                       struct stat*                      buf)
     938{
     939  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
     940  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
     941  rtems_rfs_inode_handle inode;
     942  int                    rc;
     943
     944  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
     945    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
     946
     947  rtems_rfs_rtems_lock (fs);
     948 
     949  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
     950  if (rc)
     951  {
     952    rtems_rfs_rtems_unlock (fs);
     953    return rtems_rfs_rtems_error ("stat: opening inode", rc);
     954  }
     955
     956  rc = rtems_rfs_rtems_stat_inode (fs, &inode, buf);
     957  if (rc > 0)
     958  {
     959    rtems_rfs_rtems_unlock (fs);
     960    return rtems_rfs_rtems_error ("stat: stat'ing the inode", rc);
     961  }
     962
    941963  rc = rtems_rfs_inode_close (fs, &inode);
    942964  if (rc > 0)
     
    960982 */
    961983
    962 int
     984static int
    963985rtems_rfs_rtems_mknod (const char                       *name,
    964986                       mode_t                            mode,
     
    10911113 * @return int
    10921114 */
    1093 int
     1115static int
    10941116rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
    10951117                       rtems_filesystem_location_info_t* old_loc,
     
    11511173 * @return int
    11521174 */
    1153 int
     1175static int
    11541176rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
    11551177                         struct statvfs*                   sb)
     
    11871209  .ioctl_h     = rtems_filesystem_default_ioctl,
    11881210  .lseek_h     = rtems_filesystem_default_lseek,
    1189   .fstat_h     = rtems_rfs_rtems_stat,
     1211  .fstat_h     = rtems_rfs_rtems_fstat,
    11901212  .fchmod_h    = rtems_filesystem_default_fchmod,
    11911213  .ftruncate_h = rtems_filesystem_default_ftruncate,
  • cpukit/libfs/src/rfs/rtems-rfs-rtems.h

    r03b5096 rd0fcd0b  
    275275 * The following routine does a stat on a node.
    276276 *
    277  * @param pathloc
     277 * @param fs The file system data.
     278 * @param inode The inode to stat held in memory.
     279 * @param buf The stat buffer to fill.
     280 * @return int The result code.
     281 */
     282int rtems_rfs_rtems_stat_inode (rtems_rfs_file_system*  fs,
     283                                rtems_rfs_inode_handle* inode,
     284                                struct stat*            buf);
     285
     286/**
     287 * The following routine does a stat on a node.
     288 *
     289 * @param iop
    278290 * @param buf
    279291 * @return int
    280292 */
    281 int rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* loc, struct stat* buf);
     293int rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
     294                           struct stat*                      buf);
     295
     296/**
     297 * File change mode routine changes an inode.
     298 *
     299 * @param fs The file system data.
     300 * @param inode The inode to change held in memory.
     301 * @param buf The new mode.
     302 * @return int The result code.
     303 */
     304int rtems_rfs_rtems_fchmod_inode (rtems_rfs_file_system*  fs,
     305                                  rtems_rfs_inode_handle* inode,
     306                                  mode_t                  mode);
    282307
    283308/**
    284309 * File change mode routine.
    285310 *
    286  * @param pathloc
     311 * @param iop
    287312 * @param mode
    288313 * @return int
    289314 */
    290 int rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* loc, mode_t mode);
     315int rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
     316                            mode_t                            mode);
    291317
    292318/**
  • cpukit/libmisc/shell/hexdump-conv.c

    r03b5096 rd0fcd0b  
    6464        char peekbuf[MB_LEN_MAX];
    6565
    66   printf("MB_LEN_MAX=%i\n", MB_LEN_MAX);
    67   return;
    6866        if (pr->mbleft > 0) {
    6967                str = "**";
Note: See TracChangeset for help on using the changeset viewer.