shlibs/blkid/src/probers/sysv.c

   1 /*
   2  * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
   3  *
   4  * This is written from sratch according to Linux kernel fs/sysv/super.c file.
   5  * It seems that sysv probing code in libvolume_id and also in the original
   6  * blkid is useless.
   7  *
   8  * This file may be redistributed under the terms of the
   9  * GNU Lesser General Public License.
  10  */
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <stdint.h>
  15
  16 #include "blkidP.h"
  17
  18 #define XENIX_NICINOD                           100
  19 #define XENIX_NICFREE                           100
  20
  21 struct xenix_super_block {
  22         uint16_t        s_isize;
  23         uint32_t        s_fsize;
  24         uint16_t        s_nfree;
  25         uint32_t        s_free[XENIX_NICFREE];
  26         uint16_t        s_ninode;
  27         uint16_t        s_inode[XENIX_NICINOD];
  28         uint8_t         s_flock;
  29         uint8_t         s_ilock;
  30         uint8_t         s_fmod;
  31         uint8_t         s_ronly;
  32         uint32_t        s_time;
  33         uint32_t        s_tfree;
  34         uint16_t        s_tinode;
  35         uint16_t        s_dinfo[4];
  36         uint8_t         s_fname[6];
  37         uint8_t         s_fpack[6];
  38         uint8_t         s_clean;
  39         uint8_t         s_fill[371];
  40         uint32_t        s_magic;
  41         uint32_t        s_type;
  42 } __attribute__((packed));
  43
  44
  45 #define SYSV_NICINOD                    100
  46 #define SYSV_NICFREE                    50
  47
  48 struct sysv_super_block
  49 {
  50         uint16_t        s_isize;
  51         uint16_t        s_pad0;
  52         uint32_t        s_fsize;
  53         uint16_t        s_nfree;
  54         uint16_t        s_pad1;
  55         uint32_t        s_free[SYSV_NICFREE];
  56         uint16_t        s_ninode;
  57         uint16_t        s_pad2;
  58         uint16_t        s_inode[SYSV_NICINOD];
  59         uint8_t         s_flock;
  60         uint8_t         s_ilock;
  61         uint8_t         s_fmod;
  62         uint8_t         s_ronly;
  63         uint32_t        s_time;
  64         uint16_t        s_dinfo[4];
  65         uint32_t        s_tfree;
  66         uint16_t        s_tinode;
  67         uint16_t        s_pad3;
  68         uint8_t         s_fname[6];
  69         uint8_t         s_fpack[6];
  70         uint32_t        s_fill[12];
  71         uint32_t        s_state;
  72         uint32_t        s_magic;
  73         uint32_t        s_type;
  74 };
  75
  76 static int probe_xenix(blkid_probe pr, const struct blkid_idmag *mag)
  77 {
  78         struct xenix_super_block *sb;
  79
  80         sb = blkid_probe_get_sb(pr, mag, struct xenix_super_block);
  81         if (!sb)
  82                 return -1;
  83         blkid_probe_set_label(pr, sb->s_fname, sizeof(sb->s_fname));
  84         return 0;
  85 }
  86
  87 #define SYSV_BLOCK_SIZE 1024
  88
  89 /* Note that we don't probe for Coherent FS, this FS does not have
  90  * magic string. (It requires to probe fname/fpack field..)
  91  */
  92 static int probe_sysv(blkid_probe pr, const struct blkid_idmag *mag)
  93 {
  94         struct sysv_super_block *sb;
  95         int blocks[] = {0, 9, 15, 18};
  96         int i;
  97
  98         for (i = 0; i < ARRAY_SIZE(blocks); i++) {
  99                 int off = blocks[i] * SYSV_BLOCK_SIZE + SYSV_BLOCK_SIZE/2;
 100
 101                 sb = (struct sysv_super_block *)
 102                         blkid_probe_get_buffer(pr,
 103                                         off,
 104                                         sizeof(struct sysv_super_block));
 105                 if (!sb)
 106                         return -1;
 107
 108                 if (sb->s_magic == cpu_to_le32(0xfd187e20) ||
 109                     sb->s_magic == cpu_to_be32(0xfd187e20)) {
 110                         blkid_probe_set_label(pr, sb->s_fname, sizeof(sb->s_fname));
 111                         return 0;
 112                 }
 113         }
 114         return 1;
 115 }
 116
 117 const struct blkid_idinfo xenix_idinfo =
 118 {
 119         .name           = "xenix",
 120         .usage          = BLKID_USAGE_FILESYSTEM,
 121         .probefunc      = probe_xenix,
 122         .magics         =
 123         {
 124                 { .magic = "\x2b\x55\x44", .len = 3, .kboff = 1, .sboff = 0x400 },
 125                 { .magic = "\x44\x55\x2b", .len = 3, .kboff = 1, .sboff = 0x400 },
 126                 { NULL }
 127         }
 128 };
 129
 130 const struct blkid_idinfo sysv_idinfo =
 131 {
 132         .name           = "sysv",
 133         .usage          = BLKID_USAGE_FILESYSTEM,
 134         .probefunc      = probe_sysv,
 135
 136         /* SYSV is BE and LE and superblock could be on four positions. It's
 137          * simpler to probe for the magic string by .probefunc().
 138          */
 139         .magics         = BLKID_NONE_MAGIC
 140 };
 141