source: rtems/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c @ 984c4c49

4.11
Last change on this file since 984c4c49 was 984c4c49, checked in by Ralf Corsepius <ralf.corsepius@…>, on Nov 6, 2011 at 12:00:04 PM

2011-11-06 Ralf Corsépius <ralf.corsepius@…>

PR1945/cpukit

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