1 /* $NetBSD: readufs.c,v 1.1 2014/02/24 07:23:43 skrll Exp $ */ 2 /* from Id: readufs.c,v 1.9 2003/12/16 13:54:11 itohy Exp */ 3 4 /* 5 * Read UFS (FFS / LFS) 6 * 7 * Written in 1999, 2002, 2003 by ITOH Yasufumi. 8 * Public domain. 9 * 10 * Intended to be used for boot programs (first stage). 11 * DON'T ADD ANY FANCY FEATURE. THIS SHALL BE COMPACT. 12 */ 13 14 #include "readufs.h" 15 16 #define fs ufs_info 17 18 static void raw_read_queue(void *buf, daddr_t blkpos, size_t bytelen); 19 static int ufs_read_indirect(daddr_t blk, int level, void **buf, 20 unsigned *poff, size_t count); 21 22 #ifdef DEBUG_WITH_STDIO 23 void ufs_list_dir(ino32_t dirino); 24 int main(int argc, char *argv[]); 25 #endif 26 27 #ifdef DEBUG_WITH_STDIO 28 int fd; 29 30 void 31 RAW_READ(void *buf, daddr_t blkpos, size_t bytelen) 32 { 33 34 if (pread(fd, buf, bytelen, (off_t)dbtob(blkpos)) != (ssize_t) bytelen) 35 err(1, "pread: buf %p, blk %d, len %u", 36 buf, (int) blkpos, bytelen); 37 } 38 #endif 39 40 struct ufs_info fs; 41 42 /* 43 * Read contiguous sectors at once for speedup. 44 */ 45 static size_t rq_len; 46 47 static void 48 raw_read_queue(void *buf, daddr_t blkpos, size_t bytelen) 49 /* bytelen: must be DEV_BSIZE aligned */ 50 { 51 static daddr_t rq_start; 52 static char *rq_buf; 53 54 if (rq_len) { 55 if (bytelen && blkpos == rq_start + (ssize_t) btodb(rq_len) 56 && buf == rq_buf + rq_len) { 57 rq_len += bytelen; 58 return; 59 } else { 60 #ifdef DEBUG_WITH_STDIO 61 printf("raw_read_queue: read: buf %p, blk %d, len %d\n", 62 rq_buf, (int) rq_start, rq_len); 63 #endif 64 RAW_READ(rq_buf, rq_start, rq_len); 65 } 66 } 67 rq_buf = buf; 68 rq_start = blkpos; 69 rq_len = bytelen; 70 } 71 72 #define RAW_READ_QUEUE_INIT() (rq_len = 0) 73 #define RAW_READ_QUEUE_FLUSH() \ 74 raw_read_queue((void *) 0, (daddr_t) 0, (size_t) 0) 75 76 77 /* 78 * Read a file, specified by dinode. 79 * No support for holes or (short) symbolic links. 80 */ 81 size_t 82 ufs_read(union ufs_dinode *di, void *buf, unsigned off, size_t count) 83 /* off: position in block */ 84 { 85 struct ufs_info *ufsinfo = &fs; 86 size_t bsize = ufsinfo->bsize; 87 void *b = buf; 88 int i; 89 size_t disize, nread; 90 daddr_t pos; 91 #if defined(USE_UFS1) && defined(USE_UFS2) 92 enum ufs_ufstype uver = ufsinfo->ufstype; 93 #endif 94 95 #ifdef DEBUG_WITH_STDIO 96 printf("ufs_read: off: %d, count %u\n", off, count); 97 #endif 98 99 disize = DI_SIZE(di); 100 101 if (disize < count + off * bsize) 102 count = disize - off * bsize; 103 104 /* FS block size alignment. */ 105 nread = count; 106 count = (count + bsize - 1) & ~(bsize - 1); 107 108 RAW_READ_QUEUE_INIT(); 109 110 /* Read direct blocks. */ 111 for ( ; off < UFS_NDADDR && count > 0; off++) { 112 #if defined(USE_UFS1) && defined(USE_UFS2) 113 if (uver == UFSTYPE_UFS1) 114 pos = di->di1.di_db[off]; 115 else 116 pos = di->di2.di_db[off]; 117 #else 118 pos = di->di_thisver.di_db[off]; 119 #endif 120 #if 0 121 printf("ufs_read: read: blk: %d\n", 122 (int) pos << ufsinfo->fsbtodb); 123 #endif 124 raw_read_queue(b, pos << ufsinfo->fsbtodb, bsize); 125 b += bsize; 126 count -= bsize; 127 } 128 off -= UFS_NDADDR; 129 130 /* Read indirect blocks. */ 131 for (i = 0; i < UFS_NIADDR && count > 0; i++) { 132 #if defined(USE_UFS1) && defined(USE_UFS2) 133 if (uver == UFSTYPE_UFS1) 134 pos = di->di1.di_ib[i]; 135 else 136 pos = di->di2.di_ib[i]; 137 #else 138 pos = di->di_thisver.di_ib[i]; 139 #endif 140 count = ufs_read_indirect(pos, i, &b, &off, count); 141 } 142 143 RAW_READ_QUEUE_FLUSH(); 144 145 return nread; 146 } 147 148 static int 149 ufs_read_indirect(daddr_t blk, int level, void **buf, unsigned *poff, size_t count) 150 /* poff: position in block */ 151 { 152 struct ufs_info *ufsinfo = &fs; 153 size_t bsize = ufsinfo->bsize; 154 void *idbuf = alloca(bsize); 155 #ifdef USE_UFS1 156 int32_t *idbuf1 = idbuf; 157 #endif 158 #ifdef USE_UFS2 159 int64_t *idbuf2 = idbuf; 160 #endif 161 daddr_t pos; 162 unsigned off = *poff; 163 unsigned b; 164 165 #ifdef DEBUG_WITH_STDIO 166 printf("ufs_read_indirect: off: %d, count %u\n", off, count); 167 #endif 168 if (off) { 169 unsigned subindirsize = 1, indirsize; 170 int i; 171 172 for (i = level; i > 0; i--) 173 subindirsize *= ufsinfo->nindir; 174 indirsize = subindirsize * ufsinfo->nindir; 175 if (off >= indirsize) { 176 /* no need to read any data */ 177 *poff = off - indirsize; 178 return 0; 179 } 180 181 b = off / subindirsize; 182 off -= b * subindirsize; 183 *poff = 0; 184 } else 185 b = 0; 186 187 /* read the indirect block */ 188 RAW_READ(idbuf, blk << ufsinfo->fsbtodb, bsize); 189 190 for ( ; b < ufsinfo->nindir && count > 0; b++) { 191 #if defined(USE_UFS1) && defined(USE_UFS2) 192 if (ufsinfo->ufstype == UFSTYPE_UFS1) 193 #endif 194 #ifdef USE_UFS1 195 pos = idbuf1[b]; 196 #endif 197 #if defined(USE_UFS1) && defined(USE_UFS2) 198 else 199 #endif 200 #ifdef USE_UFS2 201 pos = idbuf2[b]; 202 #endif 203 204 if (level) 205 count = ufs_read_indirect(pos, level - 1, buf, &off, count); 206 else { 207 #if 0 208 printf("ufs_read: read: blk: %d\n", 209 (int) pos << ufsinfo->fsbtodb); 210 #endif 211 raw_read_queue(*buf, pos << ufsinfo->fsbtodb, bsize); 212 *buf += bsize; 213 count -= bsize; 214 } 215 } 216 217 return count; 218 } 219 220 /* 221 * look-up fn in directory dirino 222 */ 223 ino32_t 224 ufs_lookup(ino32_t dirino, const char *fn) 225 { 226 union ufs_dinode dirdi; 227 struct direct *pdir; 228 char *p, *endp; 229 size_t disize; 230 231 if (ufs_get_inode(dirino, &dirdi)) 232 return 0; 233 234 if ((dirdi.di_common.di_mode & IFMT) != IFDIR) 235 return 0; /* Not a directory */ 236 237 disize = DI_SIZE(&dirdi); 238 239 p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1)); 240 ufs_read(&dirdi, p, 0, disize); 241 endp = p + disize; 242 for ( ; pdir = (void *) p, p < endp; p += pdir->d_reclen) { 243 if (pdir->d_ino && !strcmp(fn, pdir->d_name)) 244 return pdir->d_ino; 245 } 246 return 0; /* No such file or directory */ 247 } 248 249 /* 250 * look-up a file in absolute pathname from the root directory 251 */ 252 ino32_t 253 ufs_lookup_path(const char *path) 254 { 255 char fn[FFS_MAXNAMLEN + 1]; 256 char *p; 257 ino32_t ino = UFS_ROOTINO; 258 259 do { 260 while (*path == '/') 261 path++; 262 for (p = fn; *path && *path != '/'; ) 263 *p++ = *path++; 264 *p++ = '\0'; 265 ino = ufs_lookup(ino, fn); 266 } while (ino && *path); 267 268 return ino; 269 } 270 271 #if 0 272 size_t 273 ufs_load_file(void *buf, ino32_t dirino, const char *fn) 274 { 275 size_t cnt, disize; 276 union ufs_dinode dinode; 277 278 if (ufs_fn_inode(dirino, fn, &dinode)) 279 return (unsigned) 0; 280 disize = DI_SIZE(&dinode); 281 cnt = ufs_read(&dinode, buf, 0, disize); 282 283 return cnt; 284 } 285 #endif 286 287 int 288 ufs_init(void) 289 { 290 return 1 291 #ifdef USE_FFS 292 && try_ffs() 293 #endif 294 #ifdef USE_LFS 295 && try_lfs() 296 #endif 297 ; 298 } 299 300 #ifdef DEBUG_WITH_STDIO 301 void 302 ufs_list_dir(ino32_t dirino) 303 { 304 union ufs_dinode dirdi; 305 struct direct *pdir; 306 char *p, *endp; 307 size_t disize; 308 309 if (ufs_get_inode(dirino, &dirdi)) 310 errx(1, "ino = %d: not found", dirino); 311 312 disize = DI_SIZE(&dirdi); 313 p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1)); 314 ufs_read(&dirdi, p, 0, disize); 315 endp = p + disize; 316 for ( ; pdir = (void *) p, p < endp; p += pdir->d_reclen) { 317 if (pdir->d_ino) 318 printf("%6d %s\n", pdir->d_ino, pdir->d_name); 319 } 320 } 321 #endif 322 323 #ifdef DEBUG_WITH_STDIO 324 int 325 main(argc, argv) 326 int argc __attribute__((unused)); 327 char *argv[]; 328 { 329 union ufs_dinode dinode; 330 331 if ((fd = open(argv[1], O_RDONLY)) < 0) 332 err(1, "open: %s", argv[1]); 333 334 if (ufs_init()) 335 errx(1, "%s: unknown fs", argv[1]); 336 337 #if 1 338 ufs_list_dir(UFS_ROOTINO); 339 { 340 void *p; 341 size_t cnt; 342 ino32_t ino; 343 size_t disize; 344 345 if ((ino = ufs_lookup_path(argv[2])) == 0) 346 errx(1, "%s: not found", argv[2]); 347 ufs_get_inode(ino, &dinode); 348 disize = DI_SIZE(&dinode); 349 p = malloc((disize + fs.bsize - 1) & ~(fs.bsize - 1)); 350 cnt = ufs_read(&dinode, p, 0, disize); 351 write(3, p, cnt); 352 free(p); 353 } 354 #endif 355 356 return 0; 357 } 358 #endif 359