← Back to branch summary

~darkmuggle-deactivatedaccount/ubuntu/quantal/grub2/fix-872244

« back to all changes in this revision

Viewing changes to fs/affs.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/affs.c
1
 
/* affs.c - Amiga Fast 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 affs bootblock.  */
30
 
struct grub_affs_bblock
31
 
{
32
 
  grub_uint8_t type[3];
33
 
  grub_uint8_t flags;
34
 
  grub_uint32_t checksum;
35
 
  grub_uint32_t rootblock;
36
 
} __attribute__ ((packed));
37
 
 
38
 
/* Set if the filesystem is a AFFS filesystem.  Otherwise this is an
39
 
   OFS filesystem.  */
40
 
#define GRUB_AFFS_FLAG_FFS      1
41
 
 
42
 
/* The affs rootblock.  */
43
 
struct grub_affs_rblock
44
 
{
45
 
  grub_uint8_t type[4];
46
 
  grub_uint8_t unused1[8];
47
 
  grub_uint32_t htsize;
48
 
  grub_uint32_t unused2;
49
 
  grub_uint32_t checksum;
50
 
  grub_uint32_t hashtable[1];
51
 
} __attribute__ ((packed));
52
 
 
53
 
/* The second part of a file header block.  */
54
 
struct grub_affs_file
55
 
{
56
 
  grub_uint8_t unused1[12];
57
 
  grub_uint32_t size;
58
 
  grub_uint8_t unused2[104];
59
 
  grub_uint8_t namelen;
60
 
  grub_uint8_t name[30];
61
 
  grub_uint8_t unused3[33];
62
 
  grub_uint32_t next;
63
 
  grub_uint32_t parent;
64
 
  grub_uint32_t extension;
65
 
  grub_int32_t type;
66
 
} __attribute__ ((packed));
67
 
 
68
 
/* The location of `struct grub_affs_file' relative to the end of a
69
 
   file header block.  */
70
 
#define GRUB_AFFS_FILE_LOCATION         200
71
 
 
72
 
/* The offset in both the rootblock and the file header block for the
73
 
   hashtable, symlink and block pointers (all synonyms).  */
74
 
#define GRUB_AFFS_HASHTABLE_OFFSET      24
75
 
#define GRUB_AFFS_BLOCKPTR_OFFSET       24
76
 
#define GRUB_AFFS_SYMLINK_OFFSET        24
77
 
 
78
 
#define GRUB_AFFS_SYMLINK_SIZE(blocksize) ((blocksize) - 225)
79
 
 
80
 
#define GRUB_AFFS_FILETYPE_DIR          -3
81
 
#define GRUB_AFFS_FILETYPE_REG          2
82
 
#define GRUB_AFFS_FILETYPE_SYMLINK      3
83
 
 
84
 
 
85
 
struct grub_fshelp_node
86
 
{
87
 
  struct grub_affs_data *data;
88
 
  int block;
89
 
  int size;
90
 
  int parent;
91
 
};
92
 
 
93
 
/* Information about a "mounted" affs filesystem.  */
94
 
struct grub_affs_data
95
 
{
96
 
  struct grub_affs_bblock bblock;
97
 
  struct grub_fshelp_node diropen;
98
 
  grub_disk_t disk;
99
 
 
100
 
  /* Blocksize in sectors.  */
101
 
  int blocksize;
102
 
 
103
 
  /* The number of entries in the hashtable.  */
104
 
  int htsize;
105
 
};
106
 
 
107
 
static grub_dl_t my_mod;
108
 
 
109
 
 
110
 
static grub_disk_addr_t
111
 
grub_affs_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
112
 
