Changeset 3cfa636 in rtems


Ignore:
Timestamp:
Feb 26, 2010, 5:54:59 AM (10 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
965dc55
Parents:
28b38f3
Message:

010-02-26 Chris Johns <chrisj@…>

  • libfs/src/rfs/rtems-rfs-block.c: Reset a buffer handle after moving down an indirection level.
  • libfs/src/rfs/rtems-rfs-dir.c: Move directory entry validation into a macro and use the macro. Fix the range check on the ino so all inodes can be used.
  • libfs/src/rfs/rtems-rfs-file-system.c,
libfs/src/rfs/rtems-rfs-file-system.h
Add a version number to the superblock. Use RTEMS_RFS_INODE_SIZE.
  • libfs/src/rfs/rtems-rfs-file.c: Fix the size offset on partial block lengths. Set the size in the file handle on a truncate to 0.
  • libfs/src/rfs/rtems-rfs-format.c: Add a version number to the superblock. Use RTEMS_RFS_INODE_SIZE. A better set of defaults for small disks.
  • libfs/src/rfs/rtems-rfs-inode.c: Use RTEMS_RFS_INODE_SIZE. Free the allocated inode if it cannot be opened.
  • libfs/src/rfs/rtems-rfs-inode.h: Add RTEMS_RFS_INODE_SIZE.
  • libfs/src/rfs/rtems-rfs-rtems-file.c: Move some of the iop acceses inside the fs lock.
  • libfs/src/rfs/rtems-rfs-shell.c: Use RTEMS_RFS_INODE_SIZE.
Location:
cpukit
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r28b38f3 r3cfa636  
     12010-02-26      Chris Johns <chrisj@rtems.org>
     2
     3        * libfs/src/rfs/rtems-rfs-block.c: Reset a buffer handle after
     4        moving down an indirection level.
     5
     6        * libfs/src/rfs/rtems-rfs-dir.c: Move directory entry validation
     7        into a macro and use the macro. Fix the range check on the ino so
     8        all inodes can be used.
     9
     10        * libfs/src/rfs/rtems-rfs-file-system.c,
     11        libfs/src/rfs/rtems-rfs-file-system.h:: Add a version number to
     12        the superblock. Use RTEMS_RFS_INODE_SIZE.
     13
     14        * libfs/src/rfs/rtems-rfs-file.c: Fix the size offset on partial
     15        block lengths. Set the size in the file handle on a truncate to
     16        0.
     17
     18        * libfs/src/rfs/rtems-rfs-format.c:  Add a version number to
     19        the superblock. Use RTEMS_RFS_INODE_SIZE. A better set of defaults
     20        for small disks.
     21
     22        * libfs/src/rfs/rtems-rfs-inode.c: Use RTEMS_RFS_INODE_SIZE. Free
     23        the allocated inode if it cannot be opened.
     24
     25        * libfs/src/rfs/rtems-rfs-inode.h: Add RTEMS_RFS_INODE_SIZE.
     26
     27        * libfs/src/rfs/rtems-rfs-rtems-file.c: Move some of the iop
     28        acceses inside the fs lock.
     29
     30        * libfs/src/rfs/rtems-rfs-shell.c: Use RTEMS_RFS_INODE_SIZE.
     31
    1322010-02-24      Chris Johns <chrisj@rtems.org>
    233
  • cpukit/libfs/src/rfs/rtems-rfs-block.c

    r28b38f3 r3cfa636  
    627627      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
    628628        map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
     629
     630      rtems_rfs_buffer_handle_reset (buffer);
    629631    }
    630632    else
  • cpukit/libfs/src/rfs/rtems-rfs-dir.c

    r28b38f3 r3cfa636  
    3333#include <rtems/rfs/rtems-rfs-dir-hash.h>
    3434
     35/**
     36 * Validate the directory entry data.
     37 */
     38#define rtems_rfs_dir_entry_valid(_f, _l, _i) \
     39  (((_l) <= RTEMS_RFS_DIR_ENTRY_SIZE) || ((_l) >= rtems_rfs_fs_max_name (_f)) \
     40   || (_i < RTEMS_RFS_ROOT_INO) || (_i > rtems_rfs_fs_inodes (_f)))
     41
    3542int
    3643rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
     
    137144          break;
    138145       
    139         if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE)
    140             || (elength >= rtems_rfs_fs_max_name (fs))
    141             || (*ino < RTEMS_RFS_ROOT_INO)
    142             || (*ino >= rtems_rfs_fs_inodes (fs)))
     146        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
    143147        {
    144148          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
     
    332336      }
    333337     
    334       if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE)
    335           || (elength >= rtems_rfs_fs_max_name (fs))
    336           || (eino < RTEMS_RFS_ROOT_INO)
    337           || (eino >= rtems_rfs_fs_inodes (fs)))
     338      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    338339      {
    339340        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
     
    426427        break;
    427428     
    428       if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE)
    429           || (elength >= rtems_rfs_fs_max_name (fs))
    430           || (eino < RTEMS_RFS_ROOT_INO)
    431           || (eino >= rtems_rfs_fs_inodes (fs)))
     429      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    432430      {
    433431        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
     
    573571    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
    574572    {
    575       if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE)
    576           || (elength >= rtems_rfs_fs_max_name (fs))
    577           || (eino < RTEMS_RFS_ROOT_INO)
    578           || (eino >= rtems_rfs_fs_inodes (fs)))
     573      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    579574      {
    580575        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
     
    691686        break;
    692687
    693       if ((elength <= RTEMS_RFS_DIR_ENTRY_SIZE)
    694           || (elength >= rtems_rfs_fs_max_name (fs))
    695           || (eino < RTEMS_RFS_ROOT_INO)
    696           || (eino >= rtems_rfs_fs_inodes (fs)))
     688      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    697689      {
    698690        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
  • cpukit/libfs/src/rfs/rtems-rfs-file-system.c

    r28b38f3 r3cfa636  
    5555  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
    5656  {
    57     rtems_rfs_buffer_handle_close (fs, &handle);
    5857    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
    5958      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
     59    rtems_rfs_buffer_handle_close (fs, &handle);
    6060    return EIO;
    6161  }
     
    6666  if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
    6767  {
    68     rtems_rfs_buffer_handle_close (fs, &handle);
    6968    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
    7069      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
    71     return EIO;
    72   }
    73 
     70    rtems_rfs_buffer_handle_close (fs, &handle);
     71    return EIO;
     72  }
     73
     74  if ((read_sb (RTEMS_RFS_SB_OFFSET_VERSION) & RTEMS_RFS_VERSION_MASK) !=
     75      (RTEMS_RFS_VERSION * RTEMS_RFS_VERSION_MASK))
     76  {
     77    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
     78      printf ("rtems-rfs: read-superblock: incompatible version: %08x (%08x)\n",
     79              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
     80    rtems_rfs_buffer_handle_close (fs, &handle);
     81    return EIO;
     82  }
     83     
     84  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
     85  {
     86    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
     87      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%d target:%d\n",
     88              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
     89    rtems_rfs_buffer_handle_close (fs, &handle);
     90    return EIO;
     91  }
     92     
    7493  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
    7594  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
     
    7897  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
    7998
    80   fs->blocks_per_block = rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
     99  fs->blocks_per_block =
     100    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
    81101 
    82102  fs->block_map_singly_blocks =
     
    87107  fs->inodes = fs->group_count * fs->group_inodes;
    88108
    89   fs->inodes_per_block = fs->block_size / sizeof (rtems_rfs_inode);
     109  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
    90110 
    91111  if (fs->group_blocks >
  • cpukit/libfs/src/rfs/rtems-rfs-file-system.h

    r28b38f3 r3cfa636  
    2828#define RTEMS_RFS_SB_OFFSET_MAGIC           (0)
    2929#define RTEMS_RFS_SB_MAGIC                  (0x28092001)
    30 #define RTEMS_RFS_SB_OFFSET_BLOCK_SIZE      (4)
    31 #define RTEMS_RFS_SB_OFFSET_BLOCKS          (8)
    32 #define RTEMS_RFS_SB_OFFSET_BAD_BLOCKS      (12)
    33 #define RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH (16)
    34 #define RTEMS_RFS_SB_OFFSET_GROUPS          (20)
    35 #define RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS    (24)
    36 #define RTEMS_RFS_SB_OFFSET_GROUP_INODES    (28)
     30#define RTEMS_RFS_SB_OFFSET_VERSION         (RTEMS_RFS_SB_OFFSET_MAGIC           + 4)
     31#define RTEMS_RFS_SB_OFFSET_BLOCK_SIZE      (RTEMS_RFS_SB_OFFSET_VERSION         + 4)
     32#define RTEMS_RFS_SB_OFFSET_BLOCKS          (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE      + 4)
     33#define RTEMS_RFS_SB_OFFSET_BAD_BLOCKS      (RTEMS_RFS_SB_OFFSET_BLOCKS          + 4)
     34#define RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS      + 4)
     35#define RTEMS_RFS_SB_OFFSET_GROUPS          (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH + 4)
     36#define RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS    (RTEMS_RFS_SB_OFFSET_GROUPS          + 4)
     37#define RTEMS_RFS_SB_OFFSET_GROUP_INODES    (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS    + 4)
     38#define RTEMS_RFS_SB_OFFSET_INODE_SIZE      (RTEMS_RFS_SB_OFFSET_GROUP_INODES    + 4)
     39
     40/**
     41 * RFS Version Number.
     42 */
     43#define RTEMS_RFS_VERSION (0x00000000)
     44
     45/**
     46 * RFS Version Number Mask. The mask determines which bits of the version
     47 * number indicate compatility issues.
     48 */
     49#define RTEMS_RFS_VERSION_MASK (0x00000000)
    3750
    3851/**
  • cpukit/libfs/src/rfs/rtems-rfs-file.c

    r28b38f3 r3cfa636  
    276276  }
    277277 
    278   if (read && rtems_rfs_block_map_last (rtems_rfs_file_map (handle)))
     278  if (read
     279      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
     280      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
    279281    size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
    280282  else
     
    420422  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);
    421423  rtems_rfs_pos        size;
     424  int                  rc;
    422425
    423426  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     
    428431   */
    429432  if (new_size == 0)
    430     return rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
     433  {
     434    rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
     435    if (rc > 0)
     436      return rc;
     437  }
     438  else
     439  {
     440    size = rtems_rfs_file_size (handle);
     441 
     442    /*
     443     * If the file is same size do nothing else grow or shrink it ?
     444     */
     445    if (size != new_size)
     446    {
     447      if (size < new_size)
     448      {
     449        /*
     450         * Grow. Fill with 0's.
     451         */
     452        rtems_rfs_pos count;
     453        uint32_t      length;
     454        bool          read_block;
     455
     456        count = new_size - size;
     457        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
     458        read_block = false;
     459       
     460        while (count)
     461        {
     462          rtems_rfs_buffer_block block;
     463          rtems_rfs_block_pos    bpos;
     464          uint8_t*               dst;
     465
     466          /*
     467           * Get the block position for the current end of the file as seen by
     468           * the map. If not found and the EOF grow the map then fill the block
     469           * with 0.
     470           */
     471          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
     472          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
     473                                         map, &bpos, &block);
     474          if (rc > 0)
     475          {
     476            /*
     477             * Have we reached the EOF ?
     478             */
     479            if (rc != ENXIO)
     480              return rc;
     481
     482            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
     483                                           map, 1, &block);
     484            if (rc > 0)
     485              return rc;
     486          }
     487
     488          if (count < (length - bpos.boff))
     489          {
     490            length = count + bpos.boff;
     491            read_block = true;
     492            rtems_rfs_block_map_set_size_offset (map, length);
     493          }
     494          else
     495          {
     496            rtems_rfs_block_map_set_size_offset (map, 0);
     497          }
     498
     499          /*
     500           * Only read the block if the length is not the block size.
     501           */
     502          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
     503                                                rtems_rfs_file_buffer (handle),
     504                                                block, read_block);
     505          if (rc > 0)
     506            return rc;
     507
     508          dst = rtems_rfs_buffer_data (&handle->buffer);
     509          memset (dst + bpos.boff, 0, length - bpos.boff);
     510
     511          rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
     512
     513          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
     514                                                rtems_rfs_file_buffer (handle));
     515          if (rc > 0)
     516            return rc;
     517       
     518          count -= length - bpos.boff;
     519        }
     520      }
     521      else
     522      {
     523        /*
     524         * Shrink
     525         */
     526        rtems_rfs_block_no blocks;
     527        uint32_t           offset;
     528   
     529        blocks =
     530          rtems_rfs_block_map_count (map) -
     531          (((new_size - 1) /
     532            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
     533
     534        offset =
     535          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    431536     
    432   size = rtems_rfs_file_size (handle);
    433  
    434   /*
    435    * If the file is same size do nothing else grow or shrink it ?
    436    */
    437   if (size != new_size)
    438   {
    439     if (size < new_size)
    440     {
    441       /*
    442        * Grow. Fill with 0's.
    443        */
    444       rtems_rfs_pos count;
    445       uint32_t      length;
    446       bool          read_block;
    447 
    448       count = new_size - size;
    449       length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    450       read_block = false;
    451        
    452       while (count)
    453       {
    454         rtems_rfs_buffer_block block;
    455         rtems_rfs_block_pos    bpos;
    456         uint8_t*               dst;
    457         int                    rc;
    458 
    459         /*
    460          * Get the block position for the current end of the file as seen by
    461          * the map. If not found and the EOF grow the map then fill the block
    462          * with 0.
    463          */
    464         rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
    465         rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
    466                                        map, &bpos, &block);
    467         if (rc > 0)
     537        if (blocks)
    468538        {
    469           /*
    470            * Have we reached the EOF ?
    471            */
    472           if (rc != ENXIO)
    473             return rc;
    474 
    475           rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
    476                                          map, 1, &block);
     539          int rc;
     540          rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
     541                                           rtems_rfs_file_map (handle),
     542                                           blocks);
    477543          if (rc > 0)
    478544            return rc;
    479545        }
    480546
    481         if (count < (length - bpos.boff))
    482         {
    483           length = count + bpos.boff;
    484           read_block = true;
    485           rtems_rfs_block_map_set_size_offset (map, length);
    486         }
    487         else
    488         {
    489           rtems_rfs_block_map_set_size_offset (map, 0);
    490         }
    491 
    492         /*
    493          * Only read the block if the length is not the block size.
    494          */
    495         rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
    496                                               rtems_rfs_file_buffer (handle),
    497                                               block, read_block);
    498         if (rc > 0)
    499           return rc;
    500 
    501         dst = rtems_rfs_buffer_data (&handle->buffer);
    502         memset (dst + bpos.boff, 0, length - bpos.boff);
    503 
    504         rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
    505 
    506         rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
    507                                               rtems_rfs_file_buffer (handle));
    508         if (rc > 0)
    509           return rc;
    510        
    511         count -= length - bpos.boff;
     547        rtems_rfs_block_map_set_size_offset (map, offset);
     548
     549        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
     550                                          rtems_rfs_block_map_size (map)))
     551          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
     552                                         rtems_rfs_file_bpos (handle));
    512553      }
    513554    }
    514     else
    515     {
    516       /*
    517        * Shrink
    518        */
    519       rtems_rfs_block_no blocks;
    520       uint32_t           offset;
    521    
    522       blocks =
    523         rtems_rfs_block_map_count (map) -
    524         (((new_size - 1) /
    525           rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
    526 
    527       offset =
    528         new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    529      
    530       if (blocks)
    531       {
    532         int rc;
    533         rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
    534                                          rtems_rfs_file_map (handle),
    535                                          blocks);
    536         if (rc > 0)
    537           return rc;
    538       }
    539 
    540       rtems_rfs_block_map_set_size_offset (map, offset);
    541 
    542       if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
    543                                         rtems_rfs_block_map_size (map)))
    544         rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
    545                                        rtems_rfs_file_bpos (handle));
    546     }
    547    
    548     handle->shared->size.count  = rtems_rfs_block_map_count (map);
    549     handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
    550 
    551     if (rtems_rfs_file_update_mtime (handle))
    552       handle->shared->mtime = time (NULL);
    553   }
    554  
     555  }
     556
     557  handle->shared->size.count  = rtems_rfs_block_map_count (map);
     558  handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
     559
     560  if (rtems_rfs_file_update_mtime (handle))
     561    handle->shared->mtime = time (NULL);
     562 
    555563  return 0;
    556564}
  • cpukit/libfs/src/rfs/rtems-rfs-format.c

    r28b38f3 r3cfa636  
    6262{
    6363  int blocks;
    64   blocks = (rtems_rfs_bits_per_block (fs) * percentage) / 100;
    65   return blocks * (rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode));
     64  blocks = ((rtems_rfs_fs_blocks (fs) -
     65             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
     66  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
     67  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
    6668}
    6769
     
    7375{
    7476  int blocks;
    75   blocks =
    76     (fs->group_inodes * sizeof (rtems_rfs_inode)) / rtems_rfs_fs_block_size (fs);
    77   return ((blocks + 1) * 100 * 10) / rtems_rfs_bits_per_block (fs);
     77  int bits_per_block;
     78  blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
     79                                  rtems_rfs_fs_block_size (fs));
     80  bits_per_block = rtems_rfs_bits_per_block (fs);
     81  /*
     82   * There could be more bits that there are blocks, eg 512K disk with 512
     83   * blocks.
     84   */
     85  if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
     86    bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
     87  return ((blocks + 1) * 100 * 10) / bits_per_block;
    7888}
    7989
     
    8797    uint64_t total_size = rtems_rfs_fs_media_size (fs);
    8898
    89     if (total_size > GIGS (2))
     99    if (total_size >= GIGS (1))
    90100    {
    91101      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
     
    97107    }
    98108
    99     if (fs->block_size < 1024)
    100       fs->block_size = 1024;
     109    if (fs->block_size < 512)
     110      fs->block_size = 512;
    101111   
    102112    if (fs->block_size > (4 * 1024))
     
    127137  }
    128138 
     139  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
     140
     141  /*
     142   * The bits per block sets the upper limit for the number of blocks in a
     143   * group. The disk will be divided into groups which are the number of bits
     144   * per block.
     145   */ 
     146  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
     147                                            rtems_rfs_bits_per_block (fs));
     148
    129149  fs->group_inodes = config->group_inodes;
    130150  if (!fs->group_inodes)
     
    144164   * Round up to fill a block because the minimum allocation unit is a block.
    145165   */
    146   fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode);
     166  fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
    147167  fs->group_inodes =
    148168    rtems_rfs_rup_quotient (fs->group_inodes,
     
    399419
    400420  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
     421  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
    401422  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
    402423  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
     
    406427  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
    407428  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
     429  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
    408430
    409431  rtems_rfs_buffer_mark_dirty (&handle);
     
    549571  if (!rtems_rfs_check_config (&fs, config))
    550572    return -1;
    551 
    552   fs.blocks = rtems_rfs_fs_media_size (&fs) / fs.block_size;
    553 
    554   /*
    555    * The bits per block sets the upper limit for the number of blocks in a
    556    * group. The disk will be divided into groups which are the number of bits
    557    * per block.
    558    */ 
    559   fs.group_count =
    560     ((rtems_rfs_fs_blocks (&fs) - 1) / rtems_rfs_bits_per_block (&fs)) + 1;
    561573
    562574  if (config->verbose)
     
    576588    printf ("rtems-rfs: format: bits per block = %u\n",
    577589            rtems_rfs_bits_per_block (&fs));
    578     printf ("rtems-rfs: format: inode size = %lu\n", sizeof (rtems_rfs_inode));
     590    printf ("rtems-rfs: format: inode size = %lu\n", RTEMS_RFS_INODE_SIZE);
    579591    printf ("rtems-rfs: format: inodes = %lu (%d.%d%%)\n",
    580592            fs.group_inodes * fs.group_count,
  • cpukit/libfs/src/rfs/rtems-rfs-inode.c

    r28b38f3 r3cfa636  
    212212  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
    213213  if (rc > 0)
    214     return rc;
    215 
     214  {
     215    rtems_rfs_inode_free (fs, *ino);
     216    return rc;
     217  }
     218 
    216219  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
    217220  if (rc > 0)
     
    224227  /*
    225228   * Only handle the specifics of a directory. Let caller handle the others.
     229   *
     230   * The inode delete will free the inode.
    226231   */
    227232  if (RTEMS_RFS_S_ISDIR (mode))
     
    308313      if (rc > 0)
    309314        rrc = rc;
    310       memset (handle->node, 0xff, sizeof (rtems_rfs_inode));
     315      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
    311316      rtems_rfs_buffer_mark_dirty (&handle->buffer);
    312317      /*
  • cpukit/libfs/src/rfs/rtems-rfs-inode.h

    r28b38f3 r3cfa636  
    170170
    171171/**
     172 * The size of an inode.
     173 */
     174#define RTEMS_RFS_INODE_SIZE (sizeof (rtems_rfs_inode))
     175
     176/**
    172177 * RFS Inode Handle.
    173178 */
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c

    r28b38f3 r3cfa636  
    4040{
    4141  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
    42   rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);
     42  rtems_rfs_ino          ino;
    4343  rtems_rfs_file_handle* file;
    4444  uint32_t               flags;
     
    5252
    5353  rtems_rfs_rtems_lock (fs);
     54 
     55  ino = rtems_rfs_rtems_get_iop_ino (iop);
    5456 
    5557  rc = rtems_rfs_file_open (fs, ino, flags, &file);
     
    110112{
    111113  rtems_rfs_file_handle* file = iop->file_info;
    112   rtems_rfs_pos          pos = iop->offset;
     114  rtems_rfs_pos          pos;
    113115  uint8_t*               data = buffer;
    114116  ssize_t                read = 0;
     
    120122  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    121123
     124  pos = iop->offset;
     125 
    122126  if (pos < rtems_rfs_file_size (file))
    123127  {
     
    173177{
    174178  rtems_rfs_file_handle* file = iop->file_info;
    175   rtems_rfs_pos          pos = iop->offset;
     179  rtems_rfs_pos          pos;
    176180  const uint8_t*         data = buffer;
    177181  ssize_t                write = 0;
     
    183187  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    184188
     189  pos = iop->offset;
     190 
    185191  /*
    186192   * If the iop position is past the physical end of the file we need to set the
     
    267273    printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
    268274
     275  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
     276 
    269277  pos = iop->offset;
    270  
    271   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    272278 
    273279  rc = rtems_rfs_file_seek (file, pos, &pos);
     
    301307 
    302308  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    303 
     309 
    304310  rc = rtems_rfs_file_set_size (file, length);
    305311  if (rc)
  • cpukit/libfs/src/rfs/rtems-rfs-shell.c

    r28b38f3 r3cfa636  
    115115  int    bpcent;
    116116  int    ipcent;
    117   int    g;
    118117
    119118  printf ("RFS Filesystem Data\n");
     
    368367        printf (" %5lu: pos=%06lu:%04lx %c ",
    369368                ino, rtems_rfs_buffer_bnum (&inode.buffer),
    370                 inode.offset * sizeof (rtems_rfs_inode),
     369                inode.offset * RTEMS_RFS_INODE_SIZE,
    371370                allocated ? 'A' : 'F');
    372371   
Note: See TracChangeset for help on using the changeset viewer.