| /* Copyright (C) 2007-2008 The Android Open Source Project |
| ** |
| ** This software is licensed under the terms of the GNU General Public |
| ** License version 2, as published by the Free Software Foundation, and |
| ** may be copied, distributed, and modified under those terms. |
| ** |
| ** This program is distributed in the hope that it will be useful, |
| ** but WITHOUT ANY WARRANTY; without even the implied warranty of |
| ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| ** GNU General Public License for more details. |
| */ |
| #include "qemu_file.h" |
| #include "goldfish_nand_reg.h" |
| #include "goldfish_nand.h" |
| #include "android/utils/tempfile.h" |
| #include "qemu_debug.h" |
| #include "android/android.h" |
| |
| #ifdef TARGET_I386 |
| #include "kvm.h" |
| #endif |
| |
| #define DEBUG 1 |
| #if DEBUG |
| # define D(...) VERBOSE_PRINT(init,__VA_ARGS__) |
| # define D_ACTIVE VERBOSE_CHECK(init) |
| # define T(...) VERBOSE_PRINT(nand_limits,__VA_ARGS__) |
| # define T_ACTIVE VERBOSE_CHECK(nand_limits) |
| #else |
| # define D(...) ((void)0) |
| # define D_ACTIVE 0 |
| # define T(...) ((void)0) |
| # define T_ACTIVE 0 |
| #endif |
| |
| /* lseek uses 64-bit offsets on Darwin. */ |
| /* prefer lseek64 on Linux */ |
| #ifdef __APPLE__ |
| # define llseek lseek |
| #elif defined(__linux__) |
| # define llseek lseek64 |
| #endif |
| |
| #define XLOG xlog |
| |
| static void |
| xlog( const char* format, ... ) |
| { |
| va_list args; |
| va_start(args, format); |
| fprintf(stderr, "NAND: "); |
| vfprintf(stderr, format, args); |
| va_end(args); |
| } |
| |
| /* Information on a single device/nand image used by the emulator |
| */ |
| typedef struct { |
| char* devname; /* name for this device (not null-terminated, use len below) */ |
| size_t devname_len; |
| uint8_t* data; /* buffer for read/write actions to underlying image */ |
| int fd; |
| uint32_t flags; |
| uint32_t page_size; |
| uint32_t extra_size; |
| uint32_t erase_size; /* size of the data buffer mentioned above */ |
| uint64_t max_size; /* Capacity limit for the image. The actual underlying |
| * file may be smaller. */ |
| } nand_dev; |
| |
| nand_threshold android_nand_write_threshold; |
| nand_threshold android_nand_read_threshold; |
| |
| #ifdef CONFIG_NAND_THRESHOLD |
| |
| /* update a threshold, return 1 if limit is hit, 0 otherwise */ |
| static void |
| nand_threshold_update( nand_threshold* t, uint32_t len ) |
| { |
| if (t->counter < t->limit) { |
| uint64_t avail = t->limit - t->counter; |
| if (avail > len) |
| avail = len; |
| |
| if (t->counter == 0) { |
| T("%s: starting threshold counting to %lld", |
| __FUNCTION__, t->limit); |
| } |
| t->counter += avail; |
| if (t->counter >= t->limit) { |
| /* threshold reach, send a signal to an external process */ |
| T( "%s: sending signal %d to pid %d !", |
| __FUNCTION__, t->signal, t->pid ); |
| |
| kill( t->pid, t->signal ); |
| } |
| } |
| return; |
| } |
| |
| #define NAND_UPDATE_READ_THRESHOLD(len) \ |
| nand_threshold_update( &android_nand_read_threshold, (uint32_t)(len) ) |
| |
| #define NAND_UPDATE_WRITE_THRESHOLD(len) \ |
| nand_threshold_update( &android_nand_write_threshold, (uint32_t)(len) ) |
| |
| #else /* !NAND_THRESHOLD */ |
| |
| #define NAND_UPDATE_READ_THRESHOLD(len) \ |
| do {} while (0) |
| |
| #define NAND_UPDATE_WRITE_THRESHOLD(len) \ |
| do {} while (0) |
| |
| #endif /* !NAND_THRESHOLD */ |
| |
| static nand_dev *nand_devs = NULL; |
| static uint32_t nand_dev_count = 0; |
| |
| /* The controller is the single access point for all NAND images currently |
| * attached to the system. |
| */ |
| typedef struct { |
| uint32_t base; |
| |
| // register state |
| uint32_t dev; /* offset in nand_devs for the device that is |
| * currently being accessed */ |
| uint32_t addr_low; |
| uint32_t addr_high; |
| uint32_t transfer_size; |
| uint32_t data; |
| uint32_t batch_addr_low; |
| uint32_t batch_addr_high; |
| uint32_t result; |
| } nand_dev_controller_state; |
| |
| /* update this everytime you change the nand_dev_controller_state structure |
| * 1: initial version, saving only nand_dev_controller_state fields |
| * 2: saving actual disk contents as well |
| * 3: use the correct data length and truncate to avoid padding. |
| */ |
| #define NAND_DEV_STATE_SAVE_VERSION 4 |
| |
| #define QFIELD_STRUCT nand_dev_controller_state |
| QFIELD_BEGIN(nand_dev_controller_state_fields) |
| QFIELD_INT32(dev), |
| QFIELD_INT32(addr_low), |
| QFIELD_INT32(addr_high), |
| QFIELD_INT32(transfer_size), |
| QFIELD_INT32(data), |
| QFIELD_INT32(batch_addr_low), |
| QFIELD_INT32(batch_addr_high), |
| QFIELD_INT32(result), |
| QFIELD_END |
| |
| |
| /* EINTR-proof read - due to SIGALRM in use elsewhere */ |
| static int do_read(int fd, void* buf, size_t size) |
| { |
| int ret; |
| do { |
| ret = read(fd, buf, size); |
| } while (ret < 0 && errno == EINTR); |
| |
| return ret; |
| } |
| |
| /* EINTR-proof write - due to SIGALRM in use elsewhere */ |
| static int do_write(int fd, const void* buf, size_t size) |
| { |
| int ret; |
| do { |
| ret = write(fd, buf, size); |
| } while (ret < 0 && errno == EINTR); |
| |
| return ret; |
| } |
| |
| /* EINTR-proof lseek - due to SIGALRM in use elsewhere */ |
| static int do_lseek(int fd, off_t offset, int whence) |
| { |
| int ret; |
| do { |
| ret = lseek(fd, offset, whence); |
| } while (ret < 0 && errno == EINTR); |
| |
| return ret; |
| } |
| |
| /* EINTR-proof ftruncate - due to SIGALRM in use elsewhere */ |
| static int do_ftruncate(int fd, size_t size) |
| { |
| int ret; |
| do { |
| ret = ftruncate(fd, size); |
| } while (ret < 0 && errno == EINTR); |
| |
| return ret; |
| } |
| |
| #define NAND_DEV_SAVE_DISK_BUF_SIZE 2048 |
| |
| |
| /** |
| * Copies the current contents of a disk image into the snapshot file. |
| * |
| * TODO optimize this using some kind of copy-on-write mechanism for |
| * unchanged disk sections. |
| */ |
| static void nand_dev_save_disk_state(QEMUFile *f, nand_dev *dev) |
| { |
| int buf_size = NAND_DEV_SAVE_DISK_BUF_SIZE; |
| uint8_t buffer[NAND_DEV_SAVE_DISK_BUF_SIZE] = {0}; |
| int ret; |
| uint64_t total_copied = 0; |
| |
| /* Size of file to restore, hence size of data block following. |
| * TODO Work out whether to use lseek64 here. */ |
| |
| ret = do_lseek(dev->fd, 0, SEEK_END); |
| if (ret < 0) { |
| XLOG("%s EOF seek failed: %s\n", __FUNCTION__, strerror(errno)); |
| qemu_file_set_error(f); |
| return; |
| } |
| const uint64_t total_size = ret; |
| qemu_put_be64(f, total_size); |
| |
| /* copy all data from the stream to the stored image */ |
| ret = do_lseek(dev->fd, 0, SEEK_SET); |
| if (ret < 0) { |
| XLOG("%s seek failed: %s\n", __FUNCTION__, strerror(errno)); |
| qemu_file_set_error(f); |
| return; |
| } |
| do { |
| ret = do_read(dev->fd, buffer, buf_size); |
| if (ret < 0) { |
| XLOG("%s read failed: %s\n", __FUNCTION__, strerror(errno)); |
| qemu_file_set_error(f); |
| return; |
| } |
| qemu_put_buffer(f, buffer, ret); |
| |
| total_copied += ret; |
| } |
| while (ret == buf_size && total_copied < dev->max_size); |
| |
| /* TODO Maybe check that we've written total_size bytes */ |
| } |
| |
| |
| /** |
| * Saves the state of all disks managed by this controller to a snapshot file. |
| */ |
| static void nand_dev_save_disks(QEMUFile *f) |
| { |
| int i; |
| for (i = 0; i < nand_dev_count; i++) { |
| nand_dev_save_disk_state(f, nand_devs + i); |
| } |
| } |
| |
| /** |
| * Overwrites the contents of the disk image managed by this device with the |
| * contents as they were at the point the snapshot was made. |
| */ |
| static int nand_dev_load_disk_state(QEMUFile *f, nand_dev *dev) |
| { |
| int buf_size = NAND_DEV_SAVE_DISK_BUF_SIZE; |
| uint8_t buffer[NAND_DEV_SAVE_DISK_BUF_SIZE] = {0}; |
| int ret; |
| |
| /* File size for restore and truncate */ |
| uint64_t total_size = qemu_get_be64(f); |
| if (total_size > dev->max_size) { |
| XLOG("%s, restore failed: size required (%lld) exceeds device limit (%lld)\n", |
| __FUNCTION__, total_size, dev->max_size); |
| return -EIO; |
| } |
| |
| /* overwrite disk contents with snapshot contents */ |
| uint64_t next_offset = 0; |
| ret = do_lseek(dev->fd, 0, SEEK_SET); |
| if (ret < 0) { |
| XLOG("%s seek failed: %s\n", __FUNCTION__, strerror(errno)); |
| return -EIO; |
| } |
| while (next_offset < total_size) { |
| /* snapshot buffer may not be an exact multiple of buf_size |
| * if necessary, adjust buffer size for last copy operation */ |
| if (total_size - next_offset < buf_size) { |
| buf_size = total_size - next_offset; |
| } |
| |
| ret = qemu_get_buffer(f, buffer, buf_size); |
| if (ret != buf_size) { |
| XLOG("%s read failed: expected %d bytes but got %d\n", |
| __FUNCTION__, buf_size, ret); |
| return -EIO; |
| } |
| ret = do_write(dev->fd, buffer, buf_size); |
| if (ret != buf_size) { |
| XLOG("%s, write failed: %s\n", __FUNCTION__, strerror(errno)); |
| return -EIO; |
| } |
| |
| next_offset += buf_size; |
| } |
| |
| ret = do_ftruncate(dev->fd, total_size); |
| if (ret < 0) { |
| XLOG("%s ftruncate failed: %s\n", __FUNCTION__, strerror(errno)); |
| return -EIO; |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Restores the state of all disks managed by this driver from a snapshot file. |
| */ |
| static int nand_dev_load_disks(QEMUFile *f) |
| { |
| int i, ret; |
| for (i = 0; i < nand_dev_count; i++) { |
| ret = nand_dev_load_disk_state(f, nand_devs + i); |
| if (ret) |
| return ret; // abort on error |
| } |
| |
| return 0; |
| } |
| |
| static void nand_dev_controller_state_save(QEMUFile *f, void *opaque) |
| { |
| nand_dev_controller_state* s = opaque; |
| |
| qemu_put_struct(f, nand_dev_controller_state_fields, s); |
| |
| /* The guest will continue writing to the disk image after the state has |
| * been saved. To guarantee that the state is identical after resume, save |
| * a copy of the current disk state in the snapshot. |
| */ |
| nand_dev_save_disks(f); |
| } |
| |
| static int nand_dev_controller_state_load(QEMUFile *f, void *opaque, int version_id) |
| { |
| nand_dev_controller_state* s = opaque; |
| int ret; |
| |
| if (version_id != NAND_DEV_STATE_SAVE_VERSION) |
| return -1; |
| |
| if ((ret = qemu_get_struct(f, nand_dev_controller_state_fields, s))) |
| return ret; |
| if ((ret = nand_dev_load_disks(f))) |
| return ret; |
| |
| return 0; |
| } |
| |
| static uint32_t nand_dev_read_file(nand_dev *dev, uint32_t data, uint64_t addr, uint32_t total_len) |
| { |
| uint32_t len = total_len; |
| size_t read_len = dev->erase_size; |
| int eof = 0; |
| |
| NAND_UPDATE_READ_THRESHOLD(total_len); |
| |
| do_lseek(dev->fd, addr, SEEK_SET); |
| while(len > 0) { |
| if(read_len < dev->erase_size) { |
| memset(dev->data, 0xff, dev->erase_size); |
| read_len = dev->erase_size; |
| eof = 1; |
| } |
| if(len < read_len) |
| read_len = len; |
| if(!eof) { |
| read_len = do_read(dev->fd, dev->data, read_len); |
| } |
| #ifdef TARGET_I386 |
| if (kvm_enabled()) |
| cpu_synchronize_state(cpu_single_env, 0); |
| #endif |
| cpu_memory_rw_debug(cpu_single_env, data, dev->data, read_len, 1); |
| data += read_len; |
| len -= read_len; |
| } |
| return total_len; |
| } |
| |
| static uint32_t nand_dev_write_file(nand_dev *dev, uint32_t data, uint64_t addr, uint32_t total_len) |
| { |
| uint32_t len = total_len; |
| size_t write_len = dev->erase_size; |
| int ret; |
| |
| NAND_UPDATE_WRITE_THRESHOLD(total_len); |
| |
| do_lseek(dev->fd, addr, SEEK_SET); |
| while(len > 0) { |
| if(len < write_len) |
| write_len = len; |
| #ifdef TARGET_I386 |
| if (kvm_enabled()) |
| cpu_synchronize_state(cpu_single_env, 0); |
| #endif |
| cpu_memory_rw_debug(cpu_single_env, data, dev->data, write_len, 0); |
| ret = do_write(dev->fd, dev->data, write_len); |
| if(ret < write_len) { |
| XLOG("nand_dev_write_file, write failed: %s\n", strerror(errno)); |
| break; |
| } |
| data += write_len; |
| len -= write_len; |
| } |
| return total_len - len; |
| } |
| |
| static uint32_t nand_dev_erase_file(nand_dev *dev, uint64_t addr, uint32_t total_len) |
| { |
| uint32_t len = total_len; |
| size_t write_len = dev->erase_size; |
| int ret; |
| |
| do_lseek(dev->fd, addr, SEEK_SET); |
| memset(dev->data, 0xff, dev->erase_size); |
| while(len > 0) { |
| if(len < write_len) |
| write_len = len; |
| ret = do_write(dev->fd, dev->data, write_len); |
| if(ret < write_len) { |
| XLOG( "nand_dev_write_file, write failed: %s\n", strerror(errno)); |
| break; |
| } |
| len -= write_len; |
| } |
| return total_len - len; |
| } |
| |
| /* this is a huge hack required to make the PowerPC emulator binary usable |
| * on Mac OS X. If you define this function as 'static', the emulated kernel |
| * will panic when attempting to mount the /data partition. |
| * |
| * worse, if you do *not* define the function as static on Linux-x86, the |
| * emulated kernel will also panic !? |
| * |
| * I still wonder if this is a compiler bug, or due to some nasty thing the |
| * emulator does with CPU registers during execution of the translated code. |
| */ |
| #if !(defined __APPLE__ && defined __powerpc__) |
| static |
| #endif |
| uint32_t nand_dev_do_cmd(nand_dev_controller_state *s, uint32_t cmd) |
| { |
| uint32_t size; |
| uint64_t addr; |
| nand_dev *dev; |
| |
| if (cmd == NAND_CMD_WRITE_BATCH || cmd == NAND_CMD_READ_BATCH || |
| cmd == NAND_CMD_ERASE_BATCH) { |
| struct batch_data bd; |
| uint64_t bd_addr = ((uint64_t)s->batch_addr_high << 32) | s->batch_addr_low; |
| |
| cpu_physical_memory_read(bd_addr, (void*)&bd, sizeof(struct batch_data)); |
| s->dev = bd.dev; |
| s->addr_low = bd.addr_low; |
| s->addr_high = bd.addr_high; |
| s->transfer_size = bd.transfer_size; |
| s->data = bd.data; |
| } |
| addr = s->addr_low | ((uint64_t)s->addr_high << 32); |
| size = s->transfer_size; |
| if(s->dev >= nand_dev_count) |
| return 0; |
| dev = nand_devs + s->dev; |
| |
| switch(cmd) { |
| case NAND_CMD_GET_DEV_NAME: |
| if(size > dev->devname_len) |
| size = dev->devname_len; |
| #ifdef TARGET_I386 |
| if (kvm_enabled()) |
| cpu_synchronize_state(cpu_single_env, 0); |
| #endif |
| cpu_memory_rw_debug(cpu_single_env, s->data, (uint8_t*)dev->devname, size, 1); |
| return size; |
| case NAND_CMD_READ_BATCH: |
| case NAND_CMD_READ: |
| if(addr >= dev->max_size) |
| return 0; |
| if(size > dev->max_size - addr) |
| size = dev->max_size - addr; |
| if(dev->fd >= 0) |
| return nand_dev_read_file(dev, s->data, addr, size); |
| #ifdef TARGET_I386 |
| if (kvm_enabled()) |
| cpu_synchronize_state(cpu_single_env, 0); |
| #endif |
| cpu_memory_rw_debug(cpu_single_env,s->data, &dev->data[addr], size, 1); |
| return size; |
| case NAND_CMD_WRITE_BATCH: |
| case NAND_CMD_WRITE: |
| if(dev->flags & NAND_DEV_FLAG_READ_ONLY) |
| return 0; |
| if(addr >= dev->max_size) |
| return 0; |
| if(size > dev->max_size - addr) |
| size = dev->max_size - addr; |
| if(dev->fd >= 0) |
| return nand_dev_write_file(dev, s->data, addr, size); |
| #ifdef TARGET_I386 |
| if (kvm_enabled()) |
| cpu_synchronize_state(cpu_single_env, 0); |
| #endif |
| cpu_memory_rw_debug(cpu_single_env,s->data, &dev->data[addr], size, 0); |
| return size; |
| case NAND_CMD_ERASE_BATCH: |
| case NAND_CMD_ERASE: |
| if(dev->flags & NAND_DEV_FLAG_READ_ONLY) |
| return 0; |
| if(addr >= dev->max_size) |
| return 0; |
| if(size > dev->max_size - addr) |
| size = dev->max_size - addr; |
| if(dev->fd >= 0) |
| return nand_dev_erase_file(dev, addr, size); |
| memset(&dev->data[addr], 0xff, size); |
| return size; |
| case NAND_CMD_BLOCK_BAD_GET: // no bad block support |
| return 0; |
| case NAND_CMD_BLOCK_BAD_SET: |
| if(dev->flags & NAND_DEV_FLAG_READ_ONLY) |
| return 0; |
| return 0; |
| default: |
| cpu_abort(cpu_single_env, "nand_dev_do_cmd: Bad command %x\n", cmd); |
| return 0; |
| } |
| } |
| |
| /* I/O write */ |
| static void nand_dev_write(void *opaque, target_phys_addr_t offset, uint32_t value) |
| { |
| nand_dev_controller_state *s = (nand_dev_controller_state *)opaque; |
| |
| switch (offset) { |
| case NAND_DEV: |
| s->dev = value; |
| if(s->dev >= nand_dev_count) { |
| cpu_abort(cpu_single_env, "nand_dev_write: Bad dev %x\n", value); |
| } |
| break; |
| case NAND_ADDR_HIGH: |
| s->addr_high = value; |
| break; |
| case NAND_ADDR_LOW: |
| s->addr_low = value; |
| break; |
| case NAND_BATCH_ADDR_LOW: |
| s->batch_addr_low = value; |
| break; |
| case NAND_BATCH_ADDR_HIGH: |
| s->batch_addr_high = value; |
| break; |
| case NAND_TRANSFER_SIZE: |
| s->transfer_size = value; |
| break; |
| case NAND_DATA: |
| s->data = value; |
| break; |
| case NAND_COMMAND: |
| s->result = nand_dev_do_cmd(s, value); |
| if (value == NAND_CMD_WRITE_BATCH || value == NAND_CMD_READ_BATCH || |
| value == NAND_CMD_ERASE_BATCH) { |
| struct batch_data bd; |
| uint64_t bd_addr = ((uint64_t)s->batch_addr_high << 32) | s->batch_addr_low; |
| bd.result = s->result; |
| cpu_physical_memory_write(bd_addr, (void*)&bd, sizeof(struct batch_data)); |
| } |
| break; |
| default: |
| cpu_abort(cpu_single_env, "nand_dev_write: Bad offset %x\n", offset); |
| break; |
| } |
| } |
| |
| /* I/O read */ |
| static uint32_t nand_dev_read(void *opaque, target_phys_addr_t offset) |
| { |
| nand_dev_controller_state *s = (nand_dev_controller_state *)opaque; |
| nand_dev *dev; |
| |
| switch (offset) { |
| case NAND_VERSION: |
| return NAND_VERSION_CURRENT; |
| case NAND_NUM_DEV: |
| return nand_dev_count; |
| case NAND_RESULT: |
| return s->result; |
| } |
| |
| if(s->dev >= nand_dev_count) |
| return 0; |
| |
| dev = nand_devs + s->dev; |
| |
| switch (offset) { |
| case NAND_DEV_FLAGS: |
| return dev->flags; |
| |
| case NAND_DEV_NAME_LEN: |
| return dev->devname_len; |
| |
| case NAND_DEV_PAGE_SIZE: |
| return dev->page_size; |
| |
| case NAND_DEV_EXTRA_SIZE: |
| return dev->extra_size; |
| |
| case NAND_DEV_ERASE_SIZE: |
| return dev->erase_size; |
| |
| case NAND_DEV_SIZE_LOW: |
| return (uint32_t)dev->max_size; |
| |
| case NAND_DEV_SIZE_HIGH: |
| return (uint32_t)(dev->max_size >> 32); |
| |
| default: |
| cpu_abort(cpu_single_env, "nand_dev_read: Bad offset %x\n", offset); |
| return 0; |
| } |
| } |
| |
| static CPUReadMemoryFunc *nand_dev_readfn[] = { |
| nand_dev_read, |
| nand_dev_read, |
| nand_dev_read |
| }; |
| |
| static CPUWriteMemoryFunc *nand_dev_writefn[] = { |
| nand_dev_write, |
| nand_dev_write, |
| nand_dev_write |
| }; |
| |
| /* initialize the QFB device */ |
| void nand_dev_init(uint32_t base) |
| { |
| int iomemtype; |
| static int instance_id = 0; |
| nand_dev_controller_state *s; |
| |
| s = (nand_dev_controller_state *)qemu_mallocz(sizeof(nand_dev_controller_state)); |
| iomemtype = cpu_register_io_memory(nand_dev_readfn, nand_dev_writefn, s); |
| cpu_register_physical_memory(base, 0x00000fff, iomemtype); |
| s->base = base; |
| |
| register_savevm( "nand_dev", instance_id++, NAND_DEV_STATE_SAVE_VERSION, |
| nand_dev_controller_state_save, nand_dev_controller_state_load, s); |
| } |
| |
| static int arg_match(const char *a, const char *b, size_t b_len) |
| { |
| while(*a && b_len--) { |
| if(*a++ != *b++) |
| return 0; |
| } |
| return b_len == 0; |
| } |
| |
| void nand_add_dev(const char *arg) |
| { |
| uint64_t dev_size = 0; |
| const char *next_arg; |
| const char *value; |
| size_t arg_len, value_len; |
| nand_dev *new_devs, *dev; |
| char *devname = NULL; |
| size_t devname_len = 0; |
| char *initfilename = NULL; |
| char *rwfilename = NULL; |
| int initfd = -1; |
| int rwfd = -1; |
| int read_only = 0; |
| int pad; |
| ssize_t read_size; |
| uint32_t page_size = 2048; |
| uint32_t extra_size = 64; |
| uint32_t erase_pages = 64; |
| |
| VERBOSE_PRINT(init, "%s: %s", __FUNCTION__, arg); |
| |
| while(arg) { |
| next_arg = strchr(arg, ','); |
| value = strchr(arg, '='); |
| if(next_arg != NULL) { |
| arg_len = next_arg - arg; |
| next_arg++; |
| if(value >= next_arg) |
| value = NULL; |
| } |
| else |
| arg_len = strlen(arg); |
| if(value != NULL) { |
| size_t new_arg_len = value - arg; |
| value_len = arg_len - new_arg_len - 1; |
| arg_len = new_arg_len; |
| value++; |
| } |
| else |
| value_len = 0; |
| |
| if(devname == NULL) { |
| if(value != NULL) |
| goto bad_arg_and_value; |
| devname_len = arg_len; |
| devname = malloc(arg_len+1); |
| if(devname == NULL) |
| goto out_of_memory; |
| memcpy(devname, arg, arg_len); |
| devname[arg_len] = 0; |
| } |
| else if(value == NULL) { |
| if(arg_match("readonly", arg, arg_len)) { |
| read_only = 1; |
| } |
| else { |
| XLOG("bad arg: %.*s\n", arg_len, arg); |
| exit(1); |
| } |
| } |
| else { |
| if(arg_match("size", arg, arg_len)) { |
| char *ep; |
| dev_size = strtoull(value, &ep, 0); |
| if(ep != value + value_len) |
| goto bad_arg_and_value; |
| } |
| else if(arg_match("pagesize", arg, arg_len)) { |
| char *ep; |
| page_size = strtoul(value, &ep, 0); |
| if(ep != value + value_len) |
| goto bad_arg_and_value; |
| } |
| else if(arg_match("extrasize", arg, arg_len)) { |
| char *ep; |
| extra_size = strtoul(value, &ep, 0); |
| if(ep != value + value_len) |
| goto bad_arg_and_value; |
| } |
| else if(arg_match("erasepages", arg, arg_len)) { |
| char *ep; |
| erase_pages = strtoul(value, &ep, 0); |
| if(ep != value + value_len) |
| goto bad_arg_and_value; |
| } |
| else if(arg_match("initfile", arg, arg_len)) { |
| initfilename = malloc(value_len + 1); |
| if(initfilename == NULL) |
| goto out_of_memory; |
| memcpy(initfilename, value, value_len); |
| initfilename[value_len] = '\0'; |
| } |
| else if(arg_match("file", arg, arg_len)) { |
| rwfilename = malloc(value_len + 1); |
| if(rwfilename == NULL) |
| goto out_of_memory; |
| memcpy(rwfilename, value, value_len); |
| rwfilename[value_len] = '\0'; |
| } |
| else { |
| goto bad_arg_and_value; |
| } |
| } |
| |
| arg = next_arg; |
| } |
| |
| if (rwfilename == NULL) { |
| /* we create a temporary file to store everything */ |
| TempFile* tmp = tempfile_create(); |
| |
| if (tmp == NULL) { |
| XLOG("could not create temp file for %.*s NAND disk image: %s\n", |
| devname_len, devname, strerror(errno)); |
| exit(1); |
| } |
| rwfilename = (char*) tempfile_path(tmp); |
| if (VERBOSE_CHECK(init)) |
| dprint( "mapping '%.*s' NAND image to %s", devname_len, devname, rwfilename); |
| } |
| |
| if(rwfilename) { |
| if (initfilename) { |
| /* Overwrite with content of the 'initfilename'. */ |
| if (read_only) { |
| /* Cannot be readonly when initializing the device from another file. */ |
| XLOG("incompatible read only option is requested while initializing %.*s from %s\n", |
| devname_len, devname, initfilename); |
| exit(1); |
| } |
| rwfd = open(rwfilename, O_BINARY | O_TRUNC | O_RDWR); |
| } else { |
| rwfd = open(rwfilename, O_BINARY | (read_only ? O_RDONLY : O_RDWR)); |
| } |
| if(rwfd < 0) { |
| XLOG("could not open file %s, %s\n", rwfilename, strerror(errno)); |
| exit(1); |
| } |
| /* this could be a writable temporary file. use atexit_close_fd to ensure |
| * that it is properly cleaned up at exit on Win32 |
| */ |
| if (!read_only) |
| atexit_close_fd(rwfd); |
| } |
| |
| if(initfilename) { |
| initfd = open(initfilename, O_BINARY | O_RDONLY); |
| if(initfd < 0) { |
| XLOG("could not open file %s, %s\n", initfilename, strerror(errno)); |
| exit(1); |
| } |
| if(dev_size == 0) { |
| dev_size = do_lseek(initfd, 0, SEEK_END); |
| do_lseek(initfd, 0, SEEK_SET); |
| } |
| } |
| |
| new_devs = realloc(nand_devs, sizeof(nand_devs[0]) * (nand_dev_count + 1)); |
| if(new_devs == NULL) |
| goto out_of_memory; |
| nand_devs = new_devs; |
| dev = &new_devs[nand_dev_count]; |
| |
| dev->page_size = page_size; |
| dev->extra_size = extra_size; |
| dev->erase_size = erase_pages * (page_size + extra_size); |
| pad = dev_size % dev->erase_size; |
| if (pad != 0) { |
| dev_size += (dev->erase_size - pad); |
| D("rounding devsize up to a full eraseunit, now %llx\n", dev_size); |
| } |
| dev->devname = devname; |
| dev->devname_len = devname_len; |
| dev->max_size = dev_size; |
| dev->data = malloc(dev->erase_size); |
| if(dev->data == NULL) |
| goto out_of_memory; |
| dev->flags = read_only ? NAND_DEV_FLAG_READ_ONLY : 0; |
| #ifdef TARGET_I386 |
| dev->flags |= NAND_DEV_FLAG_BATCH_CAP; |
| #endif |
| |
| if (initfd >= 0) { |
| do { |
| read_size = do_read(initfd, dev->data, dev->erase_size); |
| if(read_size < 0) { |
| XLOG("could not read file %s, %s\n", initfilename, strerror(errno)); |
| exit(1); |
| } |
| if(do_write(rwfd, dev->data, read_size) != read_size) { |
| XLOG("could not write file %s, %s\n", rwfilename, strerror(errno)); |
| exit(1); |
| } |
| } while(read_size == dev->erase_size); |
| close(initfd); |
| } |
| dev->fd = rwfd; |
| |
| nand_dev_count++; |
| |
| return; |
| |
| out_of_memory: |
| XLOG("out of memory\n"); |
| exit(1); |
| |
| bad_arg_and_value: |
| XLOG("bad arg: %.*s=%.*s\n", arg_len, arg, value_len, value); |
| exit(1); |
| } |
| |
| #ifdef CONFIG_NAND_LIMITS |
| |
| static uint64_t |
| parse_nand_rw_limit( const char* value ) |
| { |
| char* end; |
| uint64_t val = strtoul( value, &end, 0 ); |
| |
| if (end == value) { |
| derror( "bad parameter value '%s': expecting unsigned integer", value ); |
| exit(1); |
| } |
| |
| switch (end[0]) { |
| case 'K': val <<= 10; break; |
| case 'M': val <<= 20; break; |
| case 'G': val <<= 30; break; |
| case 0: break; |
| default: |
| derror( "bad read/write limit suffix: use K, M or G" ); |
| exit(1); |
| } |
| return val; |
| } |
| |
| void |
| parse_nand_limits(char* limits) |
| { |
| int pid = -1, signal = -1; |
| int64_t reads = 0, writes = 0; |
| char* item = limits; |
| |
| /* parse over comma-separated items */ |
| while (item && *item) { |
| char* next = strchr(item, ','); |
| char* end; |
| |
| if (next == NULL) { |
| next = item + strlen(item); |
| } else { |
| *next++ = 0; |
| } |
| |
| if ( !memcmp(item, "pid=", 4) ) { |
| pid = strtol(item+4, &end, 10); |
| if (end == NULL || *end) { |
| derror( "bad parameter, expecting pid=<number>, got '%s'", |
| item ); |
| exit(1); |
| } |
| if (pid <= 0) { |
| derror( "bad parameter: process identifier must be > 0" ); |
| exit(1); |
| } |
| } |
| else if ( !memcmp(item, "signal=", 7) ) { |
| signal = strtol(item+7,&end, 10); |
| if (end == NULL || *end) { |
| derror( "bad parameter: expecting signal=<number>, got '%s'", |
| item ); |
| exit(1); |
| } |
| if (signal <= 0) { |
| derror( "bad parameter: signal number must be > 0" ); |
| exit(1); |
| } |
| } |
| else if ( !memcmp(item, "reads=", 6) ) { |
| reads = parse_nand_rw_limit(item+6); |
| } |
| else if ( !memcmp(item, "writes=", 7) ) { |
| writes = parse_nand_rw_limit(item+7); |
| } |
| else { |
| derror( "bad parameter '%s' (see -help-nand-limits)", item ); |
| exit(1); |
| } |
| item = next; |
| } |
| if (pid < 0) { |
| derror( "bad paramater: missing pid=<number>" ); |
| exit(1); |
| } |
| else if (signal < 0) { |
| derror( "bad parameter: missing signal=<number>" ); |
| exit(1); |
| } |
| else if (reads == 0 && writes == 0) { |
| dwarning( "no read or write limit specified. ignoring -nand-limits" ); |
| } else { |
| nand_threshold* t; |
| |
| t = &android_nand_read_threshold; |
| t->pid = pid; |
| t->signal = signal; |
| t->counter = 0; |
| t->limit = reads; |
| |
| t = &android_nand_write_threshold; |
| t->pid = pid; |
| t->signal = signal; |
| t->counter = 0; |
| t->limit = writes; |
| } |
| } |
| #endif /* CONFIG_NAND_LIMITS */ |
