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