← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to fs/sfs.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/sfs.c
1
 
/* sfs.c - Amiga Smart FileSystem.  */
2
 
/*
3
 
 *  GRUB  --  GRand Unified Bootloader
4
 
 *  Copyright (C) 2005,2006,2007,2008,2009  Free Software Foundation, Inc.
5
 
 *
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.
10
 
 *
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.
15
 
 *
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/>.
18
 
 */
19
 
 
20
 
#include <grub/err.h>
21
 
#include <grub/file.h>
22
 
#include <grub/mm.h>
23
 
#include <grub/misc.h>
24
 
#include <grub/disk.h>
25
 
#include <grub/dl.h>
26
 
#include <grub/types.h>
27
 
#include <grub/fshelp.h>
28
 
 
29
 
/* The common header for a block.  */
30
 
struct grub_sfs_bheader
31
 
{
32
 
  grub_uint8_t magic[4];
33
 
  grub_uint32_t chksum;
34
 
  grub_uint32_t ipointtomyself;
35
 
} __attribute__ ((packed));
36
 
 
37
 
/* The sfs rootblock.  */
38
 
struct grub_sfs_rblock
39
 
{
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;
47
 
  grub_uint32_t btree;
48
 
} __attribute__ ((packed));
49
 
 
50
 
/* A SFS object container.  */
51
 
struct grub_sfs_obj
52
 
{
53
 
  grub_uint8_t unused1[4];
54
 
  grub_uint32_t nodeid;
55
 
  grub_uint8_t unused2[4];
56
 
  union
57
 
  {
58
 
    struct
59
 
    {
60
 
      grub_uint32_t first_block;
61
 
      grub_uint32_t size;
62
 
    } file __attribute__ ((packed));
63
 
    struct
64
 
    {
65
 
      grub_uint32_t hashtable;
66
 
      grub_uint32_t dir_objc;
67
 
    } dir __attribute__ ((packed));
68
 
  } file_dir;
69
 
  grub_uint8_t unused3[4];
70
 
  grub_uint8_t type;
71
 
  grub_uint8_t filename[1];
72
 
  grub_uint8_t comment[1];
73
 
} __attribute__ ((packed));
74
 
 
75
 
#define GRUB_SFS_TYPE_DELETED   32
76
 
#define GRUB_SFS_TYPE_SYMLINK   64
77
 
#define GRUB_SFS_TYPE_DIR       128
78
 
 
79
 
/* A SFS object container.  */
80
 
struct grub_sfs_objc
81
 
{
82
 
  struct grub_sfs_bheader header;
83
 
  grub_uint32_t parent;
84
 
  grub_uint32_t next;
85
 
  grub_uint32_t prev;
86
 
  /* The amount of objects depends on the blocksize.  */
87
 
  struct grub_sfs_obj objects[1];
88
 
} __attribute__ ((packed));
89
 
 
90
 
struct grub_sfs_btree_node
91
 
{
92
 
  grub_uint32_t key;
93
 
  grub_uint32_t data;
94
 
} __attribute__ ((packed));
95
 
 
96
 
struct grub_sfs_btree_extent
97
 
{
98
 
  grub_uint32_t key;
99
 
  grub_uint32_t next;
100
 
  grub_uint32_t prev;
101
 
  grub_uint16_t size;
102
 
} __attribute__ ((packed));
103
 
 
104
 
struct grub_sfs_btree
105
 
{
106
 
  struct grub_sfs_bheader header;
107
 
  grub_uint16_t nodes;
108
 
  grub_uint8_t leaf;
109
 
  grub_uint8_t nodesize;
110
 
  /* Normally this can be kind of node, but just extents are
111
 
     supported.  */
112
 
  struct grub_sfs_btree_node node[1];
113
 
} __attribute__ ((packed));
114
 
 
115
 
 
116
 
 
117
 
struct grub_fshelp_node
118
 
{
119
 
  struct grub_sfs_data *data;
120
 
  int block;
121
 
  int size;
122
 
};
123
 
 
124
 
/* Information about a "mounted" sfs filesystem.  */
125
 
struct grub_sfs_data
126
 
