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

Last change on this file since 30c3898 was 30c3898, checked in by Sebastian Huber <sebastian.huber@…>, on Mar 3, 2018 at 12:24:42 PM

libblock: Init deps in rtems_blkdev_create()

Update #3358.

  • Property mode set to 100644
File size: 8.5 KB
Line 
1/**
2 * @file
3 *
4 * @brief Block Device IMFS
5 * @ingroup libblock
6 */
7
8/*
9 * Copyright (c) 2012, 2018 embedded brains GmbH.  All rights reserved.
10 *
11 *  embedded brains GmbH
12 *  Dornierstr. 4
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  ioctl_command_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  .mmap_h = rtems_filesystem_default_mmap,
226  .poll_h = rtems_filesystem_default_poll,
227  .readv_h = rtems_filesystem_default_readv,
228  .writev_h = rtems_filesystem_default_writev
229};
230
231static IMFS_jnode_t *rtems_blkdev_imfs_initialize(
232  IMFS_jnode_t *node,
233  void *arg
234)
235{
236  rtems_blkdev_imfs_context *ctx;
237  rtems_disk_device *dd;
238
239  node = IMFS_node_initialize_generic(node, arg);
240
241  ctx = IMFS_generic_get_context_by_node(node);
242  dd = &ctx->dd;
243  dd->dev = IMFS_generic_get_device_identifier_by_node(node);
244
245  return node;
246}
247
248static void rtems_blkdev_imfs_destroy(IMFS_jnode_t *node)
249{
250  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_node(node);
251  rtems_disk_device *dd = &ctx->dd;
252
253  rtems_bdbuf_syncdev(dd);
254  rtems_bdbuf_purge_dev(dd);
255
256  if (ctx->fd >= 0) {
257    close(ctx->fd);
258  } else {
259    (*dd->ioctl)(dd, RTEMS_BLKIO_DELETED, NULL);
260  }
261
262  free(ctx);
263
264  IMFS_node_destroy_default(node);
265}
266
267static const IMFS_node_control rtems_blkdev_imfs_control =
268  IMFS_GENERIC_INITIALIZER(
269    &rtems_blkdev_imfs_node,
270    rtems_blkdev_imfs_initialize,
271    rtems_blkdev_imfs_destroy
272  );
273
274rtems_status_code rtems_blkdev_create(
275  const char *device,
276  uint32_t media_block_size,
277  rtems_blkdev_bnum media_block_count,
278  rtems_block_device_ioctl handler,
279  void *driver_data
280)
281{
282  rtems_status_code sc;
283  rtems_blkdev_imfs_context *ctx;
284
285  sc = rtems_bdbuf_init();
286  if (sc != RTEMS_SUCCESSFUL) {
287    return RTEMS_INCORRECT_STATE;
288  }
289
290  ctx = malloc(sizeof(*ctx));
291  if (ctx != NULL) {
292    sc = rtems_disk_init_phys(
293      &ctx->dd,
294      media_block_size,
295      media_block_count,
296      handler,
297      driver_data
298    );
299
300    ctx->fd = -1;
301
302    if (sc == RTEMS_SUCCESSFUL) {
303      int rv = IMFS_make_generic_node(
304        device,
305        S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
306        &rtems_blkdev_imfs_control,
307        ctx
308      );
309
310      if (rv != 0) {
311        free(ctx);
312        sc = RTEMS_UNSATISFIED;
313      }
314    } else {
315      free(ctx);
316    }
317  } else {
318    sc = RTEMS_NO_MEMORY;
319  }
320
321  return sc;
322}
323
324rtems_status_code rtems_blkdev_create_partition(
325  const char *partition,
326  const char *parent_block_device,
327  rtems_blkdev_bnum media_block_begin,
328  rtems_blkdev_bnum media_block_count
329)
330{
331  rtems_status_code sc = RTEMS_SUCCESSFUL;
332  int fd = open(parent_block_device, O_RDWR);
333
334  if (fd >= 0) {
335    int rv;
336    struct stat st;
337
338    rv = fstat(fd, &st);
339    if (rv == 0 && S_ISBLK(st.st_mode)) {
340      rtems_disk_device *phys_dd;
341
342      rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
343      if (rv == 0) {
344        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
345
346        if (ctx != NULL) {
347          sc = rtems_disk_init_log(
348            &ctx->dd,
349            phys_dd,
350            media_block_begin,
351            media_block_count
352          );
353
354          if (sc == RTEMS_SUCCESSFUL) {
355            ctx->fd = fd;
356
357            rv = IMFS_make_generic_node(
358              partition,
359              S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
360              &rtems_blkdev_imfs_control,
361              ctx
362            );
363
364            if (rv != 0) {
365              free(ctx);
366              sc = RTEMS_UNSATISFIED;
367            }
368          } else {
369            free(ctx);
370          }
371        } else {
372          sc = RTEMS_NO_MEMORY;
373        }
374      } else {
375        sc = RTEMS_NOT_IMPLEMENTED;
376      }
377    } else {
378      sc = RTEMS_INVALID_NODE;
379    }
380
381    if (sc != RTEMS_SUCCESSFUL) {
382      close(fd);
383    }
384  } else {
385    sc = RTEMS_INVALID_ID;
386  }
387
388  return sc;
389}
Note: See TracBrowser for help on using the repository browser.