source: rtems/cpukit/libblock/src/blkdev-imfs.c @ cf36b70

4.11
Last change on this file since cf36b70 was cf36b70, checked in by Sebastian Huber <sebastian.huber@…>, on Dec 31, 2014 at 9:56:05 AM

IMFS: Replace node union with individual struct

This reduces the average node size.

Add and use IMFS_GENERIC_INITIALIZER().

  • Property mode set to 100644
File size: 8.3 KB
Line 
1/**
2 * @file
3 *
4 * @brief Block Device IMFS
5 * @ingroup libblock
6 */
7
8/*
9 * Copyright (c) 2012 embedded brains GmbH.  All rights reserved.
10 *
11 *  embedded brains GmbH
12 *  Obere Lagerstr. 30
13 *  82178 Puchheim
14 *  Germany
15 *  <rtems@embedded-brains.de>
16 *
17 * The license and distribution terms for this file may be
18 * found in the file LICENSE in this distribution or at
19 * http://www.rtems.org/license/LICENSE.
20 */
21
22#if HAVE_CONFIG_H
23  #include "config.h"
24#endif
25
26#include <sys/stat.h>
27#include <stdlib.h>
28#include <unistd.h>
29#include <fcntl.h>
30#include <string.h>
31
32#include <rtems/blkdev.h>
33#include <rtems/bdbuf.h>
34#include <rtems/imfs.h>
35
36typedef struct {
37  rtems_disk_device dd;
38  int fd;
39} rtems_blkdev_imfs_context;
40
41static ssize_t rtems_blkdev_imfs_read(
42  rtems_libio_t *iop,
43  void *buffer,
44  size_t count
45)
46{
47  int rv;
48  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
49  rtems_disk_device *dd = &ctx->dd;
50  ssize_t remaining = (ssize_t) count;
51  off_t offset = iop->offset;
52  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
53  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
54  ssize_t block_offset = (ssize_t) (offset % block_size);
55  char *dst = buffer;
56
57  while (remaining > 0) {
58    rtems_bdbuf_buffer *bd;
59    rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
60
61    if (sc == RTEMS_SUCCESSFUL) {
62      ssize_t copy = block_size - block_offset;
63
64      if (copy > remaining) {
65        copy = remaining;
66      }
67
68      memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
69
70      sc = rtems_bdbuf_release(bd);
71      if (sc == RTEMS_SUCCESSFUL) {
72        block_offset = 0;
73        remaining -= copy;
74        dst += copy;
75        ++block;
76      } else {
77        remaining = -1;
78      }
79    } else {
80      remaining = -1;
81    }
82  }
83
84  if (remaining >= 0) {
85    iop->offset += count;
86    rv = (ssize_t) count;
87  } else {
88    errno = EIO;
89    rv = -1;
90  }
91
92  return rv;
93}
94
95static ssize_t rtems_blkdev_imfs_write(
96  rtems_libio_t *iop,
97  const void *buffer,
98  size_t count
99)
100{
101  int rv;
102  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
103  rtems_disk_device *dd = &ctx->dd;
104  ssize_t remaining = (ssize_t) count;
105  off_t offset = iop->offset;
106  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
107  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
108  ssize_t block_offset = (ssize_t) (offset % block_size);
109  const char *src = buffer;
110
111  while (remaining > 0) {
112    rtems_status_code sc;
113    rtems_bdbuf_buffer *bd;
114
115    if (block_offset == 0 && remaining >= block_size) {
116       sc = rtems_bdbuf_get(dd, block, &bd);
117    } else {
118       sc = rtems_bdbuf_read(dd, block, &bd);
119    }
120
121    if (sc == RTEMS_SUCCESSFUL) {
122      ssize_t copy = block_size - block_offset;
123
124      if (copy > remaining) {
125        copy = remaining;
126      }
127
128      memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
129
130      sc = rtems_bdbuf_release_modified(bd);
131      if (sc == RTEMS_SUCCESSFUL) {
132        block_offset = 0;
133        remaining -= copy;
134        src += copy;
135        ++block;
136      } else {
137        remaining = -1;
138      }
139    } else {
140      remaining = -1;
141    }
142  }
143
144  if (remaining >= 0) {
145    iop->offset += count;
146    rv = (ssize_t) count;
147  } else {
148    errno = EIO;
149    rv = -1;
150  }
151
152  return rv;
153}
154
155static int rtems_blkdev_imfs_ioctl(
156  rtems_libio_t *iop,
157  uint32_t request,
158  void *buffer
159)
160{
161  int rv = 0;
162
163  if (request != RTEMS_BLKIO_REQUEST) {
164    rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
165    rtems_disk_device *dd = &ctx->dd;
166
167    rv = (*dd->ioctl)(dd, request, buffer);
168  } else {
169    /*
170     * It is not allowed to directly access the driver circumventing the cache.
171     */
172    errno = EINVAL;
173    rv = -1;
174  }
175
176  return rv;
177}
178
179static int rtems_blkdev_imfs_fstat(
180  const rtems_filesystem_location_info_t *loc,
181  struct stat *buf
182)
183{
184  rtems_blkdev_imfs_context *ctx =
185    IMFS_generic_get_context_by_location(loc);
186  rtems_disk_device *dd = &ctx->dd;
187
188  buf->st_rdev = rtems_disk_get_device_identifier(dd);
189  buf->st_blksize = rtems_disk_get_block_size(dd);
190  buf->st_blocks = rtems_disk_get_block_count(dd);
191
192  return IMFS_stat(loc, buf);
193}
194
195static int rtems_blkdev_imfs_fsync_or_fdatasync(
196  rtems_libio_t *iop
197)
198{
199  int rv = 0;
200  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
201  rtems_disk_device *dd = &ctx->dd;
202  rtems_status_code sc = rtems_bdbuf_syncdev(dd);
203
204  if (sc != RTEMS_SUCCESSFUL) {
205    errno = EIO;
206    rv = -1;
207  }
208
209  return rv;
210}
211
212static const rtems_filesystem_file_handlers_r rtems_blkdev_imfs_node = {
213  .open_h = rtems_filesystem_default_open,
214  .close_h = rtems_filesystem_default_close,
215  .read_h = rtems_blkdev_imfs_read,
216  .write_h = rtems_blkdev_imfs_write,
217  .ioctl_h = rtems_blkdev_imfs_ioctl,
218  .lseek_h = rtems_filesystem_default_lseek_file,
219  .fstat_h = rtems_blkdev_imfs_fstat,
220  .ftruncate_h = rtems_filesystem_default_ftruncate,
221  .fsync_h = rtems_blkdev_imfs_fsync_or_fdatasync,
222  .fdatasync_h = rtems_blkdev_imfs_fsync_or_fdatasync,
223  .fcntl_h = rtems_filesystem_default_fcntl,
224  .kqfilter_h = rtems_filesystem_default_kqfilter,
225  .poll_h = rtems_filesystem_default_poll,
226  .readv_h = rtems_filesystem_default_readv,
227  .writev_h = rtems_filesystem_default_writev
228};
229
230static IMFS_jnode_t *rtems_blkdev_imfs_initialize(
231  IMFS_jnode_t *node,
232  void *arg
233)
234{
235  rtems_blkdev_imfs_context *ctx;
236  rtems_disk_device *dd;
237
238  node = IMFS_node_initialize_generic(node, arg);
239
240  ctx = IMFS_generic_get_context_by_node(node);
241  dd = &ctx->dd;
242  dd->dev = IMFS_generic_get_device_identifier_by_node(node);
243
244  return node;
245}
246
247static void rtems_blkdev_imfs_destroy(IMFS_jnode_t *node)
248{
249  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_node(node);
250  rtems_disk_device *dd = &ctx->dd;
251
252  rtems_bdbuf_syncdev(dd);
253  rtems_bdbuf_purge_dev(dd);
254
255  if (ctx->fd >= 0) {
256    close(ctx->fd);
257  } else {
258    (*dd->ioctl)(dd, RTEMS_BLKIO_DELETED, NULL);
259  }
260
261  free(ctx);
262
263  IMFS_node_destroy_default(node);
264}
265
266static const IMFS_node_control rtems_blkdev_imfs_control =
267  IMFS_GENERIC_INITIALIZER(
268    &rtems_blkdev_imfs_node,
269    rtems_blkdev_imfs_initialize,
270    rtems_blkdev_imfs_destroy
271  );
272
273rtems_status_code rtems_blkdev_create(
274  const char *device,
275  uint32_t media_block_size,
276  rtems_blkdev_bnum media_block_count,
277  rtems_block_device_ioctl handler,
278  void *driver_data
279)
280{
281  rtems_status_code sc = RTEMS_SUCCESSFUL;
282  rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
283
284  if (ctx != NULL) {
285    sc = rtems_disk_init_phys(
286      &ctx->dd,
287      media_block_size,
288      media_block_count,
289      handler,
290      driver_data
291    );
292
293    ctx->fd = -1;
294
295    if (sc == RTEMS_SUCCESSFUL) {
296      int rv = IMFS_make_generic_node(
297        device,
298        S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
299        &rtems_blkdev_imfs_control,
300        ctx
301      );
302
303      if (rv != 0) {
304        free(ctx);
305        sc = RTEMS_UNSATISFIED;
306      }
307    } else {
308      free(ctx);
309    }
310  } else {
311    sc = RTEMS_NO_MEMORY;
312  }
313
314  return sc;
315}
316
317rtems_status_code rtems_blkdev_create_partition(
318  const char *partition,
319  const char *parent_block_device,
320  rtems_blkdev_bnum media_block_begin,
321  rtems_blkdev_bnum media_block_count
322)
323{
324  rtems_status_code sc = RTEMS_SUCCESSFUL;
325  int fd = open(parent_block_device, O_RDWR);
326
327  if (fd >= 0) {
328    int rv;
329    struct stat st;
330
331    rv = fstat(fd, &st);
332    if (rv == 0 && S_ISBLK(st.st_mode)) {
333      rtems_disk_device *phys_dd;
334
335      rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
336      if (rv == 0) {
337        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
338
339        if (ctx != NULL) {
340          sc = rtems_disk_init_log(
341            &ctx->dd,
342            phys_dd,
343            media_block_begin,
344            media_block_count
345          );
346
347          if (sc == RTEMS_SUCCESSFUL) {
348            ctx->fd = fd;
349
350            rv = IMFS_make_generic_node(
351              partition,
352              S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
353              &rtems_blkdev_imfs_control,
354              ctx
355            );
356
357            if (rv != 0) {
358              free(ctx);
359              sc = RTEMS_UNSATISFIED;
360            }
361          } else {
362            free(ctx);
363          }
364        } else {
365          sc = RTEMS_NO_MEMORY;
366        }
367      } else {
368        sc = RTEMS_NOT_IMPLEMENTED;
369      }
370    } else {
371      sc = RTEMS_INVALID_NODE;
372    }
373
374    if (sc != RTEMS_SUCCESSFUL) {
375      close(fd);
376    }
377  } else {
378    sc = RTEMS_INVALID_ID;
379  }
380
381  return sc;
382}
Note: See TracBrowser for help on using the repository browser.