{
127
 
  struct grub_sfs_rblock rblock;
128
 
  struct grub_fshelp_node diropen;
129
 
  grub_disk_t disk;
130
 
 
131
 
  /* Blocksize in sectors.  */
132
 
  unsigned int blocksize;
133
 
 
134
 
  /* Label of the filesystem.  */
135
 
  char *label;
136
 
};
137
 
 
138
 
static grub_dl_t my_mod;
139
 
 
140
 
 
141
 
/* Lookup the extent starting with BLOCK in the filesystem described
142
 
   by DATA.  Return the extent size in SIZE and the following extent
143
 
   in NEXTEXT.  */
144
 
static grub_err_t
145
 
grub_sfs_read_extent (struct grub_sfs_data *data, unsigned int block,
146
 
                      int *size, int *nextext)
147
 
{
148
 
  char *treeblock;
149
 
  struct grub_sfs_btree *tree;
150
 
  int i;
151
 
  int next;
152
 
  int prev;
153
 
 
154
 
  treeblock = grub_malloc (data->blocksize);
155
 
  if (!block)
156
 
    return 0;
157
 
 
158
 
  next = grub_be_to_cpu32 (data->rblock.btree);
159
 
  tree = (struct grub_sfs_btree *) treeblock;
160
 
 
161
 
  /* Handle this level in the btree.  */
162
 
  do
163
 
    {
164
 
      prev = 0;
165
 
 
166
 
      grub_disk_read (data->disk, next, 0, data->blocksize, treeblock);
167
 
      if (grub_errno)
168
 
        {
169
 
          grub_free (treeblock);
170
 
          return grub_errno;
171
 
        }
172
 
 
173
 
      for (i = grub_be_to_cpu16 (tree->nodes) - 1; i >= 0; i--)
174
 
        {
175
 
 
176
 
#define EXTNODE(tree, index)                                            \
177
 
        ((struct grub_sfs_btree_node *) (((char *) &(tree)->node[0])    \
178
 
                                         + (index) * (tree)->nodesize))
179
 
 
180
 
          /* Follow the tree down to the leaf level.  */
181
 
          if ((grub_be_to_cpu32 (EXTNODE(tree, i)->key) <= block)
182
 
              && !tree->leaf)
183
 
            {
184
 
              next = grub_be_to_cpu32 (EXTNODE (tree, i)->data);
185
 
              break;
186
 
            }
187
 
 
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)
190
 
            {
191
 
              struct grub_sfs_btree_extent *extent;
192
 
              extent = (struct grub_sfs_btree_extent *) EXTNODE (tree, i);
193
 
 
194
 
              /* We found a correct leaf.  */
195
 
              *size = grub_be_to_cpu16 (extent->size);
196
 
              *nextext = grub_be_to_cpu32 (extent->next);
197
 
 
198
 
              grub_free (treeblock);
199
 
              return 0;
200
 
            }
201
 
 
202
 
#undef EXTNODE
203
 
 
204
 
        }
205
 
    } while (!tree->leaf);
206
 
 
207
 
  grub_free (treeblock);
208
 
 
209
 
  return grub_error (GRUB_ERR_FILE_READ_ERROR, "SFS extent not found");
210
 
}
211
 
 
212
 
static grub_disk_addr_t
213
 
grub_sfs_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
214
 
{
215
 
  int blk = node->block;
216
 
  int size = 0;
217
 
  int next = 0;
218
 
 
219
 
  while (blk)
220
 
    {
221
 
      grub_err_t err;
222
 
 
223
 
      /* In case of the first block we don't have to lookup the
224
 
         extent, the minimum size is always 1.  */
225
 
      if (fileblock == 0)
226
 
        return blk;
227
 
 
228
 
      err = grub_sfs_read_extent (node->data, blk, &size, &next);
229
 
      if (err)
230
 
        return 0;
231
 
 
232
 
      if (fileblock < (unsigned int) size)
233
 
        return fileblock + blk;
234
 
 
235
 
      fileblock -= size;
236
 
 
237
 
      blk = next;
238
 
    }
239
 
 
240
 
  grub_error (GRUB_ERR_FILE_READ_ERROR,
241
 
              "reading a SFS block outside the extent");
242
 
 
243
 
  return 0;
244
 
}
245
 
 
246
 
 
247
 
