source: rtems/cpukit/libfs/src/jffs2/src/flashio.c

Last change on this file was 6ac6a5c8, checked in by Sebastian Huber <sebastian.huber@…>, on Mar 27, 2018 at 11:01:56 AM

jffs2: Do not use command line defines

Update #3375.

  • Property mode set to 100644
File size: 3.6 KB
Line 
1#include "rtems-jffs2-config.h"
2
3/*
4 * JFFS2 -- Journalling Flash File System, Version 2.
5 *
6 * Copyright (C) 2001-2003 Red Hat, Inc.
7 *
8 * Created by Dominic Ostrowski <dominic.ostrowski@3glab.com>
9 * Contributors: David Woodhouse, Nick Garnett, Richard Panton.
10 *
11 * For licensing information, see the file 'LICENCE' in this directory.
12 *
13 * $Id: flashio.c,v 1.1 2003/11/26 14:09:29 dwmw2 Exp $
14 *
15 */
16
17#include <linux/kernel.h>
18#include "nodelist.h"
19
20int jffs2_flash_read(struct jffs2_sb_info * c,
21                          cyg_uint32 read_buffer_offset, const size_t size,
22                          size_t * return_size, unsigned char *write_buffer)
23{
24        const struct super_block *sb = OFNI_BS_2SFFJ(c);
25        rtems_jffs2_flash_control *fc = sb->s_flash_control;
26
27        *return_size = size;
28
29        return (*fc->read)(fc, read_buffer_offset, write_buffer, size);
30}
31
32int jffs2_flash_write(struct jffs2_sb_info * c,
33                           cyg_uint32 write_buffer_offset, const size_t size,
34                           size_t * return_size, unsigned char *read_buffer)
35{
36        const struct super_block *sb = OFNI_BS_2SFFJ(c);
37        rtems_jffs2_flash_control *fc = sb->s_flash_control;
38
39        *return_size = size;
40
41        return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
42}
43
44int
45jffs2_flash_direct_writev(struct jffs2_sb_info *c, const struct iovec *vecs,
46                   unsigned long count, loff_t to, size_t * retlen)
47{
48        unsigned long i;
49        size_t totlen = 0, thislen;
50        int ret = 0;
51
52        for (i = 0; i < count; i++) {
53                // writes need to be aligned but the data we're passed may not be
54                // Observation suggests most unaligned writes are small, so we
55                // optimize for that case.
56
57                if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
58                    (((unsigned long) vecs[i].
59                      iov_base & (sizeof (unsigned long) - 1)))) {
60                        // are there iov's after this one? Or is it so much we'd need
61                        // to do multiple writes anyway?
62                        if ((i + 1) < count || vecs[i].iov_len > 256) {
63                                // cop out and malloc
64                                unsigned long j;
65                                ssize_t sizetomalloc = 0, totvecsize = 0;
66                                char *cbuf, *cbufptr;
67
68                                for (j = i; j < count; j++)
69                                        totvecsize += vecs[j].iov_len;
70
71                                // pad up in case unaligned
72                                sizetomalloc = totvecsize + sizeof (int) - 1;
73                                sizetomalloc &= ~(sizeof (int) - 1);
74                                cbuf = (char *) malloc(sizetomalloc);
75                                // malloc returns aligned memory
76                                if (!cbuf) {
77                                        ret = -ENOMEM;
78                                        goto writev_out;
79                                }
80                                cbufptr = cbuf;
81                                for (j = i; j < count; j++) {
82                                        memcpy(cbufptr, vecs[j].iov_base,
83                                               vecs[j].iov_len);
84                                        cbufptr += vecs[j].iov_len;
85                                }
86                                ret =
87                                    jffs2_flash_write(c, to, sizetomalloc,
88                                                      &thislen, cbuf);
89                                if (thislen > totvecsize)       // in case it was aligned up
90                                        thislen = totvecsize;
91                                totlen += thislen;
92                                free(cbuf);
93                                goto writev_out;
94                        } else {
95                                // otherwise optimize for the common case
96                                int buf[256 / sizeof (int)];    // int, so int aligned
97                                size_t lentowrite;
98
99                                lentowrite = vecs[i].iov_len;
100                                // pad up in case its unaligned
101                                lentowrite += sizeof (int) - 1;
102                                lentowrite &= ~(sizeof (int) - 1);
103                                memcpy(buf, vecs[i].iov_base, lentowrite);
104
105                                ret =
106                                    jffs2_flash_write(c, to, lentowrite,
107                                                      &thislen, (char *) &buf);
108                                if (thislen > vecs[i].iov_len)
109                                        thislen = vecs[i].iov_len;
110                        }       // else
111                } else
112                        ret =
113                            jffs2_flash_write(c, to, vecs[i].iov_len, &thislen,
114                                              vecs[i].iov_base);
115                totlen += thislen;
116                if (ret || thislen != vecs[i].iov_len)
117                        break;
118                to += vecs[i].iov_len;
119        }
120      writev_out:
121        if (retlen)
122                *retlen = totlen;
123
124        return ret;
125}
126
127int jffs2_flash_erase(struct jffs2_sb_info * c,
128                           struct jffs2_eraseblock * jeb)
129{
130        const struct super_block *sb = OFNI_BS_2SFFJ(c);
131        rtems_jffs2_flash_control *fc = sb->s_flash_control;
132
133        return (*fc->erase)(fc, jeb->offset);
134}
135
Note: See TracBrowser for help on using the repository browser.