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
agino2agbno(xfs_agino_t agino)78 agino2agbno (xfs_agino_t agino)
79 {
80 return agino >> XFS_INO_OFFSET_BITS;
81 }
82
83 static inline xfs_agnumber_t
ino2agno(xfs_ino_t ino)84 ino2agno (xfs_ino_t ino)
85 {
86 return ino >> XFS_INO_AGINO_BITS;
87 }
88
89 static inline xfs_agino_t
ino2agino(xfs_ino_t ino)90 ino2agino (xfs_ino_t ino)
91 {
92 return ino & XFS_INO_MASK(XFS_INO_AGINO_BITS);
93 }
94
95 static inline int
ino2offset(xfs_ino_t ino)96 ino2offset (xfs_ino_t ino)
97 {
98 return ino & XFS_INO_MASK(XFS_INO_OFFSET_BITS);
99 }
100
101 static inline __uint16_t
le16(__uint16_t x)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
le32(__uint32_t x)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
le64(__uint64_t x)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
xt_start(xfs_bmbt_rec_32_t * r)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
xt_offset(xfs_bmbt_rec_32_t * r)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
xt_len(xfs_bmbt_rec_32_t * r)160 xt_len (xfs_bmbt_rec_32_t *r)
161 {
162 return le32(r->l3) & mask32lo(21);
163 }
164
165 static inline int
xfs_highbit32(__uint32_t v)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
isinxt(xfs_fileoff_t key,xfs_fileoff_t offset,xfs_filblks_t len)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
agb2daddr(xfs_agnumber_t agno,xfs_agblock_t agbno)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
fsb2daddr(xfs_fsblock_t fsbno)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
btroot_maxrecs(void)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
di_read(xfs_ino_t ino)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
init_extents(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 *
next_extent(void)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
xfs_dabread(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
sf_ino(char * sfe,int namelen)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
sf_parent_ino(void)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
roundup8(int n)336 roundup8 (int n)
337 {
338 return ((n+7)&~7);
339 }
340
341 static char *
next_dentry(xfs_ino_t * ino)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 *
first_dentry(xfs_ino_t * ino)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
xfs_mount(void)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
xfs_read(char * buf,int len)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
xfs_dir(char * dirname)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 */
640