{
113
 
  int links;
114
 
  grub_uint32_t pos;
115
 
  int block = node->block;
116
 
  struct grub_affs_file file;
117
 
  struct grub_affs_data *data = node->data;
118
 
  grub_uint32_t mod;
119
 
 
120
 
  /* Find the block that points to the fileblock we are looking up by
121
 
     following the chain until the right table is reached.  */
122
 
  for (links = grub_divmod64 (fileblock, data->htsize, &mod); links; links--)
123
 
    {
124
 
      grub_disk_read (data->disk, block + data->blocksize - 1,
125
 
                      data->blocksize * (GRUB_DISK_SECTOR_SIZE
126
 
                                         - GRUB_AFFS_FILE_LOCATION),
127
 
                      sizeof (file), &file);
128
 
      if (grub_errno)
129
 
        return 0;
130
 
 
131
 
      block = grub_be_to_cpu32 (file.extension);
132
 
    }
133
 
 
134
 
  /* Translate the fileblock to the block within the right table.  */
135
 
  fileblock = mod;
136
 
  grub_disk_read (data->disk, block,
137
 
                  GRUB_AFFS_BLOCKPTR_OFFSET
138
 
                  + (data->htsize - fileblock - 1) * sizeof (pos),
139
 
                  sizeof (pos), &pos);
140
 
  if (grub_errno)
141
 
    return 0;
142
 
 
143
 
  return grub_be_to_cpu32 (pos);
144
 
}
145
 
 
146
 
 
147
 
/* Read LEN bytes from the file described by DATA starting with byte
148
 
   POS.  Return the amount of read bytes in READ.  */
149
 
static grub_ssize_t
150
 
grub_affs_read_file (grub_fshelp_node_t node,
151
 
                     void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
152
 
                                        unsigned offset, unsigned length),
153
 
                     int pos, grub_size_t len, char *buf)
154
 
{
155
 
  return grub_fshelp_read_file (node->data->disk, node, read_hook,
156
 
                                pos, len, buf, grub_affs_read_block,
157
 
                                node->size, 0);
158
 
}
159
 
 
160
 
 
161
 
static struct grub_affs_data *
162
 
grub_affs_mount (grub_disk_t disk)
163
 
{
164
 
  struct grub_affs_data *data;
165
 
  grub_uint32_t *rootblock = 0;
166
 
  struct grub_affs_rblock *rblock;
167
 
 
168
 
  int checksum = 0;
169
 
  int checksumr = 0;
170
 
  int blocksize = 0;
171
 
 
172
 
  data = grub_malloc (sizeof (struct grub_affs_data));
173
 
  if (!data)
174
 
    return 0;
175
 
 
176
 
  /* Read the bootblock.  */
177
 
  grub_disk_read (disk, 0, 0, sizeof (struct grub_affs_bblock),
178
 
                  &data->bblock);
179
 
  if (grub_errno)
180
 
    goto fail;
181
 
 
182
 
  /* Make sure this is an affs filesystem.  */
183
 
  if (grub_strncmp ((char *) (data->bblock.type), "DOS", 3))
184
 
    {
185
 
      grub_error (GRUB_ERR_BAD_FS, "not an AFFS filesystem");
186
 
      goto fail;
187
 
    }
188
 
 
189
 
  /* Test if the filesystem is a OFS filesystem.  */
190
 
  if (! (data->bblock.flags & GRUB_AFFS_FLAG_FFS))
191
 
    {
192
 
      grub_error (GRUB_ERR_BAD_FS, "OFS not yet supported");
193
 
      goto fail;
194
 
    }
195
 
 
196
 
  /* Read the bootblock.  */
197
 
  grub_disk_read (disk, 0, 0, sizeof (struct grub_affs_bblock),
198
 
                  &data->bblock);
199
 
  if (grub_errno)
200
 
    goto fail;
201
 
 
202
 
  /* No sane person uses more than 8KB for a block.  At least I hope
203
 
     for that person because in that case this won't work.  */
204
 
  rootblock = grub_malloc (GRUB_DISK_SECTOR_SIZE * 16);
205
 
  if (!rootblock)
206
 
    goto fail;
207
 
 
208
 
  rblock = (struct grub_affs_rblock *) rootblock;
209
 
 
210
 
  /* Read the rootblock.  */
211
 
  grub_disk_read (disk, (disk->total_sectors >> 1) + blocksize, 0,
212
 
                  GRUB_DISK_SECTOR_SIZE * 16, rootblock);
213
 
  if (grub_errno)
214
 
    goto fail;
215
 
 
216
 
  /* The filesystem blocksize is not stored anywhere in the filesystem
217
 
     itself.  One way to determine it is reading blocks for the
218
 
     rootblock until the checksum is correct.  */
219
 
  checksumr = grub_be_to_cpu32 (rblock->checksum);
220
 
  rblock->checksum = 0;
221
 
  for (blocksize = 0; blocksize < 8; blocksize++)
222
 
    {
223
 
      grub_uint32_t *currblock = rootblock + GRUB_DISK_SECTOR_SIZE * blocksize;
224
 
      unsigned int i;
225
 
 
226
 
      for (i = 0; i < GRUB_DISK_SECTOR_SIZE / sizeof (*currblock); i++)
227
 
        checksum += grub_be_to_cpu32 (currblock[i]);
228
 
 
229
 
      if (checksumr == -checksum)
230
 
        break;
231
 
    }
232
 
  if (-checksum != checksumr)
233
 
    {
234
 
      grub_error (GRUB_ERR_BAD_FS, "AFFS blocksize couldn't be determined");
235
 
      goto fail;
236
 
    }
237
 
  blocksize++;
238
 
 
239
 
  data->blocksize = blocksize;
240
 
  data->disk = disk;
241
 
  data->htsize = grub_be_to_cpu32 (rblock->htsize);
242
 
  data->diropen.data = data;
243
 
  data->diropen.block = (disk->total_sectors >> 1);
244
 
 
245
 
  grub_free (rootblock);
246
 
 
247
 
  return data;
248
 
 
249
 
 fail:
250
 
  if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
251
 
    grub_error (GRUB_ERR_BAD_FS, "not an AFFS filesystem");
252
 
 
253
 
  grub_free (data);
254
 
  grub_free (rootblock);
255
 
  return 0;
256
 
}
257
 
 
258
 
 
259
 
