![[BACK]](/icons/back.gif){kind=icon}
Return to ufs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libsa|
Return to ufs.c CVS log | Up to [local] / sys / lib / libsa |
1.1 ! nbrk 1: /* $OpenBSD: ufs.c,v 1.18 2007/03/16 21:48:59 tsi Exp $ */
! 2: /* $NetBSD: ufs.c,v 1.16 1996/09/30 16:01:22 ws Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * The Mach Operating System project at Carnegie-Mellon University.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. Neither the name of the University nor the names of its contributors
! 20: * may be used to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: *
! 35: *
! 36: * Copyright (c) 1990, 1991 Carnegie Mellon University
! 37: * All Rights Reserved.
! 38: *
! 39: * Author: David Golub
! 40: *
! 41: * Permission to use, copy, modify and distribute this software and its
! 42: * documentation is hereby granted, provided that both the copyright
! 43: * notice and this permission notice appear in all copies of the
! 44: * software, derivative works or modified versions, and any portions
! 45: * thereof, and that both notices appear in supporting documentation.
! 46: *
! 47: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 48: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
! 49: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 50: *
! 51: * Carnegie Mellon requests users of this software to return to
! 52: *
! 53: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 54: * School of Computer Science
! 55: * Carnegie Mellon University
! 56: * Pittsburgh PA 15213-3890
! 57: *
! 58: * any improvements or extensions that they make and grant Carnegie the
! 59: * rights to redistribute these changes.
! 60: */
! 61:
! 62: /*
! 63: * Stand-alone file reading package.
! 64: */
! 65:
! 66: #include <sys/param.h>
! 67: #include <sys/time.h>
! 68: #include <sys/stat.h>
! 69: #include <ufs/ffs/fs.h>
! 70: #include <ufs/ufs/dinode.h>
! 71: #include <ufs/ufs/dir.h>
! 72: #include <lib/libkern/libkern.h>
! 73:
! 74: #include "stand.h"
! 75: #include "ufs.h"
! 76:
! 77: /*
! 78: * In-core open file.
! 79: */
! 80: struct file {
! 81: off_t f_seekp; /* seek pointer */
! 82: struct fs *f_fs; /* pointer to super-block */
! 83: struct ufs1_dinode f_di; /* copy of on-disk inode */
! 84: int f_nindir[NIADDR];
! 85: /* number of blocks mapped by
! 86: indirect block at level i */
! 87: char *f_blk[NIADDR]; /* buffer for indirect block at
! 88: level i */
! 89: size_t f_blksize[NIADDR];
! 90: /* size of buffer */
! 91: daddr_t f_blkno[NIADDR];/* disk address of block in buffer */
! 92: char *f_buf; /* buffer for data block */
! 93: size_t f_buf_size; /* size of data block */
! 94: daddr_t f_buf_blkno; /* block number of data block */
! 95: };
! 96:
! 97: static int read_inode(ino_t, struct open_file *);
! 98: static int block_map(struct open_file *, daddr_t, daddr_t *);
! 99: static int buf_read_file(struct open_file *, char **, size_t *);
! 100: static int search_directory(char *, struct open_file *, ino_t *);
! 101: #ifdef COMPAT_UFS
! 102: static void ffs_oldfscompat(struct fs *);
! 103: #endif
! 104:
! 105: /*
! 106: * Read a new inode into a file structure.
! 107: */
! 108: static int
! 109: read_inode(ino_t inumber, struct open_file *f)
! 110: {
! 111: struct file *fp = (struct file *)f->f_fsdata;
! 112: struct fs *fs = fp->f_fs;
! 113: char *buf;
! 114: size_t rsize;
! 115: int rc;
! 116:
! 117: /*
! 118: * Read inode and save it.
! 119: */
! 120: buf = alloc(fs->fs_bsize);
! 121: twiddle();
! 122: rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
! 123: fsbtodb(fs, ino_to_fsba(fs, inumber)), fs->fs_bsize,
! 124: buf, &rsize);
! 125: if (rc)
! 126: goto out;
! 127: if (rsize != (size_t)fs->fs_bsize) {
! 128: rc = EIO;
! 129: goto out;
! 130: }
! 131:
! 132: {
! 133: struct ufs1_dinode *dp;
! 134:
! 135: dp = (struct ufs1_dinode *)buf;
! 136: fp->f_di = dp[ino_to_fsbo(fs, inumber)];
! 137: }
! 138:
! 139: /*
! 140: * Clear out the old buffers
! 141: */
! 142: {
! 143: int level;
! 144:
! 145: for (level = 0; level < NIADDR; level++)
! 146: fp->f_blkno[level] = -1;
! 147: fp->f_buf_blkno = -1;
! 148: fp->f_seekp = 0;
! 149: }
! 150: out:
! 151: free(buf, fs->fs_bsize);
! 152: return (rc);
! 153: }
! 154:
! 155: /*
! 156: * Given an offset in a file, find the disk block number that
! 157: * contains that block.
! 158: */
! 159: static int
! 160: block_map(struct open_file *f, daddr_t file_block, daddr_t *disk_block_p)
! 161: {
! 162: struct file *fp = (struct file *)f->f_fsdata;
! 163: daddr_t ind_block_num, *ind_p;
! 164: struct fs *fs = fp->f_fs;
! 165: int level, idx, rc;
! 166:
! 167: /*
! 168: * Index structure of an inode:
! 169: *
! 170: * di_db[0..NDADDR-1] hold block numbers for blocks
! 171: * 0..NDADDR-1
! 172: *
! 173: * di_ib[0] index block 0 is the single indirect block
! 174: * holds block numbers for blocks
! 175: * NDADDR .. NDADDR + NINDIR(fs)-1
! 176: *
! 177: * di_ib[1] index block 1 is the double indirect block
! 178: * holds block numbers for INDEX blocks for blocks
! 179: * NDADDR + NINDIR(fs) ..
! 180: * NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
! 181: *
! 182: * di_ib[2] index block 2 is the triple indirect block
! 183: * holds block numbers for double-indirect
! 184: * blocks for blocks
! 185: * NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
! 186: * NDADDR + NINDIR(fs) + NINDIR(fs)**2
! 187: * + NINDIR(fs)**3 - 1
! 188: */
! 189:
! 190: if (file_block < NDADDR) {
! 191: /* Direct block. */
! 192: *disk_block_p = fp->f_di.di_db[file_block];
! 193: return (0);
! 194: }
! 195:
! 196: file_block -= NDADDR;
! 197:
! 198: /*
! 199: * nindir[0] = NINDIR
! 200: * nindir[1] = NINDIR**2
! 201: * nindir[2] = NINDIR**3
! 202: * etc
! 203: */
! 204: for (level = 0; level < NIADDR; level++) {
! 205: if (file_block < fp->f_nindir[level])
! 206: break;
! 207: file_block -= fp->f_nindir[level];
! 208: }
! 209: if (level == NIADDR) {
! 210: /* Block number too high */
! 211: return (EFBIG);
! 212: }
! 213:
! 214: ind_block_num = fp->f_di.di_ib[level];
! 215:
! 216: for (; level >= 0; level--) {
! 217: if (ind_block_num == 0) {
! 218: *disk_block_p = 0; /* missing */
! 219: return (0);
! 220: }
! 221:
! 222: if (fp->f_blkno[level] != ind_block_num) {
! 223: if (fp->f_blk[level] == (char *)0)
! 224: fp->f_blk[level] =
! 225: alloc(fs->fs_bsize);
! 226: twiddle();
! 227: rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
! 228: fsbtodb(fp->f_fs, ind_block_num), fs->fs_bsize,
! 229: fp->f_blk[level], &fp->f_blksize[level]);
! 230: if (rc)
! 231: return (rc);
! 232: if (fp->f_blksize[level] != (size_t)fs->fs_bsize)
! 233: return (EIO);
! 234: fp->f_blkno[level] = ind_block_num;
! 235: }
! 236:
! 237: ind_p = (daddr_t *)fp->f_blk[level];
! 238:
! 239: if (level > 0) {
! 240: idx = file_block / fp->f_nindir[level - 1];
! 241: file_block %= fp->f_nindir[level - 1];
! 242: } else
! 243: idx = file_block;
! 244:
! 245: ind_block_num = ind_p[idx];
! 246: }
! 247:
! 248: *disk_block_p = ind_block_num;
! 249: return (0);
! 250: }
! 251:
! 252: /*
! 253: * Read a portion of a file into an internal buffer. Return
! 254: * the location in the buffer and the amount in the buffer.
! 255: */
! 256: static int
! 257: buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
! 258: {
! 259: struct file *fp = (struct file *)f->f_fsdata;
! 260: struct fs *fs = fp->f_fs;
! 261: daddr_t file_block, disk_block;
! 262: size_t block_size;
! 263: long off;
! 264: int rc;
! 265:
! 266: off = blkoff(fs, fp->f_seekp);
! 267: file_block = lblkno(fs, fp->f_seekp);
! 268: block_size = dblksize(fs, &fp->f_di, file_block);
! 269:
! 270: if (file_block != fp->f_buf_blkno) {
! 271: rc = block_map(f, file_block, &disk_block);
! 272: if (rc)
! 273: return (rc);
! 274:
! 275: if (fp->f_buf == (char *)0)
! 276: fp->f_buf = alloc(fs->fs_bsize);
! 277:
! 278: if (disk_block == 0) {
! 279: bzero(fp->f_buf, block_size);
! 280: fp->f_buf_size = block_size;
! 281: } else {
! 282: twiddle();
! 283: rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
! 284: fsbtodb(fs, disk_block),
! 285: block_size, fp->f_buf, &fp->f_buf_size);
! 286: if (rc)
! 287: return (rc);
! 288: }
! 289:
! 290: fp->f_buf_blkno = file_block;
! 291: }
! 292:
! 293: /*
! 294: * Return address of byte in buffer corresponding to
! 295: * offset, and size of remainder of buffer after that
! 296: * byte.
! 297: */
! 298: *buf_p = fp->f_buf + off;
! 299: *size_p = block_size - off;
! 300:
! 301: /*
! 302: * But truncate buffer at end of file.
! 303: */
! 304: if (*size_p > fp->f_di.di_size - fp->f_seekp)
! 305: *size_p = fp->f_di.di_size - fp->f_seekp;
! 306:
! 307: return (0);
! 308: }
! 309:
! 310: /*
! 311: * Search a directory for a name and return its
! 312: * i_number.
! 313: */
! 314: static int
! 315: search_directory(char *name, struct open_file *f, ino_t *inumber_p)
! 316: {
! 317: struct file *fp = (struct file *)f->f_fsdata;
! 318: int namlen, length, rc;
! 319: struct direct *dp, *edp;
! 320: size_t buf_size;
! 321: char *buf;
! 322:
! 323: length = strlen(name);
! 324:
! 325: fp->f_seekp = 0;
! 326: while (fp->f_seekp < fp->f_di.di_size) {
! 327: rc = buf_read_file(f, &buf, &buf_size);
! 328: if (rc)
! 329: return (rc);
! 330:
! 331: dp = (struct direct *)buf;
! 332: edp = (struct direct *)(buf + buf_size);
! 333: while (dp < edp) {
! 334: if (dp->d_ino == (ino_t)0)
! 335: goto next;
! 336: #if BYTE_ORDER == LITTLE_ENDIAN
! 337: if (fp->f_fs->fs_maxsymlinklen <= 0)
! 338: namlen = dp->d_type;
! 339: else
! 340: #endif
! 341: namlen = dp->d_namlen;
! 342: if (namlen == length &&
! 343: !strcmp(name, dp->d_name)) {
! 344: /* found entry */
! 345: *inumber_p = dp->d_ino;
! 346: return (0);
! 347: }
! 348: next:
! 349: dp = (struct direct *)((char *)dp + dp->d_reclen);
! 350: }
! 351: fp->f_seekp += buf_size;
! 352: }
! 353: return (ENOENT);
! 354: }
! 355:
! 356: /*
! 357: * Open a file.
! 358: */
! 359: int
! 360: ufs_open(char *path, struct open_file *f)
! 361: {
! 362: char namebuf[MAXPATHLEN+1], *cp, *ncp, *buf = NULL;
! 363: ino_t inumber, parent_inumber;
! 364: int rc, c, nlinks = 0;
! 365: struct file *fp;
! 366: size_t buf_size;
! 367: struct fs *fs;
! 368:
! 369: /* allocate file system specific data structure */
! 370: fp = alloc(sizeof(struct file));
! 371: bzero(fp, sizeof(struct file));
! 372: f->f_fsdata = (void *)fp;
! 373:
! 374: /* allocate space and read super block */
! 375: fs = alloc(SBSIZE);
! 376: fp->f_fs = fs;
! 377: twiddle();
! 378: rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
! 379: SBLOCK, SBSIZE, (char *)fs, &buf_size);
! 380: if (rc)
! 381: goto out;
! 382:
! 383: if (buf_size != SBSIZE || fs->fs_magic != FS_MAGIC ||
! 384: fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {
! 385: rc = EINVAL;
! 386: goto out;
! 387: }
! 388: #ifdef COMPAT_UFS
! 389: ffs_oldfscompat(fs);
! 390: #endif
! 391:
! 392: /*
! 393: * Calculate indirect block levels.
! 394: */
! 395: {
! 396: int mult;
! 397: int level;
! 398:
! 399: mult = 1;
! 400: for (level = 0; level < NIADDR; level++) {
! 401: mult *= NINDIR(fs);
! 402: fp->f_nindir[level] = mult;
! 403: }
! 404: }
! 405:
! 406: inumber = ROOTINO;
! 407: if ((rc = read_inode(inumber, f)) != 0)
! 408: goto out;
! 409:
! 410: cp = path;
! 411: while (*cp) {
! 412:
! 413: /*
! 414: * Remove extra separators
! 415: */
! 416: while (*cp == '/')
! 417: cp++;
! 418: if (*cp == '\0')
! 419: break;
! 420:
! 421: /*
! 422: * Check that current node is a directory.
! 423: */
! 424: if ((fp->f_di.di_mode & IFMT) != IFDIR) {
! 425: rc = ENOTDIR;
! 426: goto out;
! 427: }
! 428:
! 429: /*
! 430: * Get next component of path name.
! 431: */
! 432: {
! 433: int len = 0;
! 434:
! 435: ncp = cp;
! 436: while ((c = *cp) != '\0' && c != '/') {
! 437: if (++len > MAXNAMLEN) {
! 438: rc = ENOENT;
! 439: goto out;
! 440: }
! 441: cp++;
! 442: }
! 443: *cp = '\0';
! 444: }
! 445:
! 446: /*
! 447: * Look up component in current directory.
! 448: * Save directory inumber in case we find a
! 449: * symbolic link.
! 450: */
! 451: parent_inumber = inumber;
! 452: rc = search_directory(ncp, f, &inumber);
! 453: *cp = c;
! 454: if (rc)
! 455: goto out;
! 456:
! 457: /*
! 458: * Open next component.
! 459: */
! 460: if ((rc = read_inode(inumber, f)) != 0)
! 461: goto out;
! 462:
! 463: /*
! 464: * Check for symbolic link.
! 465: */
! 466: if ((fp->f_di.di_mode & IFMT) == IFLNK) {
! 467: int link_len = fp->f_di.di_size;
! 468: int len;
! 469:
! 470: len = strlen(cp);
! 471:
! 472: if (link_len + len > MAXPATHLEN ||
! 473: ++nlinks > MAXSYMLINKS) {
! 474: rc = ENOENT;
! 475: goto out;
! 476: }
! 477:
! 478: bcopy(cp, &namebuf[link_len], len + 1);
! 479:
! 480: if (link_len < fs->fs_maxsymlinklen) {
! 481: bcopy(fp->f_di.di_shortlink, namebuf,
! 482: (unsigned) link_len);
! 483: } else {
! 484: /*
! 485: * Read file for symbolic link
! 486: */
! 487: size_t buf_size;
! 488: daddr_t disk_block;
! 489: struct fs *fs = fp->f_fs;
! 490:
! 491: if (!buf)
! 492: buf = alloc(fs->fs_bsize);
! 493: rc = block_map(f, (daddr_t)0, &disk_block);
! 494: if (rc)
! 495: goto out;
! 496:
! 497: twiddle();
! 498: rc = (f->f_dev->dv_strategy)(f->f_devdata,
! 499: F_READ, fsbtodb(fs, disk_block),
! 500: fs->fs_bsize, buf, &buf_size);
! 501: if (rc)
! 502: goto out;
! 503:
! 504: bcopy((char *)buf, namebuf, (unsigned)link_len);
! 505: }
! 506:
! 507: /*
! 508: * If relative pathname, restart at parent directory.
! 509: * If absolute pathname, restart at root.
! 510: */
! 511: cp = namebuf;
! 512: if (*cp != '/')
! 513: inumber = parent_inumber;
! 514: else
! 515: inumber = (ino_t)ROOTINO;
! 516:
! 517: if ((rc = read_inode(inumber, f)) != 0)
! 518: goto out;
! 519: }
! 520: }
! 521:
! 522: /*
! 523: * Found terminal component.
! 524: */
! 525: rc = 0;
! 526: out:
! 527: if (buf)
! 528: free(buf, fs->fs_bsize);
! 529: if (rc) {
! 530: free(fp->f_fs, SBSIZE);
! 531: free(fp, sizeof(struct file));
! 532: }
! 533: return (rc);
! 534: }
! 535:
! 536: int
! 537: ufs_close(struct open_file *f)
! 538: {
! 539: struct file *fp = (struct file *)f->f_fsdata;
! 540: int level;
! 541:
! 542: f->f_fsdata = (void *)0;
! 543: if (fp == (struct file *)0)
! 544: return (0);
! 545:
! 546: for (level = 0; level < NIADDR; level++) {
! 547: if (fp->f_blk[level])
! 548: free(fp->f_blk[level], fp->f_fs->fs_bsize);
! 549: }
! 550: if (fp->f_buf)
! 551: free(fp->f_buf, fp->f_fs->fs_bsize);
! 552: free(fp->f_fs, SBSIZE);
! 553: free(fp, sizeof(struct file));
! 554: return (0);
! 555: }
! 556:
! 557: /*
! 558: * Copy a portion of a file into kernel memory.
! 559: * Cross block boundaries when necessary.
! 560: */
! 561: int
! 562: ufs_read(struct open_file *f, void *start, size_t size, size_t *resid)
! 563: {
! 564: struct file *fp = (struct file *)f->f_fsdata;
! 565: char *buf, *addr = start;
! 566: size_t csize, buf_size;
! 567: int rc = 0;
! 568:
! 569: while (size != 0) {
! 570: if (fp->f_seekp >= fp->f_di.di_size)
! 571: break;
! 572:
! 573: rc = buf_read_file(f, &buf, &buf_size);
! 574: if (rc)
! 575: break;
! 576:
! 577: csize = size;
! 578: if (csize > buf_size)
! 579: csize = buf_size;
! 580:
! 581: bcopy(buf, addr, csize);
! 582:
! 583: fp->f_seekp += csize;
! 584: addr += csize;
! 585: size -= csize;
! 586: }
! 587: if (resid)
! 588: *resid = size;
! 589: return (rc);
! 590: }
! 591:
! 592: /*
! 593: * Not implemented.
! 594: */
! 595: int
! 596: ufs_write(struct open_file *f, void *start, size_t size, size_t *resid)
! 597: {
! 598:
! 599: return (EROFS);
! 600: }
! 601:
! 602: off_t
! 603: ufs_seek(struct open_file *f, off_t offset, int where)
! 604: {
! 605: struct file *fp = (struct file *)f->f_fsdata;
! 606:
! 607: switch (where) {
! 608: case SEEK_SET:
! 609: fp->f_seekp = offset;
! 610: break;
! 611: case SEEK_CUR:
! 612: fp->f_seekp += offset;
! 613: break;
! 614: case SEEK_END:
! 615: fp->f_seekp = fp->f_di.di_size - offset;
! 616: break;
! 617: default:
! 618: return (-1);
! 619: }
! 620: return (fp->f_seekp);
! 621: }
! 622:
! 623: int
! 624: ufs_stat(struct open_file *f, struct stat *sb)
! 625: {
! 626: struct file *fp = (struct file *)f->f_fsdata;
! 627:
! 628: /* only important stuff */
! 629: sb->st_mode = fp->f_di.di_mode;
! 630: sb->st_uid = fp->f_di.di_uid;
! 631: sb->st_gid = fp->f_di.di_gid;
! 632: sb->st_size = fp->f_di.di_size;
! 633: return (0);
! 634: }
! 635:
! 636: #ifndef NO_READDIR
! 637: int
! 638: ufs_readdir(struct open_file *f, char *name)
! 639: {
! 640: struct file *fp = (struct file *)f->f_fsdata;
! 641: struct direct *dp, *edp;
! 642: size_t buf_size;
! 643: int rc, namlen;
! 644: char *buf;
! 645:
! 646: if (name == NULL)
! 647: fp->f_seekp = 0;
! 648: else {
! 649: /* end of dir */
! 650: if (fp->f_seekp >= fp->f_di.di_size) {
! 651: *name = '\0';
! 652: return -1;
! 653: }
! 654:
! 655: do {
! 656: if ((rc = buf_read_file(f, &buf, &buf_size)) != 0)
! 657: return rc;
! 658:
! 659: dp = (struct direct *)buf;
! 660: edp = (struct direct *)(buf + buf_size);
! 661: while (dp < edp && dp->d_ino == (ino_t)0)
! 662: dp = (struct direct *)((char *)dp + dp->d_reclen);
! 663: fp->f_seekp += buf_size -
! 664: ((u_int8_t *)edp - (u_int8_t *)dp);
! 665: } while (dp >= edp);
! 666:
! 667: #if BYTE_ORDER == LITTLE_ENDIAN
! 668: if (fp->f_fs->fs_maxsymlinklen <= 0)
! 669: namlen = dp->d_type;
! 670: else
! 671: #endif
! 672: namlen = dp->d_namlen;
! 673: strncpy(name, dp->d_name, namlen + 1);
! 674:
! 675: fp->f_seekp += dp->d_reclen;
! 676: }
! 677:
! 678: return 0;
! 679: }
! 680: #endif
! 681:
! 682: #ifdef COMPAT_UFS
! 683: /*
! 684: * Sanity checks for old file systems.
! 685: *
! 686: * XXX - goes away some day.
! 687: */
! 688: static void
! 689: ffs_oldfscompat(struct fs *fs)
! 690: {
! 691: int i;
! 692:
! 693: fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
! 694: fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
! 695: if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
! 696: fs->fs_nrpos = 8; /* XXX */
! 697: if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
! 698: quad_t sizepb = fs->fs_bsize; /* XXX */
! 699: /* XXX */
! 700: fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
! 701: for (i = 0; i < NIADDR; i++) { /* XXX */
! 702: sizepb *= NINDIR(fs); /* XXX */
! 703: fs->fs_maxfilesize += sizepb; /* XXX */
! 704: } /* XXX */
! 705: fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
! 706: fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
! 707: } /* XXX */
! 708: }
! 709: #endif