/* Read LEN bytes from the file described by DATA starting with byte
248
 
   POS.  Return the amount of read bytes in READ.  */
249
 
static grub_ssize_t
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)
254
 
{
255
 
  return grub_fshelp_read_file (node->data->disk, node, read_hook,
256
 
                                pos, len, buf, grub_sfs_read_block,
257
 
                                node->size, 0);
258
 
}
259
 
 
260
 
 
261
 
static struct grub_sfs_data *
262
 
grub_sfs_mount (grub_disk_t disk)
263
 
{
264
 
  struct grub_sfs_data *data;
265
 
  struct grub_sfs_objc *rootobjc;
266
 
  char *rootobjc_data = 0;
267
 
  unsigned int blk;
268
 
 
269
 
  data = grub_malloc (sizeof (*data));
270
 
  if (!data)
271
 
    return 0;
272
 
 
273
 
  /* Read the rootblock.  */
274
 
  grub_disk_read (disk, 0, 0, sizeof (struct grub_sfs_rblock),
275
 
                  &data->rblock);
276
 
  if (grub_errno)
277
 
    goto fail;
278
 
 
279
 
  /* Make sure this is a sfs filesystem.  */
280
 
  if (grub_strncmp ((char *) (data->rblock.header.magic), "SFS", 4))
281
 
    {
282
 
      grub_error (GRUB_ERR_BAD_FS, "not a SFS filesystem");
283
 
      goto fail;
284
 
    }
285
 
 
286
 
  data->blocksize = grub_be_to_cpu32 (data->rblock.blocksize);
287
 
  rootobjc_data = grub_malloc (data->blocksize);
288
 
  if (! rootobjc_data)
289
 
    goto fail;
290
 
 
291
 
  /* Read the root object container.  */
292
 
  grub_disk_read (disk, grub_be_to_cpu32 (data->rblock.rootobject), 0,
293
 
                  data->blocksize, rootobjc_data);
294
 
  if (grub_errno)
295
 
    goto fail;
296
 
 
297
 
  rootobjc = (struct grub_sfs_objc *) rootobjc_data;
298
 
 
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;
303
 
  data->disk = disk;
304
 
  data->label = grub_strdup ((char *) (rootobjc->objects[0].filename));
305
 
 
306
 
  return data;
307
 
 
308
 
 fail:
309
 
  if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
310
 
    grub_error (GRUB_ERR_BAD_FS, "not an SFS filesystem");
311
 
 
312
 
  grub_free (data);
313
 
  grub_free (rootobjc_data);
314
 
  return 0;
315
 
}
316
 
 
317
 
 
318
 
static char *
319
 
grub_sfs_read_symlink (grub_fshelp_node_t node)
320
 
{
321
 
  struct grub_sfs_data *data = node->data;
322
 
  char *symlink;
323
 
  char *block;
324
 
 
325
 
  block = grub_malloc (data->blocksize);
326
 
  if (!block)
327
 
    return 0;
328
 
 
329
 
  grub_disk_read (data->disk, node->block, 0, data->blocksize, block);
330
 
  if (grub_errno)
331
 
    {
332
 
      grub_free (block);
333
 
      return 0;
334
 
    }
335
 
 
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]);
339
 
  grub_free (block);
340
 
  if (!symlink)
341
 
    return 0;
342
 
 
343
 
  return symlink;
344
 
}
345
 
 
346
 
static int
347
 
grub_sfs_iterate_dir (grub_fshelp_node_t dir,
348
 
                       int NESTED_FUNC_ATTR
349
 
                       (*hook) (const char *filename,
350
 
                                enum grub_fshelp_filetype filetype,
351
 
                                grub_fshelp_node_t node))
352
 