static char *
260
 
grub_affs_read_symlink (grub_fshelp_node_t node)
261
 
{
262
 
  struct grub_affs_data *data = node->data;
263
 
  char *symlink;
264
 
 
265
 
  symlink = grub_malloc (GRUB_AFFS_SYMLINK_SIZE (data->blocksize));
266
 
  if (!symlink)
267
 
    return 0;
268
 
 
269
 
  grub_disk_read (data->disk, node->block, GRUB_AFFS_SYMLINK_OFFSET,
270
 
                  GRUB_AFFS_SYMLINK_SIZE (data->blocksize), symlink);
271
 
  if (grub_errno)
272
 
    {
273
 
      grub_free (symlink);
274
 
      return 0;
275
 
    }
276
 
  grub_dprintf ("affs", "Symlink: `%s'\n", symlink);
277
 
  return symlink;
278
 
}
279
 
 
280
 
 
281
 
static int
282
 
grub_affs_iterate_dir (grub_fshelp_node_t dir,
283
 
                       int NESTED_FUNC_ATTR
284
 
                       (*hook) (const char *filename,
285
 
                                enum grub_fshelp_filetype filetype,
286
 
                                grub_fshelp_node_t node))
287
 
{
288
 
  int i;
289
 
  struct grub_affs_file file;
290
 
  struct grub_fshelp_node *node = 0;
291
 
  struct grub_affs_data *data = dir->data;
292
 
  grub_uint32_t *hashtable;
293
 
 
294
 
  auto int NESTED_FUNC_ATTR grub_affs_create_node (const char *name, int block,
295
 
                                                   int size, int type);
296
 
 
297
 
  int NESTED_FUNC_ATTR grub_affs_create_node (const char *name, int block,
298
 
                                              int size, int type)
299
 
    {
300
 
      node = grub_malloc (sizeof (*node));
301
 
      if (!node)
302
 
        {
303
 
          grub_free (hashtable);
304
 
          return 1;
305
 
        }
306
 
 
307
 
      node->data = data;
308
 
      node->size = size;
309
 
      node->block = block;
310
 
      node->parent = grub_be_to_cpu32 (file.parent);
311
 
 
312
 
      if (hook (name, type, node))
313
 
        {
314
 
          grub_free (hashtable);
315
 
          return 1;
316
 
        }
317
 
      return 0;
318
 
    }
319
 
 
320
 
  hashtable = grub_malloc (data->htsize * sizeof (*hashtable));
321
 
  if (!hashtable)
322
 
    return 1;
323
 
 
324
 
  grub_disk_read (data->disk, dir->block, GRUB_AFFS_HASHTABLE_OFFSET,
325
 
                  data->htsize * sizeof (*hashtable), (char *) hashtable);
326
 
  if (grub_errno)
327
 
    goto fail;
328
 
 
329
 
  /* Create the directory entries for `.' and `..'.  */
330
 
  if (grub_affs_create_node (".", dir->block, dir->size, GRUB_FSHELP_DIR))
331
 
    return 1;
332
 
  if (grub_affs_create_node ("..", dir->parent ? dir->parent : dir->block,
333
 
                             dir->size, GRUB_FSHELP_DIR))
334
 
    return 1;
335
 
 
336
 
  for (i = 0; i < data->htsize; i++)
337
 
    {
338
 
      enum grub_fshelp_filetype type;
339
 
      grub_uint64_t next;
340
 
 
341
 
      if (!hashtable[i])
342
 
        continue;
343
 
 
344
 
      /* Every entry in the hashtable can be chained.  Read the entire
345
 
         chain.  */
346
 
      next = grub_be_to_cpu32 (hashtable[i]);
347
 
 
348
 
      while (next)
349
 
        {
350
 
          grub_disk_read (data->disk, next + data->blocksize - 1,
351
 
                          data->blocksize * GRUB_DISK_SECTOR_SIZE
352
 
                          - GRUB_AFFS_FILE_LOCATION,
353
 
                          sizeof (file), (char *) &file);
354
 
          if (grub_errno)
355
 
            goto fail;
356
 
 
357
 
          file.name[file.namelen] = '\0';
358
 
 
359
 
          if ((int) grub_be_to_cpu32 (file.type) == GRUB_AFFS_FILETYPE_DIR)
360
 
            type = GRUB_FSHELP_REG;
361
 
          else if (grub_be_to_cpu32 (file.type) == GRUB_AFFS_FILETYPE_REG)
362
 
            type = GRUB_FSHELP_DIR;
363
 
          else if (grub_be_to_cpu32 (file.type) == GRUB_AFFS_FILETYPE_SYMLINK)
364
 
            type = GRUB_FSHELP_SYMLINK;
365
 
          else
366
 
            type = GRUB_FSHELP_UNKNOWN;
367
 
 
368
 
          if (grub_affs_create_node ((char *) (file.name), next,
369
 
                                     grub_be_to_cpu32 (file.size), type))
370
 
            return 1;
371
 
 
372
 
          next = grub_be_to_cpu32 (file.next);
373
 
        }
374
 
    }
375
 
 
376
 
  grub_free (hashtable);
377
 
  return 0;
378
 
 
379
 
 fail:
380
 
  grub_free (node);
381
 
  grub_free (hashtable);
382
 
  return 0;
383
 
}
384
 
 
385
 
 
386
 
