Revert "fstools: Add support to read-only MTD partitions (eg. recovery images)"
[project/fstools.git] / libfstools / mtd.c
1 /*
2 * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License version 2.1
6 * as published by the Free Software Foundation
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
14 #include <sys/mount.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include <asm/byteorder.h>
19 #include <unistd.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <mtd/mtd-user.h>
23
24 #include "libfstools.h"
25
26 #include "volume.h"
27
28 #define PATH_MAX 256
29
30 struct mtd_volume {
31 struct volume v;
32 int fd;
33 int idx;
34 char *chr;
35 };
36
37 static struct driver mtd_driver;
38
39 static int mtd_open(const char *mtd, int block)
40 {
41 FILE *fp;
42 char dev[PATH_MAX];
43 int i, ret, flags = O_RDWR | O_SYNC;
44
45 if ((fp = fopen("/proc/mtd", "r"))) {
46 while (fgets(dev, sizeof(dev), fp)) {
47 if (sscanf(dev, "mtd%d:", &i) && strstr(dev, mtd)) {
48 snprintf(dev, sizeof(dev), "/dev/mtd%s/%d", (block ? "block" : ""), i);
49 ret = open(dev, flags);
50 if (ret < 0) {
51 snprintf(dev, sizeof(dev), "/dev/mtd%s%d", (block ? "block" : ""), i);
52 ret = open(dev, flags);
53 }
54 fclose(fp);
55 return ret;
56 }
57 }
58 fclose(fp);
59 }
60
61 return open(mtd, flags);
62 }
63
64 static void mtd_volume_close(struct mtd_volume *p)
65 {
66 if (!p->fd)
67 return;
68
69 close(p->fd);
70 p->fd = 0;
71 }
72
73 static int mtd_volume_load(struct mtd_volume *p)
74 {
75 struct volume *v = &p->v;
76 struct mtd_info_user mtdInfo;
77 struct erase_info_user mtdLockInfo;
78
79 if (p->fd) {
80 lseek(p->fd, 0, SEEK_SET);
81 return 0;
82 }
83
84 if (!p->chr)
85 return -1;
86
87 p->fd = mtd_open(p->chr, 0);
88 if (p->fd < 0) {
89 p->fd = 0;
90 ULOG_ERR("Could not open mtd device: %s\n", p->chr);
91 return -1;
92 }
93
94 if (ioctl(p->fd, MEMGETINFO, &mtdInfo)) {
95 mtd_volume_close(p);
96 ULOG_ERR("Could not get MTD device info from %s\n", p->chr);
97 return -1;
98 }
99
100 v->size = mtdInfo.size;
101 v->block_size = mtdInfo.erasesize;
102 switch (mtdInfo.type) {
103 case MTD_NORFLASH:
104 v->type = NORFLASH;
105 break;
106 case MTD_NANDFLASH:
107 v->type = NANDFLASH;
108 break;
109 case MTD_UBIVOLUME:
110 v->type = UBIVOLUME;
111 break;
112 default:
113 v->type = UNKNOWN_TYPE;
114 break;
115 }
116
117 mtdLockInfo.start = 0;
118 mtdLockInfo.length = v->size;
119 ioctl(p->fd, MEMUNLOCK, &mtdLockInfo);
120
121 return 0;
122 }
123
124 static char* mtd_find_index(char *name)
125 {
126 FILE *fp = fopen("/proc/mtd", "r");
127 static char line[256];
128 char *index = NULL;
129
130 if(!fp)
131 return index;
132
133 while (!index && fgets(line, sizeof(line), fp)) {
134 char *ret;
135
136 if ((ret = strstr(line, name)) && (ret[strlen(name)] == '"')) {
137 char *eol = strstr(line, ":");
138
139 if (!eol)
140 continue;
141
142 *eol = '\0';
143 index = &line[3];
144 }
145 }
146
147 fclose(fp);
148
149 return index;
150 }
151
152 static struct volume *mtd_volume_find(char *name)
153 {
154 char *idx = mtd_find_index(name);
155 struct mtd_volume *p;
156 struct volume *v;
157 char buffer[32];
158
159 if (!idx)
160 return NULL;
161
162 p = calloc(1, sizeof(struct mtd_volume));
163 if (!p)
164 return NULL;
165
166 v = &p->v;
167 v->name = strdup(name);
168 v->drv = &mtd_driver;
169 p->idx = atoi(idx);
170
171 snprintf(buffer, sizeof(buffer), "/dev/mtdblock%s", idx);
172 v->blk = strdup(buffer);
173
174 snprintf(buffer, sizeof(buffer), "/dev/mtd%s", idx);
175 p->chr = strdup(buffer);
176
177 if (mtd_volume_load(p)) {
178 ULOG_ERR("reading %s failed\n", v->name);
179 free(p);
180 return NULL;
181 }
182
183 return v;
184 }
185
186 static int mtd_volume_identify(struct volume *v)
187 {
188 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
189 __u32 deadc0de;
190 __u16 jffs2;
191 size_t sz;
192
193 if (mtd_volume_load(p)) {
194 ULOG_ERR("reading %s failed\n", v->name);
195 return -1;
196 }
197
198 sz = read(p->fd, &deadc0de, sizeof(deadc0de));
199
200 if (sz != sizeof(deadc0de)) {
201 ULOG_ERR("reading %s failed: %m\n", v->name);
202 return -1;
203 }
204
205 if (deadc0de == __be32_to_cpu(0x4f575254))
206 return FS_SNAPSHOT;
207
208 deadc0de = __be32_to_cpu(deadc0de);
209 if (deadc0de == 0xdeadc0de) {
210 return FS_DEADCODE;
211 }
212
213 jffs2 = __be16_to_cpu(deadc0de >> 16);
214 if (jffs2 == 0x1985) {
215 return FS_JFFS2;
216 }
217
218 if (v->type == UBIVOLUME && deadc0de == 0xffffffff) {
219 return FS_JFFS2;
220 }
221
222 return FS_NONE;
223 }
224
225 static int mtd_volume_erase(struct volume *v, int offset, int len)
226 {
227 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
228 struct erase_info_user eiu;
229 int first_block, num_blocks;
230
231 if (mtd_volume_load(p))
232 return -1;
233
234 if (offset % v->block_size || len % v->block_size) {
235 ULOG_ERR("mtd erase needs to be block aligned\n");
236 return -1;
237 }
238
239 first_block = offset / v->block_size;
240 num_blocks = len / v->block_size;
241 eiu.length = v->block_size;
242
243 for (eiu.start = first_block * v->block_size;
244 eiu.start < v->size && eiu.start < (first_block + num_blocks) * v->block_size;
245 eiu.start += v->block_size) {
246 ULOG_INFO("erasing %x %x\n", eiu.start, v->block_size);
247 ioctl(p->fd, MEMUNLOCK, &eiu);
248 if (ioctl(p->fd, MEMERASE, &eiu))
249 ULOG_ERR("Failed to erase block at 0x%x\n", eiu.start);
250 }
251
252 mtd_volume_close(p);
253
254 return 0;
255 }
256
257 static int mtd_volume_erase_all(struct volume *v)
258 {
259 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
260
261 mtd_volume_erase(v, 0, v->size);
262 mtd_volume_close(p);
263
264 return 0;
265 }
266
267 static int mtd_volume_init(struct volume *v)
268 {
269 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
270 struct mtd_info_user mtdinfo;
271 int ret;
272
273 if (mtd_volume_load(p))
274 return -1;
275
276 ret = ioctl(p->fd, MEMGETINFO, &mtdinfo);
277 if (ret) {
278 ULOG_ERR("ioctl(%d, MEMGETINFO) failed: %m\n", p->fd);
279 } else {
280 struct erase_info_user mtdlock;
281
282 mtdlock.start = 0;
283 mtdlock.length = mtdinfo.size;
284 ioctl(p->fd, MEMUNLOCK, &mtdlock);
285 }
286
287 return ret;
288 }
289
290 static int mtd_volume_read(struct volume *v, void *buf, int offset, int length)
291 {
292 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
293
294 if (mtd_volume_load(p))
295 return -1;
296
297 if (lseek(p->fd, offset, SEEK_SET) == (off_t) -1) {
298 ULOG_ERR("lseek/read failed\n");
299 return -1;
300 }
301
302 if (read(p->fd, buf, length) == -1) {
303 ULOG_ERR("read failed\n");
304 return -1;
305 }
306
307 return 0;
308 }
309
310 static int mtd_volume_write(struct volume *v, void *buf, int offset, int length)
311 {
312 struct mtd_volume *p = container_of(v, struct mtd_volume, v);;
313
314 if (mtd_volume_load(p))
315 return -1;
316
317 if (lseek(p->fd, offset, SEEK_SET) == (off_t) -1) {
318 ULOG_ERR("lseek/write failed at offset %d\n", offset);
319 perror("lseek");
320 return -1;
321 }
322
323 if (write(p->fd, buf, length) == -1) {
324 ULOG_ERR("write failed\n");
325 return -1;
326 }
327
328 return 0;
329 }
330
331 static struct driver mtd_driver = {
332 .name = "mtd",
333 .find = mtd_volume_find,
334 .init = mtd_volume_init,
335 .erase = mtd_volume_erase,
336 .erase_all = mtd_volume_erase_all,
337 .read = mtd_volume_read,
338 .write = mtd_volume_write,
339 .identify = mtd_volume_identify,
340 };
341 DRIVER(mtd_driver);