source: rtems/cpukit/libfs/src/rfs/rtems-rfs-inode.c @ 3cfa636

4.104.11
Last change on this file since 3cfa636 was 3cfa636, checked in by Chris Johns <chrisj@…>, on Feb 26, 2010 at 5:54:59 AM

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

  • libfs/src/rfs/rtems-rfs-block.c: Reset a buffer handle after moving down an indirection level.
  • libfs/src/rfs/rtems-rfs-dir.c: Move directory entry validation into a macro and use the macro. Fix the range check on the ino so all inodes can be used.
  • libfs/src/rfs/rtems-rfs-file-system.c,
libfs/src/rfs/rtems-rfs-file-system.h
Add a version number to the superblock. Use RTEMS_RFS_INODE_SIZE.
  • libfs/src/rfs/rtems-rfs-file.c: Fix the size offset on partial block lengths. Set the size in the file handle on a truncate to 0.
  • libfs/src/rfs/rtems-rfs-format.c: Add a version number to the superblock. Use RTEMS_RFS_INODE_SIZE. A better set of defaults for small disks.
  • libfs/src/rfs/rtems-rfs-inode.c: Use RTEMS_RFS_INODE_SIZE. Free the allocated inode if it cannot be opened.
  • libfs/src/rfs/rtems-rfs-inode.h: Add RTEMS_RFS_INODE_SIZE.
  • libfs/src/rfs/rtems-rfs-rtems-file.c: Move some of the iop acceses inside the fs lock.
  • libfs/src/rfs/rtems-rfs-shell.c: Use RTEMS_RFS_INODE_SIZE.
  • Property mode set to 100644