/* Open a file named NAME and initialize FILE.  */
387
 
static grub_err_t
388
 
grub_affs_open (struct grub_file *file, const char *name)
389
 
{
390
 
  struct grub_affs_data *data;
391
 
  struct grub_fshelp_node *fdiro = 0;
392
 
 
393
 
  grub_dl_ref (my_mod);
394
 
 
395
 
  data = grub_affs_mount (file->device->disk);
396
 
  if (!data)
397
 
    goto fail;
398
 
 
399
 
  grub_fshelp_find_file (name, &data->diropen, &fdiro, grub_affs_iterate_dir,
400
 
                         grub_affs_read_symlink, GRUB_FSHELP_REG);
401
 
  if (grub_errno)
402
 
    goto fail;
403
 
 
404
 
  file->size = fdiro->size;
405
 
  data->diropen = *fdiro;
406
 
  grub_free (fdiro);
407
 
 
408
 
  file->data = data;
409
 
  file->offset = 0;
410
 
 
411
 
  return 0;
412
 
 
413
 
 fail:
414
 
  if (data && fdiro != &data->diropen)
415
 
    grub_free (fdiro);
416
 
  grub_free (data);
417
 
 
418
 
  grub_dl_unref (my_mod);
419
 
 
420
 
  return grub_errno;
421
 
}
422
 
 
423
 
 
424
 
static grub_err_t
425
 
grub_affs_close (grub_file_t file)
426
 
{
427
 
  grub_free (file->data);
428
 
 
429
 
  grub_dl_unref (my_mod);
430
 
 
431
 
  return GRUB_ERR_NONE;
432
 
}
433
 
 
434
 
 
435
 
/* Read LEN bytes data from FILE into BUF.  */
436
 
