source: rtems/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.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: 7.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 RFS File Handlers
16 *
17 * This file contains the set of handlers used to process operations on
18 * RFS file nodes.
19 */
20
21#include <rtems/rfs/rtems-rfs-file.h>
22#include "rtems-rfs-rtems.h"
23
24/**
25 * This routine processes the open() system call.  Note that there is nothing
26 * special to be done at open() time.
27 *
28 * @param iop
29 * @param pathname
30 * @param flag
31 * @param mode
32 * @return int
33 */
34
35static int
36rtems_rfs_rtems_file_open (rtems_libio_t* iop,
37                           const char*    pathname,
38                           uint32_t       flag,
39                           uint32_t       mode)
40{
41  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
42  rtems_rfs_ino          ino;
43  rtems_rfs_file_handle* file;
44  uint32_t               flags;
45  int                    rc;
46
47  flags = 0;
48
49  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
50    printf("rtems-rfs: file-open: path:%s ino:%ld flags:%04lx mode:%04lx\n",
51           pathname, ino, flags, mode);
52
53  rtems_rfs_rtems_lock (fs);
54 
55  ino = rtems_rfs_rtems_get_iop_ino (iop);
56 
57  rc = rtems_rfs_file_open (fs, ino, flags, &file);
58  if (rc > 0)
59  {
60    rtems_rfs_rtems_unlock (fs);
61    return rtems_rfs_rtems_error ("file-open: open", rc);
62  }
63
64  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
65    printf("rtems-rfs: file-open: handle:%p\n", file);
66 
67  iop->file_info = file;
68 
69  rtems_rfs_rtems_unlock (fs);
70  return 0;
71}
72
73/**
74 * This routine processes the close() system call.  Note that there is nothing
75 * to flush at this point.
76 *
77 * @param iop
78 * @return int
79 */
80static int
81rtems_rfs_rtems_file_close (rtems_libio_t* iop)
82{
83  rtems_rfs_file_handle* file = iop->file_info;
84  rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
85  int                    rc;
86
87  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
88    printf("rtems-rfs: file-close: handle:%p\n", file);
89
90  rtems_rfs_rtems_lock (fs);
91 
92  rc = rtems_rfs_file_close (fs, file);
93  if (rc > 0)
94    rc = rtems_rfs_rtems_error ("file-close: file close", rc);
95 
96  rtems_rfs_rtems_unlock (fs);
97  return 0;
98}
99
100/**
101 * This routine processes the read() system call.
102 *
103 * @param iop
104 * @param buffer
105 * @param count
106 * @return int
107 */
108ssize_t
109rtems_rfs_rtems_file_read (rtems_libio_t* iop,
110                           void*          buffer,
111                           size_t         count)
112{
113  rtems_rfs_file_handle* file = iop->file_info;
114  rtems_rfs_pos          pos;
115  uint8_t*               data = buffer;
116  ssize_t                read = 0;
117  int                    rc;
118
119  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
120    printf("rtems-rfs: file-read: handle:%p count:%ld\n", file, count);
121
122  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
123
124  pos = iop->offset;
125 
126  if (pos < rtems_rfs_file_size (file))
127  {
128    while (count)
129    {
130      size_t size;
131
132      rc = rtems_rfs_file_io_start (file, &size, true);
133      if (rc > 0)
134      {
135        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
136        break;
137      }
138
139      if (size == 0)
140        break;
141   
142      if (size > count)
143        size = count;
144   
145      memcpy (data, rtems_rfs_file_data (file), size);
146
147      data  += size;
148      count -= size;
149      read  += size;
150
151      rc = rtems_rfs_file_io_end (file, size, true);
152      if (rc > 0)
153      {
154        read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
155        break;
156      }
157    }
158  }
159 
160  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
161 
162  return read;
163}
164
165/**
166 * This routine processes the write() system call.
167 *
168 * @param iop
169 * @param buffer
170 * @param count
171 * @return ssize_t
172 */
173ssize_t
174rtems_rfs_rtems_file_write (rtems_libio_t* iop,
175                            const void*    buffer,
176                            size_t         count)
177{
178  rtems_rfs_file_handle* file = iop->file_info;
179  rtems_rfs_pos          pos;
180  const uint8_t*         data = buffer;
181  ssize_t                write = 0;
182  int                    rc;
183
184  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
185    printf("rtems-rfs: file-write: handle:%p count:%ld\n", file, count);
186
187  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
188
189  pos = iop->offset;
190 
191  /*
192   * If the iop position is past the physical end of the file we need to set the
193   * file size to the new length before writing.
194   */
195 
196  if (pos > rtems_rfs_file_size (file))
197  {
198    rc = rtems_rfs_file_set_size (file, pos);
199    if (rc)
200      return rtems_rfs_rtems_error ("file-write: write extend", rc);
201    rtems_rfs_file_set_bpos (file, pos);
202  }
203 
204  while (count)
205  {
206    size_t size = count;
207   
208    rc = rtems_rfs_file_io_start (file, &size, false);
209    if (rc)
210    {
211      write = rtems_rfs_rtems_error ("file-write: write open", rc);
212      break;
213    }
214   
215    if (size > count)
216      size = count;
217
218    memcpy (rtems_rfs_file_data (file), data, size);
219
220    data  += size;
221    count -= size;
222    write  += size;
223   
224    rc = rtems_rfs_file_io_end (file, size, false);
225    if (rc)
226    {
227      write = rtems_rfs_rtems_error ("file-write: write close", rc);
228      break;
229    }
230  }
231 
232  iop->size = rtems_rfs_file_size (file);
233 
234  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
235 
236  return write;
237}
238
239/**
240 * This routine processes the ioctl() system call.
241 *
242 * @note  No ioctl()'s are currently supported for RFS files.
243 *
244 * @param iop
245 * @param command
246 * @param buffer
247 */
248
249int
250rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
251{
252  return 0;
253}
254
255/**
256 * This routine processes the lseek() system call.
257 *
258 * @param iop
259 * @param offset
260 * @param whence
261 * @return rtems_off64_t
262 */
263rtems_off64_t
264rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
265                            rtems_off64_t  offset,
266                            int            whence)
267{
268  rtems_rfs_file_handle* file = iop->file_info;
269  rtems_rfs_pos          pos;
270  int                    rc;
271
272  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
273    printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
274
275  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
276 
277  pos = iop->offset;
278 
279  rc = rtems_rfs_file_seek (file, pos, &pos);
280  if (rc)
281  {
282    rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
283    return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
284  }
285 
286  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
287 
288  return iop->offset;
289}
290
291/**
292 * This routine processes the ftruncate() system call.
293 *
294 * @param iop
295 * @param length
296 * @return int
297 */
298int
299rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
300                                rtems_off64_t  length)
301{
302  rtems_rfs_file_handle* file = iop->file_info;
303  int                    rc;
304
305  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
306    printf("rtems-rfs: file-ftrunc: handle:%p length:%Ld\n", file, length);
307 
308  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
309 
310  rc = rtems_rfs_file_set_size (file, length);
311  if (rc)
312    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
313
314  iop->size = rtems_rfs_file_size (file);
315 
316  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
317
318  return rc;
319}
320
321/*
322 *  Set of operations handlers for operations on RFS files.
323 */
324
325const rtems_filesystem_file_handlers_r rtems_rfs_rtems_file_handlers = {
326  .open_h      = rtems_rfs_rtems_file_open,
327  .close_h     = rtems_rfs_rtems_file_close,
328  .read_h      = rtems_rfs_rtems_file_read,
329  .write_h     = rtems_rfs_rtems_file_write,
330  .ioctl_h     = rtems_rfs_rtems_file_ioctl,
331  .lseek_h     = rtems_rfs_rtems_file_lseek,
332  .fstat_h     = rtems_rfs_rtems_stat,
333  .fchmod_h    = rtems_rfs_rtems_fchmod,
334  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,
335  .fpathconf_h = NULL,
336  .fsync_h     = rtems_rfs_rtems_fdatasync,
337  .fdatasync_h = rtems_rfs_rtems_fdatasync,
338  .fcntl_h     = rtems_rfs_rtems_fcntl,
339  .rmnod_h     = rtems_rfs_rtems_rmnod
340};
Note: See TracBrowser for help on using the repository browser.