1 /* ufs.c - Unix File System */
3 * GRUB -- GRand Unified Bootloader
4 * Copyright (C) 2004,2005,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>
29 #define GRUB_UFS_MAGIC 0x11954
30 #define GRUB_UFS2_MAGIC 0x19540119
31 #define GRUB_UFS_INODE 2
32 #define GRUB_UFS_FILETYPE_DIR 4
33 #define GRUB_UFS_FILETYPE_LNK 10
34 #define GRUB_UFS_MAX_SYMLNK_CNT 8
36 #define GRUB_UFS_DIRBLKS 12
37 #define GRUB_UFS_INDIRBLKS 3
39 #define GRUB_UFS_ATTR_TYPE 0160000
40 #define GRUB_UFS_ATTR_FILE 0100000
41 #define GRUB_UFS_ATTR_DIR 0040000
42 #define GRUB_UFS_ATTR_LNK 0120000
44 #define GRUB_UFS_VOLNAME_LEN 32
46 /* Calculate in which group the inode can be found. */
47 #define inode_group(inode,sblock) ()
49 #define UFS_BLKSZ(sblock) (grub_le_to_cpu32 (sblock->bsize))
51 #define INODE(data,field) (data->ufs_type == UFS1 ? \
52 data->inode. field : data->inode2. field)
53 #define INODE_ENDIAN(data,field,bits1,bits2) (data->ufs_type == UFS1 ? \
54 grub_le_to_cpu##bits1 (data->inode.field) : \
55 grub_le_to_cpu##bits2 (data->inode2.field))
56 #define INODE_SIZE(data) INODE_ENDIAN (data,size,32,64)
57 #define INODE_NBLOCKS(data) INODE_ENDIAN (data,nblocks,32,64)
59 #define INODE_MODE(data) INODE_ENDIAN (data,mode,16,16)
60 #define INODE_BLKSZ(data) (data->ufs_type == UFS1 ? 4 : 8)
61 #define INODE_DIRBLOCKS(data,blk) INODE_ENDIAN \
62 (data,blocks.dir_blocks[blk],32,64)
63 #define INODE_INDIRBLOCKS(data,blk) INODE_ENDIAN \
64 (data,blocks.indir_blocks[blk],32,64)
66 /* The blocks on which the superblock can be found. */
67 static int sblocklist
[] = { 128, 16, 0, 512, -1 };
69 struct grub_ufs_sblock
71 grub_uint8_t unused
[16];
72 /* The offset of the inodes in the cylinder group. */
73 grub_uint32_t inoblk_offs
;
75 grub_uint8_t unused2
[4];
77 /* The start of the cylinder group. */
78 grub_uint32_t cylg_offset
;
79 grub_uint8_t unused3
[4];
82 grub_uint8_t unused4
[12];
84 /* The size of a block in bytes. */
86 grub_uint8_t unused5
[48];
88 /* The size of filesystem blocks to disk blocks. */
89 grub_uint32_t log2_blksz
;
90 grub_uint8_t unused6
[80];
92 /* Inodes stored per cylinder group. */
93 grub_uint32_t ino_per_group
;
95 /* The frags per cylinder group. */
96 grub_uint32_t frags_per_group
;
98 grub_uint8_t unused7
[488];
100 /* Volume name for UFS2. */
101 grub_uint8_t volume_name
[GRUB_UFS_VOLNAME_LEN
];
102 grub_uint8_t unused8
[232];
104 grub_uint64_t mtime2
;
105 grub_uint8_t unused9
[420];
107 /* Magic value to check if this is really a UFS filesystem. */
112 struct grub_ufs_inode
115 grub_uint16_t nlinks
;
126 grub_uint32_t dir_blocks
[GRUB_UFS_DIRBLKS
];
127 grub_uint32_t indir_blocks
[GRUB_UFS_INDIRBLKS
];
129 grub_uint8_t symlink
[(GRUB_UFS_DIRBLKS
+ GRUB_UFS_INDIRBLKS
) * 4];
132 grub_uint32_t nblocks
;
134 grub_uint32_t unused
;
135 grub_uint8_t pad
[12];
136 } __attribute__ ((packed
));
139 struct grub_ufs2_inode
142 grub_uint16_t nlinks
;
145 grub_uint32_t blocksize
;
147 grub_int64_t nblocks
;
151 grub_uint64_t create_time
;
152 grub_uint32_t atime_sec
;
153 grub_uint32_t mtime_sec
;
154 grub_uint32_t ctime_sec
;
155 grub_uint32_t create_time_sec
;
157 grub_uint32_t kernel_flags
;
160 grub_uint64_t ext
[2];
165 grub_uint64_t dir_blocks
[GRUB_UFS_DIRBLKS
];
166 grub_uint64_t indir_blocks
[GRUB_UFS_INDIRBLKS
];
168 grub_uint8_t symlink
[(GRUB_UFS_DIRBLKS
+ GRUB_UFS_INDIRBLKS
) * 8];
171 grub_uint8_t unused
[24];
172 } __attribute__ ((packed
));
174 /* Directory entry. */
175 struct grub_ufs_dirent
178 grub_uint16_t direntlen
;
181 grub_uint16_t namelen
;
184 grub_uint8_t filetype_bsd
;
185 grub_uint8_t namelen_bsd
;
188 } __attribute__ ((packed
));
190 /* Information about a "mounted" ufs filesystem. */
193 struct grub_ufs_sblock sblock
;
197 struct grub_ufs_inode inode
;
198 struct grub_ufs2_inode inode2
;
211 static grub_dl_t my_mod
;
214 /* Forward declaration. */
215 static grub_err_t
grub_ufs_find_file (struct grub_ufs_data
*data
,
220 grub_ufs_get_file_block (struct grub_ufs_data
*data
, unsigned int blk
)
222 struct grub_ufs_sblock
*sblock
= &data
->sblock
;
223 unsigned int indirsz
;
227 if (blk
< GRUB_UFS_DIRBLKS
)
228 return INODE_DIRBLOCKS (data
, blk
);
230 log2_blksz
= grub_le_to_cpu32 (data
->sblock
.log2_blksz
);
232 blk
-= GRUB_UFS_DIRBLKS
;
234 indirsz
= UFS_BLKSZ (sblock
) / INODE_BLKSZ (data
);
235 /* Single indirect block. */
238 grub_uint32_t indir
[UFS_BLKSZ (sblock
) >> 2];
239 grub_disk_read (data
->disk
, INODE_INDIRBLOCKS (data
, 0) << log2_blksz
,
240 0, sizeof (indir
), (char *) indir
);
241 return (data
->ufs_type
== UFS1
) ? indir
[blk
] : indir
[blk
<< 1];
245 /* Double indirect block. */
246 if (blk
< indirsz
* indirsz
)
248 grub_uint32_t indir
[UFS_BLKSZ (sblock
) >> 2];
250 grub_disk_read (data
->disk
, INODE_INDIRBLOCKS (data
, 1) << log2_blksz
,
251 0, sizeof (indir
), (char *) indir
);
252 grub_disk_read (data
->disk
,
253 ((data
->ufs_type
== UFS1
) ?
254 indir
[blk
/ indirsz
] : indir
[(blk
/ indirsz
) << 1])
256 0, sizeof (indir
), (char *) indir
);
258 return (data
->ufs_type
== UFS1
) ?
259 indir
[blk
% indirsz
] : indir
[(blk
% indirsz
) << 1];
263 grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET
,
264 "ufs does not support triple indirect blocks");
269 /* Read LEN bytes from the file described by DATA starting with byte
270 POS. Return the amount of read bytes in READ. */
272 grub_ufs_read_file (struct grub_ufs_data
*data
,
273 void NESTED_FUNC_ATTR (*read_hook
) (grub_disk_addr_t sector
,
274 unsigned offset
, unsigned length
),
275 int pos
, grub_size_t len
, char *buf
)
277 struct grub_ufs_sblock
*sblock
= &data
->sblock
;
281 /* Adjust len so it we can't read past the end of the file. */
282 if (len
> INODE_SIZE (data
))
283 len
= INODE_SIZE (data
);
285 blockcnt
= (len
+ pos
+ UFS_BLKSZ (sblock
) - 1) / UFS_BLKSZ (sblock
);
287 for (i
= pos
/ UFS_BLKSZ (sblock
); i
< blockcnt
; i
++)
290 int blockoff
= pos
% UFS_BLKSZ (sblock
);
291 int blockend
= UFS_BLKSZ (sblock
);
295 blknr
= grub_ufs_get_file_block (data
, i
);
300 if (i
== blockcnt
- 1)
302 blockend
= (len
+ pos
) % UFS_BLKSZ (sblock
);
305 blockend
= UFS_BLKSZ (sblock
);
309 if (i
== (pos
/ (int) UFS_BLKSZ (sblock
)))
311 skipfirst
= blockoff
;
312 blockend
-= skipfirst
;
315 /* XXX: If the block number is 0 this block is not stored on
316 disk but is zero filled instead. */
319 data
->disk
->read_hook
= read_hook
;
320 grub_disk_read (data
->disk
,
321 blknr
<< grub_le_to_cpu32 (data
->sblock
.log2_blksz
),
322 skipfirst
, blockend
, buf
);
323 data
->disk
->read_hook
= 0;
328 grub_memset (buf
, UFS_BLKSZ (sblock
) - skipfirst
, 0);
330 buf
+= UFS_BLKSZ (sblock
) - skipfirst
;
337 /* Read inode INO from the mounted filesystem described by DATA. This
338 inode is used by default now. */
340 grub_ufs_read_inode (struct grub_ufs_data
*data
, int ino
, char *inode
)
342 struct grub_ufs_sblock
*sblock
= &data
->sblock
;
344 /* Determine the group the inode is in. */
345 int group
= ino
/ grub_le_to_cpu32 (sblock
->ino_per_group
);
347 /* Determine the inode within the group. */
348 int grpino
= ino
% grub_le_to_cpu32 (sblock
->ino_per_group
);
350 /* The first block of the group. */
351 int grpblk
= group
* (grub_le_to_cpu32 (sblock
->frags_per_group
));
353 if (data
->ufs_type
== UFS1
)
357 inode
= (char *) &data
->inode
;
361 grub_disk_read (data
->disk
,
362 (((grub_le_to_cpu32 (sblock
->inoblk_offs
) + grpblk
)
363 << grub_le_to_cpu32 (data
->sblock
.log2_blksz
)))
365 (grpino
% 4) * sizeof (struct grub_ufs_inode
),
366 sizeof (struct grub_ufs_inode
),
373 inode
= (char *) &data
->inode2
;
377 grub_disk_read (data
->disk
,
378 (((grub_le_to_cpu32 (sblock
->inoblk_offs
) + grpblk
)
379 << grub_le_to_cpu32 (data
->sblock
.log2_blksz
)))
381 (grpino
% 2) * sizeof (struct grub_ufs2_inode
),
382 sizeof (struct grub_ufs2_inode
),
390 /* Lookup the symlink the current inode points to. INO is the inode
391 number of the directory the symlink is relative to. */
393 grub_ufs_lookup_symlink (struct grub_ufs_data
*data
, int ino
)
395 char symlink
[INODE_SIZE (data
)];
397 if (++data
->linknest
> GRUB_UFS_MAX_SYMLNK_CNT
)
398 return grub_error (GRUB_ERR_SYMLINK_LOOP
, "too deep nesting of symlinks");
400 if (INODE_NBLOCKS (data
) == 0)
401 grub_strcpy (symlink
, (char *) INODE (data
, symlink
));
404 grub_disk_read (data
->disk
,
405 (INODE_DIRBLOCKS (data
, 0)
406 << grub_le_to_cpu32 (data
->sblock
.log2_blksz
)),
407 0, INODE_SIZE (data
), symlink
);
408 symlink
[INODE_SIZE (data
)] = '\0';
411 /* The symlink is an absolute path, go back to the root inode. */
412 if (symlink
[0] == '/')
413 ino
= GRUB_UFS_INODE
;
415 /* Now load in the old inode. */
416 if (grub_ufs_read_inode (data
, ino
, 0))
419 grub_ufs_find_file (data
, symlink
);
421 grub_error (grub_errno
, "Can not follow symlink `%s'.", symlink
);
427 /* Find the file with the pathname PATH on the filesystem described by
430 grub_ufs_find_file (struct grub_ufs_data
*data
, const char *path
)
432 char fpath
[grub_strlen (path
) + 1];
435 unsigned int pos
= 0;
438 grub_strcpy (fpath
, path
);
440 /* Skip the first slash. */
448 /* Extract the actual part from the pathname. */
449 next
= grub_strchr (name
, '/');
458 struct grub_ufs_dirent dirent
;
461 if (grub_strlen (name
) == 0)
462 return GRUB_ERR_NONE
;
464 if (grub_ufs_read_file (data
, 0, pos
, sizeof (dirent
),
465 (char *) &dirent
) < 0)
468 namelen
= (data
->ufs_type
== UFS2
)
469 ? dirent
.namelen_bsd
: grub_le_to_cpu16 (dirent
.namelen
);
472 char filename
[namelen
+ 1];
474 if (grub_ufs_read_file (data
, 0, pos
+ sizeof (dirent
),
475 namelen
, filename
) < 0)
478 filename
[namelen
] = '\0';
480 if (!grub_strcmp (name
, filename
))
483 grub_ufs_read_inode (data
, grub_le_to_cpu32 (dirent
.ino
), 0);
485 if ((INODE_MODE(data
) & GRUB_UFS_ATTR_TYPE
)
486 == GRUB_UFS_ATTR_LNK
)
488 grub_ufs_lookup_symlink (data
, dirino
);
499 next
= grub_strchr (name
, '/');
506 if ((INODE_MODE(data
) & GRUB_UFS_ATTR_TYPE
) != GRUB_UFS_ATTR_DIR
)
507 return grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a directory");
513 pos
+= grub_le_to_cpu16 (dirent
.direntlen
);
514 } while (pos
< INODE_SIZE (data
));
516 grub_error (GRUB_ERR_FILE_NOT_FOUND
, "file not found");
521 /* Mount the filesystem on the disk DISK. */
522 static struct grub_ufs_data
*
523 grub_ufs_mount (grub_disk_t disk
)
525 struct grub_ufs_data
*data
;
526 int *sblklist
= sblocklist
;
528 data
= grub_malloc (sizeof (struct grub_ufs_data
));
532 /* Find a UFS1 or UFS2 sblock. */
533 data
->ufs_type
= UNKNOWN
;
534 while (*sblklist
!= -1)
536 grub_disk_read (disk
, *sblklist
, 0, sizeof (struct grub_ufs_sblock
),
537 (char *) &data
->sblock
);
541 if (grub_le_to_cpu32 (data
->sblock
.magic
) == GRUB_UFS_MAGIC
)
543 data
->ufs_type
= UFS1
;
546 else if (grub_le_to_cpu32 (data
->sblock
.magic
) == GRUB_UFS2_MAGIC
)
548 data
->ufs_type
= UFS2
;
553 if (data
->ufs_type
== UNKNOWN
)
555 grub_error (GRUB_ERR_BAD_FS
, "not an ufs filesystem");
566 if (grub_errno
== GRUB_ERR_OUT_OF_RANGE
)
567 grub_error (GRUB_ERR_BAD_FS
, "not a ufs filesystem");
574 grub_ufs_dir (grub_device_t device
, const char *path
,
575 int (*hook
) (const char *filename
,
576 const struct grub_dirhook_info
*info
))
578 struct grub_ufs_data
*data
;
579 struct grub_ufs_sblock
*sblock
;
580 unsigned int pos
= 0;
582 data
= grub_ufs_mount (device
->disk
);
586 grub_ufs_read_inode (data
, GRUB_UFS_INODE
, 0);
590 sblock
= &data
->sblock
;
592 if (!path
|| path
[0] != '/')
594 grub_error (GRUB_ERR_BAD_FILENAME
, "bad filename");
598 grub_ufs_find_file (data
, path
);
602 if ((INODE_MODE (data
) & GRUB_UFS_ATTR_TYPE
) != GRUB_UFS_ATTR_DIR
)
604 grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a directory");
608 while (pos
< INODE_SIZE (data
))
610 struct grub_ufs_dirent dirent
;
613 if (grub_ufs_read_file (data
, 0, pos
, sizeof (dirent
),
614 (char *) &dirent
) < 0)
617 namelen
= (data
->ufs_type
== UFS2
)
618 ? dirent
.namelen_bsd
: grub_le_to_cpu16 (dirent
.namelen
);
621 char filename
[namelen
+ 1];
622 struct grub_dirhook_info info
;
623 grub_memset (&info
, 0, sizeof (info
));
625 if (grub_ufs_read_file (data
, 0, pos
+ sizeof (dirent
),
626 namelen
, filename
) < 0)
629 filename
[namelen
] = '\0';
630 if (data
->ufs_type
== UFS1
)
632 struct grub_ufs_inode inode
;
633 grub_ufs_read_inode (data
, dirent
.ino
, (char *) &inode
);
634 info
.dir
= ((grub_le_to_cpu16 (inode
.mode
) & GRUB_UFS_ATTR_TYPE
)
635 == GRUB_UFS_ATTR_DIR
);
636 info
.mtime
= grub_le_to_cpu64 (inode
.mtime
);
641 struct grub_ufs2_inode inode
;
642 grub_ufs_read_inode (data
, dirent
.ino
, (char *) &inode
);
643 info
.dir
= ((grub_le_to_cpu16 (inode
.mode
) & GRUB_UFS_ATTR_TYPE
)
644 == GRUB_UFS_ATTR_DIR
);
645 info
.mtime
= grub_le_to_cpu64 (inode
.mtime
);
649 if (hook (filename
, &info
))
653 pos
+= grub_le_to_cpu16 (dirent
.direntlen
);
663 /* Open a file named NAME and initialize FILE. */
665 grub_ufs_open (struct grub_file
*file
, const char *name
)
667 struct grub_ufs_data
*data
;
668 data
= grub_ufs_mount (file
->device
->disk
);
672 grub_ufs_read_inode (data
, 2, 0);
679 if (!name
|| name
[0] != '/')
681 grub_error (GRUB_ERR_BAD_FILENAME
, "bad filename");
685 grub_ufs_find_file (data
, name
);
693 file
->size
= INODE_SIZE (data
);
695 return GRUB_ERR_NONE
;
700 grub_ufs_read (grub_file_t file
, char *buf
, grub_size_t len
)
702 struct grub_ufs_data
*data
=
703 (struct grub_ufs_data
*) file
->data
;
705 return grub_ufs_read_file (data
, file
->read_hook
, file
->offset
, len
, buf
);
710 grub_ufs_close (grub_file_t file
)
712 grub_free (file
->data
);
714 return GRUB_ERR_NONE
;
719 grub_ufs_label (grub_device_t device
, char **label
)
721 struct grub_ufs_data
*data
= 0;
724 grub_dl_ref (my_mod
);
729 data
= grub_ufs_mount (device
->disk
);
732 if (data
->ufs_type
== UFS2
)
733 *label
= grub_strdup ((char *) data
->sblock
.volume_name
);
737 grub_dl_unref (my_mod
);
747 grub_ufs_mtime (grub_device_t device
, grub_int32_t
*tm
)
749 struct grub_ufs_data
*data
= 0;
752 grub_dl_ref (my_mod
);
755 data
= grub_ufs_mount (device
->disk
);
758 else if (data
->ufs_type
== UFS1
)
759 *tm
= grub_le_to_cpu32 (data
->sblock
.mtime
);
761 *tm
= grub_le_to_cpu64 (data
->sblock
.mtime2
);
764 grub_dl_unref (my_mod
);
774 static struct grub_fs grub_ufs_fs
=
778 .open
= grub_ufs_open
,
779 .read
= grub_ufs_read
,
780 .close
= grub_ufs_close
,
781 .label
= grub_ufs_label
,
782 .mtime
= grub_ufs_mtime
,
788 grub_fs_register (&grub_ufs_fs
);
796 grub_fs_unregister (&grub_ufs_fs
);