{
353
 
  struct grub_fshelp_node *node = 0;
354
 
  struct grub_sfs_data *data = dir->data;
355
 
  char *objc_data;
356
 
  struct grub_sfs_objc *objc;
357
 
  unsigned int next = dir->block;
358
 
  int pos;
359
 
 
360
 
  auto int NESTED_FUNC_ATTR grub_sfs_create_node (const char *name, int block,
361
 
                                                  int size, int type);
362
 
 
363
 
  int NESTED_FUNC_ATTR grub_sfs_create_node (const char *name, int block,
364
 
                                             int size, int type)
365
 
    {
366
 
      node = grub_malloc (sizeof (*node));
367
 
      if (!node)
368
 
        return 1;
369
 
 
370
 
      node->data = data;
371
 
      node->size = size;
372
 
      node->block = block;
373
 
 
374
 
      return hook (name, type, node);
375
 
    }
376
 
 
377
 
  objc_data = grub_malloc (data->blocksize);
378
 
  if (!objc_data)
379
 
    goto fail;
380
 
 
381
 
  /* The Object container can consist of multiple blocks, iterate over
382
 
     every block.  */
383
 
  while (next)
384
 
    {
385
 
      grub_disk_read (data->disk, next, 0, data->blocksize, objc_data);
386
 
      if (grub_errno)
387
 
        goto fail;
388
 
 
389
 
      objc = (struct grub_sfs_objc *) objc_data;
390
 
 
391
 
      pos = (char *) &objc->objects[0] - (char *) objc;
392
 
 
393
 
      /* Iterate over all entries in this block.  */
394
 
      while (pos + sizeof (struct grub_sfs_obj) < data->blocksize)
395
 
        {
396
 
          struct grub_sfs_obj *obj;
397
 
          obj = (struct grub_sfs_obj *) ((char *) objc + pos);
398
 
          char *filename = (char *) (obj->filename);
399
 
          int len;
400
 
          enum grub_fshelp_filetype type;
401
 
          unsigned int block;
402
 
 
403
 
          /* The filename and comment dynamically increase the size of
404
 
             the object.  */
405
 
          len = grub_strlen (filename);
406
 
          len += grub_strlen (filename + len + 1);
407
 
 
408
 
          pos += sizeof (*obj) + len;
409
 
          /* Round up to a multiple of two bytes.  */
410
 
          pos = ((pos + 1) >> 1) << 1;
411
 
 
412
 
          if (grub_strlen (filename) == 0)
413
 
            continue;
414
 
 
415
 
          /* First check if the file was not deleted.  */
416
 
          if (obj->type & GRUB_SFS_TYPE_DELETED)
417
 
            continue;
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;
422
 
          else
423
 
            type = GRUB_FSHELP_REG;
424
 
 
425
 
          if (type == GRUB_FSHELP_DIR)
426
 
            block = grub_be_to_cpu32 (obj->file_dir.dir.dir_objc);
427
 
          else
428
 
            block = grub_be_to_cpu32 (obj->file_dir.file.first_block);
429
 
 
430
 
          if (grub_sfs_create_node (filename, block,
431
 
                                    grub_be_to_cpu32 (obj->file_dir.file.size),
432
 
                                    type))
433
 
            {
434
 
              grub_free (objc_data);
435
 
              return 1;
436
 
            }
437
 
        }
438
 
 
439
 
      next = grub_be_to_cpu32 (objc->next);
440
 
    }
441
 
 
442
 
 fail:
443
 
  grub_free (objc_data);
444
 
  return 0;
445
 
}
446
 
 
447
 
 
448
 
/* Open a file named NAME and initialize FILE.  */
449
 
static grub_err_t
450
 
grub_sfs_open (struct grub_file *file, const char *name)
451
 
{
452
 
  struct grub_sfs_data *data;
453
 
  struct grub_fshelp_node *fdiro = 0;
454
 
 
455
 
  grub_dl_ref (my_mod);
456
 
 
457
 
  data = grub_sfs_mount (file->device->disk);
458
 
  if (!data)
459
 
    goto fail;
460
 
 
461
 
  grub_fshelp_find_file (name, &data->diropen, &fdiro, grub_sfs_iterate_dir,
462
 
                         grub_sfs_read_symlink, GRUB_FSHELP_REG);
463
 
  if (grub_errno)
464
 
    goto fail;
465
 
 
466
 
  file->size = fdiro->size;
467
 
  data->diropen = *fdiro;
468
 
  grub_free (fdiro);
469
 
 
470
 
  file->data = data;
471
 
  file->offset = 0;
472
 
 
473
 
  return 0;
474
 
 
475
 
 fail:
476
 
  if (data && fdiro != &data->diropen)
477
 
    grub_free (fdiro);
478
 
  if (data)
479
 
    grub_free (data->label);
480
 
  grub_free (data);
481
 
 
482
 
  grub_dl_unref (my_mod);
483
 
 
484
 
  return grub_errno;
485
 
}
486
 
 
487
 
 
488
 
