Home | History | Annotate | Download | only in mtdutils
      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 = TEMP_FAILURE_RETRY(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->buffer);
    273         free(ctx);
    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         printf("mtd: ECCGETSTATS error (%s)\n", strerror(errno));
    287         return -1;
    288     }
    289 
    290     loff_t pos = TEMP_FAILURE_RETRY(lseek64(fd, 0, SEEK_CUR));
    291     if (pos == -1) {
    292         printf("mtd: read_block: couldn't SEEK_CUR: %s\n", strerror(errno));
    293         return -1;
    294     }
    295 
    296     ssize_t size = partition->erase_size;
    297     int mgbb;
    298 
    299     while (pos + size <= (int) partition->size) {
    300         if (TEMP_FAILURE_RETRY(lseek64(fd, pos, SEEK_SET)) != pos ||
    301                     TEMP_FAILURE_RETRY(read(fd, data, size)) != size) {
    302             printf("mtd: read error at 0x%08llx (%s)\n",
    303                    (long long)pos, strerror(errno));
    304         } else if (ioctl(fd, ECCGETSTATS, &after)) {
    305             printf("mtd: ECCGETSTATS error (%s)\n", strerror(errno));
    306             return -1;
    307         } else if (after.failed != before.failed) {
    308             printf("mtd: ECC errors (%d soft, %d hard) at 0x%08llx\n",
    309                    after.corrected - before.corrected,
    310                    after.failed - before.failed, (long long)pos);
    311             // copy the comparison baseline for the next read.
    312             memcpy(&before, &after, sizeof(struct mtd_ecc_stats));
    313         } else if ((mgbb = ioctl(fd, MEMGETBADBLOCK, &pos))) {
    314             fprintf(stderr,
    315                     "mtd: MEMGETBADBLOCK returned %d at 0x%08llx: %s\n",
    316                     mgbb, (long long)pos, strerror(errno));
    317         } else {
    318             return 0;  // Success!
    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     size_t read = 0;
    331     while (read < 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 < 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 = TEMP_FAILURE_RETRY(lseek(fd, 0, SEEK_CUR));
    412     if (pos == (off_t) -1) {
    413         printf("mtd: write_block: couldn't SEEK_CUR: %s\n", strerror(errno));
    414         return -1;
    415     }
    416 
    417     ssize_t size = partition->erase_size;
    418     while (pos + size <= (int) partition->size) {
    419         loff_t bpos = pos;
    420         int ret = ioctl(fd, MEMGETBADBLOCK, &bpos);
    421         if (ret != 0 && !(ret == -1 && errno == EOPNOTSUPP)) {
    422             add_bad_block_offset(ctx, pos);
    423             fprintf(stderr,
    424                     "mtd: not writing bad block at 0x%08lx (ret %d): %s\n",
    425                     pos, ret, strerror(errno));
    426             pos += partition->erase_size;
    427             continue;  // Don't try to erase known factory-bad blocks.
    428         }
    429 
    430         struct erase_info_user erase_info;
    431         erase_info.start = pos;
    432         erase_info.length = size;
    433         int retry;
    434         for (retry = 0; retry < 2; ++retry) {
    435             if (ioctl(fd, MEMERASE, &erase_info) < 0) {
    436                 printf("mtd: erase failure at 0x%08lx (%s)\n",
    437                         pos, strerror(errno));
    438                 continue;
    439             }
    440             if (TEMP_FAILURE_RETRY(lseek(fd, pos, SEEK_SET)) != pos ||
    441                 TEMP_FAILURE_RETRY(write(fd, data, size)) != size) {
    442                 printf("mtd: write error at 0x%08lx (%s)\n",
    443                         pos, strerror(errno));
    444             }
    445 
    446             char verify[size];
    447             if (TEMP_FAILURE_RETRY(lseek(fd, pos, SEEK_SET)) != pos ||
    448                 TEMP_FAILURE_RETRY(read(fd, verify, size)) != size) {
    449                 printf("mtd: re-read error at 0x%08lx (%s)\n",
    450                         pos, strerror(errno));
    451                 continue;
    452             }
    453             if (memcmp(data, verify, size) != 0) {
    454                 printf("mtd: verification error at 0x%08lx (%s)\n",
    455                         pos, strerror(errno));
    456                 continue;
    457             }
    458 
    459             if (retry > 0) {
    460                 printf("mtd: wrote block after %d retries\n", retry);
    461             }
    462             printf("mtd: successfully wrote block at %lx\n", pos);
    463             return 0;  // Success!
    464         }
    465 
    466         // Try to erase it once more as we give up on this block
    467         add_bad_block_offset(ctx, pos);
    468         printf("mtd: skipping write block at 0x%08lx\n", pos);
    469         ioctl(fd, MEMERASE, &erase_info);
    470         pos += partition->erase_size;
    471     }
    472 
    473     // Ran out of space on the device
    474     errno = ENOSPC;
    475     return -1;
    476 }
    477 
    478 ssize_t mtd_write_data(MtdWriteContext *ctx, const char *data, size_t len)
    479 {
    480     size_t wrote = 0;
    481     while (wrote < len) {
    482         // Coalesce partial writes into complete blocks
    483         if (ctx->stored > 0 || len - wrote < ctx->partition->erase_size) {
    484             size_t avail = ctx->partition->erase_size - ctx->stored;
    485             size_t copy = len - wrote < avail ? len - wrote : avail;
    486             memcpy(ctx->buffer + ctx->stored, data + wrote, copy);
    487             ctx->stored += copy;
    488             wrote += copy;
    489         }
    490 
    491         // If a complete block was accumulated, write it
    492         if (ctx->stored == ctx->partition->erase_size) {
    493             if (write_block(ctx, ctx->buffer)) return -1;
    494             ctx->stored = 0;
    495         }
    496 
    497         // Write complete blocks directly from the user's buffer
    498         while (ctx->stored == 0 && len - wrote >= ctx->partition->erase_size) {
    499             if (write_block(ctx, data + wrote)) return -1;
    500             wrote += ctx->partition->erase_size;
    501         }
    502     }
    503 
    504     return wrote;
    505 }
    506 
    507 off_t mtd_erase_blocks(MtdWriteContext *ctx, int blocks)
    508 {
    509     // Zero-pad and write any pending data to get us to a block boundary
    510     if (ctx->stored > 0) {
    511         size_t zero = ctx->partition->erase_size - ctx->stored;
    512         memset(ctx->buffer + ctx->stored, 0, zero);
    513         if (write_block(ctx, ctx->buffer)) return -1;
    514         ctx->stored = 0;
    515     }
    516 
    517     off_t pos = TEMP_FAILURE_RETRY(lseek(ctx->fd, 0, SEEK_CUR));
    518     if ((off_t) pos == (off_t) -1) {
    519         printf("mtd_erase_blocks: couldn't SEEK_CUR: %s\n", strerror(errno));
    520         return -1;
    521     }
    522 
    523     const int total = (ctx->partition->size - pos) / ctx->partition->erase_size;
    524     if (blocks < 0) blocks = total;
    525     if (blocks > total) {
    526         errno = ENOSPC;
    527         return -1;
    528     }
    529 
    530     // Erase the specified number of blocks
    531     while (blocks-- > 0) {
    532         loff_t bpos = pos;
    533         if (ioctl(ctx->fd, MEMGETBADBLOCK, &bpos) > 0) {
    534             printf("mtd: not erasing bad block at 0x%08lx\n", pos);
    535             pos += ctx->partition->erase_size;
    536             continue;  // Don't try to erase known factory-bad blocks.
    537         }
    538 
    539         struct erase_info_user erase_info;
    540         erase_info.start = pos;
    541         erase_info.length = ctx->partition->erase_size;
    542         if (ioctl(ctx->fd, MEMERASE, &erase_info) < 0) {
    543             printf("mtd: erase failure at 0x%08lx\n", pos);
    544         }
    545         pos += ctx->partition->erase_size;
    546     }
    547 
    548     return pos;
    549 }
    550 
    551 int mtd_write_close(MtdWriteContext *ctx)
    552 {
    553     int r = 0;
    554     // Make sure any pending data gets written
    555     if (mtd_erase_blocks(ctx, 0) == (off_t) -1) r = -1;
    556     if (close(ctx->fd)) r = -1;
    557     free(ctx->bad_block_offsets);
    558     free(ctx->buffer);
    559     free(ctx);
    560     return r;
    561 }
    562