source: rtems/cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c @ d0fcd0b

4.11
Last change on this file since d0fcd0b was d0fcd0b, checked in by Chris Johns <chrisj@…>, on Mar 15, 2011 at 5:02:34 AM

2011-03-15 Chris Johns <chrisj@…>

PR 1763/shell

  • libmisc/shell/hexdump-conv.c: Remove debug hacks.

PR 1757/filesystem

  • libfs/src/rfs/rtems-rfs-block-pos.h, libfs/src/rfs/rtems-rfs-block.h, libfs/src/rfs/rtems-rfs-file.c, libfs/src/rfs/rtems-rfs-rtems-file.c: Set the file size in iop-size when a file is open. Fix lseek to end of file then write for sizes less than half the file system block size.
  • libfs/src/rfs/rtems-rfs-rtems-dev.c, libfs/src/rfs/rtems-rfs-rtems-dir.c, libfs/src/rfs/rtems-rfs-rtems.c, libfs/src/rfs/rtems-rfs-rtems.h: Fix the fstat and fchmod calls due to the change in the iop struct where pathinfo went away. The node_access field in pathinfo was overloaded.
  • Property mode set to 100644
File size: 6.3 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 Device Interface.
16 *
17 * This file contains the set of handlers used to map operations on RFS device
18 * nodes onto calls to the RTEMS Classic API IO Manager.
19 *
20 */
21
22#if HAVE_CONFIG_H
23#include "config.h"
24#endif
25
26#include "rtems-rfs-rtems.h"
27
28/*
29 * Convert RTEMS status to a UNIX errno
30 */
31extern int rtems_deviceio_errno (rtems_status_code code);
32
33/**
34 * This handler maps an open() operation onto rtems_io_open().
35 *
36 * @param iop
37 * @param pathname
38 * @param flag
39 * @param mode
40 * @return int
41 */
42static int
43rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
44                              const char    *pathname,
45                              uint32_t       flag,
46                              uint32_t       mode)
47{
48  rtems_libio_open_close_args_t args;
49  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
50  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_iop_ino (iop);
51  rtems_rfs_inode_handle        inode;
52  int                           major;
53  int                           minor;
54  rtems_status_code             status;
55  int                           rc;
56 
57  rtems_rfs_rtems_lock (fs);
58 
59  rc = rtems_rfs_inode_open (fs, ino, &inode, true);
60  if (rc > 0)
61  {
62    rtems_rfs_rtems_unlock (fs);
63    return rtems_rfs_rtems_error ("device_open: opening inode", rc);
64  }
65
66  major = rtems_rfs_inode_get_block (&inode, 0);
67  minor = rtems_rfs_inode_get_block (&inode, 1);
68
69  rc = rtems_rfs_inode_close (fs, &inode);
70  if (rc > 0)
71  {
72    rtems_rfs_rtems_unlock (fs);
73    return rtems_rfs_rtems_error ("device_open: closing inode", rc);
74  }
75
76  rtems_rfs_rtems_unlock (fs);
77 
78  iop->data0 = major;
79  iop->data1 = (void*)((intptr_t) minor);
80 
81  args.iop   = iop;
82  args.flags = iop->flags;
83  args.mode  = mode;
84
85  status = rtems_io_open (major, minor, (void *) &args);
86
87  return rtems_deviceio_errno (status);
88}
89
90/**
91 * This handler maps a close() operation onto rtems_io_close().
92 *
93 * @param iop
94 * @return int
95 */
96
97static int
98rtems_rfs_rtems_device_close (rtems_libio_t* iop)
99{
100  rtems_libio_open_close_args_t args;
101  rtems_status_code             status;
102  int                           major;
103  int                           minor;
104
105  major = (int) iop->data0;
106  minor = (intptr_t) iop->data1;
107
108  args.iop   = iop;
109  args.flags = 0;
110  args.mode  = 0;
111
112  status = rtems_io_close (major, minor, (void *) &args);
113
114  return rtems_deviceio_errno (status);
115}
116
117/**
118 * This handler maps a read() operation onto rtems_io_read().
119 *
120 * @param iop
121 * @param buffer
122 * @param count
123 * @return ssize_t
124 */
125
126static ssize_t
127rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
128{
129  rtems_libio_rw_args_t args;
130  rtems_status_code     status;
131  int                   major;
132  int                   minor;
133
134  major = (int) iop->data0;
135  minor = (intptr_t) iop->data1;
136
137  args.iop         = iop;
138  args.offset      = iop->offset;
139  args.buffer      = buffer;
140  args.count       = count;
141  args.flags       = iop->flags;
142  args.bytes_moved = 0;
143
144  status = rtems_io_read (major, minor, (void *) &args);
145  if (status)
146    return rtems_deviceio_errno (status);
147
148  return (ssize_t) args.bytes_moved;
149}
150
151/*
152 * This handler maps a write() operation onto rtems_io_write().
153 *
154 * @param iop
155 * @param buffer
156 * @param count
157 * @return ssize_t
158 */
159
160static ssize_t
161rtems_rfs_rtems_device_write (rtems_libio_t* iop,
162                              const void*    buffer,
163                              size_t         count)
164{
165  rtems_libio_rw_args_t args;
166  rtems_status_code     status;
167  int                   major;
168  int                   minor;
169
170  major = (int) iop->data0;
171  minor = (intptr_t) iop->data1;
172
173  args.iop         = iop;
174  args.offset      = iop->offset;
175  args.buffer      = (void *) buffer;
176  args.count       = count;
177  args.flags       = iop->flags;
178  args.bytes_moved = 0;
179
180  status = rtems_io_write (major, minor, (void *) &args);
181  if (status)
182    return rtems_deviceio_errno (status);
183
184  return (ssize_t) args.bytes_moved;
185}
186
187/**
188 * This handler maps an ioctl() operation onto rtems_io_ioctl().
189 *
190 * @param iop
191 * @param command
192 * @param buffer
193 * @return int
194 */
195
196static int
197rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
198                              uint32_t       command,
199                              void*          buffer)
200{
201  rtems_libio_ioctl_args_t args;
202  rtems_status_code        status;
203  int                      major;
204  int                      minor;
205
206  major = (int) iop->data0;
207  minor = (intptr_t) iop->data1;
208
209  args.iop     = iop;
210  args.command = command;
211  args.buffer  = buffer;
212
213  status = rtems_io_control (major, minor, (void *) &args);
214  if (status)
215    return rtems_deviceio_errno (status);
216
217  return args.ioctl_return;
218}
219
220/**
221 * This handler eats all lseek() operations and does not create an error. It
222 * assumes all devices can handle the seek. The writes fail.
223 *
224 * @param iop
225 * @param offset
226 * @param whence
227 * @return rtems_off64_t
228 */
229
230static rtems_off64_t
231rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
232                              rtems_off64_t  offset,
233                              int            whence)
234{
235  return offset;
236}
237
238/**
239 * The consumes the truncate call. You cannot truncate device files.
240 *
241 * @param iop
242 * @param length
243 * @return int
244 */
245
246static int
247rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
248{
249  return 0;
250}
251
252/*
253 *  Handler table for RFS device nodes
254 */
255
256const rtems_filesystem_file_handlers_r rtems_rfs_rtems_device_handlers = {
257  .open_h      = rtems_rfs_rtems_device_open,
258  .close_h     = rtems_rfs_rtems_device_close,
259  .read_h      = rtems_rfs_rtems_device_read,
260  .write_h     = rtems_rfs_rtems_device_write,
261  .ioctl_h     = rtems_rfs_rtems_device_ioctl,
262  .lseek_h     = rtems_rfs_rtems_device_lseek,
263  .fstat_h     = rtems_rfs_rtems_fstat,
264  .fchmod_h    = rtems_rfs_rtems_fchmod,
265  .ftruncate_h = rtems_rfs_rtems_device_ftruncate,
266  .fpathconf_h = rtems_filesystem_default_fpathconf,
267  .fsync_h     = rtems_filesystem_default_fsync,
268  .fdatasync_h = rtems_filesystem_default_fdatasync,
269  .fcntl_h     = rtems_filesystem_default_fcntl,
270  .rmnod_h     = rtems_rfs_rtems_rmnod
271};
Note: See TracBrowser for help on using the repository browser.