Changeset 66b8047 in rtems


Ignore:
Timestamp:
Nov 6, 2011, 12:44:24 PM (8 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.11, master
Children:
1ddad65
Parents:
0527367c
Message:

Remove stray whitespaces.

Location:
cpukit/libfs/src
Files:
44 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libfs/src/devfs/devfs_init.c

    r0527367c r66b8047  
    3636    rtems_filesystem_default_readlink,
    3737    rtems_filesystem_default_rename,
    38     rtems_filesystem_default_statvfs 
     38    rtems_filesystem_default_statvfs
    3939};
    4040
  • cpukit/libfs/src/devfs/devstat.c

    r0527367c r66b8047  
    3737    if (!the_dev)
    3838      rtems_set_errno_and_return_minus_one( EFAULT );
    39   #endif 
     39  #endif
    4040
    4141  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
  • cpukit/libfs/src/dosfs/msdos_dir.c

    r0527367c r66b8047  
    498498 *     set apropriately).
    499499 */
    500 off_t       
     500off_t
    501501msdos_dir_lseek(rtems_libio_t *iop, off_t offset, int whence)
    502502{
  • cpukit/libfs/src/dosfs/msdos_file.c

    r0527367c r66b8047  
    223223 *     appropriately).
    224224 */
    225 off_t       
     225off_t
    226226msdos_file_lseek(rtems_libio_t *iop, off_t offset, int whence)
    227227{
  • cpukit/libfs/src/dosfs/msdos_misc.c

    r0527367c r66b8047  
    126126        printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
    127127#endif
    128        
     128
    129129        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
    130130            return type;
     
    171171        return MSDOS_NAME_LONG;
    172172    }
    173    
     173
    174174#if MSDOS_NAME_TYPE_PRINT
    175175    printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
     
    284284    if (pathlen == 0)
    285285        return MSDOS_NO_MORE_PATH;
    286    
     286
    287287    /*
    288288     *  Check for a separator.
  • cpukit/libfs/src/dosfs/msdos_rename.c

    r0527367c r66b8047  
    8080        return rc;
    8181    }
    82    
     82
    8383    /*
    8484     * mark file removed
     
    8787                                        &old_fat_fd->dir_pos,
    8888                                        MSDOS_THIS_DIR_ENTRY_EMPTY);
    89    
     89
    9090    rtems_semaphore_release(fs_info->vol_sema);
    9191    return rc;
  • cpukit/libfs/src/imfs/imfs_eval.c

    r0527367c r66b8047  
    579579          IMFS_evaluate_hard_link( pathloc, 0 );
    580580          node = pathloc->node_access;
    581        
     581
    582582          /*
    583583           * It would be a design error if we evaluated the link and
  • cpukit/libfs/src/imfs/imfs_fifo.c

    r0527367c r66b8047  
    5757  iop->flags &= ~LIBIO_FLAGS_OPEN;
    5858  IMFS_check_node_remove(jnode);
    59  
     59
    6060  IMFS_FIFO_RETURN(err);
    6161}
  • cpukit/libfs/src/imfs/imfs_link.c

    r0527367c r66b8047  
    5656   *        added a new IMFS_create_root_node() so this path no longer
    5757   *        existed.  The result was simpler code which should not have
    58    *        this path. 
     58   *        this path.
    5959   */
    6060  new_node = IMFS_create_node(
  • cpukit/libfs/src/imfs/imfs_load_tar.c

    r0527367c r66b8047  
    2020 * File entries are created as IMFS_LINEAR_FILE nodes with their nods
    2121 * pointing to addresses in the TAR image.
    22  */ 
     22 */
    2323
    2424#include <sys/types.h>
     
    161161     *        root node.  We added a new IMFS_create_root_node() so this
    162162     *        path no longer existed.  The result was simpler code which
    163      *        should not have this path. 
     163     *        should not have this path.
    164164     */
    165165    else if (linkflag == REGTYPE) {
  • cpukit/libfs/src/imfs/imfs_mknod.c

    r0527367c r66b8047  
    5656  } else if (S_ISFIFO(mode))
    5757    type = IMFS_FIFO;
    58   else 
     58  else
    5959    IMFS_assert( 0 );
    6060
     
    6767   *        added a new IMFS_create_root_node() so this path no longer
    6868   *        existed.  The result was simpler code which should not have
    69    *        this path. 
     69   *        this path.
    7070   */
    7171  new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
  • cpukit/libfs/src/imfs/imfs_rename.c

    r0527367c r66b8047  
    3737
    3838  strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
    39  
     39
    4040  if ( the_jnode->Parent != NULL )
    4141    rtems_chain_extract( (rtems_chain_node *) the_jnode );
     
    4343  new_parent = new_parent_loc->node_access;
    4444  the_jnode->Parent = new_parent;
    45  
     45
    4646  rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
    47  
     47
    4848  /*
    4949   * Update the time.
  • cpukit/libfs/src/imfs/imfs_stat.c

    r0527367c r66b8047  
    6767  buf->st_dev =
    6868    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
    69  
     69
    7070  buf->st_mode  = the_jnode->st_mode;
    7171  buf->st_nlink = the_jnode->st_nlink;
  • cpukit/libfs/src/imfs/imfs_symlink.c

    r0527367c r66b8047  
    5959   *        added a new IMFS_create_root_node() so this path no longer
    6060   *        existed.  The result was simpler code which should not have
    61    *        this path. 
     61   *        this path.
    6262   */
    6363  new_node = IMFS_create_node(
  • cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c

    r0527367c r66b8047  
    6161    }
    6262  }
    63  
     63
    6464  printf (" %2d. Test bit range (%" PRId32 ",%ld] all %s: pass\n",
    6565          test, bit, bit + size - 1, set ? "set" : "clear");
     
    7777  int  i;
    7878  int  rc;
    79  
     79
    8080  printf (" %2d. Set all bits\n", test);
    8181  rc = rtems_rfs_bitmap_map_set_all (control);
     
    8585    return false;
    8686  }
    87  
     87
    8888  for (i = 0; i < size; i++)
    8989    rtems_rfs_bitmap_map_clear (control, bit + i);
    90  
     90
    9191  printf (" %2d. Cleared bits (%" PRId32 ", %ld] (%zd)\n",
    9292          test, bit, bit + size - 1, size);
    93  
     93
    9494  for (i = 0; i < rtems_rfs_bitmap_element_bits (); i++)
    9595  {
     
    106106    }
    107107  }
    108  
     108
    109109  for (i = 0, bit = 0; i < size; i++)
    110110  {
     
    128128  printf (" %2d. Alloc'ed all bits (%" PRId32 ", %ld] (%zd)\n",
    129129          test, bit, bit + size - 1, size);
    130  
     130
    131131  return true;
    132132}
     
    152152  memset (&fs, 0, sizeof (fs));
    153153  memset (&buffer, 0, sizeof (buffer));
    154  
     154
    155155  buffer.buffer = malloc (bytes);
    156156  buffer.block = 1;
     
    167167  memset (buffer.buffer, 0xff, bytes);
    168168#endif
    169  
     169
    170170  /*
    171171   * Do not close the handle so no writes need occur.
     
    181181  handle.buffer = &buffer;
    182182  handle.bnum = 1;
    183  
     183
    184184  printf ("\nRFS Bitmap Test : size = %zd (%zd)\n",
    185185          size, rtems_rfs_bitmap_elements (size));
    186   rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1); 
     186  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1);
    187187  if (rc > 0)
    188188  {
     
    200200          result ? "FAIL" : "pass", strerror (rc));
    201201  rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
    202  
     202
    203203  rc = rtems_rfs_bitmap_map_alloc (&control, size, &result, &bit);
    204204  printf ("  2. Find bit with seed = size: %s (%s)\n",
     
    211211          result ? "pass" : "FAIL", strerror (rc),  bit);
    212212  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    213  
     213
    214214  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
    215215  result = result && (bit == (size - 1));
     
    218218  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    219219
    220  
     220
    221221  /*
    222222   * Test the bits allocated to make sure they are set.
     
    227227          result ? "pass" : "FAIL", strerror (rc));
    228228  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    229  
     229
    230230  rc = rtems_rfs_bitmap_map_test (&control, size - 1, &result);
    231231  printf ("  6. Test bit (size - 1) (%zd): %s (%s)\n",
    232232          size - 1, result ? "pass" : "FAIL", strerror (rc));
    233233  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    234  
     234
    235235  if (!rtems_rfs_bitmap_ut_test_range (&control, 7, false, 1, size - 2))
    236236    rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
     
    245245
    246246  bit = rand () % size;
    247  
     247
    248248  rc = rtems_rfs_bitmap_map_clear (&control, bit);
    249249  printf ("  9. Clear bit %" PRId32 ": %s (%s)\n",
     
    257257          result ? "pass" : "FAIL", strerror (rc), bit);
    258258  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    259  
     259
    260260  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
    261261  result = !result || (bit != last_bit);
     
    263263          result ? "pass" : "FAIL", strerror (rc), bit);
    264264  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    265  
     265
    266266  rc = rtems_rfs_bitmap_map_clear (&control, 0);
    267267  printf (" 12. Clear bit 0: %s (%s)\n",
    268268          rc == 0 ? "pass" : "FAIL", strerror (rc));
    269269  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
    270  
     270
    271271  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
    272272  result = result && (bit == 0);
     
    289289  printf (" 16. Clear bit 0: %s (%s)\n",
    290290          rc == 0 ? "pass" : "FAIL", strerror (rc));
    291  
     291
    292292  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
    293293  result = result && (bit == 0);
     
    300300          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
    301301  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
    302  
     302
    303303  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
    304304  result = result && (bit == (size - 1));
     
    310310  printf (" 20. Clear bit 0: %s (%s)\n",
    311311          rc == 0 ? "pass" : "FAIL", strerror (rc));
    312  
     312
    313313  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
    314314  result = result && (bit == 0);
     
    320320  printf (" 22. Clear bit (size - 1) (%zd): %s (%s)\n",
    321321          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
    322  
     322
    323323  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
    324324  result = result && (bit == (size - 1));
     
    331331                                               rtems_rfs_bitmap_element_bits ());
    332332  rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
    333  
     333
    334334  bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
    335335  result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 24, bit, 57);
     
    345345  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
    346346
    347   first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits (); 
     347  first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
    348348  last_bit = first_bit + rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
    349349
     
    358358    }
    359359  }
    360  
     360
    361361  printf (" 26. Clear bit (%" PRId32 ", %" PRId32 "]: %s (%s)\n",
    362362          first_bit, last_bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
    363  
     363
    364364  clear = rtems_rfs_bitmap_map_free (&control);
    365365  result = clear == (last_bit - first_bit);
     
    374374          result ? "pass" : "FAIL", strerror (rc));
    375375  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
    376  
     376
    377377  rtems_rfs_bitmap_close (&control);
    378378  free (buffer.buffer);
     
    392392  srand (0x2398);
    393393#endif
    394  
     394
    395395  rtems_rfs_bitmap_ut_test_bitmap (2048);
    396396  rtems_rfs_bitmap_ut_test_bitmap (420);
  • cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c

    r0527367c r66b8047  
    4545 */
    4646static bool
    47 rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target, 
     47rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
    4848                       rtems_rfs_bitmap_bit     bit)
    4949{
     
    6060 */
    6161static rtems_rfs_bitmap_element
    62 rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target, 
     62rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
    6363                      rtems_rfs_bitmap_element bits)
    6464{
     
    107107 * @param bits2 The second set of bits to match.
    108108 * @retval true The bits match.
    109  * @retval false The bits do not match. 
     109 * @retval false The bits do not match.
    110110 */
    111111static bool
     
    125125 * @param bits2 The second set of bits to match.
    126126 * @retval true The bits match.
    127  * @retval false The bits do not match. 
     127 * @retval false The bits do not match.
    128128 */
    129129static bool
     
    148148{
    149149  int rc;
    150  
     150
    151151  if (!control->buffer)
    152152    return ENXIO;
    153153
    154154  *map = NULL;
    155  
     155
    156156  rc = rtems_rfs_buffer_handle_request (control->fs,
    157157                                        control->buffer,
     
    160160  if (rc)
    161161    return rc;
    162  
     162
    163163  *map = rtems_rfs_buffer_data (control->buffer);
    164164  return 0;
     
    268268  if (rc > 0)
    269269    return rc;
    270  
     270
    271271  elements = rtems_rfs_bitmap_elements (control->size);
    272272
    273273  control->free = 0;
    274  
     274
    275275  for (e = 0; e < elements; e++)
    276276    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
    277  
     277
    278278  elements = rtems_rfs_bitmap_elements (elements);
    279  
     279
    280280  for (e = 0; e < elements; e++)
    281281    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
     
    294294  int                  e;
    295295  int                  rc;
    296  
     296
    297297  rc = rtems_rfs_bitmap_load_map (control, &map);
    298298  if (rc > 0)
    299299    return rc;
    300  
     300
    301301  elements = rtems_rfs_bitmap_elements (control->size);
    302  
     302
    303303  control->free = elements;
    304  
     304
    305305  for (e = 0; e < elements; e++)
    306306    map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
     
    314314  if (last_search_bit == 0)
    315315    last_search_bit = rtems_rfs_bitmap_element_bits ();
    316  
     316
    317317  elements = rtems_rfs_bitmap_elements (elements);
    318  
     318
    319319  for (e = 0; e < (elements - 1); e++)
    320320    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
    321  
     321
    322322  control->search_bits[elements - 1] =
    323323    rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
     
    349349
    350350  *found = false;
    351  
     351
    352352  /*
    353353   * Load the bitmap.
     
    356356  if (rc > 0)
    357357    return rc;
    358  
     358
    359359  /*
    360360   * Calculate the bit we are testing plus the end point we search over.
     
    367367  else if (end_bit >= control->size)
    368368    end_bit = control->size - 1;
    369  
     369
    370370  map_index     = rtems_rfs_bitmap_map_index (test_bit);
    371371  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);
     
    375375  search_bits = &control->search_bits[search_index];
    376376  map_bits    = &map[map_index];
    377  
     377
    378378  /*
    379379   * Check each bit from the search map offset for a clear bit.
     
    425425        map_index += direction;
    426426        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
    427        
     427
    428428        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
    429    
     429
    430430        search_offset += direction;
    431      
     431
    432432        if (((direction < 0) && (test_bit <= end_bit))
    433433            || ((direction > 0) && (test_bit >= end_bit)))
     
    474474  while (((direction < 0) && (test_bit >= end_bit))
    475475         || ((direction > 0) && (test_bit <= end_bit)));
    476    
     476
    477477  return 0;
    478478}
     
    493493   */
    494494  *allocated = false;
    495  
     495
    496496  /*
    497497   * The window is the number of bits we search over in either direction each
     
    550550      lower_seed -= window;
    551551  }
    552  
     552
    553553  return 0;
    554554}
     
    562562  rtems_rfs_bitmap_bit bit;
    563563  int                  rc;
    564  
     564
    565565  rc = rtems_rfs_bitmap_load_map (control, &map);
    566566  if (rc > 0)
     
    571571  size = control->size;
    572572  bit = 0;
    573  
     573
    574574  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
    575575  while (size)
     
    589589      available = rtems_rfs_bitmap_element_bits ();
    590590    }
    591    
     591
    592592    if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
    593593      rtems_rfs_bitmap_set (*search_map, bit);
     
    601601
    602602    size -= available;
    603    
     603
    604604    if (bit == rtems_rfs_bitmap_element_bits ())
    605605    {
     
    624624{
    625625  size_t elements = rtems_rfs_bitmap_elements (size);
    626  
     626
    627627  control->buffer = buffer;
    628628  control->fs = fs;
    629629  control->block = block;
    630630  control->size = size;
    631  
     631
    632632  elements = rtems_rfs_bitmap_elements (elements);
    633633  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
    634  
     634
    635635  if (!control->search_bits)
    636636    return ENOMEM;
  • cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h

    r0527367c r66b8047  
    198198 * @return Mask section as defined by the start and end arguments.
    199199 */
    200 rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, 
     200rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start,
    201201                                                        unsigned int end);
    202202
     
    241241 * @param control The bitmap control.
    242242 * @return int The error number (errno). No error if 0.
    243  */ 
     243 */
    244244int rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control);
    245245
     
    249249 * @param control The bitmap control.
    250250 * @return int The error number (errno). No error if 0.
    251  */ 
     251 */
    252252int rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control);
    253253
  • cpukit/libfs/src/rfs/rtems-rfs-block-pos.h

    r0527367c r66b8047  
    127127                         rtems_rfs_block_pos*    bpos)
    128128{
    129   rtems_rfs_block_get_bpos (fs, 
     129  rtems_rfs_block_get_bpos (fs,
    130130                            rtems_rfs_block_get_pos (fs, bpos) + offset,
    131131                            bpos);
  • cpukit/libfs/src/rfs/rtems-rfs-block.c

    r0527367c r66b8047  
    110110  rtems_rfs_block_set_size_zero (&map->size);
    111111  rtems_rfs_block_set_bpos_zero (&map->bpos);
    112  
     112
    113113  rc = rtems_rfs_buffer_handle_open (fs, &map->singly_buffer);
    114114  if (rc > 0)
     
    125125    return rc;
    126126  }
    127  
     127
    128128  /*
    129129   * Extract the block and block count data from the inode into the targets
     
    139139
    140140  rc = rtems_rfs_inode_unload (fs, inode, false);
    141  
     141
    142142  return rc;
    143143}
     
    155155    if (brc > 0)
    156156      rc = brc;
    157    
     157
    158158    if (rc == 0)
    159159    {
     
    170170      if (brc > 0)
    171171        rc = brc;
    172      
     172
    173173      map->dirty = false;
    174174    }
     
    226226    rc = EIO;
    227227  }
    228  
     228
    229229  return 0;
    230230}
     
    239239
    240240  *block = 0;
    241  
     241
    242242  /*
    243243   * Range checking here makes the remaining logic simpler.
     
    271271      rtems_rfs_block_no direct;
    272272      rtems_rfs_block_no singly;
    273    
     273
    274274      direct = bpos->bno % fs->blocks_per_block;
    275275      singly = bpos->bno / fs->blocks_per_block;
     
    317317          rc = ENXIO;
    318318        }
    319       }   
     319      }
    320320    }
    321321  }
     
    326326    map->bpos.block = *block;
    327327  }
    328  
     328
    329329  return rc;
    330330}
     
    410410{
    411411  int b;
    412  
     412
    413413  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
    414414    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
     
    426426    rtems_rfs_bitmap_bit block;
    427427    int                  rc;
    428    
     428
    429429    /*
    430430     * Allocate the block. If an indirect block is needed and cannot be
    431431     * allocated free this block.
    432432     */
    433    
     433
    434434    rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
    435435                                       false, &block);
     
    446446      rtems_rfs_block_no direct;
    447447      rtems_rfs_block_no singly;
    448      
     448
    449449      direct = map->size.count % fs->blocks_per_block;
    450450      singly = map->size.count / fs->blocks_per_block;
     
    562562          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
    563563                                                     singly);
    564          
     564
    565565          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
    566566                                                singly_block, true);
     
    578578    map->size.count++;
    579579    map->size.offset = 0;
    580    
     580
    581581    if (b == 0)
    582582      *new_block = block;
     
    618618  {
    619619    rtems_rfs_block_no block_to_free = map->blocks[indirect];
    620  
     620
    621621    if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
    622622    {
     
    635635      map->blocks[indirect] = 0;
    636636    }
    637    
     637
    638638    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
    639639    if (rc > 0)
    640640      return rc;
    641    
     641
    642642    map->last_map_block = block_to_free;
    643643  }
    644  
     644
    645645  return rc;
    646646}
     
    654654    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
    655655            blocks, map->size.count);
    656            
     656
    657657  if (map->size.count == 0)
    658658    return 0;
    659    
     659
    660660  if (blocks > map->size.count)
    661661    blocks = map->size.count;
     
    668668
    669669    block = map->size.count - 1;
    670    
     670
    671671    if (block < RTEMS_RFS_INODE_BLOCKS)
    672672    {
     
    703703        if (rc > 0)
    704704          return rc;
    705        
     705
    706706        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
    707707                                                    direct);
     
    753753          if (rc > 0)
    754754            return rc;
    755          
     755
    756756          map->last_map_block = singly;
    757          
     757
    758758          rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
    759759                                                    doubly, doubly_singly);
    760760          if (rc)
    761761            return rc;
    762         }       
     762        }
    763763      }
    764764      else
  • cpukit/libfs/src/rfs/rtems-rfs-block.h

    r0527367c r66b8047  
    5252    rtems_rfs_buffer_mark_dirty (_h); \
    5353  } while (0)
    54  
     54
    5555/**
    5656 * A block map manges the block lists that originate from an inode. The inode
     
    197197 * @param offset The offset to set in the map's size.
    198198 */
    199 static inline void 
     199static inline void
    200200rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
    201201                                     rtems_rfs_block_off  offset)
     
    211211 * @param size The size to set in the map's size.
    212212 */
    213 static inline void 
     213static inline void
    214214rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,
    215215                              rtems_rfs_block_size* size)
  • cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c

    r0527367c r66b8047  
    8686    rc = EIO;
    8787  }
    88  
     88
    8989  return rc;
    9090}
  • cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c

    r0527367c r66b8047  
    3535int
    3636rtems_rfs_buffer_deviceio_request (rtems_rfs_buffer_handle* handle,
    37                                    dev_t                    device, 
     37                                   dev_t                    device,
    3838                                   rtems_rfs_buffer_block   block,
    3939                                   bool                     read)
  • cpukit/libfs/src/rfs/rtems-rfs-buffer.c

    r0527367c r66b8047  
    4242  rtems_rfs_buffer* buffer;
    4343  rtems_chain_node* node;
    44  
     44
    4545  node = rtems_chain_last (chain);
    4646
     
    8282{
    8383  int rc;
    84  
     84
    8585  /*
    8686   * If the handle has a buffer release it. This allows a handle to be reused
     
    159159    }
    160160  }
    161    
     161
    162162  /*
    163163   * If not located we request the buffer from the I/O layer.
     
    184184  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
    185185  fs->buffers_count++;
    186  
     186
    187187  handle->buffer->user = (void*) ((intptr_t) block);
    188188  handle->bnum = block;
    189  
     189
    190190  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
    191191    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
    192192            block, read ? "read" : "get", handle->buffer->block,
    193193            handle->buffer->references);
    194  
     194
    195195  return 0;
    196196}
     
    201201{
    202202  int rc = 0;
    203  
     203
    204204  if (rtems_rfs_buffer_handle_has_block (handle))
    205205  {
     
    213213    if (rtems_rfs_buffer_refs (handle) > 0)
    214214      rtems_rfs_buffer_refs_down (handle);
    215    
     215
    216216    if (rtems_rfs_buffer_refs (handle) == 0)
    217217    {
    218218      rtems_chain_extract (rtems_rfs_buffer_link (handle));
    219219      fs->buffers_count--;
    220      
     220
    221221      if (rtems_rfs_fs_no_local_cache (fs))
    222222      {
     
    241241          rtems_rfs_buffer* buffer;
    242242          bool              modified;
    243        
     243
    244244          if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
    245245            printf ("rtems-rfs: buffer-release: local cache overflow:"
    246246                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
    247        
     247
    248248          if (fs->release_count > fs->release_modified_count)
    249249          {
     
    262262          rc = rtems_rfs_buffer_io_release (buffer, modified);
    263263        }
    264      
     264
    265265        if (rtems_rfs_buffer_dirty (handle))
    266266        {
     
    278278    handle->buffer = NULL;
    279279  }
    280  
     280
    281281  return rc;
    282282}
     
    289289  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
    290290    printf ("rtems-rfs: buffer-open: opening: %s\n", name);
    291  
     291
    292292  if (stat (name, &st) < 0)
    293293  {
     
    334334            rtems_rfs_fs_media_blocks (fs),
    335335            rtems_rfs_fs_media_block_size (fs));
    336  
     336
    337337  return 0;
    338338}
     
    355355    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
    356356            rc, strerror (rc));
    357  
     357
    358358#if RTEMS_RFS_USE_LIBBLOCK
    359359  rtems_disk_release (fs->disk);
     
    367367  }
    368368#endif
    369  
     369
    370370  return rc;
    371371}
     
    419419    printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
    420420            rc, strerror (rc));
    421  
     421
    422422  rc = rtems_rfs_buffer_sync (fs);
    423423  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
    424424    printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
    425425            rc, strerror (rc));
    426  
     426
    427427#if RTEMS_RFS_USE_LIBBLOCK
    428428  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
     
    451451
    452452    buffer->user = (void*) 0;
    453    
     453
    454454    rc = rtems_rfs_buffer_io_release (buffer, modified);
    455455    if ((rc > 0) && (rrc == 0))
  • cpukit/libfs/src/rfs/rtems-rfs-buffer.h

    r0527367c r66b8047  
    169169 * @return int The error number (errno). No error if 0.
    170170 */
    171 int rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs, 
     171int rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
    172172                                     rtems_rfs_buffer_handle* handle,
    173173                                     rtems_rfs_buffer_block   block,
     
    198198{
    199199  handle->dirty = false;
    200   handle->bnum  = 0; 
     200  handle->bnum  = 0;
    201201  handle->buffer = NULL;
    202202  return 0;
     
    216216  rtems_rfs_buffer_handle_release (fs, handle);
    217217  handle->dirty = false;
    218   handle->bnum  = 0; 
     218  handle->bnum  = 0;
    219219  handle->buffer = NULL;
    220220  return 0;
  • cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c

    r0527367c r66b8047  
    5757  reverse, there are at least 32 bits of the output that are sometimes the same
    5858  for one pair and different for another pair.  This was tested for:
    59  
     59
    6060  * pairs that differed by one bit, by two bits, in any combination of top bits
    6161    of (a,b,c), or in any combination of bottom bits of (a,b,c).
    62      
     62
    6363  * "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed the
    6464    output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly
     
    7070  Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that satisfy this
    7171  are:
    72  
     72
    7373     4  6  8 16 19  4
    7474     9 15  3 18 27 15
    7575    14  9  3  7 17  3
    76    
     76
    7777  Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for "differ" defined
    7878  as + with a one-bit base and a two-bit delta.  I used
     
    107107  Pairs of (a,b,c) values differing in only a few bits will usually produce
    108108  values of c that look totally different.  This was tested for
    109  
     109
    110110  * pairs that differed by one bit, by two bits, in any combination of top bits
    111111    of (a,b,c), or in any combination of bottom bits of (a,b,c).
    112  
     112
    113113  * "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed the
    114114    output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly
  • cpukit/libfs/src/rfs/rtems-rfs-dir.c

    r0527367c r66b8047  
    7878  *ino = RTEMS_RFS_EMPTY_INO;
    7979  *offset = 0;
    80  
     80
    8181  rc = rtems_rfs_block_map_open (fs, inode, &map);
    8282  if (rc > 0)
     
    8787    return rc;
    8888  }
    89  
     89
    9090  rc = rtems_rfs_buffer_handle_open (fs, &entries);
    9191  if (rc > 0)
     
    106106     */
    107107    hash = rtems_rfs_dir_hash (name, length);
    108  
     108
    109109    /*
    110110     * Locate the first block. The map points to the start after open so just
     
    123123      return rc;
    124124    }
    125        
     125
    126126    while ((rc == 0) && block)
    127127    {
    128128      uint8_t* entry;
    129      
     129
    130130      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
    131131        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
    132132                rtems_rfs_inode_ino (inode), map.bpos.bno);
    133      
    134       rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 
     133
     134      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
    135135      if (rc > 0)
    136136      {
     
    147147
    148148      entry = rtems_rfs_buffer_data (&entries);
    149      
     149
    150150      map.bpos.boff = 0;
    151151
     
    154154        uint32_t ehash;
    155155        int      elength;
    156      
     156
    157157        ehash  = rtems_rfs_dir_entry_hash (entry);
    158158        elength = rtems_rfs_dir_entry_length (entry);
     
    161161        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
    162162          break;
    163        
     163
    164164        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
    165165        {
     
    171171          break;
    172172        }
    173          
     173
    174174        if (ehash == hash)
    175175        {
     
    184184          {
    185185            *offset = rtems_rfs_block_map_pos (fs, &map);
    186            
     186
    187187            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
    188188              printf ("rtems-rfs: dir-lookup-ino: "
     
    223223    }
    224224  }
    225  
     225
    226226  rtems_rfs_buffer_handle_close (fs, &entries);
    227227  rtems_rfs_block_map_close (fs, &map);
     
    250250    printf (", len=%zd\n", length);
    251251  }
    252        
     252
    253253  rc = rtems_rfs_block_map_open (fs, dir, &map);
    254254  if (rc > 0)
     
    261261    return rc;
    262262  }
    263  
     263
    264264  /*
    265265   * Search the map from the beginning to find any empty space.
    266266   */
    267267  rtems_rfs_block_set_bpos_zero (&bpos);
    268  
     268
    269269  while (true)
    270270  {
     
    273273    int                offset;
    274274    bool               read = true;
    275    
     275
    276276    /*
    277277     * Locate the first block. If an error the block will be 0. If the map is
     
    308308
    309309    bpos.bno++;
    310    
     310
    311311    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
    312312    if (rc > 0)
     
    318318      break;
    319319    }
    320    
     320
    321321    entry  = rtems_rfs_buffer_data (&buffer);
    322    
     322
    323323    if (!read)
    324324      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
    325325
    326326    offset = 0;
    327    
     327
    328328    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    329329    {
     
    354354        break;
    355355      }
    356      
     356
    357357      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    358358      {
     
    365365        return EIO;
    366366      }
    367        
     367
    368368      entry  += elength;
    369369      offset += elength;
    370370    }
    371371  }
    372  
     372
    373373  rtems_rfs_buffer_handle_close (fs, &buffer);
    374374  rtems_rfs_block_map_close (fs, &map);
     
    381381                         rtems_rfs_ino           ino,
    382382                         uint32_t                offset)
    383 { 
     383{
    384384  rtems_rfs_block_map     map;
    385385  rtems_rfs_block_no      block;
     
    421421    uint8_t* entry;
    422422    int      eoffset;
    423    
     423
    424424    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
    425425    if (rc > 0)
     
    440440    else
    441441      eoffset = offset % rtems_rfs_fs_block_size (fs);
    442    
     442
    443443    entry = rtems_rfs_buffer_data (&buffer) + eoffset;
    444    
     444
    445445    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    446446    {
     
    453453      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
    454454        break;
    455      
     455
    456456      if (rtems_rfs_dir_entry_valid (fs, elength, eino))
    457457      {
     
    500500          }
    501501        }
    502        
     502
    503503        rtems_rfs_buffer_mark_dirty (&buffer);
    504504        rtems_rfs_buffer_handle_close (fs, &buffer);
     
    512512        break;
    513513      }
    514      
     514
    515515      entry   += elength;
    516516      eoffset += elength;
     
    524524    }
    525525  }
    526  
     526
    527527  rtems_rfs_buffer_handle_close (fs, &buffer);
    528528  rtems_rfs_block_map_close (fs, &map);
     
    547547
    548548  *length = 0;
    549  
     549
    550550  rc = rtems_rfs_block_map_open (fs, dir, &map);
    551551  if (rc > 0)
     
    556556    offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
    557557              rtems_rfs_fs_block_size (fs));
    558  
     558
    559559  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
    560560  if (rc > 0)
     
    565565    return rc;
    566566  }
    567  
     567
    568568  rc = rtems_rfs_buffer_handle_open (fs, &buffer);
    569569  if (rc > 0)
     
    581581    uint8_t*      entry;
    582582    rtems_rfs_ino eino;
    583     int           elength;   
     583    int           elength;
    584584    int           remaining;
    585    
     585
    586586    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
    587587    if (rc > 0)
     
    594594    entry  = rtems_rfs_buffer_data (&buffer);
    595595    entry += map.bpos.boff;
    596    
     596
    597597    elength = rtems_rfs_dir_entry_length (entry);
    598598    eino    = rtems_rfs_dir_entry_ino (entry);
     
    609609        break;
    610610      }
    611        
     611
    612612      memset (dirent, 0, sizeof (struct dirent));
    613613      dirent->d_off = offset;
     
    617617
    618618      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
    619      
     619
    620620      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
    621621        *length += remaining;
    622      
     622
    623623      elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
    624624      if (elength > NAME_MAX)
    625625        elength = NAME_MAX;
    626      
     626
    627627      memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
    628628
    629629      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
    630630      dirent->d_namlen = elength;
    631      
     631
    632632      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
    633633        printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
     
    637637
    638638    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
    639    
     639
    640640    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
    641641      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
    642642              offset, *length);
    643      
     643
    644644    rc = rtems_rfs_block_map_next_block (fs, &map, &block);
    645645    if (rc == ENXIO)
     
    666666
    667667  empty = true;
    668  
     668
    669669  rc = rtems_rfs_block_map_open (fs, dir, &map);
    670670  if (rc > 0)
     
    677677    return rc;
    678678  }
    679  
     679
    680680  rc = rtems_rfs_buffer_handle_open (fs, &buffer);
    681681  if (rc > 0)
     
    693693    uint8_t* entry;
    694694    int      offset;
    695    
     695
    696696    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
    697697    if (rc > 0)
     
    700700    entry  = rtems_rfs_buffer_data (&buffer);
    701701    offset = 0;
    702    
     702
    703703    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    704704    {
     
    721721        break;
    722722      }
    723        
     723
    724724      /*
    725725       * Ignore the current (.) and parent (..) entries. Anything else means
     
    754754  if ((rc == 0) && !empty)
    755755    rc = ENOTEMPTY;
    756  
     756
    757757  rtems_rfs_buffer_handle_close (fs, &buffer);
    758758  rtems_rfs_block_map_close (fs, &map);
  • cpukit/libfs/src/rfs/rtems-rfs-file-system.c

    r0527367c r66b8047  
    7272
    7373  sb = rtems_rfs_buffer_data (&handle);
    74  
     74
    7575#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
    76  
     76
    7777  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
    7878  {
     
    103103    return EIO;
    104104  }
    105      
     105
    106106  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
    107107  {
     
    112112    return EIO;
    113113  }
    114      
     114
    115115  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
    116116  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
     
    121121  fs->blocks_per_block =
    122122    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
    123  
     123
    124124  fs->block_map_singly_blocks =
    125125    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
     
    130130
    131131  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
    132  
     132
    133133  if (fs->group_blocks >
    134134      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
     
    207207  uint16_t               mode;
    208208  int                    rc;
    209  
     209
    210210  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
    211211    printf ("rtems-rfs: open: %s\n", name);
    212  
     212
    213213  *fs = malloc (sizeof (rtems_rfs_file_system));
    214214  if (!*fs)
     
    292292    }
    293293  }
    294  
     294
    295295  rc = rtems_rfs_inode_close (*fs, &inode);
    296296  if (rc > 0)
     
    303303    return -1;
    304304  }
    305    
     305
    306306  errno = 0;
    307307  return 0;
     
    312312{
    313313  int group;
    314  
     314
    315315  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
    316316    printf ("rtems-rfs: close\n");
     
    320320
    321321  rtems_rfs_buffer_close (fs);
    322  
     322
    323323  free (fs);
    324   return 0; 
    325 }
     324  return 0;
     325}
  • cpukit/libfs/src/rfs/rtems-rfs-file.c

    r0527367c r66b8047  
    4141  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
    4242    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
    43            
     43
    4444  *file = NULL;
    4545
     
    6464    return rc;
    6565  }
    66  
     66
    6767  /*
    6868   * Scan the file system data list of open files for this ino. If found up
     
    9191
    9292    memset (shared, 0, sizeof (rtems_rfs_file_shared));
    93    
     93
    9494    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
    9595    if (rc > 0)
     
    135135  handle->flags  = flags;
    136136  handle->shared = shared;
    137  
     137
    138138  *file = handle;
    139  
     139
    140140  return 0;
    141141}
     
    149149
    150150  rrc = 0;
    151  
     151
    152152  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
    153153    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
     
    178178                                      &handle->shared->size);
    179179    }
    180    
     180
    181181    rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
    182182    if (rc > 0)
     
    188188        rrc = rc;
    189189    }
    190    
     190
    191191    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
    192192    if (rc > 0)
     
    198198        rrc = rc;
    199199    }
    200    
     200
    201201    rtems_chain_extract (&handle->shared->link);
    202202    free (handle->shared);
     
    206206  if ((rrc == 0) && (rc > 0))
    207207    rrc = rc;
    208  
     208
    209209  if (rrc > 0)
    210210  {
     
    214214
    215215  free (handle);
    216  
     216
    217217  return rrc;
    218218}
     
    224224{
    225225  size_t size;
    226  
     226
    227227  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
    228228    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
    229229            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
    230  
     230
    231231  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
    232232  {
     
    234234    bool                   request_read;
    235235    int                    rc;
    236      
     236
    237237    request_read = read;
    238    
     238
    239239    rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
    240240                                   rtems_rfs_file_map (handle),
     
    251251        return 0;
    252252      }
    253      
     253
    254254      if (rc != ENXIO)
    255255        return rc;
     
    257257      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
    258258        printf ("rtems-rfs: file-io: start: grow\n");
    259      
     259
    260260      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
    261261                                     rtems_rfs_file_map (handle),
     
    278278        request_read = true;
    279279    }
    280    
     280
    281281    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
    282282      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
    283283              block, request_read ? "yes" : "no");
    284    
     284
    285285    rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
    286286                                          rtems_rfs_file_buffer (handle),
     
    289289      return rc;
    290290  }
    291  
     291
    292292  if (read
    293293      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
     
    296296  else
    297297    size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    298  
     298
    299299  *available = size - rtems_rfs_file_block_offset (handle);
    300300
     
    302302    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
    303303            *available, size);
    304    
     304
    305305  return 0;
    306306}
     
    319319    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",
    320320            read ? "read" : "write", size);
    321  
     321
    322322  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
    323323  {
     
    331331        "rtems-rfs: file-io:   end: error on release: %s size=%zu: %d: %s\n",
    332332        read ? "read" : "write", size, rc, strerror (rc));
    333      
     333
    334334      return rc;
    335335    }
     
    355355  length = false;
    356356  mtime = false;
    357  
     357
    358358  if (!read &&
    359359      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
     
    365365    mtime = true;
    366366  }
    367  
     367
    368368  atime  = rtems_rfs_file_update_atime (handle);
    369369  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;
    370370  length = rtems_rfs_file_update_length (handle) && length;
    371  
     371
    372372  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
    373373    printf ("rtems-rfs: file-io:   end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
    374374            handle->bpos.bno, handle->bpos.boff,
    375375            atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
    376  
     376
    377377  if (atime || mtime)
    378378  {
     
    390390      rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
    391391  }
    392  
     392
    393393  return rc;
    394394}
     
    411411  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
    412412    printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
    413  
     413
    414414  /*
    415415   * This call only sets the position if it is in a valid part of the file. The
     
    426426                                            handle->shared))
    427427    rtems_rfs_file_set_bpos (handle, pos);
    428  
     428
    429429  *new_pos = pos;
    430430  return 0;
     
    454454  {
    455455    size = rtems_rfs_file_size (handle);
    456  
     456
    457457    /*
    458458     * If the file is same size do nothing else grow or shrink it ?
     
    472472        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    473473        read_block = false;
    474        
     474
    475475        while (count)
    476476        {
     
    530530          if (rc > 0)
    531531            return rc;
    532        
     532
    533533          count -= length - bpos.boff;
    534534        }
     
    541541        rtems_rfs_block_no blocks;
    542542        uint32_t           offset;
    543    
     543
    544544        blocks =
    545545          rtems_rfs_block_map_count (map) -
     
    549549        offset =
    550550          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
    551      
     551
    552552        if (blocks)
    553553        {
     
    575575  if (rtems_rfs_file_update_mtime (handle))
    576576    handle->shared->mtime = time (NULL);
    577  
     577
    578578  return 0;
    579579}
  • cpukit/libfs/src/rfs/rtems-rfs-file.h

    r0527367c r66b8047  
    5656   */
    5757  rtems_rfs_block_map map;
    58  
    59   /**
    60    * The size of the file as taken from the inode. The map's size and 
     58
     59  /**
     60   * The size of the file as taken from the inode. The map's size and
    6161   * this size should be the same.
    6262   */
     
    153153 * @return rtems_rfs_pos The data size in bytes.
    154154 */
    155 static inline rtems_rfs_pos 
     155static inline rtems_rfs_pos
    156156rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
    157157                                rtems_rfs_file_shared* shared)
  • cpukit/libfs/src/rfs/rtems-rfs-format.c

    r0527367c r66b8047  
    113113    if (fs->block_size < 512)
    114114      fs->block_size = 512;
    115    
     115
    116116    if (fs->block_size > (4 * 1024))
    117117      fs->block_size = (4 * 1024);
    118118  }
    119  
     119
    120120  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
    121121  {
     
    140140    return false;
    141141  }
    142  
     142
    143143  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
    144144
     
    147147   * group. The disk will be divided into groups which are the number of bits
    148148   * per block.
    149    */ 
     149   */
    150150  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
    151151                                            rtems_rfs_bits_per_block (fs));
     
    155155  {
    156156    int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
    157    
     157
    158158    /*
    159159     * The number of inodes per group is set as a percentage.
     
    161161    if (config->inode_overhead)
    162162      inode_overhead = config->inode_overhead;
    163      
     163
    164164    fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
    165165  }
     
    172172    rtems_rfs_rup_quotient (fs->group_inodes,
    173173                            fs->inodes_per_block) * fs->inodes_per_block;
    174  
     174
    175175  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
    176176    fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
     
    181181    fs->max_name_length = 512;
    182182  }
    183  
     183
    184184  return true;
    185185}
     
    198198  int                      b;
    199199  int                      rc;
    200  
     200
    201201  group_base = rtems_rfs_fs_block (fs, group, 0);
    202202
     
    235235  if (verbose)
    236236    printf (", blocks");
    237  
     237
    238238  /*
    239239   * Open the block bitmap using the new buffer.
     
    254254   */
    255255  memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
    256  
     256
    257257  /*
    258258   * Clear the bitmap.
     
    267267    return false;
    268268  }
    269  
     269
    270270  /*
    271271   * Forced allocation of the block bitmap.
     
    305305  if (verbose)
    306306    printf (", inodes");
    307  
     307
    308308  /*
    309309   * Open the inode bitmap using the old buffer. Should release any changes.
     
    324324   */
    325325  memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
    326  
     326
    327327  /*
    328328   * Clear the inode bitmap.
     
    337337    return false;
    338338  }
    339  
     339
    340340  /*
    341341   * Close the inode bitmap.
     
    370370        return false;
    371371      }
    372    
     372
    373373      /*
    374374       * Force the whole buffer to a known state. The bit map may not occupy the
     
    376376       */
    377377      memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
    378  
     378
    379379      rtems_rfs_buffer_mark_dirty (&handle);
    380380    }
    381381  }
    382  
     382
    383383  rc = rtems_rfs_buffer_handle_close (fs, &handle);
    384384  if (rc > 0)
     
    388388    return false;
    389389  }
    390  
     390
    391391  return true;
    392392}
     
    417417
    418418  sb = rtems_rfs_buffer_data (&handle);
    419  
     419
    420420#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
    421  
     421
    422422  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
    423423
     
    451451    return false;
    452452  }
    453  
     453
    454454  return true;
    455455}
     
    475475    return -1;
    476476  }
    477  
     477
    478478  rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
    479479  if (rc > 0)
     
    491491    return rc;
    492492  }
    493  
     493
    494494  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    495495  if (rc > 0)
     
    509509    printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
    510510            rc, strerror (rc));
    511  
     511
    512512  rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
    513513  if (rc > 0)
    514514    printf ("rtems-rfs: format: directory add failed: %d: %s\n",
    515515            rc, strerror (rc));
    516  
     516
    517517  rc = rtems_rfs_inode_close (fs, &inode);
    518518  if (rc > 0)
    519519    printf ("rtems-rfs: format: inode close failed: %d: %s\n",
    520520            rc, strerror (rc));
    521  
     521
    522522  rc = rtems_rfs_fs_close (fs);
    523523  if (rc < 0)
    524524    printf ("rtems-rfs: format: file system close failed: %d: %s\n",
    525525            errno, strerror (errno));
    526  
     526
    527527  return rc;
    528528}
     
    537537  if (config->verbose)
    538538    printf ("rtems-rfs: format: %s\n", name);
    539  
     539
    540540  memset (&fs, 0, sizeof (rtems_rfs_file_system));
    541541
     
    551551
    552552  fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
    553  
     553
    554554  /*
    555555   * Open the buffer interface.
     
    572572    return -1;
    573573  }
    574  
     574
    575575  /*
    576576   * Check the configuration data.
     
    612612    return -1;
    613613  }
    614  
     614
    615615  if (!rtems_rfs_write_superblock (&fs))
    616616  {
     
    626626  if (config->verbose)
    627627    printf ("\n");
    628  
     628
    629629  rc = rtems_rfs_buffer_close (&fs);
    630630  if (rc > 0)
     
    642642    return -1;
    643643  }
    644  
     644
    645645  return 0;
    646646}
  • cpukit/libfs/src/rfs/rtems-rfs-group.c

    r0527367c r66b8047  
    3636{
    3737  int rc;
    38  
     38
    3939  if (base >= rtems_rfs_fs_blocks (fs))
    4040  {
     
    5656  if (inodes > size)
    5757    inodes = size;
    58  
     58
    5959  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
    6060    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
     
    6363  group->base = base;
    6464  group->size = size;
    65  
    66   rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer); 
     65
     66  rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
    6767  if (rc > 0)
    6868  {
     
    115115    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
    116116  }
    117  
     117
    118118  return 0;
    119119}
     
    145145  if (rc > 0)
    146146    result = rc;
    147  
     147
    148148  return result;
    149149}
     
    169169  else
    170170    size = fs->group_blocks;
    171    
     171
    172172  group_start = goal / size;
    173173  bit = (rtems_rfs_bitmap_bit) (goal % size);
     
    175175  updown = true;
    176176  direction = 1;
    177      
     177
    178178  /*
    179179   * Try the goal group first and if that group fails try the groups either
     
    194194    if (offset)
    195195      bit = direction > 0 ? 0 : size - 1;
    196    
     196
    197197    /*
    198198     * If we are still looking up and down and if the group is out of range we
     
    213213    else
    214214      bitmap = &fs->groups[group].block_bitmap;
    215    
     215
    216216    rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
    217217    if (rc > 0)
    218218      return rc;
    219    
     219
    220220    if (rtems_rfs_fs_release_bitmaps (fs))
    221221      rtems_rfs_bitmap_release_buffer (fs, bitmap);
    222      
     222
    223223    if (allocated)
    224224    {
     
    238238    offset++;
    239239  }
    240  
     240
    241241  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
    242242    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
     
    264264    no -= RTEMS_RFS_ROOT_INO;
    265265    size = fs->group_inodes;
    266   }   
     266  }
    267267  else
    268268  {
     
    270270    size = fs->group_blocks;
    271271  }
    272  
     272
    273273  group = no / size;
    274274  bit = (rtems_rfs_bitmap_bit) (no % size);
    275  
     275
    276276  if (inode)
    277277    bitmap = &fs->groups[group].inode_bitmap;
     
    280280
    281281  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
    282  
     282
    283283  rtems_rfs_bitmap_release_buffer (fs, bitmap);
    284  
     284
    285285  return rc;
    286286}
     
    308308    no -= RTEMS_RFS_ROOT_INO;
    309309    size = fs->group_inodes;
    310   }   
     310  }
    311311  else
    312312  {
     
    315315    size = fs->group_blocks;
    316316  }
    317  
     317
    318318  group = no / size;
    319319  bit = (rtems_rfs_bitmap_bit) (no % size);
    320  
     320
    321321  if (inode)
    322322    bitmap = &fs->groups[group].inode_bitmap;
     
    325325
    326326  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
    327  
     327
    328328  rtems_rfs_bitmap_release_buffer (fs, bitmap);
    329  
     329
    330330  return rc;
    331331}
     
    337337{
    338338  int g;
    339  
     339
    340340  *blocks = 0;
    341341  *inodes = 0;
    342  
     342
    343343  for (g = 0; g < fs->group_count; g++)
    344344  {
     
    356356  if (*inodes > rtems_rfs_fs_inodes (fs))
    357357    *inodes = rtems_rfs_fs_inodes (fs);
    358  
     358
    359359  return 0;
    360360}
  • cpukit/libfs/src/rfs/rtems-rfs-group.h

    r0527367c r66b8047  
    3838 * localise access to files and directories.
    3939 */
    40 typedef struct _rtems_rfs_group 
     40typedef struct _rtems_rfs_group
    4141{
    4242  /**
  • cpukit/libfs/src/rfs/rtems-rfs-inode.c

    r0527367c r66b8047  
    6161  int index;
    6262  int rc;
    63  
     63
    6464  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
    6565    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
     
    6767  if (ino == RTEMS_RFS_EMPTY_INO)
    6868    return EINVAL;
    69  
     69
    7070  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
    7171    return EINVAL;
    72  
     72
    7373  handle->ino = ino;
    7474  handle->node = NULL;
    7575  handle->loads = 0;
    76  
     76
    7777  gino  = ino - RTEMS_RFS_ROOT_INO;
    7878  group = gino / fs->group_inodes;
     
    107107    rc = EIO;
    108108  }
    109  
     109
    110110  handle->ino = 0;
    111111  return rc;
     
    128128  {
    129129    int rc;
    130    
     130
    131131    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
    132132                                          handle->block, true);
     
    139139
    140140  handle->loads++;
    141  
     141
    142142  return 0;
    143143}
     
    149149{
    150150  int rc = 0;
    151  
     151
    152152  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
    153153    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
    154154            handle->ino, handle->loads,
    155155            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
    156  
     156
    157157  if (rtems_rfs_inode_is_loaded (handle))
    158158  {
     
    161161
    162162    handle->loads--;
    163    
     163
    164164    if (handle->loads == 0)
    165165    {
     
    173173    }
    174174  }
    175  
     175
    176176  return rc;
    177177}
     
    191191  rtems_rfs_inode_handle inode;
    192192  int                    rc;
    193  
     193
    194194  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
    195195  {
     
    226226      return EINVAL;
    227227  }
    228  
     228
    229229  rc = rtems_rfs_inode_alloc (fs, parent, ino);
    230230  if (rc > 0)
     
    237237    return rc;
    238238  }
    239  
     239
    240240  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
    241241  if (rc > 0)
     
    288288    rtems_rfs_inode_set_links (&parent_inode,
    289289                               rtems_rfs_inode_get_links (&parent_inode) + 1);
    290  
     290
    291291  rc = rtems_rfs_inode_close (fs, &parent_inode);
    292292  if (rc > 0)
     
    303303    return rc;
    304304  }
    305  
     305
    306306  return 0;
    307307}
     
    312312{
    313313  int rc = 0;
    314  
     314
    315315  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
    316316    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
     
    328328    if (rc > 0)
    329329      return rc;
    330    
     330
    331331    /*
    332332     * Free the blocks the inode may have attached.
     
    378378int
    379379rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
    380                                 bool                    atime, 
     380                                bool                    atime,
    381381                                bool                    mtime)
    382382{
  • cpukit/libfs/src/rfs/rtems-rfs-inode.h

    r0527367c r66b8047  
    582582 * @return int The error number (errno). No error if 0.
    583583 */
    584 int rtems_rfs_inode_open (rtems_rfs_file_system*  fs, 
     584int rtems_rfs_inode_open (rtems_rfs_file_system*  fs,
    585585                          rtems_rfs_ino           ino,
    586586                          rtems_rfs_inode_handle* handle,
     
    676676 */
    677677int rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
    678                                     bool                    atime, 
     678                                    bool                    atime,
    679679                                    bool                    mtime);
    680680
  • cpukit/libfs/src/rfs/rtems-rfs-link.c

    r0527367c r66b8047  
    6868    return ENOTSUP;
    6969  }
    70  
     70
    7171  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
    7272  if (rc)
     
    8383    return rc;
    8484  }
    85  
     85
    8686  links = rtems_rfs_inode_get_links (&target_inode) + 1;
    8787  rtems_rfs_inode_set_links (&target_inode, links);
     
    126126  if (rc)
    127127    return rc;
    128  
     128
    129129  /*
    130130   * If a directory process the unlink mode.
    131131   */
    132  
    133   dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)); 
     132
     133  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
    134134  if (dir)
    135135  {
     
    157157    }
    158158  }
    159  
     159
    160160  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
    161161  if (rc)
     
    167167    return rc;
    168168  }
    169  
     169
    170170  rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
    171171  if (rc > 0)
     
    178178    return rc;
    179179  }
    180  
     180
    181181  links = rtems_rfs_inode_get_links (&target_inode);
    182182
     
    213213    }
    214214  }
    215  
     215
    216216  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
    217217  if (rc > 0)
     
    240240    printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
    241241            rc, strerror (rc));
    242  
     242
    243243  return rc;
    244244}
     
    257257  rtems_rfs_ino          ino;
    258258  int                    rc;
    259  
     259
    260260  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
    261261  {
     
    271271  if (link_length >= rtems_rfs_fs_block_size (fs))
    272272    return ENAMETOOLONG;
    273  
     273
    274274  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
    275275                               RTEMS_RFS_S_SYMLINK,
     
    277277  if (rc > 0)
    278278    return rc;
    279  
     279
    280280  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    281281  if (rc > 0)
     
    299299    rtems_rfs_buffer_handle buffer;
    300300    uint8_t*                data;
    301    
     301
    302302    rc = rtems_rfs_block_map_open (fs, &inode, &map);
    303303    if (rc > 0)
     
    332332
    333333    data = rtems_rfs_buffer_data (&buffer);
    334    
     334
    335335    memset (data, 0xff, rtems_rfs_fs_block_size (fs));
    336336    memcpy (data, link, link_length);
     
    351351    }
    352352  }
    353  
     353
    354354  rtems_rfs_inode_set_block_offset (&inode, link_length);
    355355
    356356  rc = rtems_rfs_inode_close (fs, &inode);
    357  
     357
    358358  return rc;
    359359}
     
    368368  rtems_rfs_inode_handle inode;
    369369  int                    rc;
    370  
     370
    371371  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
    372372    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
     
    383383
    384384  *length = rtems_rfs_inode_get_block_offset (&inode);
    385  
     385
    386386  if (size < *length)
    387387  {
     
    389389    return EINVAL;
    390390  }
    391      
     391
    392392  if (rtems_rfs_inode_get_block_count (&inode) == 0)
    393393  {
     
    400400    rtems_rfs_buffer_handle buffer;
    401401    char*                   data;
    402    
     402
    403403    rc = rtems_rfs_block_map_open (fs, &inode, &map);
    404404    if (rc > 0)
     
    454454
    455455  rc = rtems_rfs_inode_close (fs, &inode);
    456  
     456
    457457  return rc;
    458458}
  • cpukit/libfs/src/rfs/rtems-rfs-mutex.c

    r0527367c r66b8047  
    4747  {
    4848    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
    49       printf ("rtems-rfs: mutex: open failed: %s\n", 
     49      printf ("rtems-rfs: mutex: open failed: %s\n",
    5050              rtems_status_text (sc));
    5151    return EIO;
     
    6464  {
    6565    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
    66       printf ("rtems-rfs: mutex: close failed: %s\n", 
     66      printf ("rtems-rfs: mutex: close failed: %s\n",
    6767              rtems_status_text (sc));
    6868    return EIO;
  • cpukit/libfs/src/rfs/rtems-rfs-mutex.h

    r0527367c r66b8047  
    7272#if RTEMS_RFS_TRACE
    7373    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
    74       printf ("rtems-rfs: mutex: obtain failed: %s\n", 
     74      printf ("rtems-rfs: mutex: obtain failed: %s\n",
    7575              rtems_status_text (sc));
    7676#endif
     
    9797#if RTEMS_RFS_TRACE
    9898    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
    99       printf ("rtems-rfs: mutex: release failed: %s\n", 
     99      printf ("rtems-rfs: mutex: release failed: %s\n",
    100100              rtems_status_text (sc));
    101101#endif
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c

    r0527367c r66b8047  
    5454  rtems_status_code             status;
    5555  int                           rc;
    56  
     56
    5757  rtems_rfs_rtems_lock (fs);
    58  
     58
    5959  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    6060  if (rc > 0)
     
    7575
    7676  rtems_rfs_rtems_unlock (fs);
    77  
     77
    7878  iop->data0 = major;
    7979  iop->data1 = (void*)((intptr_t) minor);
    80  
     80
    8181  args.iop   = iop;
    8282  args.flags = iop->flags;
     
    155155 * @param buffer
    156156 * @param count
    157  * @return ssize_t 
     157 * @return ssize_t
    158158 */
    159159
     
    225225 * @param offset
    226226 * @param whence
    227  * @return off_t       
    228  */
    229 
    230 static off_t       
     227 * @return off_t
     228 */
     229
     230static off_t
    231231rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
    232232                              off_t          offset,
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c

    r0527367c r66b8047  
    5656
    5757  rtems_rfs_rtems_lock (fs);
    58  
     58
    5959  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    6060  if (rc)
     
    6363    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
    6464  }
    65  
     65
    6666  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
    6767  {
     
    7070    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
    7171  }
    72    
     72
    7373  iop->offset = 0;
    7474
     
    121121  count  = count / sizeof (struct dirent);
    122122  dirent = buffer;
    123  
     123
    124124  rtems_rfs_rtems_lock (fs);
    125  
     125
    126126  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    127127  if (rc)
     
    132132
    133133  bytes_transferred = 0;
    134  
     134
    135135  for (d = 0; d < count; d++, dirent++)
    136136  {
     
    153153  rtems_rfs_inode_close (fs, &inode);
    154154  rtems_rfs_rtems_unlock (fs);
    155  
     155
    156156  return bytes_transferred;
    157157}
     
    172172 * @param offset
    173173 * @param whence
    174  * return off_t       
    175  */
    176 static off_t       
     174 * return off_t
     175 */
     176static off_t
    177177rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
    178178                           off_t          offset,
     
    212212
    213213  rtems_rfs_rtems_lock (fs);
    214  
     214
    215215  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
    216216  if (rc)
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c

    r0527367c r66b8047  
    6666
    6767  rtems_rfs_rtems_lock (fs);
    68  
     68
    6969  ino = rtems_rfs_rtems_get_iop_ino (iop);
    70  
     70
    7171  rc = rtems_rfs_file_open (fs, ino, flags, &file);
    7272  if (rc > 0)
     
    7878  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
    7979    printf("rtems-rfs: file-open: handle:%p\n", file);
    80  
     80
    8181  iop->size = rtems_rfs_file_size (file);
    8282  rtems_rfs_rtems_set_iop_file_handle (iop, file);
    83  
     83
    8484  rtems_rfs_rtems_unlock (fs);
    8585  return 0;
     
    104104
    105105  rtems_rfs_rtems_lock (fs);
    106  
     106
    107107  rc = rtems_rfs_file_close (fs, file);
    108108  if (rc > 0)
    109109    rc = rtems_rfs_rtems_error ("file-close: file close", rc);
    110  
     110
    111111  rtems_rfs_rtems_unlock (fs);
    112112  return rc;
     
    138138
    139139  pos = iop->offset;
    140  
     140
    141141  if (pos < rtems_rfs_file_size (file))
    142142  {
     
    154154      if (size == 0)
    155155        break;
    156    
     156
    157157      if (size > count)
    158158        size = count;
    159    
     159
    160160      memcpy (data, rtems_rfs_file_data (file), size);
    161161
     
    172172    }
    173173  }
    174  
     174
    175175  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
    176  
     176
    177177  return read;
    178178}
     
    203203
    204204  pos = iop->offset;
    205  
     205
    206206  /*
    207207   * If the iop position is past the physical end of the file we need to set
     
    211211   * more.
    212212   */
    213  
     213
    214214  if (pos >= rtems_rfs_file_size (file))
    215215  {
     
    221221    }
    222222  }
    223  
     223
    224224  rtems_rfs_file_set_bpos (file, pos);
    225  
     225
    226226  while (count)
    227227  {
    228228    size_t size = count;
    229    
     229
    230230    rc = rtems_rfs_file_io_start (file, &size, false);
    231231    if (rc)
     
    234234      break;
    235235    }
    236    
     236
    237237    if (size > count)
    238238      size = count;
     
    243243    count -= size;
    244244    write  += size;
    245    
     245
    246246    rc = rtems_rfs_file_io_end (file, size, false);
    247247    if (rc)
     
    251251    }
    252252  }
    253  
     253
    254254  iop->size = rtems_rfs_file_size (file);
    255  
     255
    256256  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
    257  
     257
    258258  return write;
    259259}
     
    281281 * @param offset
    282282 * @param whence
    283  * @return off_t       
    284  */
    285 static off_t       
     283 * @return off_t
     284 */
     285static off_t
    286286rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
    287287                            off_t          offset,
     
    296296
    297297  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    298  
     298
    299299  pos = iop->offset;
    300  
     300
    301301  rc = rtems_rfs_file_seek (file, pos, &pos);
    302302  if (rc)
     
    305305    return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
    306306  }
    307  
     307
    308308  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
    309  
     309
    310310  return iop->offset;
    311311}
     
    327327  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
    328328    printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
    329  
     329
    330330  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
    331  
     331
    332332  rc = rtems_rfs_file_set_size (file, length);
    333333  if (rc)
     
    335335
    336336  iop->size = rtems_rfs_file_size (file);
    337  
     337
    338338  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
    339339
  • cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c

    r0527367c r66b8047  
    3939  gid = rtems_rfs_inode_get_gid (inode);
    4040  mode = rtems_rfs_inode_get_mode (inode);
    41  
     41
    4242#if defined (RTEMS_POSIX_API)
    4343  st_uid = geteuid ();
     
    4747  st_gid = gid;
    4848#endif
    49  
     49
    5050  /*
    5151   * Check if I am owner or a group member or someone else.
     
    6666            flags, flags_to_test, mode & 0777,
    6767            flags_to_test & (mode & 0777));
    68  
     68
    6969  /*
    7070   * If all of the flags are set we have permission
     
    167167  const char* table[] =
    168168  {
    169     "error-msgs",   
     169    "error-msgs",
    170170    "eval-path"
    171171    "eval-for-make",
     
    191191  int  arg;
    192192  int  t;
    193  
     193
    194194  for (arg = 1; arg < argc; arg++)
    195195  {
     
    231231        }
    232232      }
    233      
     233
    234234      if (set)
    235235        rtems_rfs_rtems_trace_mask |= value;
  • cpukit/libfs/src/rfs/rtems-rfs-rtems.c

    r0527367c r66b8047  
    8484    printf ("rtems-rfs-rtems: eval-path: in: path:%s pathlen:%zi ino:%" PRId32 "\n",
    8585            path, pathlen, ino);
    86  
     86
    8787  /*
    8888   * Eat any separators at the start of the path.
     
    9393
    9494  rtems_rfs_rtems_lock (fs);
    95  
     95
    9696  while (true)
    9797  {
     
    105105      return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
    106106    }
    107    
     107
    108108    /*
    109109     * Is this the end of the pathname we were given ?
     
    122122      return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
    123123    }
    124    
     124
    125125    /*
    126126     * Extract the node name we will look for this time around.
     
    211211        rtems_rfs_rtems_unlock (fs);
    212212        return ((errno = rc) == 0) ? 0 : -1;
    213       }   
     213      }
    214214      if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
    215215        printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
     
    222222      rtems_rfs_rtems_unlock (fs);
    223223      return rtems_rfs_rtems_error ("eval_path: closing node", rc);
    224     }   
    225   }
    226  
     224    }
     225  }
     226
    227227  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
    228228  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
    229229
    230230  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
    231  
     231
    232232  rtems_rfs_inode_close (fs, &inode);
    233233  rtems_rfs_rtems_unlock (fs);
     
    267267  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
    268268    printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
    269  
     269
    270270  *name = path + strlen (path);
    271271
     
    279279    }
    280280  }
    281      
     281
    282282  /*
    283283   * Eat any separators at start of the path.
     
    287287
    288288  rtems_rfs_rtems_lock (fs);
    289  
     289
    290290  while (true)
    291291  {
     
    299299      return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
    300300    }
    301  
     301
    302302    /*
    303303     * If a directory the execute bit must be set for us to enter.
     
    310310      return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
    311311    }
    312    
     312
    313313    /*
    314314     * Is this the end of the pathname we were given ?
     
    316316    if (path == *name)
    317317      break;
    318    
     318
    319319    /*
    320320     * Extract the node name we will look for this time around.
     
    350350      break;
    351351    }
    352      
     352
    353353    /*
    354354     * If the node is a parent we must move up one directory. If the location
     
    384384        return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
    385385      }
    386      
     386
    387387      /*
    388388       * We need to find the parent of this node.
     
    423423      rtems_rfs_rtems_unlock (fs);
    424424      return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
    425     }   
     425    }
    426426  }
    427427
     
    439439    return rtems_rfs_rtems_error ("eval_for_make: cannot write", EACCES);
    440440  }
    441  
     441
    442442  /*
    443443   * Make sure the name does not already exists in the directory.
     
    458458    return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
    459459  }
    460  
     460
    461461  /*
    462462   * Set the parent ino in the path location.
     
    474474  rtems_rfs_inode_close (fs, &inode);
    475475  rtems_rfs_rtems_unlock (fs);
    476  
     476
    477477  return rc;
    478478}
     
    500500    printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
    501501            parent, target);
    502  
     502
    503503  rtems_rfs_rtems_lock (fs);
    504  
     504
    505505  rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
    506506  if (rc)
     
    511511
    512512  rtems_rfs_rtems_unlock (fs);
    513  
     513
    514514        return 0;
    515515}
     
    534534
    535535  rtems_rfs_rtems_lock (fs);
    536  
     536
    537537  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
    538538    printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
    539539           parent, doff, ino);
    540  
     540
    541541  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
    542542  if (rc)
     
    545545    return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
    546546  }
    547  
    548   rtems_rfs_rtems_unlock (fs);
    549  
     547
     548  rtems_rfs_rtems_unlock (fs);
     549
    550550  return 0;
    551551}
     
    577577    return rtems_rfs_rtems_error ("node_type: opening inode", rc);
    578578  }
    579  
     579
    580580  /*
    581581   * Do not return RTEMS_FILESYSTEM_HARD_LINK because this would result in an
     
    602602    return rtems_rfs_rtems_error ("node_type: closing inode", rc);
    603603  }
    604  
    605   rtems_rfs_rtems_unlock (fs);
    606  
     604
     605  rtems_rfs_rtems_unlock (fs);
     606
    607607  return type;
    608608}
     
    630630#endif
    631631  int                    rc;
    632  
     632
    633633  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
    634634    printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
    635635            ino, owner, group);
    636  
     636
    637637  rtems_rfs_rtems_lock (fs);
    638  
     638
    639639  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    640640  if (rc > 0)
     
    643643    return rtems_rfs_rtems_error ("chown: opening inode", rc);
    644644  }
    645  
     645
    646646  /*
    647647   *  Verify I am the owner of the node or the super user.
     
    669669
    670670  rtems_rfs_rtems_unlock (fs);
    671  
     671
    672672  return 0;
    673673}
     
    694694
    695695  rtems_rfs_rtems_lock (fs);
    696  
     696
    697697  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    698698  if (rc)
     
    711711    return rtems_rfs_rtems_error ("utime: closing inode", rc);
    712712  }
    713  
    714   rtems_rfs_rtems_unlock (fs);
    715  
     713
     714  rtems_rfs_rtems_unlock (fs);
     715
    716716  return 0;
    717717}
     
    747747
    748748  rtems_rfs_rtems_lock (fs);
    749  
     749
    750750  rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
    751751                          link_name, strlen (link_name),
     
    756756    return rtems_rfs_rtems_error ("symlink: linking", rc);
    757757  }
    758  
    759   rtems_rfs_rtems_unlock (fs);
    760  
     758
     759  rtems_rfs_rtems_unlock (fs);
     760
    761761  return 0;
    762762}
     
    780780  size_t                  length;
    781781  int                     rc;
    782  
     782
    783783  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
    784784    printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
    785  
     785
    786786  rtems_rfs_rtems_lock (fs);
    787  
     787
    788788  rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
    789789  if (rc)
     
    814814    printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
    815815            ino, mode);
    816  
     816
    817817  rtems_rfs_rtems_lock (fs);
    818  
     818
    819819  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    820820  if (rc)
     
    825825
    826826  imode = rtems_rfs_inode_get_mode (&inode);
    827  
     827
    828828  /*
    829829   *  Verify I am the owner of the node or the super user.
     
    844844
    845845  rtems_rfs_inode_set_mode (&inode, imode);
    846  
     846
    847847  rc = rtems_rfs_inode_close (fs, &inode);
    848848  if (rc > 0)
     
    851851    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
    852852  }
    853  
    854   rtems_rfs_rtems_unlock (fs);
    855  
     853
     854  rtems_rfs_rtems_unlock (fs);
     855
    856856  return 0;
    857857}
     
    872872
    873873  rtems_rfs_rtems_lock (fs);
    874  
     874
    875875  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
    876876  if (rc)
     
    881881
    882882  mode = rtems_rfs_inode_get_mode (&inode);
    883  
     883
    884884  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
    885885  {
    886     buf->st_rdev = 
     886    buf->st_rdev =
    887887      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
    888888                                   rtems_rfs_inode_get_block (&inode, 1));
    889889  }
    890  
     890
    891891  buf->st_dev     = rtems_rfs_fs_device (fs);
    892892  buf->st_ino     = rtems_rfs_inode_ino (&inode);
     
    926926      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
    927927  }
    928  
     928
    929929  buf->st_blksize = rtems_rfs_fs_block_size (fs);
    930  
     930
    931931  rc = rtems_rfs_inode_close (fs, &inode);
    932932  if (rc > 0)
     
    935935    return rtems_rfs_rtems_error ("stat: closing inode", rc);
    936936  }
    937  
     937
    938938  rtems_rfs_rtems_unlock (fs);
    939939  return 0;
     
    973973
    974974  rtems_rfs_rtems_lock (fs);
    975  
     975
    976976  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
    977977                               rtems_rfs_rtems_imode (mode),
     
    989989    return rtems_rfs_rtems_error ("mknod: inode open", rc);
    990990  }
    991    
     991
    992992  if (S_ISDIR(mode) || S_ISREG(mode))
    993993  {
     
    10011001    rtems_rfs_inode_set_block (&inode, 1, minor);
    10021002  }
    1003   else 
     1003  else
    10041004  {
    10051005    rtems_rfs_inode_close (fs, &inode);
     
    10141014    return rtems_rfs_rtems_error ("mknod: closing inode", rc);
    10151015  }
    1016  
     1016
    10171017  rtems_rfs_rtems_unlock (fs);
    10181018  return 0;
     
    10241024 * @param parent_pathloc
    10251025 * @param pathloc
    1026  * @return int 
     1026 * @return int
    10271027 */
    10281028int
     
    10411041
    10421042  rtems_rfs_rtems_lock (fs);
    1043  
     1043
    10441044  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
    10451045  if (rc)
     
    10581058 *
    10591059 * @param iop
    1060  * @return int 
     1060 * @return int
    10611061 */
    10621062int
     
    10641064{
    10651065  int rc;
    1066  
     1066
    10671067  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
    10681068  if (rc)
     
    10791079 * @param new_parent_loc The new name's parent location.
    10801080 * @param new_name The new name.
    1081  * @return int 
     1081 * @return int
    10821082 */
    10831083static int
     
    10931093  uint32_t                doff;
    10941094  int                     rc;
    1095  
     1095
    10961096  old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
    10971097  new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
     
    11161116    return rtems_rfs_rtems_error ("rename: linking", rc);
    11171117  }
    1118  
     1118
    11191119  /*
    11201120   * Unlink all inodes even directories with the dir option as false because a
     
    11501150
    11511151  rtems_rfs_group_usage (fs, &blocks, &inodes);
    1152  
     1152
    11531153  sb->f_bsize   = rtems_rfs_fs_block_size (fs);
    11541154  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);
     
    11621162  sb->f_flag    = rtems_rfs_fs_flags (fs);
    11631163  sb->f_namemax = rtems_rfs_fs_max_name (fs);
    1164  
     1164
    11651165  return 0;
    11661166}
     
    12631263    }
    12641264  }
    1265  
     1265
    12661266  rtems = malloc (sizeof (rtems_rfs_rtems_private));
    12671267  if (!rtems)
     
    12691269
    12701270  memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
    1271  
     1271
    12721272  rc = rtems_rfs_mutex_create (&rtems->access);
    12731273  if (rc > 0)
     
    12841284    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
    12851285  }
    1286  
     1286
    12871287  rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
    12881288  if (rc)
     
    12911291    return rtems_rfs_rtems_error ("initialise: open", rc);
    12921292  }
    1293  
     1293
    12941294  mt_entry->fs_info = fs;
    12951295
     
    12991299
    13001300  rtems_rfs_rtems_unlock (fs);
    1301  
     1301
    13021302  return 0;
    13031303}
     
    13141314
    13151315  rtems = rtems_rfs_fs_user (fs);
    1316  
     1316
    13171317  rc = rtems_rfs_fs_close(fs);
    1318  
     1318
    13191319  rtems_rfs_mutex_destroy (&rtems->access);
    13201320  free (rtems);
    1321  
     1321
    13221322  return rtems_rfs_rtems_error ("shutdown: close", rc);
    13231323}
  • cpukit/libfs/src/rfs/rtems-rfs-shell.c

    r0527367c r66b8047  
    5959#if __rtems__
    6060  rtems_rfs_rtems_lock (fs);
    61 #endif 
     61#endif
    6262}
    6363
     
    7070#if __rtems__
    7171  rtems_rfs_rtems_unlock (fs);
    72 #endif 
     72#endif
    7373}
    7474
     
    109109  }
    110110#endif
    111  
     111
    112112  return rc;
    113113}
     
    146146
    147147  rtems_rfs_group_usage (fs, &blocks, &inodes);
    148  
     148
    149149  rtems_rfs_shell_unlock_rfs (fs);
    150150
    151151  bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
    152152  ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
    153  
     153
    154154  printf ("       blocks used: %zd (%d.%d%%)\n",
    155155          blocks, bpcent / 10, bpcent % 10);
    156156  printf ("       inodes used: %zd (%d.%d%%)\n",
    157157          inodes, ipcent / 10, ipcent % 10);
    158  
     158
    159159  return 0;
    160160}
     
    169169  int                     b;
    170170  int                     rc;
    171  
     171
    172172  if (argc <= 1)
    173173  {
     
    179179
    180180  rtems_rfs_shell_lock_rfs (fs);
    181  
     181
    182182  rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
    183183  if (rc > 0)
     
    190190
    191191  printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
    192    
     192
    193193  rc = rtems_rfs_buffer_handle_open (fs, &buffer);
    194194  if (rc > 0)
     
    227227
    228228  printf ("\n");
    229  
     229
    230230  rc = rtems_rfs_buffer_handle_close (fs, &buffer);
    231231  if (rc > 0)
     
    236236    return 1;
    237237  }
    238  
     238
    239239  rtems_rfs_shell_unlock_rfs (fs);
    240  
     240
    241241  return 0;
    242242}
     
    310310
    311311  rtems_rfs_shell_lock_rfs (fs);
    312  
     312
    313313  for (ino = start; ino <= end; ino++)
    314314  {
     
    340340
    341341      error = false;
    342      
     342
    343343      mode = rtems_rfs_inode_get_mode (&inode);
    344344
     
    373373                inode.offset * RTEMS_RFS_INODE_SIZE,
    374374                allocated ? 'A' : 'F');
    375    
     375
    376376        if (!allocated && !forced)
    377377          printf (" --\n");
    378378        else
    379         {     
     379        {
    380380          const char* type;
    381381          type = "UKN";
     
    400400        }
    401401      }
    402      
     402
    403403      rc = rtems_rfs_inode_close (fs, &inode);
    404404      if (rc > 0)
     
    411411    }
    412412  }
    413  
     413
    414414  rtems_rfs_shell_unlock_rfs (fs);
    415  
     415
    416416  return 0;
    417417}
     
    427427  int                     b;
    428428  int                     rc;
    429  
     429
    430430  if (argc <= 1)
    431431  {
     
    437437
    438438  rtems_rfs_shell_lock_rfs (fs);
    439  
     439
    440440  rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
    441441  if (rc > 0)
     
    471471  entry = 1;
    472472  data = rtems_rfs_buffer_data (&buffer);
    473  
     473
    474474  while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
    475475  {
     
    481481    eino    = rtems_rfs_dir_entry_ino (data);
    482482    elength = rtems_rfs_dir_entry_length (data);
    483    
     483
    484484    if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
    485485      break;
     
    491491      break;
    492492    }
    493    
     493
    494494    if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
    495495    {
     
    497497      break;
    498498    }
    499    
     499
    500500    length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
    501    
     501
    502502    printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
    503503            entry, b,
     
    508508    if (length > 50)
    509509      length = 50;
    510    
     510
    511511    for (c = 0; c < length; c++)
    512512      printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
     
    519519    entry++;
    520520  }
    521  
     521
    522522  rc = rtems_rfs_buffer_handle_close (fs, &buffer);
    523523  if (rc > 0)
     
    528528    return 1;
    529529  }
    530  
     530
    531531  rtems_rfs_shell_unlock_rfs (fs);
    532  
     532
    533533  return 0;
    534534}
     
    566566    return 1;
    567567  }
    568  
     568
    569569  rtems_rfs_shell_lock_rfs (fs);
    570570
     
    581581            inodes, (inodes * 100) / fs->group_inodes);
    582582  }
    583  
     583
    584584  rtems_rfs_shell_unlock_rfs (fs);
    585  
     585
    586586  return 0;
    587587}
     
    619619  int arg;
    620620  int t;
    621  
     621
    622622  for (arg = 1; arg < argc; arg++)
    623623  {
     
    654654    }
    655655  }
    656  
     656
    657657  return 1;
    658658}
     
    676676          config.verbose = true;
    677677          break;
    678          
     678
    679679        case 's':
    680680          arg++;
     
    686686          config.block_size = strtoul (argv[arg], 0, 0);
    687687          break;
    688        
     688
    689689        case 'b':
    690690          arg++;
     
    696696          config.group_blocks = strtoul (argv[arg], 0, 0);
    697697          break;
    698          
     698
    699699        case 'i':
    700700          arg++;
     
    710710          config.initialise_inodes = true;
    711711          break;
    712          
     712
    713713        case 'o':
    714714          arg++;
     
    720720          config.inode_overhead = strtoul (argv[arg], 0, 0);
    721721          break;
    722          
     722
    723723        default:
    724724          printf ("error: invalid option: %s\n", argv[arg]);
     
    749749    return 1;
    750750  }
    751  
     751
    752752  return 0;
    753753}
  • cpukit/libfs/src/rfs/rtems-rfs-trace.c

    r0527367c r66b8047  
    101101  int                  arg;
    102102  int                  t;
    103  
     103
    104104  for (arg = 1; arg < argc; arg++)
    105105  {
Note: See TracChangeset for help on using the changeset viewer.