1 /* 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 31 struct MtdPartition { 32 int device_index; 33 unsigned int size; 34 unsigned int erase_size; 35 char *name; 36 }; 37 38 struct MtdReadContext { 39 const MtdPartition *partition; 40 char *buffer; 41 size_t consumed; 42 int fd; 43 }; 44 45 struct MtdWriteContext { 46 const MtdPartition *partition; 47 char *buffer; 48 size_t stored; 49 int fd; 50 51 off_t* bad_block_offsets; 52 int bad_block_alloc; 53 int bad_block_count; 54 }; 55 56 typedef struct { 57 MtdPartition *partitions; 58 int partitions_allocd; 59 int partition_count; 60 } MtdState; 61 62 static 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 70 int 71 mtd_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 169 bail: 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 175 const MtdPartition * 176 mtd_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 192 int 193 mtd_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) { 225 printf("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 237 int 238 mtd_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 257 MtdReadContext *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 282 static int read_block(const MtdPartition *partition, int fd, char *data) 283 { 284 struct mtd_ecc_stats before, after; 285 if (ioctl(fd, ECCGETSTATS, &before)) { 286 fprintf(stderr, "mtd: ECCGETSTATS error (%s)\n", strerror(errno)); 287 return -1; 288 } 289 290 loff_t pos = lseek64(fd, 0, SEEK_CUR); 291 292 ssize_t size = partition->erase_size; 293 int mgbb; 294 295 while (pos + size <= (int) partition->size) { 296 if (lseek64(fd, pos, SEEK_SET) != pos || read(fd, data, size) != size) { 297 fprintf(stderr, "mtd: read error at 0x%08llx (%s)\n", 298 pos, strerror(errno)); 299 } else if (ioctl(fd, ECCGETSTATS, &after)) { 300 fprintf(stderr, "mtd: ECCGETSTATS error (%s)\n", strerror(errno)); 301 return -1; 302 } else if (after.failed != before.failed) { 303 fprintf(stderr, "mtd: ECC errors (%d soft, %d hard) at 0x%08llx\n", 304 after.corrected - before.corrected, 305 after.failed - before.failed, pos); 306 } else if ((mgbb = ioctl(fd, MEMGETBADBLOCK, &pos))) { 307 fprintf(stderr, 308 "mtd: MEMGETBADBLOCK returned %d at 0x%08llx (errno=%d)\n", 309 mgbb, pos, errno); 310 } else { 311 int i; 312 for (i = 0; i < size; ++i) { 313 if (data[i] != 0) { 314 return 0; // Success! 315 } 316 } 317 fprintf(stderr, "mtd: read all-zero block at 0x%08llx; skipping\n", 318 pos); 319 } 320 321 pos += partition->erase_size; 322 } 323 324 errno = ENOSPC; 325 return -1; 326 } 327 328 ssize_t mtd_read_data(MtdReadContext *ctx, char *data, size_t len) 329 { 330 ssize_t read = 0; 331 while (read < (int) len) { 332 if (ctx->consumed < ctx->partition->erase_size) { 333 size_t avail = ctx->partition->erase_size - ctx->consumed; 334 size_t copy = len - read < avail ? len - read : avail; 335 memcpy(data + read, ctx->buffer + ctx->consumed, copy); 336 ctx->consumed += copy; 337 read += copy; 338 } 339 340 // Read complete blocks directly into the user's buffer 341 while (ctx->consumed == ctx->partition->erase_size && 342 len - read >= ctx->partition->erase_size) { 343 if (read_block(ctx->partition, ctx->fd, data + read)) return -1; 344 read += ctx->partition->erase_size; 345 } 346 347 if (read >= len) { 348 return read; 349 } 350 351 // Read the next block into the buffer 352 if (ctx->consumed == ctx->partition->erase_size && read < (int) len) { 353 if (read_block(ctx->partition, ctx->fd, ctx->buffer)) return -1; 354 ctx->consumed = 0; 355 } 356 } 357 358 return read; 359 } 360 361 void mtd_read_close(MtdReadContext *ctx) 362 { 363 close(ctx->fd); 364 free(ctx->buffer); 365 free(ctx); 366 } 367 368 MtdWriteContext *mtd_write_partition(const MtdPartition *partition) 369 { 370 MtdWriteContext *ctx = (MtdWriteContext*) malloc(sizeof(MtdWriteContext)); 371 if (ctx == NULL) return NULL; 372 373 ctx->bad_block_offsets = NULL; 374 ctx->bad_block_alloc = 0; 375 ctx->bad_block_count = 0; 376 377 ctx->buffer = malloc(partition->erase_size); 378 if (ctx->buffer == NULL) { 379 free(ctx); 380 return NULL; 381 } 382 383 char mtddevname[32]; 384 sprintf(mtddevname, "/dev/mtd/mtd%d", partition->device_index); 385 ctx->fd = open(mtddevname, O_RDWR); 386 if (ctx->fd < 0) { 387 free(ctx->buffer); 388 free(ctx); 389 return NULL; 390 } 391 392 ctx->partition = partition; 393 ctx->stored = 0; 394 return ctx; 395 } 396 397 static void add_bad_block_offset(MtdWriteContext *ctx, off_t pos) { 398 if (ctx->bad_block_count + 1 > ctx->bad_block_alloc) { 399 ctx->bad_block_alloc = (ctx->bad_block_alloc*2) + 1; 400 ctx->bad_block_offsets = realloc(ctx->bad_block_offsets, 401 ctx->bad_block_alloc * sizeof(off_t)); 402 } 403 ctx->bad_block_offsets[ctx->bad_block_count++] = pos; 404 } 405 406 static int write_block(MtdWriteContext *ctx, const char *data) 407 { 408 const MtdPartition *partition = ctx->partition; 409 int fd = ctx->fd; 410 411 off_t pos = lseek(fd, 0, SEEK_CUR); 412 if (pos == (off_t) -1) return 1; 413 414 ssize_t size = partition->erase_size; 415 while (pos + size <= (int) partition->size) { 416 loff_t bpos = pos; 417 if (ioctl(fd, MEMGETBADBLOCK, &bpos) > 0) { 418 add_bad_block_offset(ctx, pos); 419 fprintf(stderr, "mtd: not writing bad block at 0x%08lx\n", pos); 420 pos += partition->erase_size; 421 continue; // Don't try to erase known factory-bad blocks. 422 } 423 424 struct erase_info_user erase_info; 425 erase_info.start = pos; 426 erase_info.length = size; 427 int retry; 428 for (retry = 0; retry < 2; ++retry) { 429 if (ioctl(fd, MEMERASE, &erase_info) < 0) { 430 fprintf(stderr, "mtd: erase failure at 0x%08lx (%s)\n", 431 pos, strerror(errno)); 432 continue; 433 } 434 if (lseek(fd, pos, SEEK_SET) != pos || 435 write(fd, data, size) != size) { 436 fprintf(stderr, "mtd: write error at 0x%08lx (%s)\n", 437 pos, strerror(errno)); 438 } 439 440 char verify[size]; 441 if (lseek(fd, pos, SEEK_SET) != pos || 442 read(fd, verify, size) != size) { 443 fprintf(stderr, "mtd: re-read error at 0x%08lx (%s)\n", 444 pos, strerror(errno)); 445 continue; 446 } 447 if (memcmp(data, verify, size) != 0) { 448 fprintf(stderr, "mtd: verification error at 0x%08lx (%s)\n", 449 pos, strerror(errno)); 450 continue; 451 } 452 453 if (retry > 0) { 454 fprintf(stderr, "mtd: wrote block after %d retries\n", retry); 455 } 456 return 0; // Success! 457 } 458 459 // Try to erase it once more as we give up on this block 460 add_bad_block_offset(ctx, pos); 461 fprintf(stderr, "mtd: skipping write block at 0x%08lx\n", pos); 462 ioctl(fd, MEMERASE, &erase_info); 463 pos += partition->erase_size; 464 } 465 466 // Ran out of space on the device 467 errno = ENOSPC; 468 return -1; 469 } 470 471 ssize_t mtd_write_data(MtdWriteContext *ctx, const char *data, size_t len) 472 { 473 size_t wrote = 0; 474 while (wrote < len) { 475 // Coalesce partial writes into complete blocks 476 if (ctx->stored > 0 || len - wrote < ctx->partition->erase_size) { 477 size_t avail = ctx->partition->erase_size - ctx->stored; 478 size_t copy = len - wrote < avail ? len - wrote : avail; 479 memcpy(ctx->buffer + ctx->stored, data + wrote, copy); 480 ctx->stored += copy; 481 wrote += copy; 482 } 483 484 // If a complete block was accumulated, write it 485 if (ctx->stored == ctx->partition->erase_size) { 486 if (write_block(ctx, ctx->buffer)) return -1; 487 ctx->stored = 0; 488 } 489 490 // Write complete blocks directly from the user's buffer 491 while (ctx->stored == 0 && len - wrote >= ctx->partition->erase_size) { 492 if (write_block(ctx, data + wrote)) return -1; 493 wrote += ctx->partition->erase_size; 494 } 495 } 496 497 return wrote; 498 } 499 500 off_t mtd_erase_blocks(MtdWriteContext *ctx, int blocks) 501 { 502 // Zero-pad and write any pending data to get us to a block boundary 503 if (ctx->stored > 0) { 504 size_t zero = ctx->partition->erase_size - ctx->stored; 505 memset(ctx->buffer + ctx->stored, 0, zero); 506 if (write_block(ctx, ctx->buffer)) return -1; 507 ctx->stored = 0; 508 } 509 510 off_t pos = lseek(ctx->fd, 0, SEEK_CUR); 511 if ((off_t) pos == (off_t) -1) return pos; 512 513 const int total = (ctx->partition->size - pos) / ctx->partition->erase_size; 514 if (blocks < 0) blocks = total; 515 if (blocks > total) { 516 errno = ENOSPC; 517 return -1; 518 } 519 520 // Erase the specified number of blocks 521 while (blocks-- > 0) { 522 loff_t bpos = pos; 523 if (ioctl(ctx->fd, MEMGETBADBLOCK, &bpos) > 0) { 524 fprintf(stderr, "mtd: not erasing bad block at 0x%08lx\n", pos); 525 pos += ctx->partition->erase_size; 526 continue; // Don't try to erase known factory-bad blocks. 527 } 528 529 struct erase_info_user erase_info; 530 erase_info.start = pos; 531 erase_info.length = ctx->partition->erase_size; 532 if (ioctl(ctx->fd, MEMERASE, &erase_info) < 0) { 533 fprintf(stderr, "mtd: erase failure at 0x%08lx\n", pos); 534 } 535 pos += ctx->partition->erase_size; 536 } 537 538 return pos; 539 } 540 541 int mtd_write_close(MtdWriteContext *ctx) 542 { 543 int r = 0; 544 // Make sure any pending data gets written 545 if (mtd_erase_blocks(ctx, 0) == (off_t) -1) r = -1; 546 if (close(ctx->fd)) r = -1; 547 free(ctx->bad_block_offsets); 548 free(ctx->buffer); 549 free(ctx); 550 return r; 551 } 552 553 /* Return the offset of the first good block at or after pos (which 554 * might be pos itself). 555 */ 556 off_t mtd_find_write_start(MtdWriteContext *ctx, off_t pos) { 557 int i; 558 for (i = 0; i < ctx->bad_block_count; ++i) { 559 if (ctx->bad_block_offsets[i] == pos) { 560 pos += ctx->partition->erase_size; 561 } else if (ctx->bad_block_offsets[i] > pos) { 562 return pos; 563 } 564 } 565 return pos; 566 } 567
