1 /* 2 * Copyright (c) 2014, ARM Limited and Contributors. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * Redistributions of source code must retain the above copyright notice, this 8 * list of conditions and the following disclaimer. 9 * 10 * Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * Neither the name of ARM nor the names of its contributors may be used 15 * to endorse or promote products derived from this software without specific 16 * prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <assert.h> 32 #include <string.h> 33 #include "io_storage.h" 34 #include "io_driver.h" 35 #include "debug.h" 36 37 /* As we need to be able to keep state for seek, only one file can be open 38 * at a time. Make this a structure and point to the entity->info. When we 39 * can malloc memory we can change this to support more open files. 40 */ 41 typedef struct { 42 /* Use the 'in_use' flag as any value for base and file_pos could be 43 * valid. 44 */ 45 int in_use; 46 size_t base; 47 size_t file_pos; 48 } file_state; 49 50 static file_state current_file = {0}; 51 52 /* Identify the device type as memmap */ 53 io_type device_type_memmap(void) 54 { 55 return IO_TYPE_MEMMAP; 56 } 57 58 /* Memmap device functions */ 59 static int memmap_dev_open(void *spec, struct io_dev_info **dev_info); 60 static int memmap_block_open(struct io_dev_info *dev_info, const void *spec, 61 struct io_entity *entity); 62 static int memmap_block_seek(struct io_entity *entity, int mode, 63 ssize_t offset); 64 static int memmap_block_read(struct io_entity *entity, void *buffer, 65 size_t length, size_t *length_read); 66 static int memmap_block_write(struct io_entity *entity, const void *buffer, 67 size_t length, size_t *length_written); 68 static int memmap_block_close(struct io_entity *entity); 69 static int memmap_dev_close(struct io_dev_info *dev_info); 70 71 72 static struct io_dev_connector memmap_dev_connector = { 73 .dev_open = memmap_dev_open 74 }; 75 76 77 static struct io_dev_funcs memmap_dev_funcs = { 78 .type = device_type_memmap, 79 .open = memmap_block_open, 80 .seek = memmap_block_seek, 81 .size = NULL, 82 .read = memmap_block_read, 83 .write = memmap_block_write, 84 .close = memmap_block_close, 85 .dev_init = NULL, 86 .dev_close = memmap_dev_close, 87 }; 88 89 90 static struct io_dev_info memmap_dev_info = { 91 .funcs = &memmap_dev_funcs, 92 .info = (uintptr_t)NULL 93 }; 94 95 96 /* Open a connection to the memmap device */ 97 static int memmap_dev_open(void *spec __attribute__((unused)), 98 struct io_dev_info **dev_info) 99 { 100 assert(dev_info != NULL); 101 *dev_info = &memmap_dev_info; 102 103 return IO_SUCCESS; 104 } 105 106 107 108 /* Close a connection to the memmap device */ 109 static int memmap_dev_close(struct io_dev_info *dev_info) 110 { 111 /* NOP */ 112 /* TODO: Consider tracking open files and cleaning them up here */ 113 return IO_SUCCESS; 114 } 115 116 117 /* Open a file on the memmap device */ 118 /* TODO: Can we do any sensible limit checks on requested memory */ 119 static int memmap_block_open(struct io_dev_info *dev_info, const void *spec, 120 struct io_entity *entity) 121 { 122 int result = IO_FAIL; 123 const io_block_spec *block_spec = (io_block_spec *)spec; 124 125 /* Since we need to track open state for seek() we only allow one open 126 * spec at a time. When we have dynamic memory we can malloc and set 127 * entity->info. 128 */ 129 if (current_file.in_use == 0) { 130 assert(block_spec != NULL); 131 assert(entity != NULL); 132 133 current_file.in_use = 1; 134 current_file.base = block_spec->offset; 135 /* File cursor offset for seek and incremental reads etc. */ 136 current_file.file_pos = 0; 137 entity->info = (uintptr_t)¤t_file; 138 result = IO_SUCCESS; 139 } else { 140 ERROR("A Memmap device is already active. Close first.\n"); 141 result = IO_RESOURCES_EXHAUSTED; 142 } 143 144 return result; 145 } 146 147 148 /* Seek to a particular file offset on the memmap device */ 149 static int memmap_block_seek(struct io_entity *entity, int mode, ssize_t offset) 150 { 151 int result = IO_FAIL; 152 153 /* We only support IO_SEEK_SET for the moment. */ 154 if (mode == IO_SEEK_SET) { 155 assert(entity != NULL); 156 157 /* TODO: can we do some basic limit checks on seek? */ 158 ((file_state *)entity->info)->file_pos = offset; 159 result = IO_SUCCESS; 160 } else { 161 result = IO_FAIL; 162 } 163 164 return result; 165 } 166 167 168 /* Read data from a file on the memmap device */ 169 static int memmap_block_read(struct io_entity *entity, void *buffer, 170 size_t length, size_t *length_read) 171 { 172 file_state *fp; 173 174 assert(entity != NULL); 175 assert(buffer != NULL); 176 assert(length_read != NULL); 177 178 fp = (file_state *)entity->info; 179 180 memcpy(buffer, (void *)(fp->base + fp->file_pos), length); 181 182 *length_read = length; 183 /* advance the file 'cursor' for incremental reads */ 184 fp->file_pos += length; 185 186 return IO_SUCCESS; 187 } 188 189 190 /* Write data to a file on the memmap device */ 191 static int memmap_block_write(struct io_entity *entity, const void *buffer, 192 size_t length, size_t *length_written) 193 { 194 file_state *fp; 195 196 assert(entity != NULL); 197 assert(buffer != NULL); 198 assert(length_written != NULL); 199 200 fp = (file_state *)entity->info; 201 202 memcpy((void *)(fp->base + fp->file_pos), buffer, length); 203 204 *length_written = length; 205 206 /* advance the file 'cursor' for incremental writes */ 207 fp->file_pos += length; 208 209 return IO_SUCCESS; 210 } 211 212 213 /* Close a file on the memmap device */ 214 static int memmap_block_close(struct io_entity *entity) 215 { 216 assert(entity != NULL); 217 218 entity->info = 0; 219 220 /* This would be a mem free() if we had malloc.*/ 221 memset((void *)¤t_file, 0, sizeof(current_file)); 222 223 return IO_SUCCESS; 224 } 225 226 227 /* Exported functions */ 228 229 /* Register the memmap driver with the IO abstraction */ 230 int register_io_dev_memmap(struct io_dev_connector **dev_con) 231 { 232 int result = IO_FAIL; 233 assert(dev_con != NULL); 234 235 result = io_register_device(&memmap_dev_info); 236 if (result == IO_SUCCESS) 237 *dev_con = &memmap_dev_connector; 238 239 return result; 240 } 241