3 * GRUB -- GRand Unified Bootloader
4 * Copyright (C) 2004,2005,2006,2007,2008 Free Software Foundation, Inc.
6 * GRUB 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 3 of the License, or
9 * (at your option) any later version.
11 * GRUB 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.
16 * You should have received a copy of the GNU General Public License
17 * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
21 #include <grub/file.h>
23 #include <grub/misc.h>
24 #include <grub/disk.h>
26 #include <grub/types.h>
28 #define GRUB_JFS_MAX_SYMLNK_CNT 8
29 #define GRUB_JFS_FILETYPE_MASK 0170000
30 #define GRUB_JFS_FILETYPE_REG 0100000
31 #define GRUB_JFS_FILETYPE_LNK 0120000
32 #define GRUB_JFS_FILETYPE_DIR 0040000
34 #define GRUB_JFS_SBLOCK 64
35 #define GRUB_JFS_AGGR_INODE 2
36 #define GRUB_JFS_FS1_INODE_BLK 104
38 #define GRUB_JFS_TREE_LEAF 2
40 struct grub_jfs_sblock
42 /* The magic for JFS. It should contain the string "JFS1". */
43 grub_uint8_t magic
[4];
44 grub_uint32_t version
;
45 grub_uint64_t ag_size
;
47 /* The size of a filesystem block in bytes. XXX: currently only
50 grub_uint16_t log2_blksz
;
52 grub_uint8_t unused
[71];
53 grub_uint8_t volname
[11];
56 struct grub_jfs_extent
58 /* The length of the extent in filesystem blocks. */
62 /* The physical offset of the first block on the disk. */
65 } __attribute__ ((packed
));
69 grub_uint8_t unused
[3072];
70 struct grub_jfs_extent inodes
[128];
71 } __attribute__ ((packed
));
74 /* The head of the tree used to find extents. */
75 struct grub_jfs_treehead
85 grub_uint8_t unused2
[10];
86 } __attribute__ ((packed
));
88 /* A node in the extent tree. */
89 struct grub_jfs_tree_extent
94 /* The offset is the key used to lookup an extent. */
96 grub_uint32_t offset2
;
98 struct grub_jfs_extent extent
;
99 } __attribute__ ((packed
));
101 /* The tree of directory entries. */
102 struct grub_jfs_tree_dir
104 /* Pointers to the previous and next tree headers of other nodes on
111 /* The amount of dirents in this node. */
113 grub_uint8_t freecnt
;
114 grub_uint8_t freelist
;
115 grub_uint8_t maxslot
;
117 /* The location of the sorted array of pointers to dirents. */
119 grub_uint8_t unused
[10];
120 } __attribute__ ((packed
));
122 /* An internal node in the dirents tree. */
123 struct grub_jfs_internal_dirent
125 struct grub_jfs_extent ex
;
128 grub_uint16_t namepart
[11];
129 } __attribute__ ((packed
));
131 /* A leaf node in the dirents tree. */
132 struct grub_jfs_leaf_dirent
134 /* The inode for this dirent. */
138 /* The size of the name. */
140 grub_uint16_t namepart
[11];
142 } __attribute__ ((packed
));
144 /* A leaf in the dirents tree. This one is used if the previously
145 dirent was not big enough to store the name. */
146 struct grub_jfs_leaf_next_dirent
150 grub_uint16_t namepart
[15];
151 } __attribute__ ((packed
));
153 struct grub_jfs_inode
156 grub_uint32_t fileset
;
158 grub_uint8_t unused
[12];
160 grub_uint8_t unused2
[20];
162 grub_uint8_t unused3
[72];
163 grub_uint8_t unused4
[96];
167 /* The tree describing the extents of the file. */
168 struct __attribute__ ((packed
))
170 struct grub_jfs_treehead tree
;
171 struct grub_jfs_tree_extent extents
[16];
175 /* The tree describing the dirents. */
178 grub_uint8_t unused
[16];
181 /* Amount of dirents in this node. */
183 grub_uint8_t freecnt
;
184 grub_uint8_t freelist
;
185 grub_uint32_t idotdot
;
186 grub_uint8_t sorted
[8];
188 struct grub_jfs_leaf_dirent dirents
[8];
189 } dir
__attribute__ ((packed
));
193 grub_uint8_t unused
[32];
194 grub_uint8_t path
[128];
196 } __attribute__ ((packed
));
197 } __attribute__ ((packed
));
201 struct grub_jfs_sblock sblock
;
203 struct grub_jfs_inode fileset
;
204 struct grub_jfs_inode currinode
;
207 } __attribute__ ((packed
));
209 struct grub_jfs_diropen
214 struct grub_jfs_tree_dir header
;
215 struct grub_jfs_leaf_dirent dirent
[0];
216 struct grub_jfs_leaf_next_dirent next_dirent
[0];
218 } *dirpage
__attribute__ ((packed
));
219 struct grub_jfs_data
*data
;
220 struct grub_jfs_inode
*inode
;
223 struct grub_jfs_leaf_dirent
*leaf
;
224 struct grub_jfs_leaf_next_dirent
*next_leaf
;
226 /* The filename and inode of the last read dirent. */
229 } __attribute__ ((packed
));
232 static grub_dl_t my_mod
;
234 static grub_err_t
grub_jfs_lookup_symlink (struct grub_jfs_data
*data
, int ino
);
236 /* Get the block number for the block BLK in the node INODE in the
237 mounted filesystem DATA. */
239 grub_jfs_blkno (struct grub_jfs_data
*data
, struct grub_jfs_inode
*inode
,
242 auto int getblk (struct grub_jfs_treehead
*treehead
,
243 struct grub_jfs_tree_extent
*extents
);
245 int getblk (struct grub_jfs_treehead
*treehead
,
246 struct grub_jfs_tree_extent
*extents
)
251 for (i
= 0; i
< grub_le_to_cpu16 (treehead
->count
) - 2; i
++)
253 if (treehead
->flags
& GRUB_JFS_TREE_LEAF
)
255 /* Read the leafnode. */
256 if (grub_le_to_cpu32 (extents
[i
].offset2
) <= blk
257 && ((grub_le_to_cpu16 (extents
[i
].extent
.length
))
258 + (extents
[i
].extent
.length2
<< 8)
259 + grub_le_to_cpu32 (extents
[i
].offset2
)) > blk
)
260 return (blk
- grub_le_to_cpu32 (extents
[i
].offset2
)
261 + grub_le_to_cpu32 (extents
[i
].extent
.blk2
));
264 if (blk
>= grub_le_to_cpu32 (extents
[i
].offset2
))
272 struct grub_jfs_treehead treehead
;
273 struct grub_jfs_tree_extent extents
[254];
276 if (grub_disk_read (data
->disk
,
277 grub_le_to_cpu32 (extents
[found
].extent
.blk2
)
278 << (grub_le_to_cpu16 (data
->sblock
.log2_blksz
)
279 - GRUB_DISK_SECTOR_BITS
), 0,
280 sizeof (tree
), (char *) &tree
))
283 return getblk (&tree
.treehead
, &tree
.extents
[0]);
289 return getblk (&inode
->file
.tree
, &inode
->file
.extents
[0]);
294 grub_jfs_read_inode (struct grub_jfs_data
*data
, int ino
,
295 struct grub_jfs_inode
*inode
)
297 struct grub_jfs_iag iag
;
298 int iagnum
= ino
/ 4096;
299 int inoext
= (ino
% 4096) / 32;
300 int inonum
= (ino
% 4096) % 32;
301 grub_uint32_t iagblk
;
302 grub_uint32_t inoblk
;
304 iagblk
= grub_jfs_blkno (data
, &data
->fileset
, iagnum
+ 1);
308 /* Read in the IAG. */
309 if (grub_disk_read (data
->disk
,
310 iagblk
<< (grub_le_to_cpu16 (data
->sblock
.log2_blksz
)
311 - GRUB_DISK_SECTOR_BITS
), 0,
312 sizeof (struct grub_jfs_iag
), &iag
))
315 inoblk
= grub_le_to_cpu32 (iag
.inodes
[inoext
].blk2
);
316 inoblk
<<= (grub_le_to_cpu16 (data
->sblock
.log2_blksz
)
317 - GRUB_DISK_SECTOR_BITS
);
320 if (grub_disk_read (data
->disk
, inoblk
, 0,
321 sizeof (struct grub_jfs_inode
), inode
))
328 static struct grub_jfs_data
*
329 grub_jfs_mount (grub_disk_t disk
)
331 struct grub_jfs_data
*data
= 0;
333 data
= grub_malloc (sizeof (struct grub_jfs_data
));
337 /* Read the superblock. */
338 if (grub_disk_read (disk
, GRUB_JFS_SBLOCK
, 0,
339 sizeof (struct grub_jfs_sblock
), &data
->sblock
))
342 if (grub_strncmp ((char *) (data
->sblock
.magic
), "JFS1", 4))
344 grub_error (GRUB_ERR_BAD_FS
, "not a jfs filesystem");
352 /* Read the inode of the first fileset. */
353 if (grub_disk_read (data
->disk
, GRUB_JFS_FS1_INODE_BLK
, 0,
354 sizeof (struct grub_jfs_inode
), &data
->fileset
))
362 if (grub_errno
== GRUB_ERR_OUT_OF_RANGE
)
363 grub_error (GRUB_ERR_BAD_FS
, "not a jfs filesystem");
369 static struct grub_jfs_diropen
*
370 grub_jfs_opendir (struct grub_jfs_data
*data
, struct grub_jfs_inode
*inode
)
372 struct grub_jfs_internal_dirent
*de
;
373 struct grub_jfs_diropen
*diro
;
376 de
= (struct grub_jfs_internal_dirent
*) inode
->dir
.dirents
;
378 if (!((grub_le_to_cpu32 (inode
->mode
)
379 & GRUB_JFS_FILETYPE_MASK
) == GRUB_JFS_FILETYPE_DIR
))
381 grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a directory");
385 diro
= grub_zalloc (sizeof (struct grub_jfs_diropen
));
392 /* Check if the entire tree is contained within the inode. */
393 if (inode
->file
.tree
.flags
& GRUB_JFS_TREE_LEAF
)
395 diro
->leaf
= inode
->dir
.dirents
;
396 diro
->next_leaf
= (struct grub_jfs_leaf_next_dirent
*) de
;
397 diro
->sorted
= (char *) (inode
->dir
.header
.sorted
);
398 diro
->count
= inode
->dir
.header
.count
;
403 diro
->dirpage
= grub_malloc (grub_le_to_cpu32 (data
->sblock
.blksz
));
410 blk
= grub_le_to_cpu32 (de
[inode
->dir
.header
.sorted
[0]].ex
.blk2
);
411 blk
<<= (grub_le_to_cpu16 (data
->sblock
.log2_blksz
) - GRUB_DISK_SECTOR_BITS
);
413 /* Read in the nodes until we are on the leaf node level. */
417 if (grub_disk_read (data
->disk
, blk
, 0,
418 grub_le_to_cpu32 (data
->sblock
.blksz
),
419 diro
->dirpage
->sorted
))
421 grub_free (diro
->dirpage
);
426 de
= (struct grub_jfs_internal_dirent
*) diro
->dirpage
->dirent
;
427 index
= diro
->dirpage
->sorted
[diro
->dirpage
->header
.sindex
* 32];
428 blk
= (grub_le_to_cpu32 (de
[index
].ex
.blk2
)
429 << (grub_le_to_cpu16 (data
->sblock
.log2_blksz
)
430 - GRUB_DISK_SECTOR_BITS
));
431 } while (!(diro
->dirpage
->header
.flags
& GRUB_JFS_TREE_LEAF
));
433 diro
->leaf
= diro
->dirpage
->dirent
;
434 diro
->next_leaf
= diro
->dirpage
->next_dirent
;
435 diro
->sorted
= &diro
->dirpage
->sorted
[diro
->dirpage
->header
.sindex
* 32];
436 diro
->count
= diro
->dirpage
->header
.count
;
443 grub_jfs_closedir (struct grub_jfs_diropen
*diro
)
447 grub_free (diro
->dirpage
);
452 /* Read in the next dirent from the directory described by DIRO. */
454 grub_jfs_getent (struct grub_jfs_diropen
*diro
)
457 struct grub_jfs_leaf_dirent
*leaf
;
458 struct grub_jfs_leaf_next_dirent
*next_leaf
;
461 grub_uint16_t filename
[255];
463 auto void addstr (grub_uint16_t
*uname
, int ulen
);
465 /* Add the unicode string to the utf16 filename buffer. */
466 void addstr (grub_uint16_t
*name
, int ulen
)
469 filename
[strpos
++] = *(name
++);
472 /* The last node, read in more. */
473 if (diro
->index
== diro
->count
)
477 /* If the inode contains the entry tree or if this was the last
478 node, there is nothing to read. */
479 if ((diro
->inode
->file
.tree
.flags
& GRUB_JFS_TREE_LEAF
)
480 || !grub_le_to_cpu64 (diro
->dirpage
->header
.nextb
))
481 return GRUB_ERR_OUT_OF_RANGE
;
483 next
= grub_le_to_cpu64 (diro
->dirpage
->header
.nextb
);
484 next
<<= (grub_le_to_cpu16 (diro
->data
->sblock
.log2_blksz
)
485 - GRUB_DISK_SECTOR_BITS
);
487 if (grub_disk_read (diro
->data
->disk
, next
, 0,
488 grub_le_to_cpu32 (diro
->data
->sblock
.blksz
),
489 diro
->dirpage
->sorted
))
492 diro
->leaf
= diro
->dirpage
->dirent
;
493 diro
->next_leaf
= diro
->dirpage
->next_dirent
;
494 diro
->sorted
= &diro
->dirpage
->sorted
[diro
->dirpage
->header
.sindex
* 32];
495 diro
->count
= diro
->dirpage
->header
.count
;
499 leaf
= &diro
->leaf
[(int) diro
->sorted
[diro
->index
]];
500 next_leaf
= &diro
->next_leaf
[diro
->index
];
506 return grub_jfs_getent (diro
);
509 addstr (leaf
->namepart
, len
< 11 ? len
: 11);
510 diro
->ino
= grub_le_to_cpu32 (leaf
->inode
);
513 /* Move down to the leaf level. */
514 nextent
= leaf
->next
;
515 if (leaf
->next
!= 255)
518 next_leaf
= &diro
->next_leaf
[nextent
];
519 addstr (next_leaf
->namepart
, len
< 15 ? len
: 15 );
522 nextent
= next_leaf
->next
;
523 } while (next_leaf
->next
!= 255 && len
> 0);
527 /* Convert the temporary UTF16 filename to UTF8. */
528 *grub_utf16_to_utf8 ((grub_uint8_t
*) (diro
->name
), filename
, strpos
) = '\0';
534 /* Read LEN bytes from the file described by DATA starting with byte
535 POS. Return the amount of read bytes in READ. */
537 grub_jfs_read_file (struct grub_jfs_data
*data
,
538 void NESTED_FUNC_ATTR (*read_hook
) (grub_disk_addr_t sector
,
539 unsigned offset
, unsigned length
),
540 int pos
, grub_size_t len
, char *buf
)
545 /* Adjust len so it we can't read past the end of the file. */
546 if (len
> data
->currinode
.size
)
547 len
= data
->currinode
.size
;
549 blockcnt
= ((len
+ pos
+ grub_le_to_cpu32 (data
->sblock
.blksz
) - 1)
550 / grub_le_to_cpu32 (data
->sblock
.blksz
));
552 for (i
= pos
/ grub_le_to_cpu32 (data
->sblock
.blksz
); i
< blockcnt
; i
++)
555 int blockoff
= pos
% grub_le_to_cpu32 (data
->sblock
.blksz
);
556 int blockend
= grub_le_to_cpu32 (data
->sblock
.blksz
);
560 blknr
= grub_jfs_blkno (data
, &data
->currinode
, i
);
565 if (i
== blockcnt
- 1)
567 blockend
= (len
+ pos
) % grub_le_to_cpu32 (data
->sblock
.blksz
);
570 blockend
= grub_le_to_cpu32 (data
->sblock
.blksz
);
574 if (i
== (pos
/ (int) grub_le_to_cpu32 (data
->sblock
.blksz
)))
576 skipfirst
= blockoff
;
577 blockend
-= skipfirst
;
580 data
->disk
->read_hook
= read_hook
;
581 grub_disk_read (data
->disk
,
582 blknr
<< (grub_le_to_cpu16 (data
->sblock
.log2_blksz
)
583 - GRUB_DISK_SECTOR_BITS
),
584 skipfirst
, blockend
, buf
);
586 data
->disk
->read_hook
= 0;
590 buf
+= grub_le_to_cpu32 (data
->sblock
.blksz
) - skipfirst
;
597 /* Find the file with the pathname PATH on the filesystem described by
600 grub_jfs_find_file (struct grub_jfs_data
*data
, const char *path
)
602 char fpath
[grub_strlen (path
)];
605 unsigned int pos
= 0;
606 struct grub_jfs_diropen
*diro
;
608 grub_strncpy (fpath
, path
, grub_strlen (path
) + 1);
610 if (grub_jfs_read_inode (data
, GRUB_JFS_AGGR_INODE
, &data
->currinode
))
613 /* Skip the first slashes. */
621 /* Extract the actual part from the pathname. */
622 next
= grub_strchr (name
, '/');
631 diro
= grub_jfs_opendir (data
, &data
->currinode
);
637 if (grub_strlen (name
) == 0)
638 return GRUB_ERR_NONE
;
640 if (grub_jfs_getent (diro
) == GRUB_ERR_OUT_OF_RANGE
)
643 /* Check if the current direntry matches the current part of the
645 if (!grub_strcmp (name
, diro
->name
))
648 int dirino
= grub_le_to_cpu32 (data
->currinode
.inode
);
650 grub_jfs_closedir (diro
);
653 if (grub_jfs_read_inode (data
, ino
, &data
->currinode
))
656 /* Check if this is a symlink. */
657 if ((grub_le_to_cpu32 (data
->currinode
.mode
)
658 & GRUB_JFS_FILETYPE_MASK
) == GRUB_JFS_FILETYPE_LNK
)
660 grub_jfs_lookup_symlink (data
, dirino
);
671 next
= grub_strchr (name
, '/');
678 /* Open this directory for reading dirents. */
679 diro
= grub_jfs_opendir (data
, &data
->currinode
);
687 grub_jfs_closedir (diro
);
688 grub_error (GRUB_ERR_FILE_NOT_FOUND
, "file not found");
694 grub_jfs_lookup_symlink (struct grub_jfs_data
*data
, int ino
)
696 int size
= grub_le_to_cpu64 (data
->currinode
.size
);
697 char symlink
[size
+ 1];
699 if (++data
->linknest
> GRUB_JFS_MAX_SYMLNK_CNT
)
700 return grub_error (GRUB_ERR_SYMLINK_LOOP
, "too deep nesting of symlinks");
703 grub_strncpy (symlink
, (char *) (data
->currinode
.symlink
.path
), 128);
704 else if (grub_jfs_read_file (data
, 0, 0, size
, symlink
) < 0)
707 symlink
[size
] = '\0';
709 /* The symlink is an absolute path, go back to the root inode. */
710 if (symlink
[0] == '/')
713 /* Now load in the old inode. */
714 if (grub_jfs_read_inode (data
, ino
, &data
->currinode
))
717 grub_jfs_find_file (data
, symlink
);
719 grub_error (grub_errno
, "Can not follow symlink `%s'.", symlink
);
726 grub_jfs_dir (grub_device_t device
, const char *path
,
727 int (*hook
) (const char *filename
,
728 const struct grub_dirhook_info
*info
))
730 struct grub_jfs_data
*data
= 0;
731 struct grub_jfs_diropen
*diro
= 0;
733 grub_dl_ref (my_mod
);
735 data
= grub_jfs_mount (device
->disk
);
739 if (grub_jfs_find_file (data
, path
))
742 diro
= grub_jfs_opendir (data
, &data
->currinode
);
746 /* Iterate over the dirents in the directory that was found. */
747 while (grub_jfs_getent (diro
) != GRUB_ERR_OUT_OF_RANGE
)
749 struct grub_jfs_inode inode
;
750 struct grub_dirhook_info info
;
751 grub_memset (&info
, 0, sizeof (info
));
753 if (grub_jfs_read_inode (data
, diro
->ino
, &inode
))
756 info
.dir
= (grub_le_to_cpu32 (inode
.mode
)
757 & GRUB_JFS_FILETYPE_MASK
) == GRUB_JFS_FILETYPE_DIR
;
758 if (hook (diro
->name
, &info
))
762 /* XXX: GRUB_ERR_OUT_OF_RANGE is used for the last dirent. */
763 if (grub_errno
== GRUB_ERR_OUT_OF_RANGE
)
767 grub_jfs_closedir (diro
);
770 grub_dl_unref (my_mod
);
776 /* Open a file named NAME and initialize FILE. */
778 grub_jfs_open (struct grub_file
*file
, const char *name
)
780 struct grub_jfs_data
*data
;
782 grub_dl_ref (my_mod
);
784 data
= grub_jfs_mount (file
->device
->disk
);
788 grub_jfs_find_file (data
, name
);
792 /* It is only possible for open regular files. */
793 if (! ((grub_le_to_cpu32 (data
->currinode
.mode
)
794 & GRUB_JFS_FILETYPE_MASK
) == GRUB_JFS_FILETYPE_REG
))
796 grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a regular file");
801 file
->size
= grub_le_to_cpu64 (data
->currinode
.size
);
807 grub_dl_unref (my_mod
);
816 grub_jfs_read (grub_file_t file
, char *buf
, grub_size_t len
)
818 struct grub_jfs_data
*data
=
819 (struct grub_jfs_data
*) file
->data
;
821 return grub_jfs_read_file (data
, file
->read_hook
, file
->offset
, len
, buf
);
826 grub_jfs_close (grub_file_t file
)
828 grub_free (file
->data
);
830 grub_dl_unref (my_mod
);
832 return GRUB_ERR_NONE
;
837 grub_jfs_label (grub_device_t device
, char **label
)
839 struct grub_jfs_data
*data
;
840 data
= grub_jfs_mount (device
->disk
);
843 *label
= grub_strndup ((char *) (data
->sblock
.volname
), 11);
851 static struct grub_fs grub_jfs_fs
=
855 .open
= grub_jfs_open
,
856 .read
= grub_jfs_read
,
857 .close
= grub_jfs_close
,
858 .label
= grub_jfs_label
,
864 grub_fs_register (&grub_jfs_fs
);
870 grub_fs_unregister (&grub_jfs_fs
);