second/fs_xfs.c

   1 /*
   2  *  fsys_xfs.c - an implementation for the SGI XFS file system
   3  *
   4  *  Copyright (C) 2001  Ethan Benson
   5  *
   6  *  Adapted from Grub
   7  *
   8  *  Copyright (C) 2001  Serguei Tzukanov
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "types.h"
  26 #include "ctype.h"
  27 #include "string.h"
  28 #include "stdlib.h"
  29 #include "fs.h"
  30 #include "xfs/xfs.h"
  31 #include "errors.h"
  32 #include "debug.h"
  33
  34 #define SECTOR_BITS 9
  35
  36 int xfs_mount (void);
  37 int xfs_read_data (char *buf, int len);
  38 int xfs_dir (char *dirname);
  39
  40 /* Exported in struct fs_t */
  41 static int xfs_open(struct boot_file_t *file, const char *dev_name,
  42                     struct partition_t *part, const char *file_name);
  43 static int xfs_read(struct boot_file_t *file, unsigned int size, void *buffer);
  44 static int xfs_seek(struct boot_file_t *file, unsigned int newpos);
  45 static int xfs_close(struct boot_file_t *file);
  46
  47 struct fs_t xfs_filesystem = {
  48         name:"xfs",
  49         open:xfs_open,
  50         read:xfs_read,
  51         seek:xfs_seek,
  52         close:xfs_close
  53 };
  54
  55 struct boot_file_t *xfs_file;
  56 static char FSYS_BUF[32768];
  57 __u64 partition_offset;
  58 int errnum;
  59
  60 static int
  61 xfs_open(struct boot_file_t *file, const char *dev_name,
  62          struct partition_t *part, const char *file_name)
  63 {
  64         static char buffer[1024];
  65
  66         DEBUG_ENTER;
  67         DEBUG_OPEN;
  68
  69         if (part)
  70         {
  71                 DEBUG_F("Determining offset for partition %d\n", part->part_number);
  72                 partition_offset = ((__u64)(part->part_start)) * ((__u64)part->blocksize);
  73                 DEBUG_F("%Lu = %lu * %hu\n", partition_offset,
  74                         part->part_start,
  75                         part->blocksize);
  76         }
  77         else
  78                 partition_offset = 0;
  79
  80         sprintf(buffer, "%s:%d", dev_name, 0); /* 0 is full disk in OF */
  81         DEBUG_F("Trying to open dev_name=%s; filename=%s; partition offset=%Lu\n",
  82                 buffer, file_name, partition_offset);
  83         file->of_device = prom_open(buffer);
  84
  85         if (file->of_device == PROM_INVALID_HANDLE || file->of_device == NULL)
  86         {
  87                 DEBUG_F("Can't open device %p\n", file->of_device);
  88                 DEBUG_LEAVE(FILE_ERR_BADDEV);
  89                 return FILE_ERR_BADDEV;
  90         }
  91
  92         DEBUG_F("%p was successfully opened\n", file->of_device);
  93
  94         xfs_file = file;
  95
  96         if (xfs_mount() != 1)
  97         {
  98                 DEBUG_F("Couldn't open XFS @ %s/%Lu\n", buffer, partition_offset);
  99                 prom_close(file->of_device);
 100                 DEBUG_LEAVE(FILE_ERR_BAD_FSYS);
 101                 DEBUG_SLEEP;
 102                 return FILE_ERR_BAD_FSYS;
 103         }
 104
 105         DEBUG_F("Attempting to open %s\n", file_name);
 106         strcpy(buffer, file_name); /* xfs_dir modifies argument */
 107         if(!xfs_dir(buffer))
 108         {
 109                 DEBUG_F("xfs_dir() failed. errnum = %d\n", errnum);
 110                 prom_close( file->of_device );
 111                 DEBUG_LEAVE_F(errnum);
 112                 DEBUG_SLEEP;
 113                 return errnum;
 114         }
 115
 116         DEBUG_F("Successfully opened %s\n", file_name);
 117
 118         DEBUG_LEAVE(FILE_ERR_OK);
 119         return FILE_ERR_OK;
 120 }
 121
 122 static int
 123 xfs_read(struct boot_file_t *file, unsigned int size, void *buffer)
 124 {
 125         return xfs_read_data(buffer, size);
 126 }
 127
 128 static int
 129 xfs_seek(struct boot_file_t *file, unsigned int newpos)
 130 {
 131         file->pos = newpos;
 132         return FILE_ERR_OK;
 133 }
 134
 135 static int
 136 xfs_close(struct boot_file_t *file)
 137 {
 138         if(file->of_device)
 139         {
 140                 prom_close(file->of_device);
 141                 file->of_device = 0;
 142                 DEBUG_F("xfs_close called\n");
 143         }
 144         return FILE_ERR_OK;
 145 }
 146
 147 static int
 148 read_disk_block(struct boot_file_t *file, __u32 block, __u32 start,
 149                 __u32 length, void *buf)
 150 {
 151         unsigned long long pos = block * 512;
 152         pos += partition_offset + start;
 153         DEBUG_F("Reading %u bytes, starting at block %u, disk offset %Lu\n",
 154                 length, block, pos);
 155         if (!prom_lseek(file->of_device, pos)) {
 156                 DEBUG_F("prom_lseek failed\n");
 157                 return 0;
 158         }
 159         return prom_read(file->of_device, buf, length);
 160 }
 161
 162 #define MAX_LINK_COUNT  8
 163
 164 typedef struct xad {
 165         xfs_fileoff_t offset;
 166         xfs_fsblock_t start;
 167         xfs_filblks_t len;
 168 } xad_t;
 169
 170 struct xfs_info {
 171         int bsize;
 172         int dirbsize;
 173         int isize;
 174         unsigned int agblocks;
 175         int bdlog;
 176         int blklog;
 177         int inopblog;
 178         int agblklog;
 179         int agnolog;
 180         int dirblklog;
 181         unsigned int nextents;
 182         xfs_daddr_t next;
 183         xfs_daddr_t daddr;
 184         xfs_dablk_t forw;
 185         xfs_dablk_t dablk;
 186         xfs_bmbt_rec_32_t *xt;
 187         xfs_bmbt_ptr_t ptr0;
 188         int btnode_ptr0_off;
 189         int i8param;
 190         int dirpos;
 191         int dirmax;
 192         int blkoff;
 193         int fpos;
 194         xfs_ino_t rootino;
 195 };
 196
 197 static struct xfs_info xfs;
 198
 199 #define dirbuf          ((char *)FSYS_BUF)
 200 #define filebuf         ((char *)FSYS_BUF + 4096)
 201 #define inode           ((xfs_dinode_t *)((char *)FSYS_BUF + 8192))
 202 #define icore           (inode->di_core)
 203
 204 #define mask32lo(n)     (((__uint32_t)1 << (n)) - 1)
 205
 206 #define XFS_INO_MASK(k)         ((__uint32_t)((1ULL << (k)) - 1))
 207 #define XFS_INO_OFFSET_BITS     xfs.inopblog
 208 #define XFS_INO_AGBNO_BITS      xfs.agblklog
 209 #define XFS_INO_AGINO_BITS      (xfs.agblklog + xfs.inopblog)
 210 #define XFS_INO_AGNO_BITS       xfs.agnolog
 211
 212 static inline xfs_agblock_t
 213 agino2agbno (xfs_agino_t agino)
 214 {
 215         return agino >> XFS_INO_OFFSET_BITS;
 216 }
 217
 218 static inline xfs_agnumber_t
 219 ino2agno (xfs_ino_t ino)
 220 {
 221         return ino >> XFS_INO_AGINO_BITS;
 222 }
 223
 224 static inline xfs_agino_t
 225 ino2agino (xfs_ino_t ino)
 226 {
 227         return ino & XFS_INO_MASK(XFS_INO_AGINO_BITS);
 228 }
 229
 230 static inline int
 231 ino2offset (xfs_ino_t ino)
 232 {
 233         return ino & XFS_INO_MASK(XFS_INO_OFFSET_BITS);
 234 }
 235
 236 /* XFS is big endian, powerpc is big endian */
 237
 238 static inline __const__ __uint16_t
 239 le16 (__uint16_t x)
 240 {
 241         return x;
 242 }
 243
 244 static inline __const__ __uint32_t
 245 le32 (__uint32_t x)
 246 {
 247         return x;
 248 }
 249
 250 static inline __const__ __uint64_t
 251 le64 (__uint64_t x)
 252 {
 253         return x;
 254 }
 255
 256 static xfs_fsblock_t
 257 xt_start (xfs_bmbt_rec_32_t *r)
 258 {
 259         return (((xfs_fsblock_t)(le32 (r->l1) & mask32lo(9))) << 43) |
 260                (((xfs_fsblock_t)le32 (r->l2)) << 11) |
 261                (((xfs_fsblock_t)le32 (r->l3)) >> 21);
 262 }
 263
 264 static xfs_fileoff_t
 265 xt_offset (xfs_bmbt_rec_32_t *r)
 266 {
 267         return (((xfs_fileoff_t)le32 (r->l0) &
 268                 mask32lo(31)) << 23) |
 269                 (((xfs_fileoff_t)le32 (r->l1)) >> 9);
 270 }
 271
 272 static xfs_filblks_t
 273 xt_len (xfs_bmbt_rec_32_t *r)
 274 {
 275         return le32(r->l3) & mask32lo(21);
 276 }
 277
 278 static const char xfs_highbit[256] = {
 279        -1, 0, 1, 1, 2, 2, 2, 2,                 /* 00 .. 07 */
 280         3, 3, 3, 3, 3, 3, 3, 3,                 /* 08 .. 0f */
 281         4, 4, 4, 4, 4, 4, 4, 4,                 /* 10 .. 17 */
 282         4, 4, 4, 4, 4, 4, 4, 4,                 /* 18 .. 1f */
 283         5, 5, 5, 5, 5, 5, 5, 5,                 /* 20 .. 27 */
 284         5, 5, 5, 5, 5, 5, 5, 5,                 /* 28 .. 2f */
 285         5, 5, 5, 5, 5, 5, 5, 5,                 /* 30 .. 37 */
 286         5, 5, 5, 5, 5, 5, 5, 5,                 /* 38 .. 3f */
 287         6, 6, 6, 6, 6, 6, 6, 6,                 /* 40 .. 47 */
 288         6, 6, 6, 6, 6, 6, 6, 6,                 /* 48 .. 4f */
 289         6, 6, 6, 6, 6, 6, 6, 6,                 /* 50 .. 57 */
 290         6, 6, 6, 6, 6, 6, 6, 6,                 /* 58 .. 5f */
 291         6, 6, 6, 6, 6, 6, 6, 6,                 /* 60 .. 67 */
 292         6, 6, 6, 6, 6, 6, 6, 6,                 /* 68 .. 6f */
 293         6, 6, 6, 6, 6, 6, 6, 6,                 /* 70 .. 77 */
 294         6, 6, 6, 6, 6, 6, 6, 6,                 /* 78 .. 7f */
 295         7, 7, 7, 7, 7, 7, 7, 7,                 /* 80 .. 87 */
 296         7, 7, 7, 7, 7, 7, 7, 7,                 /* 88 .. 8f */
 297         7, 7, 7, 7, 7, 7, 7, 7,                 /* 90 .. 97 */
 298         7, 7, 7, 7, 7, 7, 7, 7,                 /* 98 .. 9f */
 299         7, 7, 7, 7, 7, 7, 7, 7,                 /* a0 .. a7 */
 300         7, 7, 7, 7, 7, 7, 7, 7,                 /* a8 .. af */
 301         7, 7, 7, 7, 7, 7, 7, 7,                 /* b0 .. b7 */
 302         7, 7, 7, 7, 7, 7, 7, 7,                 /* b8 .. bf */
 303         7, 7, 7, 7, 7, 7, 7, 7,                 /* c0 .. c7 */
 304         7, 7, 7, 7, 7, 7, 7, 7,                 /* c8 .. cf */
 305         7, 7, 7, 7, 7, 7, 7, 7,                 /* d0 .. d7 */
 306         7, 7, 7, 7, 7, 7, 7, 7,                 /* d8 .. df */
 307         7, 7, 7, 7, 7, 7, 7, 7,                 /* e0 .. e7 */
 308         7, 7, 7, 7, 7, 7, 7, 7,                 /* e8 .. ef */
 309         7, 7, 7, 7, 7, 7, 7, 7,                 /* f0 .. f7 */
 310         7, 7, 7, 7, 7, 7, 7, 7,                 /* f8 .. ff */
 311 };
 312
 313 static int
 314 xfs_highbit32(__uint32_t v)
 315 {
 316         int             i;
 317
 318         if (v & 0xffff0000)
 319                 if (v & 0xff000000)
 320                         i = 24;
 321                 else
 322                         i = 16;
 323         else if (v & 0x0000ffff)
 324                 if (v & 0x0000ff00)
 325                         i = 8;
 326                 else
 327                         i = 0;
 328         else
 329                 return -1;
 330         return i + xfs_highbit[(v >> i) & 0xff];
 331 }
 332
 333 static int
 334 isinxt (xfs_fileoff_t key, xfs_fileoff_t offset, xfs_filblks_t len)
 335 {
 336         return (key >= offset) ? (key < offset + len ? 1 : 0) : 0;
 337 }
 338
 339 static xfs_daddr_t
 340 agb2daddr (xfs_agnumber_t agno, xfs_agblock_t agbno)
 341 {
 342         return ((xfs_fsblock_t)agno*xfs.agblocks + agbno) << xfs.bdlog;
 343 }
 344
 345 static xfs_daddr_t
 346 fsb2daddr (xfs_fsblock_t fsbno)
 347 {
 348         return agb2daddr ((xfs_agnumber_t)(fsbno >> xfs.agblklog),
 349                          (xfs_agblock_t)(fsbno & mask32lo(xfs.agblklog)));
 350 }
 351
 352 static inline int
 353 btroot_maxrecs (void)
 354 {
 355         int tmp = icore.di_forkoff ? (icore.di_forkoff << 3) : xfs.isize;
 356
 357         return (tmp - sizeof(xfs_bmdr_block_t) -
 358                 (int)((char *)&inode->di_u - (char*)inode)) /
 359                 (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t));
 360 }
 361
 362 static int
 363 di_read (xfs_ino_t ino)
 364 {
 365         xfs_agino_t agino;
 366         xfs_agnumber_t agno;
 367         xfs_agblock_t agbno;
 368         xfs_daddr_t daddr;
 369         int offset;
 370
 371         agno = ino2agno (ino);
 372         agino = ino2agino (ino);
 373         agbno = agino2agbno (agino);
 374         offset = ino2offset (ino);
 375         daddr = agb2daddr (agno, agbno);
 376
 377         read_disk_block(xfs_file, daddr, offset*xfs.isize, xfs.isize, (char *)inode);
 378
 379         xfs.ptr0 = *(xfs_bmbt_ptr_t *)
 380                     (inode->di_u.di_c + sizeof(xfs_bmdr_block_t)
 381                     + btroot_maxrecs ()*sizeof(xfs_bmbt_key_t));
 382
 383         return 1;
 384 }
 385
 386 static void
 387 init_extents (void)
 388 {
 389         xfs_bmbt_ptr_t ptr0;
 390         xfs_btree_lblock_t h;
 391
 392         switch (icore.di_format) {
 393         case XFS_DINODE_FMT_EXTENTS:
 394                 xfs.xt = inode->di_u.di_bmx;
 395                 xfs.nextents = le32 (icore.di_nextents);
 396                 break;
 397         case XFS_DINODE_FMT_BTREE:
 398                 ptr0 = xfs.ptr0;
 399                 for (;;) {
 400                         xfs.daddr = fsb2daddr (le64(ptr0));
 401                         read_disk_block(xfs_file, xfs.daddr, 0,
 402                                         sizeof(xfs_btree_lblock_t), (char *)&h);
 403                         if (!h.bb_level) {
 404                                 xfs.nextents = le16(h.bb_numrecs);
 405                                 xfs.next = fsb2daddr (le64(h.bb_leftsib));
 406                                 xfs.fpos = sizeof(xfs_btree_block_t);
 407                                 return;
 408                         }
 409                         read_disk_block(xfs_file, xfs.daddr, xfs.btnode_ptr0_off,
 410                                  sizeof(xfs_bmbt_ptr_t), (char *)&ptr0);
 411                 }
 412         }
 413 }
 414
 415 static xad_t *
 416 next_extent (void)
 417 {
 418         static xad_t xad;
 419
 420         switch (icore.di_format) {
 421         case XFS_DINODE_FMT_EXTENTS:
 422                 if (xfs.nextents == 0)
 423                         return NULL;
 424                 break;
 425         case XFS_DINODE_FMT_BTREE:
 426                 if (xfs.nextents == 0) {
 427                         xfs_btree_lblock_t h;
 428                         if (xfs.next == 0)
 429                                 return NULL;
 430                         xfs.daddr = xfs.next;
 431                         read_disk_block(xfs_file, xfs.daddr, 0,
 432                                         sizeof(xfs_btree_lblock_t), (char *)&h);
 433                         xfs.nextents = le16(h.bb_numrecs);
 434                         xfs.next = fsb2daddr (le64(h.bb_leftsib));
 435                         xfs.fpos = sizeof(xfs_btree_block_t);
 436                 }
 437                 /* Yeah, I know that's slow, but I really don't care */
 438                 read_disk_block(xfs_file, xfs.daddr, xfs.fpos,
 439                                 sizeof(xfs_bmbt_rec_t), filebuf);
 440                 xfs.xt = (xfs_bmbt_rec_32_t *)filebuf;
 441                 xfs.fpos += sizeof(xfs_bmbt_rec_32_t);
 442                 break;
 443         default:
 444                 return NULL;
 445         }
 446         xad.offset = xt_offset (xfs.xt);
 447         xad.start = xt_start (xfs.xt);
 448         xad.len = xt_len (xfs.xt);
 449         ++xfs.xt;
 450         --xfs.nextents;
 451
 452         return &xad;
 453 }
 454
 455 /*
 456  * Name lies - the function reads only first 100 bytes
 457  */
 458 static void
 459 xfs_dabread (void)
 460 {
 461         xad_t *xad;
 462         xfs_fileoff_t offset;;
 463
 464         init_extents ();
 465         while ((xad = next_extent ())) {
 466                 offset = xad->offset;
 467                 if (isinxt (xfs.dablk, offset, xad->len)) {
 468                         read_disk_block(xfs_file, fsb2daddr (xad->start + xfs.dablk - offset),
 469                                         0, 100, dirbuf);
 470                         break;
 471                 }
 472         }
 473 }
 474
 475 static inline xfs_ino_t
 476 sf_ino (char *sfe, int namelen)
 477 {
 478         void *p = sfe + namelen + 3;
 479
 480         return (xfs.i8param == 0)
 481                 ? le64(*(xfs_ino_t *)p) : le32(*(__uint32_t *)p);
 482 }
 483
 484 static inline xfs_ino_t
 485 sf_parent_ino (void)
 486 {
 487         return (xfs.i8param == 0)
 488                 ? le64(*(xfs_ino_t *)(&inode->di_u.di_dir2sf.hdr.parent))
 489                 : le32(*(__uint32_t *)(&inode->di_u.di_dir2sf.hdr.parent));
 490 }
 491
 492 static inline int
 493 roundup8 (int n)
 494 {
 495         return ((n+7)&~7);
 496 }
 497
 498 static char *
 499 next_dentry (xfs_ino_t *ino)
 500 {
 501         int namelen = 1;
 502         int toread;
 503         static char *usual[2] = {".", ".."};
 504         static xfs_dir2_sf_entry_t *sfe;
 505         char *name = usual[0];
 506
 507         if (xfs.dirpos >= xfs.dirmax) {
 508                 if (xfs.forw == 0)
 509                         return NULL;
 510                 xfs.dablk = xfs.forw;
 511                 xfs_dabread ();
 512 #define h       ((xfs_dir2_leaf_hdr_t *)dirbuf)
 513                 xfs.dirmax = le16 (h->count) - le16 (h->stale);
 514                 xfs.forw = le32 (h->info.forw);
 515 #undef h
 516                 xfs.dirpos = 0;
 517         }
 518
 519         switch (icore.di_format) {
 520         case XFS_DINODE_FMT_LOCAL:
 521                 switch (xfs.dirpos) {
 522                 case -2:
 523                         *ino = 0;
 524                         break;
 525                 case -1:
 526                         *ino = sf_parent_ino ();
 527                         ++name;
 528                         ++namelen;
 529                         sfe = (xfs_dir2_sf_entry_t *)
 530                                 (inode->di_u.di_c
 531                                  + sizeof(xfs_dir2_sf_hdr_t)
 532                                  - xfs.i8param);
 533                         break;
 534                 default:
 535                         namelen = sfe->namelen;
 536                         *ino = sf_ino ((char *)sfe, namelen);
 537                         name = sfe->name;
 538                         sfe = (xfs_dir2_sf_entry_t *)
 539                                   ((char *)sfe + namelen + 11 - xfs.i8param);
 540                 }
 541                 break;
 542         case XFS_DINODE_FMT_BTREE:
 543         case XFS_DINODE_FMT_EXTENTS:
 544 #define dau     ((xfs_dir2_data_union_t *)dirbuf)
 545                 for (;;) {
 546                         if (xfs.blkoff >= xfs.dirbsize) {
 547                                 xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
 548                                 xfs_file->pos &= ~(xfs.dirbsize - 1);
 549                                 xfs_file->pos |= xfs.blkoff;
 550                         }
 551                         xfs_read_data (dirbuf, 4);
 552                         xfs.blkoff += 4;
 553                         if (dau->unused.freetag == XFS_DIR2_DATA_FREE_TAG) {
 554                                 toread = roundup8 (le16(dau->unused.length)) - 4;
 555                                 xfs.blkoff += toread;
 556                                 xfs_file->pos += toread;
 557                                 continue;
 558                         }
 559                         break;
 560                 }
 561                 xfs_read_data ((char *)dirbuf + 4, 5);
 562                 *ino = le64 (dau->entry.inumber);
 563                 namelen = dau->entry.namelen;
 564 #undef dau
 565                 toread = roundup8 (namelen + 11) - 9;
 566                 xfs_read_data (dirbuf, toread);
 567                 name = (char *)dirbuf;
 568                 xfs.blkoff += toread + 5;
 569                 break;
 570         }
 571         ++xfs.dirpos;
 572         name[namelen] = 0;
 573
 574         return name;
 575 }
 576
 577 static char *
 578 first_dentry (xfs_ino_t *ino)
 579 {
 580         xfs.forw = 0;
 581         switch (icore.di_format) {
 582         case XFS_DINODE_FMT_LOCAL:
 583                 xfs.dirmax = inode->di_u.di_dir2sf.hdr.count;
 584                 xfs.i8param = inode->di_u.di_dir2sf.hdr.i8count ? 0 : 4;
 585                 xfs.dirpos = -2;
 586                 break;
 587         case XFS_DINODE_FMT_EXTENTS:
 588         case XFS_DINODE_FMT_BTREE:
 589                 xfs_file->pos = 0;
 590                 xfs_file->len = le64 (icore.di_size);
 591                 xfs_read_data (dirbuf, sizeof(xfs_dir2_data_hdr_t));
 592                 if (((xfs_dir2_data_hdr_t *)dirbuf)->magic == le32(XFS_DIR2_BLOCK_MAGIC)) {
 593 #define tail            ((xfs_dir2_block_tail_t *)dirbuf)
 594                         xfs_file->pos = xfs.dirbsize - sizeof(*tail);
 595                         xfs_read_data (dirbuf, sizeof(*tail));
 596                         xfs.dirmax = le32 (tail->count) - le32 (tail->stale);
 597 #undef tail
 598                 } else {
 599                         xfs.dablk = (1ULL << 35) >> xfs.blklog;
 600 #define h               ((xfs_dir2_leaf_hdr_t *)dirbuf)
 601 #define n               ((xfs_da_intnode_t *)dirbuf)
 602                         for (;;) {
 603                                 xfs_dabread ();
 604                                 if ((n->hdr.info.magic == le16(XFS_DIR2_LEAFN_MAGIC))
 605                                     || (n->hdr.info.magic == le16(XFS_DIR2_LEAF1_MAGIC))) {
 606                                         xfs.dirmax = le16 (h->count) - le16 (h->stale);
 607                                         xfs.forw = le32 (h->info.forw);
 608                                         break;
 609                                 }
 610                                 xfs.dablk = le32 (n->btree[0].before);
 611                         }
 612 #undef n
 613 #undef h
 614                 }
 615                 xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
 616                 xfs_file->pos = xfs.blkoff;
 617                 xfs.dirpos = 0;
 618                 break;
 619         }
 620         return next_dentry (ino);
 621 }
 622
 623 int
 624 xfs_mount (void)
 625 {
 626         xfs_sb_t super;
 627
 628         if (read_disk_block(xfs_file, 0, 0, sizeof(super), &super) != sizeof(super)) {
 629                 DEBUG_F("read_disk_block failed!\n");
 630                 return 0;
 631         } else if (super.sb_magicnum != XFS_SB_MAGIC) {
 632                 DEBUG_F("xfs_mount: Bad magic: %x\n", super.sb_magicnum);
 633                 return 0;
 634         } else if ((super.sb_versionnum & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4) {
 635                 DEBUG_F("xfs_mount: Bad version: %x\n", super.sb_versionnum);
 636                 return 0;
 637         }
 638
 639         xfs.bsize = le32 (super.sb_blocksize);
 640         xfs.blklog = super.sb_blocklog;
 641         xfs.bdlog = xfs.blklog - SECTOR_BITS;
 642         xfs.rootino = le64 (super.sb_rootino);
 643         xfs.isize = le16 (super.sb_inodesize);
 644         xfs.agblocks = le32 (super.sb_agblocks);
 645         xfs.dirblklog = super.sb_dirblklog;
 646         xfs.dirbsize = xfs.bsize << super.sb_dirblklog;
 647
 648         xfs.inopblog = super.sb_inopblog;
 649         xfs.agblklog = super.sb_agblklog;
 650         xfs.agnolog = xfs_highbit32 (le32 (super.sb_agcount) - 1) + 1;
 651
 652         xfs.btnode_ptr0_off =
 653                 ((xfs.bsize - sizeof(xfs_btree_block_t)) /
 654                 (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t)))
 655                  * sizeof(xfs_bmbt_key_t) + sizeof(xfs_btree_block_t);
 656
 657         return 1;
 658 }
 659
 660 int
 661 xfs_read_data (char *buf, int len)
 662 {
 663         xad_t *xad;
 664         xfs_fileoff_t endofprev, endofcur, offset;
 665         xfs_filblks_t xadlen;
 666         int toread, startpos, endpos;
 667
 668         if (icore.di_format == XFS_DINODE_FMT_LOCAL) {
 669                 memmove(buf, inode->di_u.di_c + xfs_file->pos, len);
 670                 xfs_file->pos += len;
 671                 return len;
 672         }
 673
 674         startpos = xfs_file->pos;
 675         endpos = xfs_file->pos + len;
 676         if (endpos > xfs_file->len)
 677                 endpos = xfs_file->len;
 678         endofprev = (xfs_fileoff_t)-1;
 679         init_extents ();
 680         while (len > 0 && (xad = next_extent ())) {
 681                 offset = xad->offset;
 682                 xadlen = xad->len;
 683                 if (isinxt (xfs_file->pos >> xfs.blklog, offset, xadlen)) {
 684                         endofcur = (offset + xadlen) << xfs.blklog;
 685                         toread = (endofcur >= endpos)
 686                                   ? len : (endofcur - xfs_file->pos);
 687                         read_disk_block(xfs_file, fsb2daddr (xad->start),
 688                                         xfs_file->pos - (offset << xfs.blklog), toread, buf);
 689                         buf += toread;
 690                         len -= toread;
 691                         xfs_file->pos += toread;
 692                 } else if (offset > endofprev) {
 693                         toread = ((offset << xfs.blklog) >= endpos)
 694                                   ? len : ((offset - endofprev) << xfs.blklog);
 695                         len -= toread;
 696                         xfs_file->pos += toread;
 697                         for (; toread; toread--) {
 698                                 *buf++ = 0;
 699                         }
 700                         continue;
 701                 }
 702                 endofprev = offset + xadlen;
 703         }
 704
 705         return xfs_file->pos - startpos;
 706 }
 707
 708 int
 709 xfs_dir (char *dirname)
 710 {
 711         xfs_ino_t ino, parent_ino, new_ino;
 712         xfs_fsize_t di_size;
 713         int di_mode;
 714         int cmp, n, link_count;
 715         char linkbuf[xfs.bsize];
 716         char *rest, *name, ch;
 717
 718         DEBUG_ENTER;
 719
 720         parent_ino = ino = xfs.rootino;
 721         link_count = 0;
 722         for (;;) {
 723                 di_read (ino);
 724                 di_size = le64 (icore.di_size);
 725                 di_mode = le16 (icore.di_mode);
 726
 727                 DEBUG_F("di_mode: %o\n", di_mode);
 728                 if ((di_mode & IFMT) == IFLNK) {
 729                         if (++link_count > MAX_LINK_COUNT) {
 730                                 errnum = FILE_ERR_SYMLINK_LOOP;
 731                                 DEBUG_LEAVE(FILE_ERR_SYMLINK_LOOP);
 732                                 return 0;
 733                         }
 734                         if (di_size < xfs.bsize - 1) {
 735                                 xfs_file->pos = 0;
 736                                 xfs_file->len = di_size;
 737                                 n = xfs_read_data (linkbuf, xfs_file->len);
 738                         } else {
 739                                 errnum = FILE_ERR_LENGTH;
 740                                 DEBUG_LEAVE(FILE_ERR_LENGTH);
 741                                 return 0;
 742                         }
 743
 744                         ino = (linkbuf[0] == '/') ? xfs.rootino : parent_ino;
 745                         while (n < (xfs.bsize - 1) && (linkbuf[n++] = *dirname++));
 746                         linkbuf[n] = 0;
 747                         dirname = linkbuf;
 748                         continue;
 749                 }
 750
 751                 DEBUG_F("*dirname: %s\n", dirname);
 752                 if (!*dirname || isspace (*dirname)) {
 753                         if ((di_mode & IFMT) != IFREG) {
 754                                 errnum = FILE_ERR_BAD_TYPE;
 755                                 DEBUG_LEAVE(FILE_ERR_BAD_TYPE);
 756                                 return 0;
 757                         }
 758                         xfs_file->pos = 0;
 759                         xfs_file->len = di_size;
 760                         DEBUG_LEAVE(1);
 761                         return 1;
 762                 }
 763
 764                 if ((di_mode & IFMT) != IFDIR) {
 765                         errnum = FILE_ERR_NOTDIR;
 766                         DEBUG_LEAVE(FILE_ERR_NOTDIR);
 767                         return 0;
 768                 }
 769
 770                 for (; *dirname == '/'; dirname++);
 771
 772                 for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
 773                 *rest = 0;
 774
 775                 name = first_dentry (&new_ino);
 776                 for (;;) {
 777                         cmp = (!*dirname) ? -1 : strcmp(dirname, name);
 778                         if (cmp == 0) {
 779                                 parent_ino = ino;
 780                                 if (new_ino)
 781                                         ino = new_ino;
 782                                 *(dirname = rest) = ch;
 783                                 break;
 784                         }
 785                         name = next_dentry (&new_ino);
 786                         if (name == NULL) {
 787                                 errnum = FILE_ERR_NOTFOUND;
 788                                 DEBUG_LEAVE(FILE_ERR_NOTFOUND);
 789                                 *rest = ch;
 790                                 return 0;
 791                         }
 792                 }
 793         }
 794 }
 795
 796 /*
 797  * Local variables:
 798  * c-file-style: "K&R"
 799  * c-basic-offset: 8
 800  * End:
 801  */