second/fs_xfs.c

   1 /*
   2  *  fs_xfs.c - an implementation for the SGI XFS file system
   3  *
   4  *  Copyright (C) 2001, 2002 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 uint64_t 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 = ((uint64_t) part->part_start) * 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, uint64_t block, int start,
 149                 int length, void *buf)
 150 {
 151         uint64_t pos = block * 512;
 152         pos += partition_offset + start;
 153         DEBUG_F("Reading %d bytes, starting at block %Lu, 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 #define le16(x) (x)
 238 #define le32(x) (x)
 239 #define le64(x) (x)
 240
 241 static xfs_fsblock_t
 242 xt_start (xfs_bmbt_rec_32_t *r)
 243 {
 244         return (((xfs_fsblock_t)(le32 (r->l1) & mask32lo(9))) << 43) |
 245                (((xfs_fsblock_t)le32 (r->l2)) << 11) |
 246                (((xfs_fsblock_t)le32 (r->l3)) >> 21);
 247 }
 248
 249 static xfs_fileoff_t
 250 xt_offset (xfs_bmbt_rec_32_t *r)
 251 {
 252         return (((xfs_fileoff_t)le32 (r->l0) &
 253                 mask32lo(31)) << 23) |
 254                 (((xfs_fileoff_t)le32 (r->l1)) >> 9);
 255 }
 256
 257 static xfs_filblks_t
 258 xt_len (xfs_bmbt_rec_32_t *r)
 259 {
 260         return le32(r->l3) & mask32lo(21);
 261 }
 262
 263 static const char xfs_highbit[256] = {
 264        -1, 0, 1, 1, 2, 2, 2, 2,                 /* 00 .. 07 */
 265         3, 3, 3, 3, 3, 3, 3, 3,                 /* 08 .. 0f */
 266         4, 4, 4, 4, 4, 4, 4, 4,                 /* 10 .. 17 */
 267         4, 4, 4, 4, 4, 4, 4, 4,                 /* 18 .. 1f */
 268         5, 5, 5, 5, 5, 5, 5, 5,                 /* 20 .. 27 */
 269         5, 5, 5, 5, 5, 5, 5, 5,                 /* 28 .. 2f */
 270         5, 5, 5, 5, 5, 5, 5, 5,                 /* 30 .. 37 */
 271         5, 5, 5, 5, 5, 5, 5, 5,                 /* 38 .. 3f */
 272         6, 6, 6, 6, 6, 6, 6, 6,                 /* 40 .. 47 */
 273         6, 6, 6, 6, 6, 6, 6, 6,                 /* 48 .. 4f */
 274         6, 6, 6, 6, 6, 6, 6, 6,                 /* 50 .. 57 */
 275         6, 6, 6, 6, 6, 6, 6, 6,                 /* 58 .. 5f */
 276         6, 6, 6, 6, 6, 6, 6, 6,                 /* 60 .. 67 */
 277         6, 6, 6, 6, 6, 6, 6, 6,                 /* 68 .. 6f */
 278         6, 6, 6, 6, 6, 6, 6, 6,                 /* 70 .. 77 */
 279         6, 6, 6, 6, 6, 6, 6, 6,                 /* 78 .. 7f */
 280         7, 7, 7, 7, 7, 7, 7, 7,                 /* 80 .. 87 */
 281         7, 7, 7, 7, 7, 7, 7, 7,                 /* 88 .. 8f */
 282         7, 7, 7, 7, 7, 7, 7, 7,                 /* 90 .. 97 */
 283         7, 7, 7, 7, 7, 7, 7, 7,                 /* 98 .. 9f */
 284         7, 7, 7, 7, 7, 7, 7, 7,                 /* a0 .. a7 */
 285         7, 7, 7, 7, 7, 7, 7, 7,                 /* a8 .. af */
 286         7, 7, 7, 7, 7, 7, 7, 7,                 /* b0 .. b7 */
 287         7, 7, 7, 7, 7, 7, 7, 7,                 /* b8 .. bf */
 288         7, 7, 7, 7, 7, 7, 7, 7,                 /* c0 .. c7 */
 289         7, 7, 7, 7, 7, 7, 7, 7,                 /* c8 .. cf */
 290         7, 7, 7, 7, 7, 7, 7, 7,                 /* d0 .. d7 */
 291         7, 7, 7, 7, 7, 7, 7, 7,                 /* d8 .. df */
 292         7, 7, 7, 7, 7, 7, 7, 7,                 /* e0 .. e7 */
 293         7, 7, 7, 7, 7, 7, 7, 7,                 /* e8 .. ef */
 294         7, 7, 7, 7, 7, 7, 7, 7,                 /* f0 .. f7 */
 295         7, 7, 7, 7, 7, 7, 7, 7,                 /* f8 .. ff */
 296 };
 297
 298 static int
 299 xfs_highbit32(__uint32_t v)
 300 {
 301         int             i;
 302
 303         if (v & 0xffff0000)
 304                 if (v & 0xff000000)
 305                         i = 24;
 306                 else
 307                         i = 16;
 308         else if (v & 0x0000ffff)
 309                 if (v & 0x0000ff00)
 310                         i = 8;
 311                 else
 312                         i = 0;
 313         else
 314                 return -1;
 315         return i + xfs_highbit[(v >> i) & 0xff];
 316 }
 317
 318 static int
 319 isinxt (xfs_fileoff_t key, xfs_fileoff_t offset, xfs_filblks_t len)
 320 {
 321         return (key >= offset) ? (key < offset + len ? 1 : 0) : 0;
 322 }
 323
 324 static xfs_daddr_t
 325 agb2daddr (xfs_agnumber_t agno, xfs_agblock_t agbno)
 326 {
 327         return ((xfs_fsblock_t)agno*xfs.agblocks + agbno) << xfs.bdlog;
 328 }
 329
 330 static xfs_daddr_t
 331 fsb2daddr (xfs_fsblock_t fsbno)
 332 {
 333         return agb2daddr ((xfs_agnumber_t)(fsbno >> xfs.agblklog),
 334                          (xfs_agblock_t)(fsbno & mask32lo(xfs.agblklog)));
 335 }
 336
 337 static inline int
 338 btroot_maxrecs (void)
 339 {
 340         int tmp = icore.di_forkoff ? (icore.di_forkoff << 3) : xfs.isize;
 341
 342         return (tmp - sizeof(xfs_bmdr_block_t) -
 343                 (int)((char *)&inode->di_u - (char*)inode)) /
 344                 (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t));
 345 }
 346
 347 static int
 348 di_read (xfs_ino_t ino)
 349 {
 350         xfs_agino_t agino;
 351         xfs_agnumber_t agno;
 352         xfs_agblock_t agbno;
 353         xfs_daddr_t daddr;
 354         int offset;
 355
 356         agno = ino2agno (ino);
 357         agino = ino2agino (ino);
 358         agbno = agino2agbno (agino);
 359         offset = ino2offset (ino);
 360         daddr = agb2daddr (agno, agbno);
 361
 362         read_disk_block(xfs_file, daddr, offset*xfs.isize, xfs.isize, (char *)inode);
 363
 364         xfs.ptr0 = *(xfs_bmbt_ptr_t *)
 365                     (inode->di_u.di_c + sizeof(xfs_bmdr_block_t)
 366                     + btroot_maxrecs ()*sizeof(xfs_bmbt_key_t));
 367
 368         return 1;
 369 }
 370
 371 static void
 372 init_extents (void)
 373 {
 374         xfs_bmbt_ptr_t ptr0;
 375         xfs_btree_lblock_t h;
 376
 377         switch (icore.di_format) {
 378         case XFS_DINODE_FMT_EXTENTS:
 379                 xfs.xt = inode->di_u.di_bmx;
 380                 xfs.nextents = le32 (icore.di_nextents);
 381                 break;
 382         case XFS_DINODE_FMT_BTREE:
 383                 ptr0 = xfs.ptr0;
 384                 for (;;) {
 385                         xfs.daddr = fsb2daddr (le64(ptr0));
 386                         read_disk_block(xfs_file, xfs.daddr, 0,
 387                                         sizeof(xfs_btree_lblock_t), (char *)&h);
 388                         if (!h.bb_level) {
 389                                 xfs.nextents = le16(h.bb_numrecs);
 390                                 xfs.next = fsb2daddr (le64(h.bb_leftsib));
 391                                 xfs.fpos = sizeof(xfs_btree_block_t);
 392                                 return;
 393                         }
 394                         read_disk_block(xfs_file, xfs.daddr, xfs.btnode_ptr0_off,
 395                                  sizeof(xfs_bmbt_ptr_t), (char *)&ptr0);
 396                 }
 397         }
 398 }
 399
 400 static xad_t *
 401 next_extent (void)
 402 {
 403         static xad_t xad;
 404
 405         switch (icore.di_format) {
 406         case XFS_DINODE_FMT_EXTENTS:
 407                 if (xfs.nextents == 0)
 408                         return NULL;
 409                 break;
 410         case XFS_DINODE_FMT_BTREE:
 411                 if (xfs.nextents == 0) {
 412                         xfs_btree_lblock_t h;
 413                         if (xfs.next == 0)
 414                                 return NULL;
 415                         xfs.daddr = xfs.next;
 416                         read_disk_block(xfs_file, xfs.daddr, 0,
 417                                         sizeof(xfs_btree_lblock_t), (char *)&h);
 418                         xfs.nextents = le16(h.bb_numrecs);
 419                         xfs.next = fsb2daddr (le64(h.bb_leftsib));
 420                         xfs.fpos = sizeof(xfs_btree_block_t);
 421                 }
 422                 /* Yeah, I know that's slow, but I really don't care */
 423                 read_disk_block(xfs_file, xfs.daddr, xfs.fpos,
 424                                 sizeof(xfs_bmbt_rec_t), filebuf);
 425                 xfs.xt = (xfs_bmbt_rec_32_t *)filebuf;
 426                 xfs.fpos += sizeof(xfs_bmbt_rec_32_t);
 427                 break;
 428         default:
 429                 return NULL;
 430         }
 431         xad.offset = xt_offset (xfs.xt);
 432         xad.start = xt_start (xfs.xt);
 433         xad.len = xt_len (xfs.xt);
 434         ++xfs.xt;
 435         --xfs.nextents;
 436
 437         return &xad;
 438 }
 439
 440 /*
 441  * Name lies - the function reads only first 100 bytes
 442  */
 443 static void
 444 xfs_dabread (void)
 445 {
 446         xad_t *xad;
 447         xfs_fileoff_t offset;;
 448
 449         init_extents ();
 450         while ((xad = next_extent ())) {
 451                 offset = xad->offset;
 452                 if (isinxt (xfs.dablk, offset, xad->len)) {
 453                         read_disk_block(xfs_file, fsb2daddr (xad->start + xfs.dablk - offset),
 454                                         0, 100, dirbuf);
 455                         break;
 456                 }
 457         }
 458 }
 459
 460 static inline xfs_ino_t
 461 sf_ino (char *sfe, int namelen)
 462 {
 463         void *p = sfe + namelen + 3;
 464
 465         return (xfs.i8param == 0)
 466                 ? le64(*(xfs_ino_t *)p) : le32(*(__uint32_t *)p);
 467 }
 468
 469 static inline xfs_ino_t
 470 sf_parent_ino (void)
 471 {
 472         return (xfs.i8param == 0)
 473                 ? le64(*(xfs_ino_t *)(&inode->di_u.di_dir2sf.hdr.parent))
 474                 : le32(*(__uint32_t *)(&inode->di_u.di_dir2sf.hdr.parent));
 475 }
 476
 477 static inline int
 478 roundup8 (int n)
 479 {
 480         return ((n+7)&~7);
 481 }
 482
 483 static char *
 484 next_dentry (xfs_ino_t *ino)
 485 {
 486         int namelen = 1;
 487         int toread;
 488         static char *usual[2] = {".", ".."};
 489         static xfs_dir2_sf_entry_t *sfe;
 490         char *name = usual[0];
 491
 492         if (xfs.dirpos >= xfs.dirmax) {
 493                 if (xfs.forw == 0)
 494                         return NULL;
 495                 xfs.dablk = xfs.forw;
 496                 xfs_dabread ();
 497 #define h       ((xfs_dir2_leaf_hdr_t *)dirbuf)
 498                 xfs.dirmax = le16 (h->count) - le16 (h->stale);
 499                 xfs.forw = le32 (h->info.forw);
 500 #undef h
 501                 xfs.dirpos = 0;
 502         }
 503
 504         switch (icore.di_format) {
 505         case XFS_DINODE_FMT_LOCAL:
 506                 switch (xfs.dirpos) {
 507                 case -2:
 508                         *ino = 0;
 509                         break;
 510                 case -1:
 511                         *ino = sf_parent_ino ();
 512                         ++name;
 513                         ++namelen;
 514                         sfe = (xfs_dir2_sf_entry_t *)
 515                                 (inode->di_u.di_c
 516                                  + sizeof(xfs_dir2_sf_hdr_t)
 517                                  - xfs.i8param);
 518                         break;
 519                 default:
 520                         namelen = sfe->namelen;
 521                         *ino = sf_ino ((char *)sfe, namelen);
 522                         name = sfe->name;
 523                         sfe = (xfs_dir2_sf_entry_t *)
 524                                   ((char *)sfe + namelen + 11 - xfs.i8param);
 525                 }
 526                 break;
 527         case XFS_DINODE_FMT_BTREE:
 528         case XFS_DINODE_FMT_EXTENTS:
 529 #define dau     ((xfs_dir2_data_union_t *)dirbuf)
 530                 for (;;) {
 531                         if (xfs.blkoff >= xfs.dirbsize) {
 532                                 xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
 533                                 xfs_file->pos &= ~(xfs.dirbsize - 1);
 534                                 xfs_file->pos |= xfs.blkoff;
 535                         }
 536                         xfs_read_data (dirbuf, 4);
 537                         xfs.blkoff += 4;
 538                         if (dau->unused.freetag == XFS_DIR2_DATA_FREE_TAG) {
 539                                 toread = roundup8 (le16(dau->unused.length)) - 4;
 540                                 xfs.blkoff += toread;
 541                                 xfs_file->pos += toread;
 542                                 continue;
 543                         }
 544                         break;
 545                 }
 546                 xfs_read_data ((char *)dirbuf + 4, 5);
 547                 *ino = le64 (dau->entry.inumber);
 548                 namelen = dau->entry.namelen;
 549 #undef dau
 550                 toread = roundup8 (namelen + 11) - 9;
 551                 xfs_read_data (dirbuf, toread);
 552                 name = (char *)dirbuf;
 553                 xfs.blkoff += toread + 5;
 554                 break;
 555         }
 556         ++xfs.dirpos;
 557         name[namelen] = 0;
 558
 559         return name;
 560 }
 561
 562 static char *
 563 first_dentry (xfs_ino_t *ino)
 564 {
 565         xfs.forw = 0;
 566         switch (icore.di_format) {
 567         case XFS_DINODE_FMT_LOCAL:
 568                 xfs.dirmax = inode->di_u.di_dir2sf.hdr.count;
 569                 xfs.i8param = inode->di_u.di_dir2sf.hdr.i8count ? 0 : 4;
 570                 xfs.dirpos = -2;
 571                 break;
 572         case XFS_DINODE_FMT_EXTENTS:
 573         case XFS_DINODE_FMT_BTREE:
 574                 xfs_file->pos = 0;
 575                 xfs_file->len = le64 (icore.di_size);
 576                 xfs_read_data (dirbuf, sizeof(xfs_dir2_data_hdr_t));
 577                 if (((xfs_dir2_data_hdr_t *)dirbuf)->magic == le32(XFS_DIR2_BLOCK_MAGIC)) {
 578 #define tail            ((xfs_dir2_block_tail_t *)dirbuf)
 579                         xfs_file->pos = xfs.dirbsize - sizeof(*tail);
 580                         xfs_read_data (dirbuf, sizeof(*tail));
 581                         xfs.dirmax = le32 (tail->count) - le32 (tail->stale);
 582 #undef tail
 583                 } else {
 584                         xfs.dablk = (1ULL << 35) >> xfs.blklog;
 585 #define h               ((xfs_dir2_leaf_hdr_t *)dirbuf)
 586 #define n               ((xfs_da_intnode_t *)dirbuf)
 587                         for (;;) {
 588                                 xfs_dabread ();
 589                                 if ((n->hdr.info.magic == le16(XFS_DIR2_LEAFN_MAGIC))
 590                                     || (n->hdr.info.magic == le16(XFS_DIR2_LEAF1_MAGIC))) {
 591                                         xfs.dirmax = le16 (h->count) - le16 (h->stale);
 592                                         xfs.forw = le32 (h->info.forw);
 593                                         break;
 594                                 }
 595                                 xfs.dablk = le32 (n->btree[0].before);
 596                         }
 597 #undef n
 598 #undef h
 599                 }
 600                 xfs.blkoff = sizeof(xfs_dir2_data_hdr_t);
 601                 xfs_file->pos = xfs.blkoff;
 602                 xfs.dirpos = 0;
 603                 break;
 604         }
 605         return next_dentry (ino);
 606 }
 607
 608 int
 609 xfs_mount (void)
 610 {
 611         xfs_sb_t super;
 612
 613         if (read_disk_block(xfs_file, 0, 0, sizeof(super), &super) != sizeof(super)) {
 614                 DEBUG_F("read_disk_block failed!\n");
 615                 return 0;
 616         } else if (super.sb_magicnum != XFS_SB_MAGIC) {
 617                 DEBUG_F("xfs_mount: Bad magic: %x\n", super.sb_magicnum);
 618                 return 0;
 619         } else if ((super.sb_versionnum & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4) {
 620                 DEBUG_F("xfs_mount: Bad version: %x\n", super.sb_versionnum);
 621                 return 0;
 622         }
 623
 624         xfs.bsize = le32 (super.sb_blocksize);
 625         xfs.blklog = super.sb_blocklog;
 626         xfs.bdlog = xfs.blklog - SECTOR_BITS;
 627         xfs.rootino = le64 (super.sb_rootino);
 628         xfs.isize = le16 (super.sb_inodesize);
 629         xfs.agblocks = le32 (super.sb_agblocks);
 630         xfs.dirblklog = super.sb_dirblklog;
 631         xfs.dirbsize = xfs.bsize << super.sb_dirblklog;
 632
 633         xfs.inopblog = super.sb_inopblog;
 634         xfs.agblklog = super.sb_agblklog;
 635         xfs.agnolog = xfs_highbit32 (le32 (super.sb_agcount) - 1) + 1;
 636
 637         xfs.btnode_ptr0_off =
 638                 ((xfs.bsize - sizeof(xfs_btree_block_t)) /
 639                 (sizeof (xfs_bmbt_key_t) + sizeof (xfs_bmbt_ptr_t)))
 640                  * sizeof(xfs_bmbt_key_t) + sizeof(xfs_btree_block_t);
 641
 642         return 1;
 643 }
 644
 645 int
 646 xfs_read_data (char *buf, int len)
 647 {
 648         xad_t *xad;
 649         xfs_fileoff_t endofprev, endofcur, offset;
 650         xfs_filblks_t xadlen;
 651         int toread, startpos, endpos;
 652
 653         if (icore.di_format == XFS_DINODE_FMT_LOCAL) {
 654                 memmove(buf, inode->di_u.di_c + xfs_file->pos, len);
 655                 xfs_file->pos += len;
 656                 return len;
 657         }
 658
 659         startpos = xfs_file->pos;
 660         endpos = xfs_file->pos + len;
 661         if (endpos > xfs_file->len)
 662                 endpos = xfs_file->len;
 663         endofprev = (xfs_fileoff_t)-1;
 664         init_extents ();
 665         while (len > 0 && (xad = next_extent ())) {
 666                 offset = xad->offset;
 667                 xadlen = xad->len;
 668                 if (isinxt (xfs_file->pos >> xfs.blklog, offset, xadlen)) {
 669                         endofcur = (offset + xadlen) << xfs.blklog;
 670                         toread = (endofcur >= endpos)
 671                                   ? len : (endofcur - xfs_file->pos);
 672                         read_disk_block(xfs_file, fsb2daddr (xad->start),
 673                                         xfs_file->pos - (offset << xfs.blklog), toread, buf);
 674                         buf += toread;
 675                         len -= toread;
 676                         xfs_file->pos += toread;
 677                 } else if (offset > endofprev) {
 678                         toread = ((offset << xfs.blklog) >= endpos)
 679                                   ? len : ((offset - endofprev) << xfs.blklog);
 680                         len -= toread;
 681                         xfs_file->pos += toread;
 682                         for (; toread; toread--) {
 683                                 *buf++ = 0;
 684                         }
 685                         continue;
 686                 }
 687                 endofprev = offset + xadlen;
 688         }
 689
 690         return xfs_file->pos - startpos;
 691 }
 692
 693 int
 694 xfs_dir (char *dirname)
 695 {
 696         xfs_ino_t ino, parent_ino, new_ino;
 697         xfs_fsize_t di_size;
 698         int di_mode;
 699         int cmp, n, link_count;
 700         char linkbuf[xfs.bsize];
 701         char *rest, *name, ch;
 702
 703         DEBUG_ENTER;
 704
 705         parent_ino = ino = xfs.rootino;
 706         link_count = 0;
 707         for (;;) {
 708                 di_read (ino);
 709                 di_size = le64 (icore.di_size);
 710                 di_mode = le16 (icore.di_mode);
 711
 712                 DEBUG_F("di_mode: %o\n", di_mode);
 713                 if ((di_mode & IFMT) == IFLNK) {
 714                         if (++link_count > MAX_LINK_COUNT) {
 715                                 errnum = FILE_ERR_SYMLINK_LOOP;
 716                                 DEBUG_LEAVE(FILE_ERR_SYMLINK_LOOP);
 717                                 return 0;
 718                         }
 719                         if (di_size < xfs.bsize - 1) {
 720                                 xfs_file->pos = 0;
 721                                 xfs_file->len = di_size;
 722                                 n = xfs_read_data (linkbuf, xfs_file->len);
 723                         } else {
 724                                 errnum = FILE_ERR_LENGTH;
 725                                 DEBUG_LEAVE(FILE_ERR_LENGTH);
 726                                 return 0;
 727                         }
 728
 729                         ino = (linkbuf[0] == '/') ? xfs.rootino : parent_ino;
 730                         while (n < (xfs.bsize - 1) && (linkbuf[n++] = *dirname++));
 731                         linkbuf[n] = 0;
 732                         dirname = linkbuf;
 733                         continue;
 734                 }
 735
 736                 DEBUG_F("*dirname: %s\n", dirname);
 737                 if (!*dirname || isspace (*dirname)) {
 738                         if ((di_mode & IFMT) != IFREG) {
 739                                 errnum = FILE_ERR_BAD_TYPE;
 740                                 DEBUG_LEAVE(FILE_ERR_BAD_TYPE);
 741                                 return 0;
 742                         }
 743                         xfs_file->pos = 0;
 744                         xfs_file->len = di_size;
 745                         DEBUG_LEAVE(1);
 746                         return 1;
 747                 }
 748
 749                 if ((di_mode & IFMT) != IFDIR) {
 750                         errnum = FILE_ERR_NOTDIR;
 751                         DEBUG_LEAVE(FILE_ERR_NOTDIR);
 752                         return 0;
 753                 }
 754
 755                 for (; *dirname == '/'; dirname++);
 756
 757                 for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
 758                 *rest = 0;
 759
 760                 name = first_dentry (&new_ino);
 761                 for (;;) {
 762                         cmp = (!*dirname) ? -1 : strcmp(dirname, name);
 763                         if (cmp == 0) {
 764                                 parent_ino = ino;
 765                                 if (new_ino)
 766                                         ino = new_ino;
 767                                 *(dirname = rest) = ch;
 768                                 break;
 769                         }
 770                         name = next_dentry (&new_ino);
 771                         if (name == NULL) {
 772                                 errnum = FILE_ERR_NOTFOUND;
 773                                 DEBUG_LEAVE(FILE_ERR_NOTFOUND);
 774                                 *rest = ch;
 775                                 return 0;
 776                         }
 777                 }
 778         }
 779 }
 780
 781 /*
 782  * Local variables:
 783  * c-file-style: "k&r"
 784  * c-basic-offset: 8
 785  * End:
 786  */