1 /* sfs.c - Amiga Smart FileSystem. */
3 * GRUB -- GRand Unified Bootloader
4 * Copyright (C) 2005,2006,2007,2008,2009 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>
27 #include <grub/fshelp.h>
29 /* The common header for a block. */
30 struct grub_sfs_bheader
32 grub_uint8_t magic
[4];
34 grub_uint32_t ipointtomyself
;
35 } __attribute__ ((packed
));
37 /* The sfs rootblock. */
38 struct grub_sfs_rblock
40 struct grub_sfs_bheader header
;
41 grub_uint32_t version
;
42 grub_uint8_t unused1
[36];
43 grub_uint32_t blocksize
;
44 grub_uint8_t unused2
[40];
45 grub_uint8_t unused3
[8];
46 grub_uint32_t rootobject
;
48 } __attribute__ ((packed
));
50 /* A SFS object container. */
53 grub_uint8_t unused1
[4];
55 grub_uint8_t unused2
[4];
60 grub_uint32_t first_block
;
62 } file
__attribute__ ((packed
));
65 grub_uint32_t hashtable
;
66 grub_uint32_t dir_objc
;
67 } dir
__attribute__ ((packed
));
69 grub_uint8_t unused3
[4];
71 grub_uint8_t filename
[1];
72 grub_uint8_t comment
[1];
73 } __attribute__ ((packed
));
75 #define GRUB_SFS_TYPE_DELETED 32
76 #define GRUB_SFS_TYPE_SYMLINK 64
77 #define GRUB_SFS_TYPE_DIR 128
79 /* A SFS object container. */
82 struct grub_sfs_bheader header
;
86 /* The amount of objects depends on the blocksize. */
87 struct grub_sfs_obj objects
[1];
88 } __attribute__ ((packed
));
90 struct grub_sfs_btree_node
94 } __attribute__ ((packed
));
96 struct grub_sfs_btree_extent
102 } __attribute__ ((packed
));
104 struct grub_sfs_btree
106 struct grub_sfs_bheader header
;
109 grub_uint8_t nodesize
;
110 /* Normally this can be kind of node, but just extents are
112 struct grub_sfs_btree_node node
[1];
113 } __attribute__ ((packed
));
117 struct grub_fshelp_node
119 struct grub_sfs_data
*data
;
124 /* Information about a "mounted" sfs filesystem. */
127 struct grub_sfs_rblock rblock
;
128 struct grub_fshelp_node diropen
;
131 /* Blocksize in sectors. */
132 unsigned int blocksize
;
134 /* Label of the filesystem. */
138 static grub_dl_t my_mod
;
141 /* Lookup the extent starting with BLOCK in the filesystem described
142 by DATA. Return the extent size in SIZE and the following extent
145 grub_sfs_read_extent (struct grub_sfs_data
*data
, unsigned int block
,
146 int *size
, int *nextext
)
149 struct grub_sfs_btree
*tree
;
154 treeblock
= grub_malloc (data
->blocksize
);
158 next
= grub_be_to_cpu32 (data
->rblock
.btree
);
159 tree
= (struct grub_sfs_btree
*) treeblock
;
161 /* Handle this level in the btree. */
166 grub_disk_read (data
->disk
, next
, 0, data
->blocksize
, treeblock
);
169 grub_free (treeblock
);
173 for (i
= grub_be_to_cpu16 (tree
->nodes
) - 1; i
>= 0; i
--)
176 #define EXTNODE(tree, index) \
177 ((struct grub_sfs_btree_node *) (((char *) &(tree)->node[0]) \
178 + (index) * (tree)->nodesize))
180 /* Follow the tree down to the leaf level. */
181 if ((grub_be_to_cpu32 (EXTNODE(tree
, i
)->key
) <= block
)
184 next
= grub_be_to_cpu32 (EXTNODE (tree
, i
)->data
);
188 /* If the leaf level is reached, just find the correct extent. */
189 if (grub_be_to_cpu32 (EXTNODE (tree
, i
)->key
) == block
&& tree
->leaf
)
191 struct grub_sfs_btree_extent
*extent
;
192 extent
= (struct grub_sfs_btree_extent
*) EXTNODE (tree
, i
);
194 /* We found a correct leaf. */
195 *size
= grub_be_to_cpu16 (extent
->size
);
196 *nextext
= grub_be_to_cpu32 (extent
->next
);
198 grub_free (treeblock
);
205 } while (!tree
->leaf
);
207 grub_free (treeblock
);
209 return grub_error (GRUB_ERR_FILE_READ_ERROR
, "SFS extent not found");
212 static grub_disk_addr_t
213 grub_sfs_read_block (grub_fshelp_node_t node
, grub_disk_addr_t fileblock
)
215 int blk
= node
->block
;
223 /* In case of the first block we don't have to lookup the
224 extent, the minimum size is always 1. */
228 err
= grub_sfs_read_extent (node
->data
, blk
, &size
, &next
);
232 if (fileblock
< (unsigned int) size
)
233 return fileblock
+ blk
;
240 grub_error (GRUB_ERR_FILE_READ_ERROR
,
241 "reading a SFS block outside the extent");
247 /* Read LEN bytes from the file described by DATA starting with byte
248 POS. Return the amount of read bytes in READ. */
250 grub_sfs_read_file (grub_fshelp_node_t node
,
251 void NESTED_FUNC_ATTR (*read_hook
) (grub_disk_addr_t sector
,
252 unsigned offset
, unsigned length
),
253 int pos
, grub_size_t len
, char *buf
)
255 return grub_fshelp_read_file (node
->data
->disk
, node
, read_hook
,
256 pos
, len
, buf
, grub_sfs_read_block
,
261 static struct grub_sfs_data
*
262 grub_sfs_mount (grub_disk_t disk
)
264 struct grub_sfs_data
*data
;
265 struct grub_sfs_objc
*rootobjc
;
266 char *rootobjc_data
= 0;
269 data
= grub_malloc (sizeof (*data
));
273 /* Read the rootblock. */
274 grub_disk_read (disk
, 0, 0, sizeof (struct grub_sfs_rblock
),
279 /* Make sure this is a sfs filesystem. */
280 if (grub_strncmp ((char *) (data
->rblock
.header
.magic
), "SFS", 4))
282 grub_error (GRUB_ERR_BAD_FS
, "not a SFS filesystem");
286 data
->blocksize
= grub_be_to_cpu32 (data
->rblock
.blocksize
);
287 rootobjc_data
= grub_malloc (data
->blocksize
);
291 /* Read the root object container. */
292 grub_disk_read (disk
, grub_be_to_cpu32 (data
->rblock
.rootobject
), 0,
293 data
->blocksize
, rootobjc_data
);
297 rootobjc
= (struct grub_sfs_objc
*) rootobjc_data
;
299 blk
= grub_be_to_cpu32 (rootobjc
->objects
[0].file_dir
.dir
.dir_objc
);
300 data
->diropen
.size
= 0;
301 data
->diropen
.block
= blk
;
302 data
->diropen
.data
= data
;
304 data
->label
= grub_strdup ((char *) (rootobjc
->objects
[0].filename
));
309 if (grub_errno
== GRUB_ERR_OUT_OF_RANGE
)
310 grub_error (GRUB_ERR_BAD_FS
, "not an SFS filesystem");
313 grub_free (rootobjc_data
);
319 grub_sfs_read_symlink (grub_fshelp_node_t node
)
321 struct grub_sfs_data
*data
= node
->data
;
325 block
= grub_malloc (data
->blocksize
);
329 grub_disk_read (data
->disk
, node
->block
, 0, data
->blocksize
, block
);
336 /* This is just a wild guess, but it always worked for me. How the
337 SLNK block looks like is not documented in the SFS docs. */
338 symlink
= grub_strdup (&block
[24]);
347 grub_sfs_iterate_dir (grub_fshelp_node_t dir
,
349 (*hook
) (const char *filename
,
350 enum grub_fshelp_filetype filetype
,
351 grub_fshelp_node_t node
))
353 struct grub_fshelp_node
*node
= 0;
354 struct grub_sfs_data
*data
= dir
->data
;
356 struct grub_sfs_objc
*objc
;
357 unsigned int next
= dir
->block
;
360 auto int NESTED_FUNC_ATTR
grub_sfs_create_node (const char *name
, int block
,
363 int NESTED_FUNC_ATTR
grub_sfs_create_node (const char *name
, int block
,
366 node
= grub_malloc (sizeof (*node
));
374 return hook (name
, type
, node
);
377 objc_data
= grub_malloc (data
->blocksize
);
381 /* The Object container can consist of multiple blocks, iterate over
385 grub_disk_read (data
->disk
, next
, 0, data
->blocksize
, objc_data
);
389 objc
= (struct grub_sfs_objc
*) objc_data
;
391 pos
= (char *) &objc
->objects
[0] - (char *) objc
;
393 /* Iterate over all entries in this block. */
394 while (pos
+ sizeof (struct grub_sfs_obj
) < data
->blocksize
)
396 struct grub_sfs_obj
*obj
;
397 obj
= (struct grub_sfs_obj
*) ((char *) objc
+ pos
);
398 char *filename
= (char *) (obj
->filename
);
400 enum grub_fshelp_filetype type
;
403 /* The filename and comment dynamically increase the size of
405 len
= grub_strlen (filename
);
406 len
+= grub_strlen (filename
+ len
+ 1);
408 pos
+= sizeof (*obj
) + len
;
409 /* Round up to a multiple of two bytes. */
410 pos
= ((pos
+ 1) >> 1) << 1;
412 if (grub_strlen (filename
) == 0)
415 /* First check if the file was not deleted. */
416 if (obj
->type
& GRUB_SFS_TYPE_DELETED
)
418 else if (obj
->type
& GRUB_SFS_TYPE_SYMLINK
)
419 type
= GRUB_FSHELP_SYMLINK
;
420 else if (obj
->type
& GRUB_SFS_TYPE_DIR
)
421 type
= GRUB_FSHELP_DIR
;
423 type
= GRUB_FSHELP_REG
;
425 if (type
== GRUB_FSHELP_DIR
)
426 block
= grub_be_to_cpu32 (obj
->file_dir
.dir
.dir_objc
);
428 block
= grub_be_to_cpu32 (obj
->file_dir
.file
.first_block
);
430 if (grub_sfs_create_node (filename
, block
,
431 grub_be_to_cpu32 (obj
->file_dir
.file
.size
),
434 grub_free (objc_data
);
439 next
= grub_be_to_cpu32 (objc
->next
);
443 grub_free (objc_data
);
448 /* Open a file named NAME and initialize FILE. */
450 grub_sfs_open (struct grub_file
*file
, const char *name
)
452 struct grub_sfs_data
*data
;
453 struct grub_fshelp_node
*fdiro
= 0;
455 grub_dl_ref (my_mod
);
457 data
= grub_sfs_mount (file
->device
->disk
);
461 grub_fshelp_find_file (name
, &data
->diropen
, &fdiro
, grub_sfs_iterate_dir
,
462 grub_sfs_read_symlink
, GRUB_FSHELP_REG
);
466 file
->size
= fdiro
->size
;
467 data
->diropen
= *fdiro
;
476 if (data
&& fdiro
!= &data
->diropen
)
479 grub_free (data
->label
);
482 grub_dl_unref (my_mod
);
489 grub_sfs_close (grub_file_t file
)
491 grub_free (file
->data
);
493 grub_dl_unref (my_mod
);
495 return GRUB_ERR_NONE
;
499 /* Read LEN bytes data from FILE into BUF. */
501 grub_sfs_read (grub_file_t file
, char *buf
, grub_size_t len
)
503 struct grub_sfs_data
*data
= (struct grub_sfs_data
*) file
->data
;
505 int size
= grub_sfs_read_file (&data
->diropen
, file
->read_hook
,
506 file
->offset
, len
, buf
);
513 grub_sfs_dir (grub_device_t device
, const char *path
,
514 int (*hook
) (const char *filename
,
515 const struct grub_dirhook_info
*info
))
517 struct grub_sfs_data
*data
= 0;
518 struct grub_fshelp_node
*fdiro
= 0;
520 auto int NESTED_FUNC_ATTR
iterate (const char *filename
,
521 enum grub_fshelp_filetype filetype
,
522 grub_fshelp_node_t node
);
524 int NESTED_FUNC_ATTR
iterate (const char *filename
,
525 enum grub_fshelp_filetype filetype
,
526 grub_fshelp_node_t node
)
528 struct grub_dirhook_info info
;
529 grub_memset (&info
, 0, sizeof (info
));
530 info
.dir
= ((filetype
& GRUB_FSHELP_TYPE_MASK
) == GRUB_FSHELP_DIR
);
532 return hook (filename
, &info
);
535 grub_dl_ref (my_mod
);
537 data
= grub_sfs_mount (device
->disk
);
541 grub_fshelp_find_file (path
, &data
->diropen
, &fdiro
, grub_sfs_iterate_dir
,
542 grub_sfs_read_symlink
, GRUB_FSHELP_DIR
);
546 grub_sfs_iterate_dir (fdiro
, iterate
);
549 if (data
&& fdiro
!= &data
->diropen
)
552 grub_free (data
->label
);
555 grub_dl_unref (my_mod
);
562 grub_sfs_label (grub_device_t device
, char **label
)
564 struct grub_sfs_data
*data
;
565 grub_disk_t disk
= device
->disk
;
567 data
= grub_sfs_mount (disk
);
569 *label
= data
->label
;
577 static struct grub_fs grub_sfs_fs
=
581 .open
= grub_sfs_open
,
582 .read
= grub_sfs_read
,
583 .close
= grub_sfs_close
,
584 .label
= grub_sfs_label
,
590 grub_fs_register (&grub_sfs_fs
);
596 grub_fs_unregister (&grub_sfs_fs
);