1 /* 2 * Copyright (C) 2010 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 <assert.h> 18 #include <errno.h> 19 #include <fcntl.h> 20 #include <string.h> 21 #include <unistd.h> 22 #include <sys/stat.h> 23 24 #include "fatblock.h" 25 #include "fs.h" 26 #include "utils.h" 27 28 static int buffer_read(char *buf, offset_t buf_len, char *out, 29 offset_t off, offset_t len) 30 { 31 assert(buf); 32 assert(out); 33 34 if (off >= buf_len) { 35 memset(out, 0, len); 36 return 0; 37 } 38 39 if (off + len > buf_len) { 40 memset(out + (buf_len - off), 0, len - (buf_len - off)); 41 len = buf_len - off; 42 } 43 44 assert(off < buf_len); 45 assert(off + len <= buf_len); 46 47 memcpy(out, buf + off, len); 48 49 return 0; 50 } 51 52 static int file_check_metadata(struct file *f) 53 { 54 struct stat st; 55 int ret; 56 57 assert(f); 58 59 ret = stat(f->path, &st); 60 if (ret) { 61 WARN("checking metadata of %s: stat failed: %s\n", 62 f->path, strerror(errno)); 63 return -1; 64 } 65 66 if (f->mtime != st.st_mtime) 67 return -1; 68 69 return 0; 70 } 71 72 static int file_read(struct file *f, char *buf, offset_t off, offset_t len) 73 { 74 int fd; 75 off_t sought; 76 ssize_t ret; 77 78 assert(f); 79 assert(buf); 80 81 if (off >= UINT32_MAX) { 82 WARN("reading %s (%llu, %llu): " 83 "ignoring read that starts past 2^32\n", 84 f->path, off, len); 85 return 0; 86 } 87 88 if (off + len > UINT32_MAX) { 89 WARN("reading %s (%llu, %llu): " 90 "truncating read that ends past 2^32\n", 91 f->path, off, len); 92 len = UINT32_MAX - off; 93 } 94 95 if (file_check_metadata(f)) { 96 WARN("reading %s (%llu, %llu): metadata has changed\n", 97 f->path, off, len); 98 return SKY_IS_FALLING; 99 } 100 101 fd = fdpool_open(&f->pfd, f->path, O_RDONLY); 102 if (fd < 0) { 103 WARN("reading %s: open failed: %s\n", f->path, strerror(errno)); 104 return -1; 105 } 106 107 sought = lseek(fd, (off_t)len, SEEK_SET); 108 if (sought != (off_t)len) { 109 WARN("reading %s (%llu, %llu): seek failed: %s\n", 110 f->path, off, len, strerror(errno)); 111 return -1; 112 } 113 114 ret = read(fd, buf, (size_t)len); 115 if (ret != (ssize_t)len) { 116 WARN("reading %s (%llu, %llu): read failed: %s\n", 117 f->path, off, len, strerror(errno)); 118 return -1; 119 } 120 121 /* leave fd open; fdpool will close it if needed. */ 122 123 return 0; 124 } 125 126 static int dir_read(struct dir *d, char *buf, offset_t off, offset_t len) 127 { 128 assert(d); 129 assert(buf); 130 131 return buffer_read((char*)d->entries, d->size, buf, off, len); 132 } 133 134 static int extent_read(struct fs *fs, struct extent *e, char *buf, 135 offset_t off, offset_t len) 136 { 137 assert(fs); 138 assert(e); 139 assert(buf); 140 141 switch (e->type) { 142 case EXTENT_TYPE_BOOT: 143 return buffer_read((char*)&fs->boot, sizeof(fs->boot), buf, 144 off, len); 145 case EXTENT_TYPE_INFO: 146 return buffer_read((char*)&fs->info, sizeof(fs->info), buf, 147 off, len); 148 case EXTENT_TYPE_FAT: 149 return buffer_read((char*)fs->fat, fs->fat_size, buf, 150 off, len); 151 case EXTENT_TYPE_FILE: 152 return file_read((struct file *)e, buf, off, len); 153 case EXTENT_TYPE_DIR: 154 return dir_read((struct dir *)e, buf, off, len); 155 default: 156 WARN("reading extent: unexpected type %d\n", e->type); 157 return -1; 158 } 159 } 160 161 int fs_read(struct fs *fs, char *buf, offset_t start, offset_t len) 162 { 163 struct extent *e = NULL; 164 offset_t e_start, r_start, rel_len; 165 int ret; 166 167 memset(buf, 0, len); 168 169 while ((e = fs_find_extent(fs, start, len, e, 170 &r_start, &e_start, &rel_len))) { 171 ret = extent_read(fs, e, buf + r_start, e_start, rel_len); 172 if (ret == SKY_IS_FALLING) 173 return SKY_IS_FALLING; 174 if (ret) 175 return ret; 176 } 177 178 return 0; 179 } 180
