blob: 48d5ea9ab9238739410fd9a17be378eade1a6ae7 [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <unistd.h>
21#include <fcntl.h>
22#include <errno.h>
23#include <sys/mount.h> // for _IOW, _IOR, mount()
24#include <sys/stat.h>
25#include <mtd/mtd-user.h>
26#undef NDEBUG
27#include <assert.h>
28
29#include "mtdutils.h"
30
31struct MtdPartition {
32 int device_index;
33 unsigned int size;
34 unsigned int erase_size;
35 char *name;
36};
37
38struct MtdReadContext {
39 const MtdPartition *partition;
40 char *buffer;
41 size_t consumed;
42 int fd;
43};
44
45struct MtdWriteContext {
46 const MtdPartition *partition;
47 char *buffer;
48 size_t stored;
49 int fd;
Doug Zongker4c5f9f32010-01-12 16:18:33 -080050
51 off_t* bad_block_offsets;
52 int bad_block_alloc;
53 int bad_block_count;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080054};
55
56typedef struct {
57 MtdPartition *partitions;
58 int partitions_allocd;
59 int partition_count;
60} MtdState;
61
62static MtdState g_mtd_state = {
63 NULL, // partitions
64 0, // partitions_allocd
65 -1 // partition_count
66};
67
68#define MTD_PROC_FILENAME "/proc/mtd"
69
70int
71mtd_scan_partitions()
72{
73 char buf[2048];
74 const char *bufp;
75 int fd;
76 int i;
77 ssize_t nbytes;
78
79 if (g_mtd_state.partitions == NULL) {
80 const int nump = 32;
81 MtdPartition *partitions = malloc(nump * sizeof(*partitions));
82 if (partitions == NULL) {
83 errno = ENOMEM;
84 return -1;
85 }
86 g_mtd_state.partitions = partitions;
87 g_mtd_state.partitions_allocd = nump;
88 memset(partitions, 0, nump * sizeof(*partitions));
89 }
90 g_mtd_state.partition_count = 0;
91
92 /* Initialize all of the entries to make things easier later.
93 * (Lets us handle sparsely-numbered partitions, which
94 * may not even be possible.)
95 */
96 for (i = 0; i < g_mtd_state.partitions_allocd; i++) {
97 MtdPartition *p = &g_mtd_state.partitions[i];
98 if (p->name != NULL) {
99 free(p->name);
100 p->name = NULL;
101 }
102 p->device_index = -1;
103 }
104
105 /* Open and read the file contents.
106 */
107 fd = open(MTD_PROC_FILENAME, O_RDONLY);
108 if (fd < 0) {
109 goto bail;
110 }
111 nbytes = read(fd, buf, sizeof(buf) - 1);
112 close(fd);
113 if (nbytes < 0) {
114 goto bail;
115 }
116 buf[nbytes] = '\0';
117
118 /* Parse the contents of the file, which looks like:
119 *
120 * # cat /proc/mtd
121 * dev: size erasesize name
122 * mtd0: 00080000 00020000 "bootloader"
123 * mtd1: 00400000 00020000 "mfg_and_gsm"
124 * mtd2: 00400000 00020000 "0000000c"
125 * mtd3: 00200000 00020000 "0000000d"
126 * mtd4: 04000000 00020000 "system"
127 * mtd5: 03280000 00020000 "userdata"
128 */
129 bufp = buf;
130 while (nbytes > 0) {
131 int mtdnum, mtdsize, mtderasesize;
132 int matches;
133 char mtdname[64];
134 mtdname[0] = '\0';
135 mtdnum = -1;
136
137 matches = sscanf(bufp, "mtd%d: %x %x \"%63[^\"]",
138 &mtdnum, &mtdsize, &mtderasesize, mtdname);
139 /* This will fail on the first line, which just contains
140 * column headers.
141 */
142 if (matches == 4) {
143 MtdPartition *p = &g_mtd_state.partitions[mtdnum];
144 p->device_index = mtdnum;
145 p->size = mtdsize;
146 p->erase_size = mtderasesize;
147 p->name = strdup(mtdname);
148 if (p->name == NULL) {
149 errno = ENOMEM;
150 goto bail;
151 }
152 g_mtd_state.partition_count++;
153 }
154
155 /* Eat the line.
156 */
157 while (nbytes > 0 && *bufp != '\n') {
158 bufp++;
159 nbytes--;
160 }
161 if (nbytes > 0) {
162 bufp++;
163 nbytes--;
164 }
165 }
166
167 return g_mtd_state.partition_count;
168
169bail:
170 // keep "partitions" around so we can free the names on a rescan.
171 g_mtd_state.partition_count = -1;
172 return -1;
173}
174
175const MtdPartition *
176mtd_find_partition_by_name(const char *name)
177{
178 if (g_mtd_state.partitions != NULL) {
179 int i;
180 for (i = 0; i < g_mtd_state.partitions_allocd; i++) {
181 MtdPartition *p = &g_mtd_state.partitions[i];
182 if (p->device_index >= 0 && p->name != NULL) {
183 if (strcmp(p->name, name) == 0) {
184 return p;
185 }
186 }
187 }
188 }
189 return NULL;
190}
191
192int
193mtd_mount_partition(const MtdPartition *partition, const char *mount_point,
194 const char *filesystem, int read_only)
195{
196 const unsigned long flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
197 char devname[64];
198 int rv = -1;
199
200 sprintf(devname, "/dev/block/mtdblock%d", partition->device_index);
201 if (!read_only) {
202 rv = mount(devname, mount_point, filesystem, flags, NULL);
203 }
204 if (read_only || rv < 0) {
205 rv = mount(devname, mount_point, filesystem, flags | MS_RDONLY, 0);
206 if (rv < 0) {
207 printf("Failed to mount %s on %s: %s\n",
208 devname, mount_point, strerror(errno));
209 } else {
210 printf("Mount %s on %s read-only\n", devname, mount_point);
211 }
212 }
213#if 1 //TODO: figure out why this is happening; remove include of stat.h
214 if (rv >= 0) {
215 /* For some reason, the x bits sometimes aren't set on the root
216 * of mounted volumes.
217 */
218 struct stat st;
219 rv = stat(mount_point, &st);
220 if (rv < 0) {
221 return rv;
222 }
223 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
224 if (new_mode != st.st_mode) {
225printf("Fixing execute permissions for %s\n", mount_point);
226 rv = chmod(mount_point, new_mode);
227 if (rv < 0) {
228 printf("Couldn't fix permissions for %s: %s\n",
229 mount_point, strerror(errno));
230 }
231 }
232 }
233#endif
234 return rv;
235}
236
237int
238mtd_partition_info(const MtdPartition *partition,
239 size_t *total_size, size_t *erase_size, size_t *write_size)
240{
241 char mtddevname[32];
242 sprintf(mtddevname, "/dev/mtd/mtd%d", partition->device_index);
243 int fd = open(mtddevname, O_RDONLY);
244 if (fd < 0) return -1;
245
246 struct mtd_info_user mtd_info;
247 int ret = ioctl(fd, MEMGETINFO, &mtd_info);
248 close(fd);
249 if (ret < 0) return -1;
250
251 if (total_size != NULL) *total_size = mtd_info.size;
252 if (erase_size != NULL) *erase_size = mtd_info.erasesize;
253 if (write_size != NULL) *write_size = mtd_info.writesize;
254 return 0;
255}
256
257MtdReadContext *mtd_read_partition(const MtdPartition *partition)
258{
259 MtdReadContext *ctx = (MtdReadContext*) malloc(sizeof(MtdReadContext));
260 if (ctx == NULL) return NULL;
261
262 ctx->buffer = malloc(partition->erase_size);
263 if (ctx->buffer == NULL) {
264 free(ctx);
265 return NULL;
266 }
267
268 char mtddevname[32];
269 sprintf(mtddevname, "/dev/mtd/mtd%d", partition->device_index);
270 ctx->fd = open(mtddevname, O_RDONLY);
271 if (ctx->fd < 0) {
272 free(ctx);
273 free(ctx->buffer);
274 return NULL;
275 }
276
277 ctx->partition = partition;
278 ctx->consumed = partition->erase_size;
279 return ctx;
280}
281
Doug Zongkerd12560a2010-09-14 14:25:48 -0700282// Seeks to a location in the partition. Don't mix with reads of
283// anything other than whole blocks; unpredictable things will result.
284void mtd_read_skip_to(const MtdReadContext* ctx, size_t offset) {
285 lseek64(ctx->fd, offset, SEEK_SET);
286}
287
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800288static int read_block(const MtdPartition *partition, int fd, char *data)
289{
290 struct mtd_ecc_stats before, after;
291 if (ioctl(fd, ECCGETSTATS, &before)) {
292 fprintf(stderr, "mtd: ECCGETSTATS error (%s)\n", strerror(errno));
293 return -1;
294 }
295
Doug Zongker17a47092009-12-14 18:03:27 -0800296 loff_t pos = lseek64(fd, 0, SEEK_CUR);
297
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800298 ssize_t size = partition->erase_size;
Doug Zongker17a47092009-12-14 18:03:27 -0800299 int mgbb;
300
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800301 while (pos + size <= (int) partition->size) {
Doug Zongker17a47092009-12-14 18:03:27 -0800302 if (lseek64(fd, pos, SEEK_SET) != pos || read(fd, data, size) != size) {
303 fprintf(stderr, "mtd: read error at 0x%08llx (%s)\n",
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800304 pos, strerror(errno));
305 } else if (ioctl(fd, ECCGETSTATS, &after)) {
306 fprintf(stderr, "mtd: ECCGETSTATS error (%s)\n", strerror(errno));
307 return -1;
308 } else if (after.failed != before.failed) {
Doug Zongker17a47092009-12-14 18:03:27 -0800309 fprintf(stderr, "mtd: ECC errors (%d soft, %d hard) at 0x%08llx\n",
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800310 after.corrected - before.corrected,
311 after.failed - before.failed, pos);
Doug Zongker17a47092009-12-14 18:03:27 -0800312 } else if ((mgbb = ioctl(fd, MEMGETBADBLOCK, &pos))) {
313 fprintf(stderr,
314 "mtd: MEMGETBADBLOCK returned %d at 0x%08llx (errno=%d)\n",
315 mgbb, pos, errno);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800316 } else {
Doug Zongker61ba7a82010-09-12 13:36:40 -0700317 return 0; // Success!
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800318 }
319
320 pos += partition->erase_size;
321 }
322
323 errno = ENOSPC;
324 return -1;
325}
326
327ssize_t mtd_read_data(MtdReadContext *ctx, char *data, size_t len)
328{
329 ssize_t read = 0;
330 while (read < (int) len) {
331 if (ctx->consumed < ctx->partition->erase_size) {
332 size_t avail = ctx->partition->erase_size - ctx->consumed;
333 size_t copy = len - read < avail ? len - read : avail;
334 memcpy(data + read, ctx->buffer + ctx->consumed, copy);
335 ctx->consumed += copy;
336 read += copy;
337 }
338
339 // Read complete blocks directly into the user's buffer
340 while (ctx->consumed == ctx->partition->erase_size &&
341 len - read >= ctx->partition->erase_size) {
342 if (read_block(ctx->partition, ctx->fd, data + read)) return -1;
343 read += ctx->partition->erase_size;
344 }
345
Doug Zongkerbec02d52009-07-01 12:09:29 -0700346 if (read >= len) {
347 return read;
348 }
349
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800350 // Read the next block into the buffer
351 if (ctx->consumed == ctx->partition->erase_size && read < (int) len) {
352 if (read_block(ctx->partition, ctx->fd, ctx->buffer)) return -1;
353 ctx->consumed = 0;
354 }
355 }
356
357 return read;
358}
359
360void mtd_read_close(MtdReadContext *ctx)
361{
362 close(ctx->fd);
363 free(ctx->buffer);
364 free(ctx);
365}
366
367MtdWriteContext *mtd_write_partition(const MtdPartition *partition)
368{
369 MtdWriteContext *ctx = (MtdWriteContext*) malloc(sizeof(MtdWriteContext));
370 if (ctx == NULL) return NULL;
371
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800372 ctx->bad_block_offsets = NULL;
373 ctx->bad_block_alloc = 0;
374 ctx->bad_block_count = 0;
375
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800376 ctx->buffer = malloc(partition->erase_size);
377 if (ctx->buffer == NULL) {
378 free(ctx);
379 return NULL;
380 }
381
382 char mtddevname[32];
383 sprintf(mtddevname, "/dev/mtd/mtd%d", partition->device_index);
384 ctx->fd = open(mtddevname, O_RDWR);
385 if (ctx->fd < 0) {
386 free(ctx->buffer);
387 free(ctx);
388 return NULL;
389 }
390
391 ctx->partition = partition;
392 ctx->stored = 0;
393 return ctx;
394}
395
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800396static void add_bad_block_offset(MtdWriteContext *ctx, off_t pos) {
397 if (ctx->bad_block_count + 1 > ctx->bad_block_alloc) {
398 ctx->bad_block_alloc = (ctx->bad_block_alloc*2) + 1;
399 ctx->bad_block_offsets = realloc(ctx->bad_block_offsets,
400 ctx->bad_block_alloc * sizeof(off_t));
401 }
402 ctx->bad_block_offsets[ctx->bad_block_count++] = pos;
403}
404
405static int write_block(MtdWriteContext *ctx, const char *data)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800406{
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800407 const MtdPartition *partition = ctx->partition;
408 int fd = ctx->fd;
409
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800410 off_t pos = lseek(fd, 0, SEEK_CUR);
411 if (pos == (off_t) -1) return 1;
412
413 ssize_t size = partition->erase_size;
414 while (pos + size <= (int) partition->size) {
415 loff_t bpos = pos;
Doug Zongkeraaf3f562010-09-09 16:41:49 -0700416 int ret = ioctl(fd, MEMGETBADBLOCK, &bpos);
417 if (ret != 0 && !(ret == -1 && errno == EOPNOTSUPP)) {
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800418 add_bad_block_offset(ctx, pos);
Doug Zongkeraaf3f562010-09-09 16:41:49 -0700419 fprintf(stderr,
420 "mtd: not writing bad block at 0x%08lx (ret %d errno %d)\n",
421 pos, ret, errno);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800422 pos += partition->erase_size;
423 continue; // Don't try to erase known factory-bad blocks.
424 }
425
426 struct erase_info_user erase_info;
427 erase_info.start = pos;
428 erase_info.length = size;
429 int retry;
430 for (retry = 0; retry < 2; ++retry) {
431 if (ioctl(fd, MEMERASE, &erase_info) < 0) {
432 fprintf(stderr, "mtd: erase failure at 0x%08lx (%s)\n",
433 pos, strerror(errno));
434 continue;
435 }
436 if (lseek(fd, pos, SEEK_SET) != pos ||
437 write(fd, data, size) != size) {
438 fprintf(stderr, "mtd: write error at 0x%08lx (%s)\n",
439 pos, strerror(errno));
440 }
441
442 char verify[size];
443 if (lseek(fd, pos, SEEK_SET) != pos ||
444 read(fd, verify, size) != size) {
445 fprintf(stderr, "mtd: re-read error at 0x%08lx (%s)\n",
446 pos, strerror(errno));
447 continue;
448 }
449 if (memcmp(data, verify, size) != 0) {
450 fprintf(stderr, "mtd: verification error at 0x%08lx (%s)\n",
451 pos, strerror(errno));
452 continue;
453 }
454
455 if (retry > 0) {
456 fprintf(stderr, "mtd: wrote block after %d retries\n", retry);
457 }
Doug Zongker8e5e4da2010-09-14 18:06:55 -0700458 fprintf(stderr, "mtd: successfully wrote block at %llx\n", pos);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800459 return 0; // Success!
460 }
461
462 // Try to erase it once more as we give up on this block
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800463 add_bad_block_offset(ctx, pos);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800464 fprintf(stderr, "mtd: skipping write block at 0x%08lx\n", pos);
465 ioctl(fd, MEMERASE, &erase_info);
466 pos += partition->erase_size;
467 }
468
469 // Ran out of space on the device
470 errno = ENOSPC;
471 return -1;
472}
473
474ssize_t mtd_write_data(MtdWriteContext *ctx, const char *data, size_t len)
475{
476 size_t wrote = 0;
477 while (wrote < len) {
478 // Coalesce partial writes into complete blocks
479 if (ctx->stored > 0 || len - wrote < ctx->partition->erase_size) {
480 size_t avail = ctx->partition->erase_size - ctx->stored;
481 size_t copy = len - wrote < avail ? len - wrote : avail;
482 memcpy(ctx->buffer + ctx->stored, data + wrote, copy);
483 ctx->stored += copy;
484 wrote += copy;
485 }
486
487 // If a complete block was accumulated, write it
488 if (ctx->stored == ctx->partition->erase_size) {
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800489 if (write_block(ctx, ctx->buffer)) return -1;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800490 ctx->stored = 0;
491 }
492
493 // Write complete blocks directly from the user's buffer
494 while (ctx->stored == 0 && len - wrote >= ctx->partition->erase_size) {
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800495 if (write_block(ctx, data + wrote)) return -1;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800496 wrote += ctx->partition->erase_size;
497 }
498 }
499
500 return wrote;
501}
502
503off_t mtd_erase_blocks(MtdWriteContext *ctx, int blocks)
504{
505 // Zero-pad and write any pending data to get us to a block boundary
506 if (ctx->stored > 0) {
507 size_t zero = ctx->partition->erase_size - ctx->stored;
508 memset(ctx->buffer + ctx->stored, 0, zero);
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800509 if (write_block(ctx, ctx->buffer)) return -1;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800510 ctx->stored = 0;
511 }
512
513 off_t pos = lseek(ctx->fd, 0, SEEK_CUR);
514 if ((off_t) pos == (off_t) -1) return pos;
515
516 const int total = (ctx->partition->size - pos) / ctx->partition->erase_size;
517 if (blocks < 0) blocks = total;
518 if (blocks > total) {
519 errno = ENOSPC;
520 return -1;
521 }
522
523 // Erase the specified number of blocks
524 while (blocks-- > 0) {
525 loff_t bpos = pos;
526 if (ioctl(ctx->fd, MEMGETBADBLOCK, &bpos) > 0) {
527 fprintf(stderr, "mtd: not erasing bad block at 0x%08lx\n", pos);
528 pos += ctx->partition->erase_size;
529 continue; // Don't try to erase known factory-bad blocks.
530 }
531
532 struct erase_info_user erase_info;
533 erase_info.start = pos;
534 erase_info.length = ctx->partition->erase_size;
535 if (ioctl(ctx->fd, MEMERASE, &erase_info) < 0) {
536 fprintf(stderr, "mtd: erase failure at 0x%08lx\n", pos);
537 }
538 pos += ctx->partition->erase_size;
539 }
540
541 return pos;
542}
543
544int mtd_write_close(MtdWriteContext *ctx)
545{
546 int r = 0;
547 // Make sure any pending data gets written
548 if (mtd_erase_blocks(ctx, 0) == (off_t) -1) r = -1;
549 if (close(ctx->fd)) r = -1;
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800550 free(ctx->bad_block_offsets);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800551 free(ctx->buffer);
552 free(ctx);
553 return r;
554}
Doug Zongker4c5f9f32010-01-12 16:18:33 -0800555
556/* Return the offset of the first good block at or after pos (which
557 * might be pos itself).
558 */
559off_t mtd_find_write_start(MtdWriteContext *ctx, off_t pos) {
560 int i;
561 for (i = 0; i < ctx->bad_block_count; ++i) {
562 if (ctx->bad_block_offsets[i] == pos) {
563 pos += ctx->partition->erase_size;
564 } else if (ctx->bad_block_offsets[i] > pos) {
565 return pos;
566 }
567 }
568 return pos;
569}