source: rtems/cpukit/libfs/src/rfs/rtems-rfs-file-system.c @ f25425b1

4.115
Last change on this file since f25425b1 was f25425b1, checked in by Ralf Corsepius <ralf.corsepius@…>, on Oct 17, 2011 at 1:59:26 PM

2011-10-17 Ralf Corsépius <ralf.corsepius@…>

  • libfs/src/rfs/rtems-rfs-file-system.c (rtems_rfs_fs_open): Comment out unused vars "group", "group_base".
  • Property mode set to 100644
File size: 8.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 Open
16 *
17 * Open the file system by reading the superblock and then the group data.
18 */
19
20#if HAVE_CONFIG_H
21#include "config.h"
22#endif
23
24#include <inttypes.h>
25
26#include <rtems/rfs/rtems-rfs-data.h>
27#include <rtems/rfs/rtems-rfs-file-system.h>
28#include <rtems/rfs/rtems-rfs-inode.h>
29#include <rtems/rfs/rtems-rfs-trace.h>
30
31uint64_t
32rtems_rfs_fs_size (rtems_rfs_file_system* fs)
33{
34  uint64_t blocks = rtems_rfs_fs_blocks (fs);
35  uint64_t block_size = rtems_rfs_fs_block_size (fs);
36  return blocks * block_size;
37}
38
39uint64_t
40rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
41{
42  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
43  uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
44  return media_blocks * media_block_size;
45}
46
47static int
48rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
49{
50  rtems_rfs_buffer_handle handle;
51  uint8_t*                sb;
52  int                     group;
53  int                     rc;
54
55  rc = rtems_rfs_buffer_handle_open (fs, &handle);
56  if (rc > 0)
57  {
58    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
59      printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
60              rc, strerror (rc));
61    return rc;
62  }
63
64  rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
65  if (rc > 0)
66  {
67    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
68      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
69              rc, strerror (rc));
70    return rc;
71  }
72
73  sb = rtems_rfs_buffer_data (&handle);
74 
75#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
76 
77  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
78  {
79    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
80      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
81    rtems_rfs_buffer_handle_close (fs, &handle);
82    return EIO;
83  }
84
85  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
86  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
87
88  if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
89  {
90    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
91      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
92    rtems_rfs_buffer_handle_close (fs, &handle);
93    return EIO;
94  }
95
96  if ((read_sb (RTEMS_RFS_SB_OFFSET_VERSION) & RTEMS_RFS_VERSION_MASK) !=
97      (RTEMS_RFS_VERSION * RTEMS_RFS_VERSION_MASK))
98  {
99    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
100      printf ("rtems-rfs: read-superblock: incompatible version: %08" PRIx32 " (%08" PRIx32 ")\n",
101              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
102    rtems_rfs_buffer_handle_close (fs, &handle);
103    return EIO;
104  }
105     
106  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
107  {
108    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
109      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
110              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
111    rtems_rfs_buffer_handle_close (fs, &handle);
112    return EIO;
113  }
114     
115  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
116  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
117  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
118  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
119  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
120
121  fs->blocks_per_block =
122    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
123 
124  fs->block_map_singly_blocks =
125    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
126  fs->block_map_doubly_blocks =
127    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
128
129  fs->inodes = fs->group_count * fs->group_inodes;
130
131  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
132 
133  if (fs->group_blocks >
134      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
135  {
136    rtems_rfs_buffer_handle_close (fs, &handle);
137    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
138      printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
139    return EIO;
140  }
141
142  rtems_rfs_buffer_handle_close (fs, &handle);
143
144  /*
145   * Change the block size to the value in the superblock.
146   */
147  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
148  if (rc > 0)
149  {
150    rtems_rfs_buffer_handle_close (fs, &handle);
151    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
152      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
153              rc, strerror (rc));
154    return rc;
155  }
156
157  fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
158
159  if (!fs->groups)
160  {
161    rtems_rfs_buffer_handle_close (fs, &handle);
162    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
163      printf ("rtems-rfs: read-superblock: no memory for group table\n");
164    return ENOMEM;
165  }
166
167  /*
168   * Perform each phase of group initialisation at the same time. This way we
169   * know how far the initialisation has gone if an error occurs and we need to
170   * close everything.
171   */
172  for (group = 0; group < fs->group_count; group++)
173  {
174    rc = rtems_rfs_group_open (fs,
175                               rtems_rfs_fs_block (fs, group, 0),
176                               fs->group_blocks,
177                               fs->group_inodes,
178                               &fs->groups[group]);
179    if (rc > 0)
180    {
181      int g;
182      for (g = 0; g < group; g++)
183        rtems_rfs_group_close (fs, &fs->groups[g]);
184      rtems_rfs_buffer_handle_close (fs, &handle);
185      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
186        printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
187                rc, strerror (rc));
188      return rc;
189    }
190  }
191
192  return 0;
193}
194
195int
196rtems_rfs_fs_open (const char*             name,
197                   void*                   user,
198                   uint32_t                flags,
199                   rtems_rfs_file_system** fs)
200{
201#if UNUSED
202  rtems_rfs_group*       group;
203  size_t                 group_base;
204#endif
205  rtems_rfs_inode_handle inode;
206  uint16_t               mode;
207  int                    rc;
208 
209  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
210    printf ("rtems-rfs: open: %s\n", name);
211 
212  *fs = malloc (sizeof (rtems_rfs_file_system));
213  if (!*fs)
214  {
215    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
216      printf ("rtems-rfs: open: no memory for file system data\n");
217    errno = ENOMEM;
218    return -1;
219  }
220
221  memset (*fs, 0, sizeof (rtems_rfs_file_system));
222
223  (*fs)->user = user;
224  rtems_chain_initialize_empty (&(*fs)->buffers);
225  rtems_chain_initialize_empty (&(*fs)->release);
226  rtems_chain_initialize_empty (&(*fs)->release_modified);
227  rtems_chain_initialize_empty (&(*fs)->file_shares);
228
229  (*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
230  (*fs)->buffers_count = 0;
231  (*fs)->release_count = 0;
232  (*fs)->release_modified_count = 0;
233  (*fs)->flags = flags;
234
235#if UNUSED
236  group = &(*fs)->groups[0];
237  group_base = 0;
238#endif
239
240  /*
241   * Open the buffer interface.
242   */
243  rc = rtems_rfs_buffer_open (name, *fs);
244  if (rc > 0)
245  {
246    free (*fs);
247    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
248      printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
249              rc, strerror (rc));
250    errno = rc;
251    return -1;
252  }
253
254  rc = rtems_rfs_fs_read_superblock (*fs);
255  if (rc > 0)
256  {
257    rtems_rfs_buffer_close (*fs);
258    free (*fs);
259    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
260      printf ("rtems-rfs: open: reading superblock: %d: %s\n",
261              rc, strerror (rc));
262    errno = rc;
263    return -1;
264  }
265
266  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
267  if (rc > 0)
268  {
269    rtems_rfs_buffer_close (*fs);
270    free (*fs);
271    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
272      printf ("rtems-rfs: open: reading root inode: %d: %s\n",
273              rc, strerror (rc));
274    errno = rc;
275    return -1;
276  }
277
278  if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
279  {
280    mode = rtems_rfs_inode_get_mode (&inode);
281
282    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
283    {
284      rtems_rfs_inode_close (*fs, &inode);
285      rtems_rfs_buffer_close (*fs);
286      free (*fs);
287      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
288        printf ("rtems-rfs: open: invalid root inode mode\n");
289      errno = EIO;
290      return -1;
291    }
292  }
293 
294  rc = rtems_rfs_inode_close (*fs, &inode);
295  if (rc > 0)
296  {
297    rtems_rfs_buffer_close (*fs);
298    free (*fs);
299    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
300      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
301    errno = rc;
302    return -1;
303  }
304   
305  errno = 0;
306  return 0;
307}
308
309int
310rtems_rfs_fs_close (rtems_rfs_file_system* fs)
311{
312  int group;
313 
314  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
315    printf ("rtems-rfs: close\n");
316
317  for (group = 0; group < fs->group_count; group++)
318    rtems_rfs_group_close (fs, &fs->groups[group]);
319
320  rtems_rfs_buffer_close (fs);
321 
322  free (fs);
323  return 0; 
324}
Note: See TracBrowser for help on using the repository browser.