static grub_err_t
489
 
grub_sfs_close (grub_file_t file)
490
 
{
491
 
  grub_free (file->data);
492
 
 
493
 
  grub_dl_unref (my_mod);
494
 
 
495
 
  return GRUB_ERR_NONE;
496
 
}
497
 
 
498
 
 
499
 
/* Read LEN bytes data from FILE into BUF.  */
500
 
static grub_ssize_t
501
 
grub_sfs_read (grub_file_t file, char *buf, grub_size_t len)
502
 
{
503
 
  struct grub_sfs_data *data = (struct grub_sfs_data *) file->data;
504
 
 
505
 
  int size = grub_sfs_read_file (&data->diropen, file->read_hook,
506
 
                                 file->offset, len, buf);
507
 
 
508
 
  return size;
509
 
}
510
 
 
511
 
 
512
 
static grub_err_t
513
 
grub_sfs_dir (grub_device_t device, const char *path,
514
 
               int (*hook) (const char *filename,
515
 
                            const struct grub_dirhook_info *info))
516
 
{
517
 
  struct grub_sfs_data *data = 0;
518
 
  struct grub_fshelp_node *fdiro = 0;
519
 
 
520
 
  auto int NESTED_FUNC_ATTR iterate (const char *filename,
521
 
                                     enum grub_fshelp_filetype filetype,
522
 
                                     grub_fshelp_node_t node);
523
 
 
524
 
  int NESTED_FUNC_ATTR iterate (const char *filename,
525
 
                                enum grub_fshelp_filetype filetype,
526
 
                                grub_fshelp_node_t node)
527
 
    {
528
 
      struct grub_dirhook_info info;
529
 
      grub_memset (&info, 0, sizeof (info));
530
 
      info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
531
 
      grub_free (node);
532
 
      return hook (filename, &info);
533
 
    }
534
 
 
535
 
  grub_dl_ref (my_mod);
536
 
 
537
 
  data = grub_sfs_mount (device->disk);
538
 
  if (!data)
539
 
    goto fail;
540
 
 
541
 
  grub_fshelp_find_file (path, &data->diropen, &fdiro, grub_sfs_iterate_dir,
542
 
                        grub_sfs_read_symlink, GRUB_FSHELP_DIR);
543
 
  if (grub_errno)
544
 
    goto fail;
545
 
 
546
 
  grub_sfs_iterate_dir (fdiro, iterate);
547
 
 
548
 
 fail:
549
 
  if (data && fdiro != &data->diropen)
550
 
    grub_free (fdiro);
551
 
  if (data)
552
 
    grub_free (data->label);
553
 
  grub_free (data);
554
 
 
555
 
  grub_dl_unref (my_mod);
556
 
 
557
 
  return grub_errno;
558
 
}
559
 
 
560
 
 
561
 
static grub_err_t
562
 
grub_sfs_label (grub_device_t device, char **label)
563
 
{
564
 
  struct grub_sfs_data *data;
565
 
  grub_disk_t disk = device->disk;
566
 
 
567
 
  data = grub_sfs_mount (disk);
568
 
  if (data)
569
 
    *label = data->label;
570
 
 
571
 
  grub_free (data);
572
 
 
573
 
  return grub_errno;
574
 
}
575
 
 
576
 
 
577
 
static struct grub_fs grub_sfs_fs =
578
 
  {
579
 
    .name = "sfs",
580
 
    .dir = grub_sfs_dir,
581
 
    .open = grub_sfs_open,
582
 
    .read = grub_sfs_read,
583
 
    .close = grub_sfs_close,
584
 
    .label = grub_sfs_label,
585
 
    .next = 0
586
 
  };
587
 
 
588
 
GRUB_MOD_INIT(sfs)
589
 
{
590
 
  grub_fs_register (&grub_sfs_fs);
591
 
  my_mod = mod;
592
 
}
593
 
 
594
 
GRUB_MOD_FINI(sfs)
595
 
{
596
 
  grub_fs_unregister (&grub_sfs_fs);
597
 
}