fs/ufs.c

   1 /* ufs.c - Unix File System */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2004,2005,2007  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
  28
  29 #define GRUB_UFS_MAGIC          0x11954
  30 #define GRUB_UFS2_MAGIC         0x19540119
  31 #define GRUB_UFS_INODE          2
  32 #define GRUB_UFS_FILETYPE_DIR   4
  33 #define GRUB_UFS_FILETYPE_LNK   10
  34 #define GRUB_UFS_MAX_SYMLNK_CNT 8
  35
  36 #define GRUB_UFS_DIRBLKS        12
  37 #define GRUB_UFS_INDIRBLKS      3
  38
  39 #define GRUB_UFS_ATTR_DIR       040000
  40
  41 #define GRUB_UFS_VOLNAME_LEN    32
  42
  43 /* Calculate in which group the inode can be found.  */
  44 #define inode_group(inode,sblock) ()
  45
  46 #define UFS_BLKSZ(sblock) (grub_le_to_cpu32 (sblock->bsize))
  47
  48 #define INODE(data,field) (data->ufs_type == UFS1 ? \
  49                            data->inode.  field : data->inode2.  field)
  50 #define INODE_ENDIAN(data,field,bits1,bits2) (data->ufs_type == UFS1 ? \
  51                            grub_le_to_cpu##bits1 (data->inode.field) : \
  52                            grub_le_to_cpu##bits2 (data->inode2.field))
  53 #define INODE_SIZE(data) INODE_ENDIAN (data,size,32,64)
  54 #define INODE_MODE(data) INODE_ENDIAN (data,mode,16,16)
  55 #define INODE_BLKSZ(data) (data->ufs_type == UFS1 ? 4 : 8)
  56 #define INODE_DIRBLOCKS(data,blk) INODE_ENDIAN \
  57                                    (data,blocks.dir_blocks[blk],32,64)
  58 #define INODE_INDIRBLOCKS(data,blk) INODE_ENDIAN \
  59                                      (data,blocks.indir_blocks[blk],32,64)
  60
  61 /* The blocks on which the superblock can be found.  */
  62 static int sblocklist[] = { 128, 16, 0, 512, -1 };
  63
  64 struct grub_ufs_sblock
  65 {
  66   grub_uint8_t unused[16];
  67   /* The offset of the inodes in the cylinder group.  */
  68   grub_uint32_t inoblk_offs;
  69
  70   grub_uint8_t unused2[4];
  71
  72   /* The start of the cylinder group.  */
  73   grub_uint32_t cylg_offset;
  74
  75   grub_uint8_t unused3[20];
  76
  77   /* The size of a block in bytes.  */
  78   grub_int32_t bsize;
  79   grub_uint8_t unused4[48];
  80
  81   /* The size of filesystem blocks to disk blocks.  */
  82   grub_uint32_t log2_blksz;
  83   grub_uint8_t unused5[80];
  84
  85   /* Inodes stored per cylinder group.  */
  86   grub_uint32_t ino_per_group;
  87
  88   /* The frags per cylinder group.  */
  89   grub_uint32_t frags_per_group;
  90
  91   grub_uint8_t unused7[488];
  92
  93   /* Volume name for UFS2.  */
  94   grub_uint8_t volume_name[GRUB_UFS_VOLNAME_LEN];
  95
  96   grub_uint8_t unused8[660];
  97
  98   /* Magic value to check if this is really a UFS filesystem.  */
  99   grub_uint32_t magic;
 100 };
 101
 102 /* UFS inode.  */
 103 struct grub_ufs_inode
 104 {
 105   grub_uint16_t mode;
 106   grub_uint16_t nlinks;
 107   grub_uint16_t uid;
 108   grub_uint16_t gid;
 109   grub_int64_t size;
 110   grub_uint64_t atime;
 111   grub_uint64_t mtime;
 112   grub_uint64_t ctime;
 113   union
 114   {
 115     struct
 116     {
 117       grub_uint32_t dir_blocks[GRUB_UFS_DIRBLKS];
 118       grub_uint32_t indir_blocks[GRUB_UFS_INDIRBLKS];
 119     } blocks;
 120     grub_uint8_t symlink[(GRUB_UFS_DIRBLKS + GRUB_UFS_INDIRBLKS) * 4];
 121   };
 122   grub_uint32_t flags;
 123   grub_uint32_t nblocks;
 124   grub_uint32_t gen;
 125   grub_uint32_t unused;
 126   grub_uint8_t pad[12];
 127 };
 128
 129 /* UFS inode.  */
 130 struct grub_ufs2_inode
 131 {
 132   grub_uint16_t mode;
 133   grub_uint16_t nlinks;
 134   grub_uint32_t uid;
 135   grub_uint32_t gid;
 136   grub_uint32_t blocksize;
 137   grub_int64_t size;
 138   grub_int64_t nblocks;
 139   grub_uint64_t atime;
 140   grub_uint64_t mtime;
 141   grub_uint64_t ctime;
 142   grub_uint64_t create_time;
 143   grub_uint32_t atime_sec;
 144   grub_uint32_t mtime_sec;
 145   grub_uint32_t ctime_sec;
 146   grub_uint32_t create_time_sec;
 147   grub_uint32_t gen;
 148   grub_uint32_t kernel_flags;
 149   grub_uint32_t flags;
 150   grub_uint32_t extsz;
 151   grub_uint64_t ext[2];
 152   union
 153   {
 154     struct
 155     {
 156       grub_uint64_t dir_blocks[GRUB_UFS_DIRBLKS];
 157       grub_uint64_t indir_blocks[GRUB_UFS_INDIRBLKS];
 158     } blocks;
 159     grub_uint8_t symlink[(GRUB_UFS_DIRBLKS + GRUB_UFS_INDIRBLKS) * 8];
 160   };
 161
 162   grub_uint8_t unused[24];
 163 };
 164
 165 /* Directory entry.  */
 166 struct grub_ufs_dirent
 167 {
 168   grub_uint32_t ino;
 169   grub_uint16_t direntlen;
 170   grub_uint8_t filetype;
 171   grub_uint8_t namelen;
 172 };
 173
 174 /* Information about a "mounted" ufs filesystem.  */
 175 struct grub_ufs_data
 176 {
 177   struct grub_ufs_sblock sblock;
 178   grub_disk_t disk;
 179   union
 180   {
 181     struct grub_ufs_inode inode;
 182     struct grub_ufs2_inode inode2;
 183   };
 184   enum
 185     {
 186       UFS1,
 187       UFS2,
 188       UNKNOWN
 189     } ufs_type;
 190   int ino;
 191   int linknest;
 192 };
 193
 194 #ifndef GRUB_UTIL
 195 static grub_dl_t my_mod;
 196 #endif
 197 \f
 198 /* Forward declaration.  */
 199 static grub_err_t grub_ufs_find_file (struct grub_ufs_data *data,
 200                                       const char *path);
 201
 202
 203 static int
 204 grub_ufs_get_file_block (struct grub_ufs_data *data, unsigned int blk)
 205 {
 206   struct grub_ufs_sblock *sblock = &data->sblock;
 207   unsigned int indirsz;
 208   int log2_blksz;
 209
 210   /* Direct.  */
 211   if (blk < GRUB_UFS_DIRBLKS)
 212     return INODE_DIRBLOCKS (data, blk);
 213
 214   log2_blksz = grub_le_to_cpu32 (data->sblock.log2_blksz);
 215
 216   blk -= GRUB_UFS_DIRBLKS;
 217
 218   indirsz = UFS_BLKSZ (sblock) / INODE_BLKSZ (data);
 219   /* Single indirect block.  */
 220   if (blk < indirsz)
 221     {
 222       grub_uint32_t indir[UFS_BLKSZ (sblock) >> 2];
 223       grub_disk_read (data->disk, INODE_INDIRBLOCKS (data, 0) << log2_blksz,
 224                       0, sizeof (indir), (char *) indir);
 225       return (data->ufs_type == UFS1) ? indir[blk] : indir[blk << 1];
 226     }
 227   blk -= indirsz;
 228
 229   /* Double indirect block.  */
 230   if (blk < UFS_BLKSZ (sblock) / indirsz)
 231     {
 232       grub_uint32_t indir[UFS_BLKSZ (sblock) >> 2];
 233
 234       grub_disk_read (data->disk, INODE_INDIRBLOCKS (data, 1) << log2_blksz,
 235                       0, sizeof (indir), (char *) indir);
 236       grub_disk_read (data->disk,
 237                       (data->ufs_type == UFS1) ?
 238                       indir[blk / indirsz] : indir [(blk / indirsz) << 1],
 239                       0, sizeof (indir), (char *) indir);
 240
 241       return (data->ufs_type == UFS1) ?
 242              indir[blk % indirsz] : indir[(blk % indirsz) << 1];
 243     }
 244
 245
 246   grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
 247               "ufs does not support triple indirect blocks");
 248   return 0;
 249 }
 250
 251
 252 /* Read LEN bytes from the file described by DATA starting with byte
 253    POS.  Return the amount of read bytes in READ.  */
 254 static grub_ssize_t
 255 grub_ufs_read_file (struct grub_ufs_data *data,
 256                     void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
 257                                        unsigned offset, unsigned length),
 258                     int pos, grub_size_t len, char *buf)
 259 {
 260   struct grub_ufs_sblock *sblock = &data->sblock;
 261   int i;
 262   int blockcnt;
 263
 264   /* Adjust len so it we can't read past the end of the file.  */
 265   if (len > INODE_SIZE (data))
 266     len = INODE_SIZE (data);
 267
 268   blockcnt = (len + pos + UFS_BLKSZ (sblock) - 1) / UFS_BLKSZ (sblock);
 269
 270   for (i = pos / UFS_BLKSZ (sblock); i < blockcnt; i++)
 271     {
 272       int blknr;
 273       int blockoff = pos % UFS_BLKSZ (sblock);
 274       int blockend = UFS_BLKSZ (sblock);
 275
 276       int skipfirst = 0;
 277
 278       blknr = grub_ufs_get_file_block (data, i);
 279       if (grub_errno)
 280         return -1;
 281
 282       /* Last block.  */
 283       if (i == blockcnt - 1)
 284         {
 285           blockend = (len + pos) % UFS_BLKSZ (sblock);
 286
 287           if (!blockend)
 288             blockend = UFS_BLKSZ (sblock);
 289         }
 290
 291       /* First block.  */
 292       if (i == (pos / (int) UFS_BLKSZ (sblock)))
 293         {
 294           skipfirst = blockoff;
 295           blockend -= skipfirst;
 296         }
 297
 298       /* XXX: If the block number is 0 this block is not stored on
 299          disk but is zero filled instead.  */
 300       if (blknr)
 301         {
 302           data->disk->read_hook = read_hook;
 303           grub_disk_read (data->disk,
 304                           blknr << grub_le_to_cpu32 (data->sblock.log2_blksz),
 305                           skipfirst, blockend, buf);
 306           data->disk->read_hook = 0;
 307           if (grub_errno)
 308             return -1;
 309         }
 310       else
 311         grub_memset (buf, UFS_BLKSZ (sblock) - skipfirst, 0);
 312
 313       buf += UFS_BLKSZ (sblock) - skipfirst;
 314     }
 315
 316   return len;
 317 }
 318
 319
 320 /* Read inode INO from the mounted filesystem described by DATA.  This
 321    inode is used by default now.  */
 322 static grub_err_t
 323 grub_ufs_read_inode (struct grub_ufs_data *data, int ino)
 324 {
 325   struct grub_ufs_sblock *sblock = &data->sblock;
 326
 327   /* Determine the group the inode is in.  */
 328   int group = ino / grub_le_to_cpu32 (sblock->ino_per_group);
 329
 330   /* Determine the inode within the group.  */
 331   int grpino = ino % grub_le_to_cpu32 (sblock->ino_per_group);
 332
 333   /* The first block of the group.  */
 334   int grpblk = group * (grub_le_to_cpu32 (sblock->frags_per_group));
 335
 336   if (data->ufs_type == UFS1)
 337     {
 338       struct grub_ufs_inode *inode = &data->inode;
 339
 340       grub_disk_read (data->disk,
 341                       (((grub_le_to_cpu32 (sblock->inoblk_offs) + grpblk)
 342                         << grub_le_to_cpu32 (data->sblock.log2_blksz)))
 343                       + grpino / 4,
 344                       (grpino % 4) * sizeof (struct grub_ufs_inode),
 345                       sizeof (struct grub_ufs_inode),
 346                       (char *) inode);
 347     }
 348   else
 349     {
 350       struct grub_ufs2_inode *inode = &data->inode2;
 351
 352       grub_disk_read (data->disk,
 353                       (((grub_le_to_cpu32 (sblock->inoblk_offs) + grpblk)
 354                         << grub_le_to_cpu32 (data->sblock.log2_blksz)))
 355                       + grpino / 2,
 356                       (grpino % 2) * sizeof (struct grub_ufs2_inode),
 357                       sizeof (struct grub_ufs2_inode),
 358                       (char *) inode);
 359     }
 360
 361   data->ino = ino;
 362   return grub_errno;
 363 }
 364
 365
 366 /* Lookup the symlink the current inode points to.  INO is the inode
 367    number of the directory the symlink is relative to.  */
 368 static grub_err_t
 369 grub_ufs_lookup_symlink (struct grub_ufs_data *data, int ino)
 370 {
 371   char symlink[INODE_SIZE (data)];
 372
 373   if (++data->linknest > GRUB_UFS_MAX_SYMLNK_CNT)
 374     return grub_error (GRUB_ERR_SYMLINK_LOOP, "too deep nesting of symlinks");
 375
 376   if (INODE_SIZE (data) < (GRUB_UFS_DIRBLKS + GRUB_UFS_INDIRBLKS
 377                           * INODE_BLKSZ (data)))
 378     grub_strcpy (symlink, (char *) INODE (data, symlink));
 379   else
 380     {
 381       grub_disk_read (data->disk,
 382                       (INODE_DIRBLOCKS (data, 0)
 383                        << grub_le_to_cpu32 (data->sblock.log2_blksz)),
 384                       0, INODE_SIZE (data), symlink);
 385       symlink[INODE_SIZE (data)] = '\0';
 386     }
 387
 388   /* The symlink is an absolute path, go back to the root inode.  */
 389   if (symlink[0] == '/')
 390     ino = GRUB_UFS_INODE;
 391
 392   /* Now load in the old inode.  */
 393   if (grub_ufs_read_inode (data, ino))
 394     return grub_errno;
 395
 396   grub_ufs_find_file (data, symlink);
 397   if (grub_errno)
 398     grub_error (grub_errno, "Can not follow symlink `%s'.", symlink);
 399
 400   return grub_errno;
 401 }
 402
 403
 404 /* Find the file with the pathname PATH on the filesystem described by
 405    DATA.  */
 406 static grub_err_t
 407 grub_ufs_find_file (struct grub_ufs_data *data, const char *path)
 408 {
 409   char fpath[grub_strlen (path) + 1];
 410   char *name = fpath;
 411   char *next;
 412   unsigned int pos = 0;
 413   int dirino;
 414
 415   grub_strcpy (fpath, path);
 416
 417   /* Skip the first slash.  */
 418   if (name[0] == '/')
 419     {
 420       name++;
 421       if (!*name)
 422         return 0;
 423     }
 424
 425   /* Extract the actual part from the pathname.  */
 426   next = grub_strchr (name, '/');
 427   if (next)
 428     {
 429       next[0] = '\0';
 430       next++;
 431     }
 432
 433   do
 434     {
 435       struct grub_ufs_dirent dirent;
 436
 437       if (grub_strlen (name) == 0)
 438         return GRUB_ERR_NONE;
 439
 440       if (grub_ufs_read_file (data, 0, pos, sizeof (dirent),
 441                               (char *) &dirent) < 0)
 442         return grub_errno;
 443
 444       {
 445         char filename[dirent.namelen + 1];
 446
 447         if (grub_ufs_read_file (data, 0, pos + sizeof (dirent),
 448                                 dirent.namelen, filename) < 0)
 449           return grub_errno;
 450
 451         filename[dirent.namelen] = '\0';
 452
 453         if (!grub_strcmp (name, filename))
 454           {
 455             dirino = data->ino;
 456             grub_ufs_read_inode (data, grub_le_to_cpu32 (dirent.ino));
 457
 458             if (dirent.filetype == GRUB_UFS_FILETYPE_LNK)
 459               {
 460                 grub_ufs_lookup_symlink (data, dirino);
 461                 if (grub_errno)
 462                   return grub_errno;
 463               }
 464
 465             if (!next)
 466               return 0;
 467
 468             pos = 0;
 469
 470             name = next;
 471             next = grub_strchr (name, '/');
 472             if (next)
 473               {
 474                 next[0] = '\0';
 475                 next++;
 476               }
 477
 478             if (!(dirent.filetype & GRUB_UFS_FILETYPE_DIR))
 479               return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
 480
 481             continue;
 482           }
 483       }
 484
 485       pos += grub_le_to_cpu16 (dirent.direntlen);
 486     } while (pos < INODE_SIZE (data));
 487
 488   grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
 489   return grub_errno;
 490 }
 491
 492
 493 /* Mount the filesystem on the disk DISK.  */
 494 static struct grub_ufs_data *
 495 grub_ufs_mount (grub_disk_t disk)
 496 {
 497   struct grub_ufs_data *data;
 498   int *sblklist = sblocklist;
 499
 500   data = grub_malloc (sizeof (struct grub_ufs_data));
 501   if (!data)
 502     return 0;
 503
 504   /* Find a UFS1 or UFS2 sblock.  */
 505   data->ufs_type = UNKNOWN;
 506   while (*sblklist != -1)
 507     {
 508       grub_disk_read (disk, *sblklist, 0, sizeof (struct grub_ufs_sblock),
 509                       (char *) &data->sblock);
 510       if (grub_errno)
 511         goto fail;
 512
 513       if (grub_le_to_cpu32 (data->sblock.magic) == GRUB_UFS_MAGIC)
 514         {
 515           data->ufs_type = UFS1;
 516           break;
 517         }
 518       else if (grub_le_to_cpu32 (data->sblock.magic) == GRUB_UFS2_MAGIC)
 519         {
 520           data->ufs_type = UFS2;
 521           break;
 522         }
 523       sblklist++;
 524     }
 525   if (data->ufs_type == UNKNOWN)
 526     {
 527       grub_error (GRUB_ERR_BAD_FS, "not an ufs filesystem");
 528       goto fail;
 529     }
 530
 531   data->disk = disk;
 532   data->linknest = 0;
 533   return data;
 534
 535  fail:
 536   grub_free (data);
 537
 538   if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
 539     grub_error (GRUB_ERR_BAD_FS, "not a ufs filesystem");
 540
 541   return 0;
 542 }
 543
 544
 545 static grub_err_t
 546 grub_ufs_dir (grub_device_t device, const char *path,
 547                int (*hook) (const char *filename, int dir))
 548 {
 549   struct grub_ufs_data *data;
 550   struct grub_ufs_sblock *sblock;
 551   unsigned int pos = 0;
 552
 553   data = grub_ufs_mount (device->disk);
 554   if (!data)
 555     return grub_errno;
 556
 557   grub_ufs_read_inode (data, GRUB_UFS_INODE);
 558   if (grub_errno)
 559     return grub_errno;
 560
 561   sblock = &data->sblock;
 562
 563   if (!path || path[0] != '/')
 564     {
 565       grub_error (GRUB_ERR_BAD_FILENAME, "bad filename");
 566       return grub_errno;
 567     }
 568
 569   grub_ufs_find_file (data, path);
 570   if (grub_errno)
 571     goto fail;
 572
 573   if (!(INODE_MODE (data) & GRUB_UFS_ATTR_DIR))
 574     {
 575       grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
 576       goto fail;
 577     }
 578
 579   while (pos < INODE_SIZE (data))
 580     {
 581       struct grub_ufs_dirent dirent;
 582
 583       if (grub_ufs_read_file (data, 0, pos, sizeof (dirent),
 584                               (char *) &dirent) < 0)
 585         break;
 586
 587       {
 588         char filename[dirent.namelen + 1];
 589
 590         if (grub_ufs_read_file (data, 0, pos + sizeof (dirent),
 591                                 dirent.namelen, filename) < 0)
 592           break;
 593
 594         filename[dirent.namelen] = '\0';
 595         if (hook (filename, dirent.filetype == GRUB_UFS_FILETYPE_DIR))
 596           break;
 597       }
 598
 599       pos += grub_le_to_cpu16 (dirent.direntlen);
 600     }
 601
 602  fail:
 603   grub_free (data);
 604
 605   return grub_errno;
 606 }
 607
 608
 609 /* Open a file named NAME and initialize FILE.  */
 610 static grub_err_t
 611 grub_ufs_open (struct grub_file *file, const char *name)
 612 {
 613   struct grub_ufs_data *data;
 614   data = grub_ufs_mount (file->device->disk);
 615   if (!data)
 616     return grub_errno;
 617
 618   grub_ufs_read_inode (data, 2);
 619   if (grub_errno)
 620     {
 621       grub_free (data);
 622       return grub_errno;
 623     }
 624
 625   if (!name || name[0] != '/')
 626     {
 627       grub_error (GRUB_ERR_BAD_FILENAME, "bad filename");
 628       return grub_errno;
 629     }
 630
 631   grub_ufs_find_file (data, name);
 632   if (grub_errno)
 633     {
 634       grub_free (data);
 635       return grub_errno;
 636     }
 637
 638   file->data = data;
 639   file->size = INODE_SIZE (data);
 640
 641   return GRUB_ERR_NONE;
 642 }
 643
 644
 645 static grub_ssize_t
 646 grub_ufs_read (grub_file_t file, char *buf, grub_size_t len)
 647 {
 648   struct grub_ufs_data *data =
 649     (struct grub_ufs_data *) file->data;
 650
 651   return grub_ufs_read_file (data, file->read_hook, file->offset, len, buf);
 652 }
 653
 654
 655 static grub_err_t
 656 grub_ufs_close (grub_file_t file)
 657 {
 658   grub_free (file->data);
 659
 660   return GRUB_ERR_NONE;
 661 }
 662
 663
 664 static grub_err_t
 665 grub_ufs_label (grub_device_t device, char **label)
 666 {
 667   struct grub_ufs_data *data = 0;
 668
 669 #ifndef GRUB_UTIL
 670   grub_dl_ref (my_mod);
 671 #endif
 672
 673   *label = 0;
 674
 675   data = grub_ufs_mount (device->disk);
 676   if (data)
 677     {
 678       if (data->ufs_type == UFS2)
 679         *label = grub_strdup ((char *) data->sblock.volume_name);
 680     }
 681
 682 #ifndef GRUB_UTIL
 683   grub_dl_unref (my_mod);
 684 #endif
 685
 686   grub_free (data);
 687
 688   return grub_errno;
 689 }
 690
 691 \f
 692 static struct grub_fs grub_ufs_fs =
 693   {
 694     .name = "ufs",
 695     .dir = grub_ufs_dir,
 696     .open = grub_ufs_open,
 697     .read = grub_ufs_read,
 698     .close = grub_ufs_close,
 699     .label = grub_ufs_label,
 700     .next = 0
 701   };
 702
 703 GRUB_MOD_INIT(ufs)
 704 {
 705   grub_fs_register (&grub_ufs_fs);
 706 #ifndef GRUB_UTIL
 707   my_mod = mod;
 708 #endif
 709 }
 710
 711 GRUB_MOD_FINI(ufs)
 712 {
 713   grub_fs_unregister (&grub_ufs_fs);
 714 }
 715