static grub_ssize_t
437
 
grub_affs_read (grub_file_t file, char *buf, grub_size_t len)
438
 
{
439
 
  struct grub_affs_data *data =
440
 
    (struct grub_affs_data *) file->data;
441
 
 
442
 
  int size = grub_affs_read_file (&data->diropen, file->read_hook,
443
 
                              file->offset, len, buf);
444
 
 
445
 
  return size;
446
 
}
447
 
 
448
 
 
449
 
static grub_err_t
450
 
grub_affs_dir (grub_device_t device, const char *path,
451
 
               int (*hook) (const char *filename,
452
 
                            const struct grub_dirhook_info *info))
453
 
{
454
 
  struct grub_affs_data *data = 0;
455
 
  struct grub_fshelp_node *fdiro = 0;
456
 
 
457
 
  auto int NESTED_FUNC_ATTR iterate (const char *filename,
458
 
                                     enum grub_fshelp_filetype filetype,
459
 
                                     grub_fshelp_node_t node);
460
 
 
461
 
  int NESTED_FUNC_ATTR iterate (const char *filename,
462
 
                                enum grub_fshelp_filetype filetype,
463
 
                                grub_fshelp_node_t node)
464
 
    {
465
 
      struct grub_dirhook_info info;
466
 
      grub_memset (&info, 0, sizeof (info));
467
 
      info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
468
 
      grub_free (node);
469
 
      return hook (filename, &info);
470
 
    }
471
 
 
472
 
  grub_dl_ref (my_mod);
473
 
 
474
 
  data = grub_affs_mount (device->disk);
475
 
  if (!data)
476
 
    goto fail;
477
 
 
478
 
  grub_fshelp_find_file (path, &data->diropen, &fdiro, grub_affs_iterate_dir,
479
 
                         grub_affs_read_symlink, GRUB_FSHELP_DIR);
480
 
  if (grub_errno)
481
 
    goto fail;
482
 
 
483
 
  grub_affs_iterate_dir (fdiro, iterate);
484
 
 
485
 
 fail:
486
 
  if (data && fdiro != &data->diropen)
487
 
    grub_free (fdiro);
488
 
  grub_free (data);
489
 
 
490
 
  grub_dl_unref (my_mod);
491
 
 
492
 
  return grub_errno;
493
 
}
494
 
 
495
 
 
496
 
static grub_err_t
497
 
grub_affs_label (grub_device_t device, char **label)
498
 
{
499
 
  struct grub_affs_data *data;
500
 
  struct grub_affs_file file;
501
 
  grub_disk_t disk = device->disk;
502
 
 
503
 
  grub_dl_ref (my_mod);
504
 
 
505
 
  data = grub_affs_mount (disk);
506
 
  if (data)
507
 
    {
508
 
      /* The rootblock maps quite well on a file header block, it's
509
 
         something we can use here.  */
510
 
      grub_disk_read (data->disk, disk->total_sectors >> 1,
511
 
                      data->blocksize * (GRUB_DISK_SECTOR_SIZE
512
 
                                         - GRUB_AFFS_FILE_LOCATION),
513
 
                      sizeof (file), &file);
514
 
      if (grub_errno)
515
 
        return 0;
516
 
 
517
 
      *label = grub_strndup ((char *) (file.name), file.namelen);
518
 
    }
519
 
  else
520
 
    *label = 0;
521
 
 
522
 
  grub_dl_unref (my_mod);
523
 
 
524
 
  grub_free (data);
525
 
 
526
 
  return grub_errno;
527
 
}
528
 
 
529
 
 
530
 
static struct grub_fs grub_affs_fs =
531
 
  {
532
 
    .name = "affs",
533
 
    .dir = grub_affs_dir,
534
 
    .open = grub_affs_open,
535
 
    .read = grub_affs_read,
536
 
    .close = grub_affs_close,
537
 
    .label = grub_affs_label,
538
 
    .next = 0
539
 
  };
540
 
 
541
 
GRUB_MOD_INIT(affs)
542
 
{
543
 
  grub_fs_register (&grub_affs_fs);
544
 
  my_mod = mod;
545
 
}
546
 
 
547
 
GRUB_MOD_FINI(affs)
548
 
{
549
 
  grub_fs_unregister (&grub_affs_fs);
550
 
}