1 /* minix.c - The minix filesystem, version 1 and 2. */
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_MINIX_MAGIC 0x137F
29 #define GRUB_MINIX2_MAGIC 0x2468
30 #define GRUB_MINIX_MAGIC_30 0x138F
31 #define GRUB_MINIX2_MAGIC_30 0x2478
32 #define GRUB_MINIX_BSIZE 1024U
33 #define GRUB_MINIX_LOG2_BSIZE 1
34 #define GRUB_MINIX_ROOT_INODE 1
35 #define GRUB_MINIX_MAX_SYMLNK_CNT 8
36 #define GRUB_MINIX_SBLOCK 2
38 #define GRUB_MINIX_IFDIR 0040000U
39 #define GRUB_MINIX_IFLNK 0120000U
41 #define GRUB_MINIX_INODE(data,field) (data->version == 1 ? \
42 data->inode. field : data->inode2. field)
43 #define GRUB_MINIX_INODE_ENDIAN(data,field,bits1,bits2) (data->version == 1 ? \
44 grub_le_to_cpu##bits1 (data->inode.field) : \
45 grub_le_to_cpu##bits2 (data->inode2.field))
46 #define GRUB_MINIX_INODE_SIZE(data) GRUB_MINIX_INODE_ENDIAN (data,size,16,32)
47 #define GRUB_MINIX_INODE_MODE(data) GRUB_MINIX_INODE_ENDIAN (data,mode,16,16)
48 #define GRUB_MINIX_INODE_DIR_ZONES(data,blk) GRUB_MINIX_INODE_ENDIAN \
49 (data,dir_zones[blk],16,32)
50 #define GRUB_MINIX_INODE_INDIR_ZONE(data) \
51 GRUB_MINIX_INODE_ENDIAN (data,indir_zone,16,32)
52 #define GRUB_MINIX_INODE_DINDIR_ZONE(data) \
53 GRUB_MINIX_INODE_ENDIAN (data,double_indir_zone,16,32)
54 #define GRUB_MINIX_INODE_BLKSZ(data) (data->version == 1 ? 2 : 4)
55 #define GRUB_MINIX_LOG2_ZONESZ (GRUB_MINIX_LOG2_BSIZE \
56 + grub_le_to_cpu16 (sblock->log2_zone_size))
57 #define GRUB_MINIX_ZONESZ (GRUB_MINIX_BSIZE \
58 << grub_le_to_cpu16 (sblock->log2_zone_size))
60 struct grub_minix_sblock
62 grub_uint16_t inode_cnt
;
63 grub_uint16_t zone_cnt
;
64 grub_uint16_t inode_bmap_size
;
65 grub_uint16_t zone_bmap_size
;
66 grub_uint16_t first_data_zone
;
67 grub_uint16_t log2_zone_size
;
68 grub_uint32_t max_file_size
;
72 struct grub_minix_inode
80 grub_uint16_t dir_zones
[7];
81 grub_uint16_t indir_zone
;
82 grub_uint16_t double_indir_zone
;
85 struct grub_minix2_inode
95 grub_uint32_t dir_zones
[7];
96 grub_uint32_t indir_zone
;
97 grub_uint32_t double_indir_zone
;
102 /* Information about a "mounted" minix filesystem. */
103 struct grub_minix_data
105 struct grub_minix_sblock sblock
;
106 struct grub_minix_inode inode
;
107 struct grub_minix2_inode inode2
;
115 static grub_dl_t my_mod
;
117 static grub_err_t
grub_minix_find_file (struct grub_minix_data
*data
,
121 grub_minix_get_file_block (struct grub_minix_data
*data
, unsigned int blk
)
123 struct grub_minix_sblock
*sblock
= &data
->sblock
;
126 auto int grub_get_indir (int, int);
128 /* Read the block pointer in ZONE, on the offset NUM. */
129 int grub_get_indir (int zone
, int num
)
131 if (data
->version
== 1)
133 grub_uint16_t indir16
;
134 grub_disk_read (data
->disk
,
135 zone
<< GRUB_MINIX_LOG2_ZONESZ
,
136 sizeof (grub_uint16_t
) * num
,
137 sizeof (grub_uint16_t
), (char *) &indir16
);
138 return grub_le_to_cpu16 (indir16
);
142 grub_uint32_t indir32
;
143 grub_disk_read (data
->disk
,
144 zone
<< GRUB_MINIX_LOG2_ZONESZ
,
145 sizeof (grub_uint32_t
) * num
,
146 sizeof (grub_uint32_t
), (char *) &indir32
);
147 return grub_le_to_cpu32 (indir32
);
153 return GRUB_MINIX_INODE_DIR_ZONES (data
, blk
);
155 /* Indirect block. */
157 if (blk
< GRUB_MINIX_ZONESZ
/ GRUB_MINIX_INODE_BLKSZ (data
))
159 indir
= grub_get_indir (GRUB_MINIX_INODE_INDIR_ZONE (data
), blk
);
163 /* Double indirect block. */
164 blk
-= GRUB_MINIX_ZONESZ
/ GRUB_MINIX_INODE_BLKSZ (data
);
165 if (blk
< (GRUB_MINIX_ZONESZ
/ GRUB_MINIX_INODE_BLKSZ (data
))
166 * (GRUB_MINIX_ZONESZ
/ GRUB_MINIX_INODE_BLKSZ (data
)))
168 indir
= grub_get_indir (GRUB_MINIX_INODE_DINDIR_ZONE (data
),
169 blk
/ GRUB_MINIX_ZONESZ
);
171 indir
= grub_get_indir (indir
, blk
% GRUB_MINIX_ZONESZ
);
176 /* This should never happen. */
177 grub_error (GRUB_ERR_OUT_OF_RANGE
, "file bigger than maximum size");
183 /* Read LEN bytes from the file described by DATA starting with byte
184 POS. Return the amount of read bytes in READ. */
186 grub_minix_read_file (struct grub_minix_data
*data
,
187 void NESTED_FUNC_ATTR (*read_hook
) (grub_disk_addr_t sector
,
188 unsigned offset
, unsigned length
),
189 int pos
, grub_disk_addr_t len
, char *buf
)
191 struct grub_minix_sblock
*sblock
= &data
->sblock
;
195 /* Adjust len so it we can't read past the end of the file. */
196 if (len
+ pos
> GRUB_MINIX_INODE_SIZE (data
))
197 len
= GRUB_MINIX_INODE_SIZE (data
) - pos
;
199 blockcnt
= (len
+ pos
+ GRUB_MINIX_BSIZE
- 1) / GRUB_MINIX_BSIZE
;
201 for (i
= pos
/ GRUB_MINIX_BSIZE
; i
< blockcnt
; i
++)
204 int blockoff
= pos
% GRUB_MINIX_BSIZE
;
205 int blockend
= GRUB_MINIX_BSIZE
;
209 blknr
= grub_minix_get_file_block (data
, i
);
214 if (i
== blockcnt
- 1)
216 blockend
= (len
+ pos
) % GRUB_MINIX_BSIZE
;
219 blockend
= GRUB_MINIX_BSIZE
;
223 if (i
== (pos
/ (int) GRUB_MINIX_BSIZE
))
225 skipfirst
= blockoff
;
226 blockend
-= skipfirst
;
229 data
->disk
->read_hook
= read_hook
;
230 grub_disk_read (data
->disk
, blknr
<< GRUB_MINIX_LOG2_ZONESZ
,
231 skipfirst
, blockend
, buf
);
233 data
->disk
->read_hook
= 0;
237 buf
+= GRUB_MINIX_BSIZE
- skipfirst
;
244 /* Read inode INO from the mounted filesystem described by DATA. This
245 inode is used by default now. */
247 grub_minix_read_inode (struct grub_minix_data
*data
, int ino
)
249 struct grub_minix_sblock
*sblock
= &data
->sblock
;
251 /* Block in which the inode is stored. */
255 /* The first inode in minix is inode 1. */
258 block
= ((2 + grub_le_to_cpu16 (sblock
->inode_bmap_size
)
259 + grub_le_to_cpu16 (sblock
->zone_bmap_size
))
260 << GRUB_MINIX_LOG2_BSIZE
);
262 if (data
->version
== 1)
264 block
+= ino
/ (GRUB_DISK_SECTOR_SIZE
/ sizeof (struct grub_minix_inode
));
265 int offs
= (ino
% (GRUB_DISK_SECTOR_SIZE
266 / sizeof (struct grub_minix_inode
))
267 * sizeof (struct grub_minix_inode
));
269 grub_disk_read (data
->disk
, block
, offs
,
270 sizeof (struct grub_minix_inode
), &data
->inode
);
274 block
+= ino
/ (GRUB_DISK_SECTOR_SIZE
275 / sizeof (struct grub_minix2_inode
));
277 % (GRUB_DISK_SECTOR_SIZE
/ sizeof (struct grub_minix2_inode
))
278 * sizeof (struct grub_minix2_inode
));
280 grub_disk_read (data
->disk
, block
, offs
,
281 sizeof (struct grub_minix2_inode
),&data
->inode2
);
284 return GRUB_ERR_NONE
;
288 /* Lookup the symlink the current inode points to. INO is the inode
289 number of the directory the symlink is relative to. */
291 grub_minix_lookup_symlink (struct grub_minix_data
*data
, int ino
)
293 char symlink
[GRUB_MINIX_INODE_SIZE (data
) + 1];
295 if (++data
->linknest
> GRUB_MINIX_MAX_SYMLNK_CNT
)
296 return grub_error (GRUB_ERR_SYMLINK_LOOP
, "too deep nesting of symlinks");
298 if (grub_minix_read_file (data
, 0, 0,
299 GRUB_MINIX_INODE_SIZE (data
), symlink
) < 0)
302 symlink
[GRUB_MINIX_INODE_SIZE (data
)] = '\0';
304 /* The symlink is an absolute path, go back to the root inode. */
305 if (symlink
[0] == '/')
306 ino
= GRUB_MINIX_ROOT_INODE
;
308 /* Now load in the old inode. */
309 if (grub_minix_read_inode (data
, ino
))
312 grub_minix_find_file (data
, symlink
);
314 grub_error (grub_errno
, "cannot follow symlink `%s'", symlink
);
320 /* Find the file with the pathname PATH on the filesystem described by
323 grub_minix_find_file (struct grub_minix_data
*data
, const char *path
)
325 char fpath
[grub_strlen (path
) + 1];
328 unsigned int pos
= 0;
331 grub_strcpy (fpath
, path
);
333 /* Skip the first slash. */
341 /* Extract the actual part from the pathname. */
342 next
= grub_strchr (name
, '/');
352 char filename
[data
->filename_size
+ 1];
354 if (grub_strlen (name
) == 0)
355 return GRUB_ERR_NONE
;
357 if (grub_minix_read_file (data
, 0, pos
, sizeof (ino
),
360 if (grub_minix_read_file (data
, 0, pos
+ sizeof (ino
),
361 data
->filename_size
, (char *) filename
)< 0)
364 filename
[data
->filename_size
] = '\0';
366 /* Check if the current direntry matches the current part of the
368 if (!grub_strcmp (name
, filename
))
371 grub_minix_read_inode (data
, grub_le_to_cpu16 (ino
));
373 /* Follow the symlink. */
374 if ((GRUB_MINIX_INODE_MODE (data
)
375 & GRUB_MINIX_IFLNK
) == GRUB_MINIX_IFLNK
)
377 grub_minix_lookup_symlink (data
, dirino
);
388 next
= grub_strchr (name
, '/');
395 if ((GRUB_MINIX_INODE_MODE (data
)
396 & GRUB_MINIX_IFDIR
) != GRUB_MINIX_IFDIR
)
397 return grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a directory");
402 pos
+= sizeof (ino
) + data
->filename_size
;
403 } while (pos
< GRUB_MINIX_INODE_SIZE (data
));
405 grub_error (GRUB_ERR_FILE_NOT_FOUND
, "file not found");
410 /* Mount the filesystem on the disk DISK. */
411 static struct grub_minix_data
*
412 grub_minix_mount (grub_disk_t disk
)
414 struct grub_minix_data
*data
;
416 data
= grub_malloc (sizeof (struct grub_minix_data
));
420 /* Read the superblock. */
421 grub_disk_read (disk
, GRUB_MINIX_SBLOCK
, 0,
422 sizeof (struct grub_minix_sblock
),&data
->sblock
);
426 if (grub_le_to_cpu16 (data
->sblock
.magic
) == GRUB_MINIX_MAGIC
)
429 data
->filename_size
= 14;
431 else if (grub_le_to_cpu16 (data
->sblock
.magic
) == GRUB_MINIX2_MAGIC
)
434 data
->filename_size
= 14;
436 else if (grub_le_to_cpu16 (data
->sblock
.magic
) == GRUB_MINIX_MAGIC_30
)
439 data
->filename_size
= 30;
441 else if (grub_le_to_cpu16 (data
->sblock
.magic
) == GRUB_MINIX2_MAGIC_30
)
444 data
->filename_size
= 30;
456 grub_error (GRUB_ERR_BAD_FS
, "not a minix filesystem");
461 grub_minix_dir (grub_device_t device
, const char *path
,
462 int (*hook
) (const char *filename
,
463 const struct grub_dirhook_info
*info
))
465 struct grub_minix_data
*data
= 0;
466 struct grub_minix_sblock
*sblock
;
467 unsigned int pos
= 0;
469 data
= grub_minix_mount (device
->disk
);
473 grub_minix_read_inode (data
, GRUB_MINIX_ROOT_INODE
);
477 sblock
= &data
->sblock
;
479 grub_minix_find_file (data
, path
);
483 if ((GRUB_MINIX_INODE_MODE (data
) & GRUB_MINIX_IFDIR
) != GRUB_MINIX_IFDIR
)
485 grub_error (GRUB_ERR_BAD_FILE_TYPE
, "not a directory");
489 while (pos
< GRUB_MINIX_INODE_SIZE (data
))
492 char filename
[data
->filename_size
+ 1];
493 int dirino
= data
->ino
;
494 struct grub_dirhook_info info
;
495 grub_memset (&info
, 0, sizeof (info
));
498 if (grub_minix_read_file (data
, 0, pos
, sizeof (ino
),
502 if (grub_minix_read_file (data
, 0, pos
+ sizeof (ino
),
504 (char *) filename
) < 0)
506 filename
[data
->filename_size
] = '\0';
508 /* The filetype is not stored in the dirent. Read the inode to
509 find out the filetype. This *REALLY* sucks. */
510 grub_minix_read_inode (data
, grub_le_to_cpu16 (ino
));
511 info
.dir
= ((GRUB_MINIX_INODE_MODE (data
)
512 & GRUB_MINIX_IFDIR
) == GRUB_MINIX_IFDIR
);
513 if (hook (filename
, &info
) ? 1 : 0)
516 /* Load the old inode back in. */
517 grub_minix_read_inode (data
, dirino
);
519 pos
+= sizeof (ino
) + data
->filename_size
;
528 /* Open a file named NAME and initialize FILE. */
530 grub_minix_open (struct grub_file
*file
, const char *name
)
532 struct grub_minix_data
*data
;
533 data
= grub_minix_mount (file
->device
->disk
);
537 /* Open the inode op the root directory. */
538 grub_minix_read_inode (data
, GRUB_MINIX_ROOT_INODE
);
545 if (!name
|| name
[0] != '/')
547 grub_error (GRUB_ERR_BAD_FILENAME
, "bad filename");
551 /* Traverse the directory tree to the node that should be
553 grub_minix_find_file (data
, name
);
561 file
->size
= GRUB_MINIX_INODE_SIZE (data
);
563 return GRUB_ERR_NONE
;
568 grub_minix_read (grub_file_t file
, char *buf
, grub_size_t len
)
570 struct grub_minix_data
*data
=
571 (struct grub_minix_data
*) file
->data
;
573 return grub_minix_read_file (data
, file
->read_hook
, file
->offset
, len
, buf
);
578 grub_minix_close (grub_file_t file
)
580 grub_free (file
->data
);
582 return GRUB_ERR_NONE
;
587 grub_minix_label (grub_device_t device
__attribute ((unused
)),
588 char **label
__attribute ((unused
)))
590 return GRUB_ERR_NONE
;
594 static struct grub_fs grub_minix_fs
=
597 .dir
= grub_minix_dir
,
598 .open
= grub_minix_open
,
599 .read
= grub_minix_read
,
600 .close
= grub_minix_close
,
601 .label
= grub_minix_label
,
607 grub_fs_register (&grub_minix_fs
);
613 grub_fs_unregister (&grub_minix_fs
);