File size: 9.9 KB
Line 
1/*
2 *  COPYRIGHT (c) 2010 Chris Johns <chrisj@rtems.org>
3 *
4 *  The license and distribution terms for this file may be
5 *  found in the file LICENSE in this distribution or at
6 *  http://www.rtems.com/license/LICENSE.
7 *
8 *  $Id$
9 */
10/**
11 * @file
12 *
13 * @ingroup rtems-rfs
14 *
15 * RTEMS File Systems Inode Routines.
16 *
17 * These functions manage inodes in the RFS file system. An inode is part of a
18 * block that reside after the bitmaps in the group.
19 */
20
21#include <rtems/rfs/rtems-rfs-block.h>
22#include <rtems/rfs/rtems-rfs-file-system.h>
23#include <rtems/rfs/rtems-rfs-inode.h>
24#include <rtems/rfs/rtems-rfs-dir.h>
25
26int
27rtems_rfs_inode_alloc (rtems_rfs_file_system* fs,
28                       rtems_rfs_bitmap_bit   goal,
29                       rtems_rfs_ino*         ino)
30{
31  rtems_rfs_bitmap_bit bit;
32  int                  rc;
33  rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
34  *ino = bit;
35  return rc;
36}
37
38int
39rtems_rfs_inode_free (rtems_rfs_file_system* fs,
40                      rtems_rfs_ino          ino)
41{
42  rtems_rfs_bitmap_bit bit;
43  bit = ino;
44  return rtems_rfs_group_bitmap_free (fs, true, bit);
45}
46
47int
48rtems_rfs_inode_open (rtems_rfs_file_system*  fs,
49                      rtems_rfs_ino           ino,
50                      rtems_rfs_inode_handle* handle,
51                      bool                    load)
52{
53  int group;
54  int gino;
55  int index;
56  int rc;
57 
58  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
59    printf ("rtems-rfs: inode-open: ino: %lu\n", ino);
60
61  if (ino == RTEMS_RFS_EMPTY_INO)
62    return EINVAL;
63 
64  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
65    return EINVAL;
66 
67  handle->ino = ino;
68  handle->node = NULL;
69  handle->loads = 0;
70 
71  gino  = ino - RTEMS_RFS_ROOT_INO;
72  group = gino / fs->group_inodes;
73  gino  = gino % fs->group_inodes;
74  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
75
76  handle->offset = gino % fs->inodes_per_block;
77  handle->block  = rtems_rfs_group_block (&fs->groups[group], index);
78
79  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
80  if ((rc == 0) && load)
81    rc = rtems_rfs_inode_load (fs, handle);
82  return rc;
83}
84
85int
86rtems_rfs_inode_close (rtems_rfs_file_system*  fs,
87                       rtems_rfs_inode_handle* handle)
88{
89  int rc;
90
91  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
92    printf ("rtems-rfs: inode-close: ino: %lu\n", handle->ino);
93
94  rc = rtems_rfs_inode_unload (fs, handle, true);
95
96  if ((rc == 0) && (handle->loads > 0))
97  {
98    if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
99      printf ("rtems-rfs: inode-close: bad loads number: %d\n",
100              handle->loads);
101    rc = EIO;
102  }
103 
104  handle->ino = 0;
105  return rc;
106}
107
108int
109rtems_rfs_inode_load (rtems_rfs_file_system*  fs,
110                      rtems_rfs_inode_handle* handle)
111{
112  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
113    printf ("rtems-rfs: inode-load: ino=%lu loads=%i loaded=%s\n",
114            handle->ino, handle->loads,
115            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
116
117  /*
118   * An inode does not move so once loaded no need to do again.
119   */
120
121  if (!rtems_rfs_inode_is_loaded (handle))
122  {
123    int rc;
124   
125    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
126                                          handle->block, true);
127    if (rc > 0)
128      return rc;
129
130    handle->node = rtems_rfs_buffer_data (&handle->buffer);
131    handle->node += handle->offset;
132  }
133
134  handle->loads++;
135 
136  return 0;
137}
138
139int
140rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,
141                        rtems_rfs_inode_handle* handle,
142                        bool                    update_ctime)
143{
144  int rc = 0;
145 
146  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
147    printf ("rtems-rfs: inode-unload: ino=%lu loads=%i loaded=%s\n",
148            handle->ino, handle->loads,
149            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
150 
151  if (rtems_rfs_inode_is_loaded (handle))
152  {
153    if (handle->loads == 0)
154      return EIO;
155
156    handle->loads--;
157   
158    if (handle->loads == 0)
159    {
160      /*
161       * If the buffer is dirty it will be release. Also set the ctime.
162       */
163      if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
164        rtems_rfs_inode_set_ctime (handle, time (NULL));
165      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
166      handle->node = NULL;
167    }
168  }
169 
170  return rc;
171}
172
173int
174rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
175                        rtems_rfs_ino           parent,
176                        const char*             name,
177                        size_t                  length,
178                        uint16_t                mode,
179                        uint16_t                links,
180                        uid_t                   uid,
181                        gid_t                   gid,
182                        rtems_rfs_ino*          ino)
183{
184  rtems_rfs_inode_handle parent_inode;
185  rtems_rfs_inode_handle inode;
186  int                    rc;
187 
188  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
189  {
190    const char* type = "unknown";
191    int         c;
192    if (RTEMS_RFS_S_ISDIR (mode))
193      type = "dir";
194    else if (RTEMS_RFS_S_ISCHR (mode))
195      type = "char";
196    else if (RTEMS_RFS_S_ISBLK (mode))
197      type = "block";
198    else if (RTEMS_RFS_S_ISREG (mode))
199      type = "file";
200    else if (RTEMS_RFS_S_ISLNK (mode))
201      type = "link";
202    printf("rtems-rfs: inode-create: parent:%lu name:", parent);
203    for (c = 0; c < length; c++)
204      printf ("%c", name[c]);
205    printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
206  }
207
208  rc = rtems_rfs_inode_alloc (fs, parent, ino);
209  if (rc > 0)
210    return rc;
211
212  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
213  if (rc > 0)
214  {
215    rtems_rfs_inode_free (fs, *ino);
216    return rc;
217  }
218 
219  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
220  if (rc > 0)
221  {
222    rtems_rfs_inode_close (fs, &inode);
223    rtems_rfs_inode_free (fs, *ino);
224    return rc;
225  }
226
227  /*
228   * Only handle the specifics of a directory. Let caller handle the others.
229   *
230   * The inode delete will free the inode.
231   */
232  if (RTEMS_RFS_S_ISDIR (mode))
233  {
234    rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
235    if (rc == 0)
236      rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
237    if (rc > 0)
238    {
239      rtems_rfs_inode_delete (fs, &inode);
240      rtems_rfs_inode_close (fs, &inode);
241      return rc;
242    }
243  }
244
245  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
246  if (rc > 0)
247  {
248    rtems_rfs_inode_delete (fs, &inode);
249    rtems_rfs_inode_close (fs, &inode);
250    return rc;
251  }
252
253  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
254  if (rc > 0)
255  {
256    rtems_rfs_inode_delete (fs, &inode);
257    rtems_rfs_inode_close (fs, &inode);
258    rtems_rfs_inode_close (fs, &parent_inode);
259    return rc;
260  }
261
262  /*
263   * If the node is a directory update the parent link count as the
264   * new directory has the '..' link that points to the parent.
265   */
266  if (RTEMS_RFS_S_ISDIR (mode))
267    rtems_rfs_inode_set_links (&parent_inode,
268                               rtems_rfs_inode_get_links (&parent_inode) + 1);
269 
270  rc = rtems_rfs_inode_close (fs, &parent_inode);
271  if (rc > 0)
272  {
273    rtems_rfs_inode_delete (fs, &inode);
274    rtems_rfs_inode_close (fs, &inode);
275    return rc;
276  }
277
278  rc = rtems_rfs_inode_close (fs, &inode);
279  if (rc > 0)
280  {
281    rtems_rfs_inode_free (fs, *ino);
282    return rc;
283  }
284 
285  return 0;
286}
287
288int
289rtems_rfs_inode_delete (rtems_rfs_file_system*  fs,
290                        rtems_rfs_inode_handle* handle)
291{
292  int rc = 0;
293  if (rtems_rfs_inode_is_loaded (handle))
294  {
295    rtems_rfs_block_map map;
296
297    /*
298     * Free the ino number.
299     */
300    rc = rtems_rfs_inode_free (fs, handle->ino);
301    if (rc > 0)
302      return rc;
303   
304    /*
305     * Free the blocks the inode may have attached.
306     */
307    rc = rtems_rfs_block_map_open (fs, handle, &map);
308    if (rc == 0)
309    {
310      int rrc;
311      rrc = rtems_rfs_block_map_free_all (fs, &map);
312      rc = rtems_rfs_block_map_close (fs, &map);
313      if (rc > 0)
314        rrc = rc;
315      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
316      rtems_rfs_buffer_mark_dirty (&handle->buffer);
317      /*
318       * Do the release here to avoid the ctime field being set on a
319       * close. Also if there loads is greater then one then other loads
320       * active. Forcing the loads count to 0.
321       */
322      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
323      handle->loads = 0;
324      handle->node = NULL;
325    }
326  }
327  return rc;
328}
329
330int
331rtems_rfs_inode_initialise (rtems_rfs_inode_handle* handle,
332                            uint16_t                links,
333                            uint16_t                mode,
334                            uid_t                   uid,
335                            gid_t                   gid)
336{
337  int b;
338  rtems_rfs_inode_set_links (handle, links);
339  rtems_rfs_inode_set_flags (handle, 0);
340  rtems_rfs_inode_set_mode (handle,  mode);
341  rtems_rfs_inode_set_uid_gid (handle, uid, gid);
342  rtems_rfs_inode_set_block_offset (handle, 0);
343  rtems_rfs_inode_set_block_count (handle, 0);
344  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
345    rtems_rfs_inode_set_block (handle, b, 0);
346  rtems_rfs_inode_set_last_map_block (handle, 0);
347  rtems_rfs_inode_set_last_data_block (handle, 0);
348  return rtems_rfs_inode_time_stamp_now (handle, true, true);
349}
350
351int
352rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
353                                bool                    atime, 
354                                bool                    mtime)
355{
356  time_t now;
357  if (!rtems_rfs_inode_is_loaded (handle))
358    return ENXIO;
359  now = time (NULL);
360  if (atime)
361    rtems_rfs_inode_set_atime (handle, now);
362  if (mtime)
363    rtems_rfs_inode_set_mtime (handle, now);
364  return 0;
365}
366
367rtems_rfs_pos
368rtems_rfs_inode_get_size (rtems_rfs_file_system*  fs,
369                          rtems_rfs_inode_handle* handle)
370{
371  rtems_rfs_block_size size;
372  size.count = rtems_rfs_inode_get_block_count (handle);
373  size.offset = rtems_rfs_inode_get_block_offset (handle);
374  return rtems_rfs_block_get_size (fs, &size);
375}
Note: See TracBrowser for help on using the repository browser.