source: grub-pc/trunk/fuentes/grub-core/fs/minix.c @ 22

Last change on this file since 22 was 22, checked in by mabarracus, 4 years ago

updated version and apply net.ifnames=0 into debian/rules

File size: 18.3 KB
Line 
1/* minix.c - The minix filesystem, version 1 and 2.  */
2/*
3 *  GRUB  --  GRand Unified Bootloader
4 *  Copyright (C) 2004,2005,2006,2007,2008  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/i18n.h>
28
29GRUB_MOD_LICENSE ("GPLv3+");
30
31#ifdef MODE_MINIX3
32#define GRUB_MINIX_MAGIC        0x4D5A
33#elif defined(MODE_MINIX2)
34#define GRUB_MINIX_MAGIC        0x2468
35#define GRUB_MINIX_MAGIC_30     0x2478
36#else
37#define GRUB_MINIX_MAGIC        0x137F
38#define GRUB_MINIX_MAGIC_30     0x138F
39#endif
40
41#define GRUB_MINIX_INODE_DIR_BLOCKS     7
42#define GRUB_MINIX_LOG2_BSIZE   1
43#define GRUB_MINIX_ROOT_INODE   1
44#define GRUB_MINIX_MAX_SYMLNK_CNT       8
45#define GRUB_MINIX_SBLOCK       2
46
47#define GRUB_MINIX_IFDIR        0040000U
48#define GRUB_MINIX_IFLNK        0120000U
49
50#ifdef MODE_BIGENDIAN
51#define grub_cpu_to_minix16_compile_time grub_cpu_to_be16_compile_time
52#define grub_minix_to_cpu16 grub_be_to_cpu16
53#define grub_minix_to_cpu32 grub_be_to_cpu32
54#else
55#define grub_cpu_to_minix16_compile_time grub_cpu_to_le16_compile_time
56#define grub_minix_to_cpu16 grub_le_to_cpu16
57#define grub_minix_to_cpu32 grub_le_to_cpu32
58#endif
59
60#if defined(MODE_MINIX2) || defined(MODE_MINIX3)
61typedef grub_uint32_t grub_minix_uintn_t;
62#define grub_minix_to_cpu_n grub_minix_to_cpu32
63#else
64typedef grub_uint16_t grub_minix_uintn_t;
65#define grub_minix_to_cpu_n grub_minix_to_cpu16
66#endif
67
68#define GRUB_MINIX_INODE_BLKSZ(data) sizeof (grub_minix_uintn_t)
69#ifdef MODE_MINIX3
70typedef grub_uint32_t grub_minix_ino_t;
71#define grub_minix_to_cpu_ino grub_minix_to_cpu32
72#else
73typedef grub_uint16_t grub_minix_ino_t;
74#define grub_minix_to_cpu_ino grub_minix_to_cpu16
75#endif
76
77#define GRUB_MINIX_INODE_SIZE(data) (grub_minix_to_cpu32 (data->inode.size))
78#define GRUB_MINIX_INODE_MODE(data) (grub_minix_to_cpu16 (data->inode.mode))
79#define GRUB_MINIX_INODE_DIR_ZONES(data,blk) (grub_minix_to_cpu_n   \
80                                              (data->inode.dir_zones[blk]))
81#define GRUB_MINIX_INODE_INDIR_ZONE(data)  (grub_minix_to_cpu_n \
82                                            (data->inode.indir_zone))
83#define GRUB_MINIX_INODE_DINDIR_ZONE(data) (grub_minix_to_cpu_n \
84                                            (data->inode.double_indir_zone))
85
86#ifndef MODE_MINIX3
87#define GRUB_MINIX_LOG2_ZONESZ  (GRUB_MINIX_LOG2_BSIZE                          \
88                                 + grub_minix_to_cpu16 (data->sblock.log2_zone_size))
89#endif
90#define GRUB_MINIX_ZONESZ       ((grub_uint64_t) data->block_size <<                    \
91                                 (GRUB_DISK_SECTOR_BITS + grub_minix_to_cpu16 (data->sblock.log2_zone_size)))
92
93#ifdef MODE_MINIX3
94#define GRUB_MINIX_ZONE2SECT(zone) ((zone) * data->block_size)
95#else
96#define GRUB_MINIX_ZONE2SECT(zone) ((zone) << GRUB_MINIX_LOG2_ZONESZ)
97#endif
98
99
100#ifdef MODE_MINIX3
101struct grub_minix_sblock
102{
103  grub_uint32_t inode_cnt;
104  grub_uint16_t zone_cnt;
105  grub_uint16_t inode_bmap_size;
106  grub_uint16_t zone_bmap_size;
107  grub_uint16_t first_data_zone;
108  grub_uint16_t log2_zone_size;
109  grub_uint16_t pad;
110  grub_uint32_t max_file_size;
111  grub_uint32_t zones;
112  grub_uint16_t magic;
113 
114  grub_uint16_t pad2;
115  grub_uint16_t block_size;
116  grub_uint8_t disk_version; 
117};
118#else
119struct grub_minix_sblock
120{
121  grub_uint16_t inode_cnt;
122  grub_uint16_t zone_cnt;
123  grub_uint16_t inode_bmap_size;
124  grub_uint16_t zone_bmap_size;
125  grub_uint16_t first_data_zone;
126  grub_uint16_t log2_zone_size;
127  grub_uint32_t max_file_size;
128  grub_uint16_t magic;
129};
130#endif
131
132#if defined(MODE_MINIX3) || defined(MODE_MINIX2)
133struct grub_minix_inode
134{
135  grub_uint16_t mode;
136  grub_uint16_t nlinks;
137  grub_uint16_t uid;
138  grub_uint16_t gid;
139  grub_uint32_t size;
140  grub_uint32_t atime;
141  grub_uint32_t mtime;
142  grub_uint32_t ctime;
143  grub_uint32_t dir_zones[7];
144  grub_uint32_t indir_zone;
145  grub_uint32_t double_indir_zone;
146  grub_uint32_t triple_indir_zone;
147};
148#else
149struct grub_minix_inode
150{
151  grub_uint16_t mode;
152  grub_uint16_t uid;
153  grub_uint32_t size;
154  grub_uint32_t mtime;
155  grub_uint8_t gid;
156  grub_uint8_t nlinks;
157  grub_uint16_t dir_zones[7];
158  grub_uint16_t indir_zone;
159  grub_uint16_t double_indir_zone;
160};
161
162#endif
163
164#if defined(MODE_MINIX3)
165#define MAX_MINIX_FILENAME_SIZE 60
166#else
167#define MAX_MINIX_FILENAME_SIZE 30
168#endif
169
170/* Information about a "mounted" minix filesystem.  */
171struct grub_minix_data
172{
173  struct grub_minix_sblock sblock;
174  struct grub_minix_inode inode;
175  grub_minix_ino_t ino;
176  int linknest;
177  grub_disk_t disk;
178  int filename_size;
179  grub_size_t block_size;
180};
181
182static grub_dl_t my_mod;
183
184static grub_err_t grub_minix_find_file (struct grub_minix_data *data,
185                                        const char *path);
186
187  /* Read the block pointer in ZONE, on the offset NUM.  */
188static grub_minix_uintn_t
189grub_get_indir (struct grub_minix_data *data, 
190                 grub_minix_uintn_t zone,
191                 grub_minix_uintn_t num)
192{
193  grub_minix_uintn_t indirn;
194  grub_disk_read (data->disk,
195                  GRUB_MINIX_ZONE2SECT(zone),
196                  sizeof (grub_minix_uintn_t) * num,
197                  sizeof (grub_minix_uintn_t), (char *) &indirn);
198  return grub_minix_to_cpu_n (indirn);
199}
200
201static grub_minix_uintn_t
202grub_minix_get_file_block (struct grub_minix_data *data, unsigned int blk)
203{
204  grub_minix_uintn_t indir;
205  const grub_uint32_t block_per_zone = (GRUB_MINIX_ZONESZ
206                                        / GRUB_MINIX_INODE_BLKSZ (data));
207
208  /* Direct block.  */
209  if (blk < GRUB_MINIX_INODE_DIR_BLOCKS)
210    return GRUB_MINIX_INODE_DIR_ZONES (data, blk);
211
212  /* Indirect block.  */
213  blk -= GRUB_MINIX_INODE_DIR_BLOCKS;
214  if (blk < block_per_zone)
215    {
216      indir = grub_get_indir (data, GRUB_MINIX_INODE_INDIR_ZONE (data), blk);
217      return indir;
218    }
219
220  /* Double indirect block.  */
221  blk -= block_per_zone;
222  if (blk < block_per_zone * block_per_zone)
223    {
224      indir = grub_get_indir (data, GRUB_MINIX_INODE_DINDIR_ZONE (data),
225                              blk / block_per_zone);
226
227      indir = grub_get_indir (data, indir, blk % block_per_zone);
228
229      return indir;
230    }
231
232#if defined (MODE_MINIX3) || defined (MODE_MINIX2)
233  blk -= block_per_zone * block_per_zone;
234  if (blk < ((grub_uint64_t) block_per_zone * (grub_uint64_t) block_per_zone
235             * (grub_uint64_t) block_per_zone))
236    {
237      indir = grub_get_indir (data, grub_minix_to_cpu_n (data->inode.triple_indir_zone),
238                              (blk / block_per_zone) / block_per_zone);
239      indir = grub_get_indir (data, indir, (blk / block_per_zone) % block_per_zone);
240      indir = grub_get_indir (data, indir, blk % block_per_zone);
241
242      return indir;
243    }
244#endif
245
246  /* This should never happen.  */
247  grub_error (GRUB_ERR_OUT_OF_RANGE, "file bigger than maximum size");
248
249  return 0;
250}
251
252
253/* Read LEN bytes from the file described by DATA starting with byte
254   POS.  Return the amount of read bytes in READ.  */
255static grub_ssize_t
256grub_minix_read_file (struct grub_minix_data *data,
257                      grub_disk_read_hook_t read_hook, void *read_hook_data,
258                      grub_off_t pos, grub_size_t len, char *buf)
259{
260  grub_uint32_t i;
261  grub_uint32_t blockcnt;
262  grub_uint32_t posblock;
263  grub_uint32_t blockoff;
264
265  /* Adjust len so it we can't read past the end of the file.  */
266  if (len + pos > GRUB_MINIX_INODE_SIZE (data))
267    len = GRUB_MINIX_INODE_SIZE (data) - pos;
268  if (len == 0)
269    return 0;
270
271  /* Files are at most 2G/4G - 1 bytes on minixfs. Avoid 64-bit division.  */
272  blockcnt = ((grub_uint32_t) ((len + pos - 1)
273               >> GRUB_DISK_SECTOR_BITS)) / data->block_size + 1;
274  posblock = (((grub_uint32_t) pos)
275              / (data->block_size << GRUB_DISK_SECTOR_BITS));
276  blockoff = (((grub_uint32_t) pos)
277              % (data->block_size << GRUB_DISK_SECTOR_BITS));
278
279  for (i = posblock; i < blockcnt; i++)
280    {
281      grub_disk_addr_t blknr;
282      grub_uint64_t blockend = data->block_size << GRUB_DISK_SECTOR_BITS;
283      grub_off_t skipfirst = 0;
284
285      blknr = grub_minix_get_file_block (data, i);
286      if (grub_errno)
287        return -1;
288
289      /* Last block.  */
290      if (i == blockcnt - 1)
291        {
292          /* len + pos < 4G (checked above), so it doesn't overflow.  */
293          blockend = (((grub_uint32_t) (len + pos))
294                      % (data->block_size << GRUB_DISK_SECTOR_BITS));
295
296          if (!blockend)
297            blockend = data->block_size << GRUB_DISK_SECTOR_BITS;
298        }
299
300      /* First block.  */
301      if (i == posblock)
302        {
303          skipfirst = blockoff;
304          blockend -= skipfirst;
305        }
306
307      data->disk->read_hook = read_hook;
308      data->disk->read_hook_data = read_hook_data;
309      grub_disk_read (data->disk,
310                      GRUB_MINIX_ZONE2SECT(blknr),
311                      skipfirst, blockend, buf);
312      data->disk->read_hook = 0;
313      if (grub_errno)
314        return -1;
315
316      buf += (data->block_size << GRUB_DISK_SECTOR_BITS) - skipfirst;
317    }
318
319  return len;
320}
321
322
323/* Read inode INO from the mounted filesystem described by DATA.  This
324   inode is used by default now.  */
325static grub_err_t
326grub_minix_read_inode (struct grub_minix_data *data, grub_minix_ino_t ino)
327{
328  struct grub_minix_sblock *sblock = &data->sblock;
329
330  /* Block in which the inode is stored.  */
331  grub_disk_addr_t block;
332  data->ino = ino;
333
334  /* The first inode in minix is inode 1.  */
335  ino--;
336  block = GRUB_MINIX_ZONE2SECT (2 + grub_minix_to_cpu16 (sblock->inode_bmap_size)
337                                + grub_minix_to_cpu16 (sblock->zone_bmap_size));
338  block += ino / (GRUB_DISK_SECTOR_SIZE / sizeof (struct grub_minix_inode));
339  int offs = (ino % (GRUB_DISK_SECTOR_SIZE
340                     / sizeof (struct grub_minix_inode))
341              * sizeof (struct grub_minix_inode));
342 
343  grub_disk_read (data->disk, block, offs,
344                  sizeof (struct grub_minix_inode), &data->inode);
345
346  return GRUB_ERR_NONE;
347}
348
349
350/* Lookup the symlink the current inode points to.  INO is the inode
351   number of the directory the symlink is relative to.  */
352static grub_err_t
353grub_minix_lookup_symlink (struct grub_minix_data *data, grub_minix_ino_t ino)
354{
355  char *symlink;
356  grub_size_t sz = GRUB_MINIX_INODE_SIZE (data);
357
358  if (++data->linknest > GRUB_MINIX_MAX_SYMLNK_CNT)
359    return grub_error (GRUB_ERR_SYMLINK_LOOP, N_("too deep nesting of symlinks"));
360
361  symlink = grub_malloc (sz + 1);
362  if (!symlink)
363    return grub_errno;
364  if (grub_minix_read_file (data, 0, 0, 0, sz, symlink) < 0)
365    return grub_errno;
366
367  symlink[sz] = '\0';
368
369  /* The symlink is an absolute path, go back to the root inode.  */
370  if (symlink[0] == '/')
371    ino = GRUB_MINIX_ROOT_INODE;
372
373  /* Now load in the old inode.  */
374  if (grub_minix_read_inode (data, ino))
375    return grub_errno;
376
377  grub_minix_find_file (data, symlink);
378
379  return grub_errno;
380}
381
382
383/* Find the file with the pathname PATH on the filesystem described by
384   DATA.  */
385static grub_err_t
386grub_minix_find_file (struct grub_minix_data *data, const char *path)
387{
388  const char *name;
389  const char *next = path;
390  unsigned int pos = 0;
391  grub_minix_ino_t dirino;
392
393  while (1)
394    {
395      name = next;
396      /* Skip the first slash.  */
397      while (*name == '/')
398        name++;
399      if (!*name)
400        return GRUB_ERR_NONE;
401
402      if ((GRUB_MINIX_INODE_MODE (data)
403           & GRUB_MINIX_IFDIR) != GRUB_MINIX_IFDIR)
404        return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
405
406      /* Extract the actual part from the pathname.  */
407      for (next = name; *next && *next != '/'; next++);
408
409      for (pos = 0; ; )
410        {
411          grub_minix_ino_t ino;
412          char filename[MAX_MINIX_FILENAME_SIZE + 1];
413
414          if (pos >= GRUB_MINIX_INODE_SIZE (data))
415            {
416              grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), path);
417              return grub_errno;
418            }
419
420          if (grub_minix_read_file (data, 0, 0, pos, sizeof (ino),
421                                    (char *) &ino) < 0)
422            return grub_errno;
423          if (grub_minix_read_file (data, 0, 0, pos + sizeof (ino),
424                                    data->filename_size, (char *) filename)< 0)
425            return grub_errno;
426
427          pos += sizeof (ino) + data->filename_size;
428
429          filename[data->filename_size] = '\0';
430
431          /* Check if the current direntry matches the current part of the
432             pathname.  */
433          if (grub_strncmp (name, filename, next - name) == 0
434              && filename[next - name] == '\0')
435            {
436              dirino = data->ino;
437              grub_minix_read_inode (data, grub_minix_to_cpu_ino (ino));
438
439              /* Follow the symlink.  */
440              if ((GRUB_MINIX_INODE_MODE (data)
441                   & GRUB_MINIX_IFLNK) == GRUB_MINIX_IFLNK)
442                {
443                  grub_minix_lookup_symlink (data, dirino);
444                  if (grub_errno)
445                    return grub_errno;
446                }
447
448              break;
449            }
450        }
451    }
452}
453
454
455/* Mount the filesystem on the disk DISK.  */
456static struct grub_minix_data *
457grub_minix_mount (grub_disk_t disk)
458{
459  struct grub_minix_data *data;
460
461  data = grub_malloc (sizeof (struct grub_minix_data));
462  if (!data)
463    return 0;
464
465  /* Read the superblock.  */
466  grub_disk_read (disk, GRUB_MINIX_SBLOCK, 0,
467                  sizeof (struct grub_minix_sblock),&data->sblock);
468  if (grub_errno)
469    goto fail;
470
471  if (data->sblock.magic == grub_cpu_to_minix16_compile_time (GRUB_MINIX_MAGIC))
472    {
473#if !defined(MODE_MINIX3)
474      data->filename_size = 14;
475#else
476      data->filename_size = 60;
477#endif
478    }
479#if !defined(MODE_MINIX3)
480  else if (data->sblock.magic
481           == grub_cpu_to_minix16_compile_time (GRUB_MINIX_MAGIC_30))
482    data->filename_size = 30;
483#endif
484  else
485    goto fail;
486
487  /* 20 means 1G zones. We could support up to 31 but already 1G isn't
488     supported by anything else.  */
489  if (grub_minix_to_cpu16 (data->sblock.log2_zone_size) >= 20)
490    goto fail;
491
492  data->disk = disk;
493  data->linknest = 0;
494#ifdef MODE_MINIX3
495  /* These tests are endian-independent. No need to byteswap.  */
496  if (data->sblock.block_size == 0xffff)
497    data->block_size = 2;
498  else
499    {
500      if ((data->sblock.block_size == grub_cpu_to_minix16_compile_time (0x200))
501          || (data->sblock.block_size == 0)
502          || (data->sblock.block_size & grub_cpu_to_minix16_compile_time (0x1ff)))
503        goto fail;
504      data->block_size = grub_minix_to_cpu16 (data->sblock.block_size)
505        >> GRUB_DISK_SECTOR_BITS;
506    }
507#else
508  data->block_size = 2;
509#endif
510
511  return data;
512
513 fail:
514  grub_free (data);
515#if defined(MODE_MINIX3)
516  grub_error (GRUB_ERR_BAD_FS, "not a minix3 filesystem");
517#elif defined(MODE_MINIX2)
518  grub_error (GRUB_ERR_BAD_FS, "not a minix2 filesystem");
519#else
520  grub_error (GRUB_ERR_BAD_FS, "not a minix filesystem");
521#endif
522  return 0;
523}
524
525static grub_err_t
526grub_minix_dir (grub_device_t device, const char *path,
527                grub_fs_dir_hook_t hook, void *hook_data)
528{
529  struct grub_minix_data *data = 0;
530  unsigned int pos = 0;
531
532  data = grub_minix_mount (device->disk);
533  if (!data)
534    return grub_errno;
535
536  grub_minix_read_inode (data, GRUB_MINIX_ROOT_INODE);
537  if (grub_errno)
538    goto fail;
539
540  grub_minix_find_file (data, path);
541  if (grub_errno)
542    goto fail;
543
544  if ((GRUB_MINIX_INODE_MODE (data) & GRUB_MINIX_IFDIR) != GRUB_MINIX_IFDIR)
545    {
546      grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
547      goto fail;
548    }
549
550  while (pos < GRUB_MINIX_INODE_SIZE (data))
551    {
552      grub_minix_ino_t ino;
553      char filename[MAX_MINIX_FILENAME_SIZE + 1];
554      grub_minix_ino_t dirino = data->ino;
555      struct grub_dirhook_info info;
556      grub_memset (&info, 0, sizeof (info));
557
558
559      if (grub_minix_read_file (data, 0, 0, pos, sizeof (ino),
560                                (char *) &ino) < 0)
561        return grub_errno;
562
563      if (grub_minix_read_file (data, 0, 0, pos + sizeof (ino),
564                                data->filename_size,
565                                (char *) filename) < 0)
566        return grub_errno;
567      filename[data->filename_size] = '\0';
568      if (!ino)
569        {
570          pos += sizeof (ino) + data->filename_size;
571          continue;
572        }
573
574      grub_minix_read_inode (data, grub_minix_to_cpu_ino (ino));
575      info.dir = ((GRUB_MINIX_INODE_MODE (data)
576                   & GRUB_MINIX_IFDIR) == GRUB_MINIX_IFDIR);
577      info.mtimeset = 1;
578      info.mtime = grub_minix_to_cpu32 (data->inode.mtime);
579
580      if (hook (filename, &info, hook_data) ? 1 : 0)
581        break;
582
583      /* Load the old inode back in.  */
584      grub_minix_read_inode (data, dirino);
585
586      pos += sizeof (ino) + data->filename_size;
587    }
588
589 fail:
590  grub_free (data);
591  return grub_errno;
592}
593
594
595/* Open a file named NAME and initialize FILE.  */
596static grub_err_t
597grub_minix_open (struct grub_file *file, const char *name)
598{
599  struct grub_minix_data *data;
600  data = grub_minix_mount (file->device->disk);
601  if (!data)
602    return grub_errno;
603
604  /* Open the inode op the root directory.  */
605  grub_minix_read_inode (data, GRUB_MINIX_ROOT_INODE);
606  if (grub_errno)
607    {
608      grub_free (data);
609      return grub_errno;
610    }
611
612  if (!name || name[0] != '/')
613    {
614      grub_error (GRUB_ERR_BAD_FILENAME, N_("invalid file name `%s'"), name);
615      return grub_errno;
616    }
617
618  /* Traverse the directory tree to the node that should be
619     opened.  */
620  grub_minix_find_file (data, name);
621  if (grub_errno)
622    {
623      grub_free (data);
624      return grub_errno;
625    }
626
627  file->data = data;
628  file->size = GRUB_MINIX_INODE_SIZE (data);
629
630  return GRUB_ERR_NONE;
631}
632
633
634static grub_ssize_t
635grub_minix_read (grub_file_t file, char *buf, grub_size_t len)
636{
637  struct grub_minix_data *data =
638    (struct grub_minix_data *) file->data;
639
640  return grub_minix_read_file (data, file->read_hook, file->read_hook_data,
641                               file->offset, len, buf);
642}
643
644
645static grub_err_t
646grub_minix_close (grub_file_t file)
647{
648  grub_free (file->data);
649
650  return GRUB_ERR_NONE;
651}
652
653
654
655static struct grub_fs grub_minix_fs =
656  {
657#ifdef MODE_BIGENDIAN
658#if defined(MODE_MINIX3)
659    .name = "minix3_be",
660#elif defined(MODE_MINIX2)
661    .name = "minix2_be",
662#else
663    .name = "minix_be",
664#endif
665#else
666#if defined(MODE_MINIX3)
667    .name = "minix3",
668#elif defined(MODE_MINIX2)
669    .name = "minix2",
670#else
671    .name = "minix",
672#endif
673#endif
674    .dir = grub_minix_dir,
675    .open = grub_minix_open,
676    .read = grub_minix_read,
677    .close = grub_minix_close,
678#ifdef GRUB_UTIL
679    .reserved_first_sector = 1,
680    .blocklist_install = 1,
681#endif
682    .next = 0
683  };
684
685#ifdef MODE_BIGENDIAN
686#if defined(MODE_MINIX3)
687GRUB_MOD_INIT(minix3_be)
688#elif defined(MODE_MINIX2)
689GRUB_MOD_INIT(minix2_be)
690#else
691GRUB_MOD_INIT(minix_be)
692#endif
693#else
694#if defined(MODE_MINIX3)
695GRUB_MOD_INIT(minix3)
696#elif defined(MODE_MINIX2)
697GRUB_MOD_INIT(minix2)
698#else
699GRUB_MOD_INIT(minix)
700#endif
701#endif
702{
703  grub_fs_register (&grub_minix_fs);
704  my_mod = mod;
705}
706
707#ifdef MODE_BIGENDIAN
708#if defined(MODE_MINIX3)
709GRUB_MOD_FINI(minix3_be)
710#elif defined(MODE_MINIX2)
711GRUB_MOD_FINI(minix2_be)
712#else
713GRUB_MOD_FINI(minix_be)
714#endif
715#else
716#if defined(MODE_MINIX3)
717GRUB_MOD_FINI(minix3)
718#elif defined(MODE_MINIX2)
719GRUB_MOD_FINI(minix2)
720#else
721GRUB_MOD_FINI(minix)
722#endif
723#endif
724{
725  grub_fs_unregister (&grub_minix_fs);
726}
Note: See TracBrowser for help on using the repository browser.