Return to fsys_xfs.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs

Annotation of qemu/roms/openbios/fs/grubfs/fsys_xfs.c, revision 1.1

1.1     ! root        1: /* fsys_xfs.c - an implementation for the SGI XFS file system */
        !             2: /*
        !             3:  *  GRUB  --  GRand Unified Bootloader
        !             4:  *  Copyright (C) 2001,2002  Free Software Foundation, Inc.
        !             5:  *
        !             6:  *  This program is free software; you can redistribute it and/or modify
        !             7:  *  it under the terms of the GNU General Public License as published by
        !             8:  *  the Free Software Foundation; either version 2 of the License, or
        !             9:  *  (at your option) any later version.
        !            10:  *
        !            11:  *  This program is distributed in the hope that it will be useful,
        !            12:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14:  *  GNU General Public License for more details.
        !            15:  *
        !            16:  *  You should have received a copy of the GNU General Public License
        !            17:  *  along with this program; if not, write to the Free Software
        !            18:  *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
        !            19:  *  MA 02110-1301, USA.
        !            20:  */
        !            21: 
        !            22: #ifdef FSYS_XFS
        !            23: 
        !            24: #include "shared.h"
        !            25: #include "filesys.h"
        !            26: #include "xfs.h"
        !            27: 
        !            28: #define MAX_LINK_COUNT 8
        !            29: 
        !            30: typedef struct xad {
        !            31:        xfs_fileoff_t offset;
        !            32:        xfs_fsblock_t start;
        !            33:        xfs_filblks_t len;
        !            34: } xad_t;
        !            35: 
        !            36: struct xfs_info {
        !            37:        int bsize;
        !            38:        int dirbsize;
        !            39:        int isize;
        !            40:        unsigned int agblocks;
        !            41:        int bdlog;
        !            42:        int blklog;
        !            43:        int inopblog;
        !            44:        int agblklog;
        !            45:        int agnolog;
        !            46:        unsigned int nextents;
        !            47:        xfs_daddr_t next;
        !            48:        xfs_daddr_t daddr;
        !            49:        xfs_dablk_t forw;
        !            50:        xfs_dablk_t dablk;
        !            51:        xfs_bmbt_rec_32_t *xt;
        !            52:        xfs_bmbt_ptr_t ptr0;
        !            53:        int btnode_ptr0_off;
        !            54:        int i8param;
        !            55:        int dirpos;
        !            56:        int dirmax;
        !            57:        int blkoff;
        !            58:        int fpos;
        !            59:        xfs_ino_t rootino;
        !            60: };
        !            61: 
        !            62: static struct xfs_info xfs;
        !            63: 
        !            64: #define dirbuf         ((char *)FSYS_BUF)
        !            65: #define filebuf                ((char *)FSYS_BUF + 4096)
        !            66: #define inode          ((xfs_dinode_t *)((char *)FSYS_BUF + 8192))
        !            67: #define icore          (inode->di_core)
        !            68: 
        !            69: #define        mask32lo(n)     (((__uint32_t)1 << (n)) - 1)
        !            70: 
        !            71: #define        XFS_INO_MASK(k)         ((__uint32_t)((1ULL << (k)) - 1))
        !            72: #define        XFS_INO_OFFSET_BITS     xfs.inopblog
        !            73: #define        XFS_INO_AGBNO_BITS      xfs.agblklog
        !            74: #define        XFS_INO_AGINO_BITS      (xfs.agblklog + xfs.inopblog)
        !            75: #define        XFS_INO_AGNO_BITS       xfs.agnolog
        !            76: 
        !            77: static inline xfs_agblock_t
        !            78: agino2agbno (xfs_agino_t agino)
        !            79: {
        !            80:        return agino >> XFS_INO_OFFSET_BITS;
        !            81: }
        !            82: 
        !            83: static inline xfs_agnumber_t
        !            84: ino2agno (xfs_ino_t ino)
        !            85: {
        !            86:        return ino >> XFS_INO_AGINO_BITS;
        !            87: }
        !            88: 
        !            89: static inline xfs_agino_t
        !            90: ino2agino (xfs_ino_t ino)
        !            91: {
        !            92:        return ino & XFS_INO_MASK(XFS_INO_AGINO_BITS);
        !            93: }
        !            94: 
        !            95: static inline int
        !            96: ino2offset (xfs_ino_t ino)
        !            97: {
        !            98:        return ino & XFS_INO_MASK(XFS_INO_OFFSET_BITS);
        !            99: }
        !           100: 
        !           101: static inline __uint16_t
        !           102: le16 (__uint16_t x)
        !           103: {
        !           104: #ifdef __i386__
        !           105:        __asm__("xchgb %b0,%h0" \
        !           106:                : "=q" (x) \
        !           107:                :  "0" (x)); \
        !           108:                return x;
        !           109: #else
        !           110:        return __be16_to_cpu(x);
        !           111: #endif
        !           112: }
        !           113: 
        !           114: static inline __uint32_t
        !           115: le32 (__uint32_t x)
        !           116: {
        !           117: #ifdef __i386__
        !           118: #if 1
        !           119:         /* 386 doesn't have bswap. So what. */
        !           120:        __asm__("bswap %0" : "=r" (x) : "0" (x));
        !           121: #else
        !           122:        /* This is slower but this works on all x86 architectures.  */
        !           123:        __asm__("xchgb %b0, %h0" \
        !           124:                "\n\troll $16, %0" \
        !           125:                "\n\txchgb %b0, %h0" \
        !           126:                : "=q" (x) : "0" (x));
        !           127: #endif
        !           128:        return x;
        !           129: #else
        !           130:        return __be32_to_cpu(x);
        !           131: #endif
        !           132: }
        !           133: 
        !           134: static inline __uint64_t
        !           135: le64 (__uint64_t x)
        !           136: {
        !           137:        __uint32_t h = x >> 32;
        !           138:         __uint32_t l = x & ((1ULL<<32)-1);
        !           139:         return (((__uint64_t)le32(l)) << 32) | ((__uint64_t)(le32(h)));
        !           140: }
        !           141: 
        !           142: 
        !           143: static xfs_fsblock_t
        !           144: xt_start (xfs_bmbt_rec_32_t *r)
        !           145: {
        !           146:        return (((xfs_fsblock_t)(le32 (r->l1) & mask32lo(9))) << 43) |
        !           147:               (((xfs_fsblock_t)le32 (r->l2)) << 11) |
        !           148:               (((xfs_fsblock_t)le32 (r->l3)) >> 21);
        !           149: }
        !           150: 
        !           151: static xfs_fileoff_t
        !           152: xt_offset (xfs_bmbt_rec_32_t *r)
        !           153: {
        !           154:        return (((xfs_fileoff_t)le32 (r->l0) &
        !           155:                mask32lo(31)) << 23) |
        !           156:                (((xfs_fileoff_t)le32 (r->l1)) >> 9);
        !           157: }
        !           158: 
        !           159: static xfs_filblks_t
        !           160: xt_len (xfs_bmbt_rec_32_t *r)
        !           161: {
        !           162:        return le32(r->l3) & mask32lo(21);
        !           163: }
        !           164: 
        !           165: static inline int
        !           166: xfs_highbit32(__uint32_t v)
        !           167: {
        !           168:        int i;
        !           169: 
        !           170:        if (--v) {
        !           171:                for (i = 0; i < 31; i++, v >>= 1) {
        !           172:                        if (v == 0)
        !           173:                                return i;
        !           174:                }
        !           175:        }
        !           176:        return 0;
        !           177: }
        !           178: 
        !           179: static int
        !           180: isinxt (xfs_fileoff_t key, xfs_fileoff_t offset, xfs_filblks_t len)
        !           181: {
        !           182:        return (key >= offset) ? (key < offset + len ? 1 : 0) : 0;
        !           183: }
        !           184: 
        !           185: static xfs_daddr_t
        !           186: agb2daddr (xfs_agnumber_t agno, xfs_agblock_t agbno)
        !           187: {
        !           188:        return ((xfs_fsblock_t)agno*xfs.agblocks + agbno) << xfs.bdlog;
        !           189: }
        !           190: 
        !           191: static xfs_daddr_t
        !           192: fsb2daddr (xfs_fsblock_t fsbno)
        !           193: {
        !           194:        return agb2daddr ((xfs_agnumber_t)(fsbno >> xfs.agblklog),
        !           195:                         (xfs_agblock_t)(fsbno & mask32lo(xfs.agblklog)));
        !           196: }
        !           197: 
        !           198: #undef offsetof
        !           199: #define offsetof(t,m)  ((long)&(((t *)0)->m))
        !           200: 
        !           201: static inline int
        !           202: btroot_maxrecs (void)
        !           203: {
        !           204:        int tmp = icore.di_forkoff ? (icore.di_forkoff << 3) : xfs.isize;
        !           205: 
        !           206:        return (tmp - sizeof(xfs_bmdr_block_t) - offsetof(xfs_dinode_t, di_u)) /
        !           207:                (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t));
        !           208: }
        !           209: 
        !           210: static int
        !           211: di_read (xfs_ino_t ino)
        !           212: {
        !           213:        xfs_agino_t agino;
        !           214:        xfs_agnumber_t agno;
        !           215:        xfs_agblock_t agbno;
        !           216:        xfs_daddr_t daddr;
        !           217:        int offset;
        !           218: 
        !           219:        agno = ino2agno (ino);
        !           220:        agino = ino2agino (ino);
        !           221:        agbno = agino2agbno (agino);
        !           222:        offset = ino2offset (ino);
        !           223:        daddr = agb2daddr (agno, agbno);
        !           224: 
        !           225:        devread (daddr, offset*xfs.isize, xfs.isize, (char *)inode);
        !           226: 
        !           227:        xfs.ptr0 = *(xfs_bmbt_ptr_t *)
        !           228:                    (inode->di_u.di_c + sizeof(xfs_bmdr_block_t)
        !           229:                    + btroot_maxrecs ()*sizeof(xfs_bmbt_key_t));
        !           230: 
        !           231:        return 1;
        !           232: }
        !           233: 
        !           234: static void
        !           235: init_extents (void)
        !           236: {
        !           237:        xfs_bmbt_ptr_t ptr0;
        !           238:        xfs_btree_lblock_t h;
        !           239: 
        !           240:        switch (icore.di_format) {
        !           241:        case XFS_DINODE_FMT_EXTENTS:
        !           242:                xfs.xt = inode->di_u.di_bmx;
        !           243:                xfs.nextents = le32 (icore.di_nextents);
        !           244:                break;
        !           245:        case XFS_DINODE_FMT_BTREE:
        !           246:                ptr0 = xfs.ptr0;
        !           247:                for (;;) {
        !           248:                        xfs.daddr = fsb2daddr (le64(ptr0));
        !           249:                        devread (xfs.daddr, 0,
        !           250:                                 sizeof(xfs_btree_lblock_t), (char *)&h);
        !           251:                        if (!h.bb_level) {
        !           252:                                xfs.nextents = le16(h.bb_numrecs);
        !           253:                                xfs.next = fsb2daddr (le64(h.bb_rightsib));
        !           254:                                xfs.fpos = sizeof(xfs_btree_block_t);
        !           255:                                return;
        !           256:                        }
        !           257:                        devread (xfs.daddr, xfs.btnode_ptr0_off,
        !           258:                                 sizeof(xfs_bmbt_ptr_t), (char *)&ptr0);
        !           259:                }
        !           260:        }
        !           261: }
        !           262: 
        !           263: static xad_t *
        !           264: next_extent (void)
        !           265: {
        !           266:        static xad_t xad;
        !           267: 
        !           268:        switch (icore.di_format) {
        !           269:        case XFS_DINODE_FMT_EXTENTS:
        !           270:                if (xfs.nextents == 0)
        !           271:                        return NULL;
        !           272:                break;
        !           273:        case XFS_DINODE_FMT_BTREE:
        !           274:                if (xfs.nextents == 0) {
        !           275:                        xfs_btree_lblock_t h;
        !           276:                        if (xfs.next == 0)
        !           277:                                return NULL;
        !           278:                        xfs.daddr = xfs.next;
        !           279:                        devread (xfs.daddr, 0, sizeof(xfs_btree_lblock_t), (char *)&h);
        !           280:                        xfs.nextents = le16(h.bb_numrecs);
        !           281:                        xfs.next = fsb2daddr (le64(h.bb_rightsib));
        !           282:                        xfs.fpos = sizeof(xfs_btree_block_t);
        !           283:                }
        !           284:                /* Yeah, I know that's slow, but I really don't care */
        !           285:                devread (xfs.daddr, xfs.fpos, sizeof(xfs_bmbt_rec_t), filebuf);
        !           286:                xfs.xt = (xfs_bmbt_rec_32_t *)filebuf;
        !           287:                xfs.fpos += sizeof(xfs_bmbt_rec_32_t);
        !           288:        }
        !           289:        xad.offset = xt_offset (xfs.xt);
        !           290:        xad.start = xt_start (xfs.xt);
        !           291:        xad.len = xt_len (xfs.xt);
        !           292:        ++xfs.xt;
        !           293:        --xfs.nextents;
        !           294: 
        !           295:        return &xad;
        !           296: }
        !           297: 
        !           298: /*
        !           299:  * Name lies - the function reads only first 100 bytes
        !           300:  */
        !           301: static void
        !           302: xfs_dabread (void)
        !           303: {
        !           304:        xad_t *xad;
        !           305:        xfs_fileoff_t offset;;
        !           306: 
        !           307:        init_extents ();
        !           308:        while ((xad = next_extent ())) {
        !           309:                offset = xad->offset;
        !           310:                if (isinxt (xfs.dablk, offset, xad->len)) {
        !           311:                        devread (fsb2daddr (xad->start + xfs.dablk - offset),
        !           312:                                 0, 100, dirbuf);
        !           313:                        break;
        !           314:                }
        !           315:        }
        !           316: }
        !           317: 
        !           318: static inline xfs_ino_t
        !           319: sf_ino (char *sfe, int namelen)
        !           320: {
        !           321:        void *p = sfe + namelen + 3;
        !           322: 
        !           323:        return (xfs.i8param == 0)
        !           324:                ? le64(*(xfs_ino_t *)p) : le32(*(__uint32_t *)p);
        !           325: }
        !           326: 
        !           327: static inline xfs_ino_t
        !           328: sf_parent_ino (void)
        !           329: {
        !           330:        return (xfs.i8param == 0)
        !           331:                ? le64(*(xfs_ino_t *)(&inode->di_u.di_dir2sf.hdr.parent))
        !           332:                : le32(*(__uint32_t *)(&inode->di_u.di_dir2sf.hdr.parent));
        !           333: }
        !           334: 
        !           335: static inline int
        !           336: roundup8 (int n)
        !           337: {
        !           338:        return ((n+7)&~7);
        !           339: }
        !           340: 
        !           341: static char *
        !           342: next_dentry (xfs_ino_t *ino)
        !           343: {
        !           344:        int namelen = 1;
        !           345:        int toread;
        !           346:         static char *usual[2];
        !           347:        static xfs_dir2_sf_entry_t *sfe;
        !           348:         char *name;
        !           349: 
        !           350:         if (!usual[0]) {
        !           351:             usual[0] = strdup(".");
        !           352:             usual[1] = strdup("..");
        !           353:         }
        !           354:         name = usual[0];
        !           355: 
        !           356:        if (xfs.dirpos >= xfs.dirmax) {
        !           357:                if (xfs.forw == 0)
        !           358:                        return NULL;
        !           359:                xfs.dablk = xfs.forw;
        !           360:                xfs_dabread ();
        !           361: #define h      ((xfs_dir2_leaf_hdr_t *)dirbuf)
        !           362:                xfs.dirmax = le16 (h->count) - le16 (h->stale);
        !           363:                xfs.forw = le32 (h->info.forw);
        !           364: #undef h
        !           365:                xfs.dirpos = 0;
        !           366:        }
        !           367: 
        !           368:        switch (icore.di_format) {
        !           369:        case XFS_DINODE_FMT_LOCAL:
        !           370:                switch (xfs.dirpos) {
        !           371:                case -2:
        !           372:                        *ino = 0;
        !           373:                        break;
        !           374:                case -1:
        !           375:                        *ino = sf_parent_ino ();
        !           376:                        ++name;
        !           377:                        ++namelen;
        !           378:                        sfe = (xfs_dir2_sf_entry_t *)
        !           379:                                (inode->di_u.di_c
        !           380:                                 + sizeof(xfs_dir2_sf_hdr_t)
        !           381:                                 - xfs.i8param);
        !           382:                        break;
        !           383:                default:
        !           384:                        namelen = sfe->namelen;
        !           385:                        *ino = sf_ino ((char *)sfe, namelen);
        !           386:                        name = (char *)sfe->name;
        !           387:                        sfe = (xfs_dir2_sf_entry_t *)
        !           388:                                  ((char *)sfe + namelen + 11 - xfs.i8param);
        !           389:                }
        !           390:                break;
        !           391:        case XFS_DINODE_FMT_BTREE:
        !           392:        case XFS_DINODE_FMT_EXTENTS:
        !           393: #define dau    ((xfs_dir2_data_union_t *)dirbuf)
        !           394:                for (;;) {
        !           395:                        if (xfs.blkoff >= xfs.dirbsize) {
        !           396:                                xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
        !           397:                                filepos &= ~(xfs.dirbsize - 1);
        !           398:                                filepos |= xfs.blkoff;
        !           399:                        }
        !           400:                        xfs_read (dirbuf, 4);
        !           401:                        xfs.blkoff += 4;
        !           402:                        if (dau->unused.freetag == XFS_DIR2_DATA_FREE_TAG) {
        !           403:                                toread = roundup8 (le16(dau->unused.length)) - 4;
        !           404:                                xfs.blkoff += toread;
        !           405:                                filepos += toread;
        !           406:                                continue;
        !           407:                        }
        !           408:                        break;
        !           409:                }
        !           410:                xfs_read ((char *)dirbuf + 4, 5);
        !           411:                *ino = le64 (dau->entry.inumber);
        !           412:                namelen = dau->entry.namelen;
        !           413: #undef dau
        !           414:                toread = roundup8 (namelen + 11) - 9;
        !           415:                xfs_read (dirbuf, toread);
        !           416:                name = (char *)dirbuf;
        !           417:                xfs.blkoff += toread + 5;
        !           418:        }
        !           419:        ++xfs.dirpos;
        !           420:        name[namelen] = 0;
        !           421: 
        !           422:        return name;
        !           423: }
        !           424: 
        !           425: static char *
        !           426: first_dentry (xfs_ino_t *ino)
        !           427: {
        !           428:        xfs.forw = 0;
        !           429:        switch (icore.di_format) {
        !           430:        case XFS_DINODE_FMT_LOCAL:
        !           431:                xfs.dirmax = inode->di_u.di_dir2sf.hdr.count;
        !           432:                xfs.i8param = inode->di_u.di_dir2sf.hdr.i8count ? 0 : 4;
        !           433:                xfs.dirpos = -2;
        !           434:                break;
        !           435:        case XFS_DINODE_FMT_EXTENTS:
        !           436:        case XFS_DINODE_FMT_BTREE:
        !           437:                filepos = 0;
        !           438:                xfs_read (dirbuf, sizeof(xfs_dir2_data_hdr_t));
        !           439:                if (((xfs_dir2_data_hdr_t *)dirbuf)->magic == le32(XFS_DIR2_BLOCK_MAGIC)) {
        !           440: #define tail           ((xfs_dir2_block_tail_t *)dirbuf)
        !           441:                        filepos = xfs.dirbsize - sizeof(*tail);
        !           442:                        xfs_read (dirbuf, sizeof(*tail));
        !           443:                        xfs.dirmax = le32 (tail->count) - le32 (tail->stale);
        !           444: #undef tail
        !           445:                } else {
        !           446:                        xfs.dablk = (1ULL << 35) >> xfs.blklog;
        !           447: #define h              ((xfs_dir2_leaf_hdr_t *)dirbuf)
        !           448: #define n              ((xfs_da_intnode_t *)dirbuf)
        !           449:                        for (;;) {
        !           450:                                xfs_dabread ();
        !           451:                                if ((n->hdr.info.magic == le16(XFS_DIR2_LEAFN_MAGIC))
        !           452:                                    || (n->hdr.info.magic == le16(XFS_DIR2_LEAF1_MAGIC))) {
        !           453:                                        xfs.dirmax = le16 (h->count) - le16 (h->stale);
        !           454:                                        xfs.forw = le32 (h->info.forw);
        !           455:                                        break;
        !           456:                                }
        !           457:                                xfs.dablk = le32 (n->btree[0].before);
        !           458:                        }
        !           459: #undef n
        !           460: #undef h
        !           461:                }
        !           462:                xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
        !           463:                filepos = xfs.blkoff;
        !           464:                xfs.dirpos = 0;
        !           465:        }
        !           466:        return next_dentry (ino);
        !           467: }
        !           468: 
        !           469: int
        !           470: xfs_mount (void)
        !           471: {
        !           472:        xfs_sb_t super;
        !           473: 
        !           474:        if (!devread (0, 0, sizeof(super), (char *)&super)
        !           475:            || (le32(super.sb_magicnum) != XFS_SB_MAGIC)
        !           476:            || ((le16(super.sb_versionnum)
        !           477:                & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4) ) {
        !           478:                return 0;
        !           479:        }
        !           480: 
        !           481:        xfs.bsize = le32 (super.sb_blocksize);
        !           482:        xfs.blklog = super.sb_blocklog;
        !           483:        xfs.bdlog = xfs.blklog - SECTOR_BITS;
        !           484:        xfs.rootino = le64 (super.sb_rootino);
        !           485:        xfs.isize = le16 (super.sb_inodesize);
        !           486:        xfs.agblocks = le32 (super.sb_agblocks);
        !           487:        xfs.dirbsize = xfs.bsize << super.sb_dirblklog;
        !           488: 
        !           489:        xfs.inopblog = super.sb_inopblog;
        !           490:        xfs.agblklog = super.sb_agblklog;
        !           491:        xfs.agnolog = xfs_highbit32 (le32(super.sb_agcount));
        !           492: 
        !           493:        xfs.btnode_ptr0_off =
        !           494:                ((xfs.bsize - sizeof(xfs_btree_block_t)) /
        !           495:                (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t)))
        !           496:                 * sizeof(xfs_bmbt_key_t) + sizeof(xfs_btree_block_t);
        !           497: 
        !           498:        return 1;
        !           499: }
        !           500: 
        !           501: int
        !           502: xfs_read (char *buf, int len)
        !           503: {
        !           504:        xad_t *xad;
        !           505:        xfs_fileoff_t endofprev, endofcur, offset;
        !           506:        xfs_filblks_t xadlen;
        !           507:        int toread, startpos, endpos;
        !           508: 
        !           509:        if (icore.di_format == XFS_DINODE_FMT_LOCAL) {
        !           510:                grub_memmove (buf, inode->di_u.di_c + filepos, len);
        !           511:                filepos += len;
        !           512:                return len;
        !           513:        }
        !           514: 
        !           515:        startpos = filepos;
        !           516:        endpos = filepos + len;
        !           517:        endofprev = (xfs_fileoff_t)-1;
        !           518:        init_extents ();
        !           519:        while (len > 0 && (xad = next_extent ())) {
        !           520:                offset = xad->offset;
        !           521:                xadlen = xad->len;
        !           522:                if (isinxt (filepos >> xfs.blklog, offset, xadlen)) {
        !           523:                        endofcur = (offset + xadlen) << xfs.blklog;
        !           524:                        toread = (endofcur >= endpos)
        !           525:                                  ? len : (endofcur - filepos);
        !           526: 
        !           527:                        disk_read_func = disk_read_hook;
        !           528:                        devread (fsb2daddr (xad->start),
        !           529:                                 filepos - (offset << xfs.blklog), toread, buf);
        !           530:                        disk_read_func = NULL;
        !           531: 
        !           532:                        buf += toread;
        !           533:                        len -= toread;
        !           534:                        filepos += toread;
        !           535:                } else if (offset > endofprev) {
        !           536:                        toread = ((offset << xfs.blklog) >= endpos)
        !           537:                                  ? len : ((offset - endofprev) << xfs.blklog);
        !           538:                        len -= toread;
        !           539:                        filepos += toread;
        !           540:                        for (; toread; toread--) {
        !           541:                                *buf++ = 0;
        !           542:                        }
        !           543:                        continue;
        !           544:                }
        !           545:                endofprev = offset + xadlen;
        !           546:        }
        !           547: 
        !           548:        return filepos - startpos;
        !           549: }
        !           550: 
        !           551: int
        !           552: xfs_dir (char *dirname)
        !           553: {
        !           554:        xfs_ino_t ino, parent_ino, new_ino;
        !           555:        xfs_fsize_t di_size;
        !           556:        int di_mode;
        !           557:        int cmp, n, link_count;
        !           558:        char linkbuf[xfs.bsize];
        !           559:        char *rest, *name, ch;
        !           560: 
        !           561:        parent_ino = ino = xfs.rootino;
        !           562:        link_count = 0;
        !           563:        for (;;) {
        !           564:                di_read (ino);
        !           565:                di_size = le64 (icore.di_size);
        !           566:                di_mode = le16 (icore.di_mode);
        !           567: 
        !           568:                if ((di_mode & IFMT) == IFLNK) {
        !           569:                        if (++link_count > MAX_LINK_COUNT) {
        !           570:                                errnum = ERR_SYMLINK_LOOP;
        !           571:                                return 0;
        !           572:                        }
        !           573:                        if (di_size < xfs.bsize - 1) {
        !           574:                                filepos = 0;
        !           575:                                filemax = di_size;
        !           576:                                n = xfs_read (linkbuf, filemax);
        !           577:                        } else {
        !           578:                                errnum = ERR_FILELENGTH;
        !           579:                                return 0;
        !           580:                        }
        !           581: 
        !           582:                        ino = (linkbuf[0] == '/') ? xfs.rootino : parent_ino;
        !           583:                        while (n < (xfs.bsize - 1) && (linkbuf[n++] = *dirname++));
        !           584:                        linkbuf[n] = 0;
        !           585:                        dirname = linkbuf;
        !           586:                        continue;
        !           587:                }
        !           588: 
        !           589:                if (!*dirname || isspace (*dirname)) {
        !           590:                        if ((di_mode & IFMT) != IFREG) {
        !           591:                                errnum = ERR_BAD_FILETYPE;
        !           592:                                return 0;
        !           593:                        }
        !           594:                        filepos = 0;
        !           595:                        filemax = di_size;
        !           596:                        return 1;
        !           597:                }
        !           598: 
        !           599:                if ((di_mode & IFMT) != IFDIR) {
        !           600:                        errnum = ERR_BAD_FILETYPE;
        !           601:                        return 0;
        !           602:                }
        !           603: 
        !           604:                for (; *dirname == '/'; dirname++);
        !           605: 
        !           606:                for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
        !           607:                *rest = 0;
        !           608: 
        !           609:                name = first_dentry (&new_ino);
        !           610:                for (;;) {
        !           611:                        cmp = (!*dirname) ? -1 : substring (dirname, name);
        !           612: #ifndef STAGE1_5
        !           613:                        if (print_possibilities && ch != '/' && cmp <= 0) {
        !           614:                                if (print_possibilities > 0)
        !           615:                                        print_possibilities = -print_possibilities;
        !           616:                                print_a_completion (name);
        !           617:                        } else
        !           618: #endif
        !           619:                        if (cmp == 0) {
        !           620:                                parent_ino = ino;
        !           621:                                if (new_ino)
        !           622:                                        ino = new_ino;
        !           623:                                *(dirname = rest) = ch;
        !           624:                                break;
        !           625:                        }
        !           626:                        name = next_dentry (&new_ino);
        !           627:                        if (name == NULL) {
        !           628:                                if (print_possibilities < 0)
        !           629:                                        return 1;
        !           630: 
        !           631:                                errnum = ERR_FILE_NOT_FOUND;
        !           632:                                *rest = ch;
        !           633:                                return 0;
        !           634:                        }
        !           635:                }
        !           636:        }
        !           637: }
        !           638: 
        !           639: #endif /* FSYS_XFS */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.