Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 1 | /* |
| 2 | * probe.c - identify a block device by its contents, and return a dev |
| 3 | * struct with the details |
| 4 | * |
| 5 | * Copyright (C) 1999 by Andries Brouwer |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 6 | * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 7 | * Copyright (C) 2001 by Andreas Dilger |
| 8 | * |
| 9 | * %Begin-Header% |
| 10 | * This file may be redistributed under the terms of the |
| 11 | * GNU Lesser General Public License. |
| 12 | * %End-Header% |
| 13 | */ |
| 14 | |
| 15 | #include <stdio.h> |
| 16 | #include <string.h> |
| 17 | #include <stdlib.h> |
| 18 | #include <unistd.h> |
| 19 | #include <fcntl.h> |
| 20 | #include <sys/types.h> |
| 21 | #ifdef HAVE_SYS_STAT_H |
| 22 | #include <sys/stat.h> |
| 23 | #endif |
| 24 | #ifdef HAVE_SYS_MKDEV_H |
| 25 | #include <sys/mkdev.h> |
| 26 | #endif |
| 27 | #ifdef HAVE_ERRNO_H |
| 28 | #include <errno.h> |
| 29 | #endif |
Theodore Ts'o | 7a603aa | 2003-01-26 01:54:39 -0500 | [diff] [blame] | 30 | #include "blkidP.h" |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 31 | #include "uuid/uuid.h" |
| 32 | #include "probe.h" |
| 33 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 34 | /* |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 35 | * This is a special case code to check for an MDRAID device. We do |
| 36 | * this special since it requires checking for a superblock at the end |
| 37 | * of the device. |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 38 | */ |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 39 | static int check_mdraid(int fd, unsigned char *ret_uuid) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 40 | { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 41 | struct mdp_superblock_s *md; |
| 42 | blkid_loff_t offset; |
| 43 | char buf[4096]; |
| 44 | |
| 45 | if (fd < 0) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 46 | return -BLKID_ERR_PARAM; |
| 47 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 48 | offset = (blkid_get_dev_size(fd) & ~((blkid_loff_t)65535)) - 65536; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 49 | |
| 50 | if (blkid_llseek(fd, offset, 0) < 0 || |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 51 | read(fd, buf, 4096) != 4096) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 52 | return -BLKID_ERR_IO; |
| 53 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 54 | /* Check for magic number */ |
| 55 | if (memcmp("\251+N\374", buf, 4)) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 56 | return -BLKID_ERR_PARAM; |
| 57 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 58 | if (!ret_uuid) |
| 59 | return 0; |
| 60 | *ret_uuid = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 61 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 62 | /* The MD UUID is not contiguous in the superblock, make it so */ |
| 63 | md = (struct mdp_superblock_s *)buf; |
| 64 | if (md->set_uuid0 || md->set_uuid1 || md->set_uuid2 || md->set_uuid3) { |
| 65 | memcpy(ret_uuid, &md->set_uuid0, 4); |
| 66 | memcpy(ret_uuid, &md->set_uuid1, 12); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 67 | } |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 68 | return 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 69 | } |
| 70 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 71 | static void set_uuid(blkid_dev dev, uuid_t uuid) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 72 | { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 73 | char str[37]; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 74 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 75 | if (!uuid_is_null(uuid)) { |
| 76 | uuid_unparse(uuid, str); |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 77 | blkid_set_tag(dev, "UUID", str, sizeof(str)); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 78 | } |
| 79 | } |
| 80 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 81 | static int probe_ext2(int fd __BLKID_ATTR((unused)), |
| 82 | blkid_cache cache __BLKID_ATTR((unused)), |
| 83 | blkid_dev dev, |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 84 | struct blkid_magic *id, unsigned char *buf) |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 85 | { |
| 86 | struct ext2_super_block *es; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 87 | const char *sec_type = 0, *label = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 88 | |
| 89 | es = (struct ext2_super_block *)buf; |
| 90 | |
Theodore Ts'o | f0a22d0 | 2003-02-22 13:19:53 -0500 | [diff] [blame] | 91 | DBG(DEBUG_PROBE, printf("ext2_sb.compat = %08X:%08X:%08X\n", |
Theodore Ts'o | 76b07bb | 2003-01-27 01:09:24 -0500 | [diff] [blame] | 92 | blkid_le32(es->s_feature_compat), |
| 93 | blkid_le32(es->s_feature_incompat), |
| 94 | blkid_le32(es->s_feature_ro_compat))); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 95 | |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 96 | /* Distinguish between jbd and ext2/3 fs */ |
| 97 | if (id && (blkid_le32(es->s_feature_incompat) & |
| 98 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 99 | return -BLKID_ERR_PARAM; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 100 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 101 | if (strlen(es->s_volume_name)) |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 102 | label = es->s_volume_name; |
| 103 | blkid_set_tag(dev, "LABEL", label, sizeof(es->s_volume_name)); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 104 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 105 | set_uuid(dev, es->s_uuid); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 106 | |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 107 | if (blkid_le32(es->s_feature_compat) & |
| 108 | EXT3_FEATURE_COMPAT_HAS_JOURNAL) |
| 109 | sec_type = "ext3"; |
| 110 | |
| 111 | blkid_set_tag(dev, "SEC_TYPE", sec_type, 0); |
| 112 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 113 | return 0; |
| 114 | } |
| 115 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 116 | static int probe_jbd(int fd __BLKID_ATTR((unused)), |
| 117 | blkid_cache cache __BLKID_ATTR((unused)), |
| 118 | blkid_dev dev, |
| 119 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 120 | unsigned char *buf) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 121 | { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 122 | struct ext2_super_block *es = (struct ext2_super_block *) buf; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 123 | |
Theodore Ts'o | 76b07bb | 2003-01-27 01:09:24 -0500 | [diff] [blame] | 124 | if (!(blkid_le32(es->s_feature_incompat) & |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 125 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 126 | return -BLKID_ERR_PARAM; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 127 | |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 128 | return (probe_ext2(fd, cache, dev, 0, buf)); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 129 | } |
| 130 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 131 | static int probe_vfat(int fd __BLKID_ATTR((unused)), |
| 132 | blkid_cache cache __BLKID_ATTR((unused)), |
| 133 | blkid_dev dev, |
| 134 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 135 | unsigned char *buf) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 136 | { |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 137 | struct vfat_super_block *vs; |
| 138 | char serno[10]; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 139 | const char *label = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 140 | |
| 141 | vs = (struct vfat_super_block *)buf; |
| 142 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 143 | if (strncmp(vs->vs_label, "NO NAME", 7)) { |
Theodore Ts'o | d3f9179 | 2003-01-25 00:26:48 -0500 | [diff] [blame] | 144 | char *end = vs->vs_label + sizeof(vs->vs_label) - 1; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 145 | |
| 146 | while (*end == ' ' && end >= vs->vs_label) |
| 147 | --end; |
| 148 | if (end >= vs->vs_label) |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 149 | label = vs->vs_label; |
| 150 | blkid_set_tag(dev, "LABEL", label, end - vs->vs_label + 1); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | /* We can't just print them as %04X, because they are unaligned */ |
| 154 | sprintf(serno, "%02X%02X-%02X%02X", vs->vs_serno[3], vs->vs_serno[2], |
| 155 | vs->vs_serno[1], vs->vs_serno[0]); |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 156 | blkid_set_tag(dev, "UUID", serno, sizeof(serno)); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 157 | |
| 158 | return 0; |
| 159 | } |
| 160 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 161 | static int probe_msdos(int fd __BLKID_ATTR((unused)), |
| 162 | blkid_cache cache __BLKID_ATTR((unused)), |
| 163 | blkid_dev dev, |
| 164 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 165 | unsigned char *buf) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 166 | { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 167 | struct msdos_super_block *ms = (struct msdos_super_block *) buf; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 168 | char serno[10]; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 169 | const char *label = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 170 | |
| 171 | if (strncmp(ms->ms_label, "NO NAME", 7)) { |
Theodore Ts'o | d3f9179 | 2003-01-25 00:26:48 -0500 | [diff] [blame] | 172 | char *end = ms->ms_label + sizeof(ms->ms_label) - 1; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 173 | |
| 174 | while (*end == ' ' && end >= ms->ms_label) |
| 175 | --end; |
| 176 | if (end >= ms->ms_label) |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 177 | label = ms->ms_label; |
| 178 | blkid_set_tag(dev, "LABEL", label, end - ms->ms_label + 1); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | /* We can't just print them as %04X, because they are unaligned */ |
| 182 | sprintf(serno, "%02X%02X-%02X%02X", ms->ms_serno[3], ms->ms_serno[2], |
| 183 | ms->ms_serno[1], ms->ms_serno[0]); |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 184 | blkid_set_tag(dev, "UUID", serno, 0); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 185 | |
| 186 | return 0; |
| 187 | } |
| 188 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 189 | static int probe_xfs(int fd __BLKID_ATTR((unused)), |
| 190 | blkid_cache cache __BLKID_ATTR((unused)), |
| 191 | blkid_dev dev, |
| 192 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 193 | unsigned char *buf) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 194 | { |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 195 | struct xfs_super_block *xs; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 196 | const char *label = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 197 | |
| 198 | xs = (struct xfs_super_block *)buf; |
| 199 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 200 | if (strlen(xs->xs_fname)) |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 201 | label = xs->xs_fname; |
| 202 | blkid_set_tag(dev, "LABEL", label, sizeof(xs->xs_fname)); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 203 | set_uuid(dev, xs->xs_uuid); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 204 | return 0; |
| 205 | } |
| 206 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 207 | static int probe_reiserfs(int fd __BLKID_ATTR((unused)), |
| 208 | blkid_cache cache __BLKID_ATTR((unused)), |
| 209 | blkid_dev dev, |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 210 | struct blkid_magic *id, unsigned char *buf) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 211 | { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 212 | struct reiserfs_super_block *rs = (struct reiserfs_super_block *) buf; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 213 | unsigned int blocksize; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 214 | const char *label = 0; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 215 | |
Theodore Ts'o | 76b07bb | 2003-01-27 01:09:24 -0500 | [diff] [blame] | 216 | blocksize = blkid_le16(rs->rs_blocksize); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 217 | |
| 218 | /* If the superblock is inside the journal, we have the wrong one */ |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 219 | if (id->bim_kboff/(blocksize>>10) > blkid_le32(rs->rs_journal_block)) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 220 | return -BLKID_ERR_BIG; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 221 | |
| 222 | /* LABEL/UUID are only valid for later versions of Reiserfs v3.6. */ |
| 223 | if (!strcmp(id->bim_magic, "ReIsEr2Fs") || |
| 224 | !strcmp(id->bim_magic, "ReIsEr3Fs")) { |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 225 | if (strlen(rs->rs_label)) |
| 226 | label = rs->rs_label; |
| 227 | blkid_set_tag(dev, "LABEL", label, sizeof(rs->rs_label)); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 228 | set_uuid(dev, rs->rs_uuid); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | return 0; |
| 232 | } |
| 233 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 234 | static int probe_jfs(int fd __BLKID_ATTR((unused)), |
| 235 | blkid_cache cache __BLKID_ATTR((unused)), |
| 236 | blkid_dev dev, |
| 237 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 238 | unsigned char *buf) |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 239 | { |
| 240 | struct jfs_super_block *js; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 241 | const char *label = 0; |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 242 | |
| 243 | js = (struct jfs_super_block *)buf; |
| 244 | |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 245 | if (strlen((char *) js->js_label)) |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 246 | label = (char *) js->js_label; |
| 247 | blkid_set_tag(dev, "LABEL", label, sizeof(js->js_label)); |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 248 | set_uuid(dev, js->js_uuid); |
| 249 | return 0; |
| 250 | } |
| 251 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 252 | static int probe_romfs(int fd __BLKID_ATTR((unused)), |
| 253 | blkid_cache cache __BLKID_ATTR((unused)), |
| 254 | blkid_dev dev, |
| 255 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 256 | unsigned char *buf) |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 257 | { |
| 258 | struct romfs_super_block *ros; |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 259 | const char *label = 0; |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 260 | |
| 261 | ros = (struct romfs_super_block *)buf; |
| 262 | |
Theodore Ts'o | a30b944 | 2003-07-20 11:22:34 -0400 | [diff] [blame] | 263 | if (strlen((char *) ros->ros_volume)) |
| 264 | label = (char *) ros->ros_volume; |
| 265 | blkid_set_tag(dev, "LABEL", label, strlen(label)); |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 266 | return 0; |
| 267 | } |
| 268 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 269 | static const char |
Theodore Ts'o | 3de5bf6 | 2003-07-22 01:06:36 -0400 | [diff] [blame] | 270 | *udf_magic[] = { "BEA01", "BOOT2", "CD001", "CDW02", "NSR02", |
| 271 | "NSR03", "TEA01", 0 }; |
| 272 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 273 | static int probe_udf(int fd, blkid_cache cache __BLKID_ATTR((unused)), |
| 274 | blkid_dev dev __BLKID_ATTR((unused)), |
| 275 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 276 | unsigned char *buf __BLKID_ATTR((unused))) |
Theodore Ts'o | 3de5bf6 | 2003-07-22 01:06:36 -0400 | [diff] [blame] | 277 | { |
| 278 | int j, bs; |
| 279 | struct iso_volume_descriptor isosb; |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 280 | const char ** m; |
Theodore Ts'o | 3de5bf6 | 2003-07-22 01:06:36 -0400 | [diff] [blame] | 281 | |
| 282 | /* determine the block size by scanning in 2K increments |
| 283 | (block sizes larger than 2K will be null padded) */ |
| 284 | for (bs = 1; bs < 16; bs++) { |
| 285 | lseek(fd, bs*2048+32768, SEEK_SET); |
| 286 | if (read(fd, (char *)&isosb, sizeof(isosb)) != sizeof(isosb)) |
| 287 | return 1; |
| 288 | if (isosb.id[0]) |
| 289 | break; |
| 290 | } |
| 291 | |
| 292 | /* Scan up to another 64 blocks looking for additional VSD's */ |
| 293 | for (j = 1; j < 64; j++) { |
| 294 | if (j > 1) { |
| 295 | lseek(fd, j*bs*2048+32768, SEEK_SET); |
| 296 | if (read(fd, (char *)&isosb, sizeof(isosb)) |
| 297 | != sizeof(isosb)) |
| 298 | return 1; |
| 299 | } |
| 300 | /* If we find NSR0x then call it udf: |
| 301 | NSR01 for UDF 1.00 |
| 302 | NSR02 for UDF 1.50 |
| 303 | NSR03 for UDF 2.00 */ |
| 304 | if (!strncmp(isosb.id, "NSR0", 4)) |
| 305 | return 0; |
| 306 | for (m = udf_magic; *m; m++) |
| 307 | if (!strncmp(*m, isosb.id, 5)) |
| 308 | break; |
| 309 | if (*m == 0) |
| 310 | return 1; |
| 311 | } |
| 312 | return 1; |
| 313 | } |
| 314 | |
Theodore Ts'o | 9387c28 | 2004-03-04 19:59:58 -0500 | [diff] [blame] | 315 | static int probe_ocfs(int fd __BLKID_ATTR((unused)), |
| 316 | blkid_cache cache __BLKID_ATTR((unused)), |
| 317 | blkid_dev dev, |
| 318 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 319 | unsigned char *buf) |
| 320 | { |
| 321 | struct ocfs_volume_header ovh; |
| 322 | struct ocfs_volume_label ovl; |
Theodore Ts'o | 3838f7d | 2004-11-30 19:05:38 -0500 | [diff] [blame^] | 323 | __u32 major; |
Theodore Ts'o | 9387c28 | 2004-03-04 19:59:58 -0500 | [diff] [blame] | 324 | |
| 325 | memcpy(&ovh, buf, sizeof(ovh)); |
| 326 | memcpy(&ovl, buf+512, sizeof(ovl)); |
| 327 | |
| 328 | major = ocfsmajor(ovh); |
| 329 | if (major == 1) |
Theodore Ts'o | 4b8f81a | 2004-11-19 14:28:01 -0500 | [diff] [blame] | 330 | blkid_set_tag(dev,"SEC_TYPE","ocfs1",sizeof("ocfs1")); |
Theodore Ts'o | 9387c28 | 2004-03-04 19:59:58 -0500 | [diff] [blame] | 331 | else if (major >= 9) |
| 332 | blkid_set_tag(dev,"SEC_TYPE","ntocfs",sizeof("ntocfs")); |
| 333 | |
| 334 | blkid_set_tag(dev, "LABEL", ovl.label, ocfslabellen(ovl)); |
| 335 | blkid_set_tag(dev, "MOUNT", ovh.mount, ocfsmountlen(ovh)); |
| 336 | set_uuid(dev, ovl.vol_id); |
| 337 | return 0; |
| 338 | } |
| 339 | |
Theodore Ts'o | 414846b | 2004-09-17 21:37:49 -0400 | [diff] [blame] | 340 | static int probe_ocfs2(int fd __BLKID_ATTR((unused)), |
| 341 | blkid_cache cache __BLKID_ATTR((unused)), |
| 342 | blkid_dev dev, |
| 343 | struct blkid_magic *id __BLKID_ATTR((unused)), |
| 344 | unsigned char *buf) |
| 345 | { |
| 346 | struct ocfs2_super_block *osb; |
| 347 | |
| 348 | osb = (struct ocfs2_super_block *)buf; |
| 349 | |
| 350 | blkid_set_tag(dev, "LABEL", osb->s_label, sizeof(osb->s_label)); |
| 351 | set_uuid(dev, osb->s_uuid); |
| 352 | return 0; |
| 353 | } |
| 354 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 355 | /* |
| 356 | * BLKID_BLK_OFFS is at least as large as the highest bim_kboff defined |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 357 | * in the type_array table below + bim_kbalign. |
| 358 | * |
| 359 | * When probing for a lot of magics, we handle everything in 1kB buffers so |
| 360 | * that we don't have to worry about reading each combination of block sizes. |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 361 | */ |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 362 | #define BLKID_BLK_OFFS 64 /* currently reiserfs */ |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 363 | |
| 364 | /* |
| 365 | * Various filesystem magics that we can check for. Note that kboff and |
| 366 | * sboff are in kilobytes and bytes respectively. All magics are in |
| 367 | * byte strings so we don't worry about endian issues. |
| 368 | */ |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 369 | static struct blkid_magic type_array[] = { |
| 370 | /* type kboff sboff len magic probe */ |
| 371 | { "jbd", 1, 0x38, 2, "\123\357", probe_jbd }, |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 372 | { "ext2", 1, 0x38, 2, "\123\357", probe_ext2 }, |
| 373 | { "reiserfs", 8, 0x34, 8, "ReIsErFs", probe_reiserfs }, |
| 374 | { "reiserfs", 64, 0x34, 9, "ReIsEr2Fs", probe_reiserfs }, |
| 375 | { "reiserfs", 64, 0x34, 9, "ReIsEr3Fs", probe_reiserfs }, |
| 376 | { "reiserfs", 64, 0x34, 8, "ReIsErFs", probe_reiserfs }, |
| 377 | { "reiserfs", 8, 20, 8, "ReIsErFs", probe_reiserfs }, |
| 378 | { "ntfs", 0, 3, 8, "NTFS ", 0 }, |
| 379 | { "vfat", 0, 0x52, 5, "MSWIN", probe_vfat }, |
| 380 | { "vfat", 0, 0x52, 8, "FAT32 ", probe_vfat }, |
| 381 | { "msdos", 0, 0x36, 5, "MSDOS", probe_msdos }, |
| 382 | { "msdos", 0, 0x36, 8, "FAT16 ", probe_msdos }, |
| 383 | { "msdos", 0, 0x36, 8, "FAT12 ", probe_msdos }, |
| 384 | { "minix", 1, 0x10, 2, "\177\023", 0 }, |
| 385 | { "minix", 1, 0x10, 2, "\217\023", 0 }, |
| 386 | { "minix", 1, 0x10, 2, "\150\044", 0 }, |
| 387 | { "minix", 1, 0x10, 2, "\170\044", 0 }, |
| 388 | { "vxfs", 1, 0, 4, "\365\374\001\245", 0 }, |
| 389 | { "xfs", 0, 0, 4, "XFSB", probe_xfs }, |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 390 | { "romfs", 0, 0, 8, "-rom1fs-", probe_romfs }, |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 391 | { "bfs", 0, 0, 4, "\316\372\173\033", 0 }, |
| 392 | { "cramfs", 0, 0, 4, "E=\315\034", 0 }, |
| 393 | { "qnx4", 0, 4, 6, "QNX4FS", 0 }, |
Theodore Ts'o | 3de5bf6 | 2003-07-22 01:06:36 -0400 | [diff] [blame] | 394 | { "udf", 32, 1, 5, "BEA01", probe_udf }, |
| 395 | { "udf", 32, 1, 5, "BOOT2", probe_udf }, |
| 396 | { "udf", 32, 1, 5, "CD001", probe_udf }, |
| 397 | { "udf", 32, 1, 5, "CDW02", probe_udf }, |
| 398 | { "udf", 32, 1, 5, "NSR02", probe_udf }, |
| 399 | { "udf", 32, 1, 5, "NSR03", probe_udf }, |
| 400 | { "udf", 32, 1, 5, "TEA01", probe_udf }, |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 401 | { "iso9660", 32, 1, 5, "CD001", 0 }, |
| 402 | { "iso9660", 32, 9, 5, "CDROM", 0 }, |
Theodore Ts'o | 09a2ef8 | 2003-04-03 00:04:28 -0500 | [diff] [blame] | 403 | { "jfs", 32, 0, 4, "JFS1", probe_jfs }, |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 404 | { "hfs", 1, 0, 2, "BD", 0 }, |
| 405 | { "ufs", 8, 0x55c, 4, "T\031\001\000", 0 }, |
| 406 | { "hpfs", 8, 0, 4, "I\350\225\371", 0 }, |
| 407 | { "sysv", 0, 0x3f8, 4, "\020~\030\375", 0 }, |
| 408 | { "swap", 0, 0xff6, 10, "SWAP-SPACE", 0 }, |
| 409 | { "swap", 0, 0xff6, 10, "SWAPSPACE2", 0 }, |
| 410 | { "swap", 0, 0x1ff6, 10, "SWAP-SPACE", 0 }, |
| 411 | { "swap", 0, 0x1ff6, 10, "SWAPSPACE2", 0 }, |
| 412 | { "swap", 0, 0x3ff6, 10, "SWAP-SPACE", 0 }, |
| 413 | { "swap", 0, 0x3ff6, 10, "SWAPSPACE2", 0 }, |
Theodore Ts'o | 414846b | 2004-09-17 21:37:49 -0400 | [diff] [blame] | 414 | { "ocfs", 0, 8, 9, "OracleCFS", probe_ocfs }, |
| 415 | { "ocfs2", 1, 0, 6, "OCFSV2", probe_ocfs2 }, |
| 416 | { "ocfs2", 2, 0, 6, "OCFSV2", probe_ocfs2 }, |
| 417 | { "ocfs2", 4, 0, 6, "OCFSV2", probe_ocfs2 }, |
| 418 | { "ocfs2", 8, 0, 6, "OCFSV2", probe_ocfs2 }, |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 419 | { NULL, 0, 0, 0, NULL, NULL } |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 420 | }; |
| 421 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 422 | /* |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 423 | * Verify that the data in dev is consistent with what is on the actual |
| 424 | * block device (using the devname field only). Normally this will be |
| 425 | * called when finding items in the cache, but for long running processes |
| 426 | * is also desirable to revalidate an item before use. |
| 427 | * |
| 428 | * If we are unable to revalidate the data, we return the old data and |
| 429 | * do not set the BLKID_BID_FL_VERIFIED flag on it. |
| 430 | */ |
Theodore Ts'o | 7a603aa | 2003-01-26 01:54:39 -0500 | [diff] [blame] | 431 | blkid_dev blkid_verify_devname(blkid_cache cache, blkid_dev dev) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 432 | { |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 433 | struct blkid_magic *id; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 434 | unsigned char *bufs[BLKID_BLK_OFFS + 1], *buf; |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 435 | const char *type; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 436 | struct stat st; |
Theodore Ts'o | 7ce0806 | 2004-04-19 21:42:18 -0400 | [diff] [blame] | 437 | time_t diff, now; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 438 | int fd, idx; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 439 | |
| 440 | if (!dev) |
| 441 | return NULL; |
| 442 | |
Theodore Ts'o | 7ce0806 | 2004-04-19 21:42:18 -0400 | [diff] [blame] | 443 | now = time(0); |
| 444 | diff = now - dev->bid_time; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 445 | |
Theodore Ts'o | 7ce0806 | 2004-04-19 21:42:18 -0400 | [diff] [blame] | 446 | if ((now < dev->bid_time) || |
| 447 | (diff < BLKID_PROBE_MIN) || |
| 448 | (dev->bid_flags & BLKID_BID_FL_VERIFIED && |
| 449 | diff < BLKID_PROBE_INTERVAL)) |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 450 | return dev; |
| 451 | |
Theodore Ts'o | f0a22d0 | 2003-02-22 13:19:53 -0500 | [diff] [blame] | 452 | DBG(DEBUG_PROBE, |
| 453 | printf("need to revalidate %s (time since last check %lu)\n", |
Theodore Ts'o | ce72b86 | 2003-02-14 01:31:45 -0500 | [diff] [blame] | 454 | dev->bid_name, diff)); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 455 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 456 | if (((fd = open(dev->bid_name, O_RDONLY)) < 0) || |
| 457 | (fstat(fd, &st) < 0) || !S_ISBLK(st.st_mode)) { |
Theodore Ts'o | ce72b86 | 2003-02-14 01:31:45 -0500 | [diff] [blame] | 458 | if (errno == ENXIO || errno == ENODEV || errno == ENOENT) { |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 459 | blkid_free_dev(dev); |
| 460 | return NULL; |
| 461 | } |
| 462 | /* We don't have read permission, just return cache data. */ |
Theodore Ts'o | f0a22d0 | 2003-02-22 13:19:53 -0500 | [diff] [blame] | 463 | DBG(DEBUG_PROBE, |
| 464 | printf("returning unverified data for %s\n", |
| 465 | dev->bid_name)); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 466 | return dev; |
| 467 | } |
| 468 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 469 | memset(bufs, 0, sizeof(bufs)); |
| 470 | |
| 471 | /* |
| 472 | * Iterate over the type array. If we already know the type, |
| 473 | * then try that first. If it doesn't work, then blow away |
| 474 | * the type information, and try again. |
| 475 | * |
| 476 | */ |
| 477 | try_again: |
| 478 | type = 0; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 479 | if (!dev->bid_type || !strcmp(dev->bid_type, "mdraid")) { |
| 480 | uuid_t uuid; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 481 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 482 | if (check_mdraid(fd, uuid) == 0) { |
| 483 | set_uuid(dev, uuid); |
| 484 | type = "mdraid"; |
| 485 | goto found_type; |
| 486 | } |
| 487 | } |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 488 | for (id = type_array; id->bim_type; id++) { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 489 | if (dev->bid_type && |
| 490 | strcmp(id->bim_type, dev->bid_type)) |
| 491 | continue; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 492 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 493 | idx = id->bim_kboff + (id->bim_sboff >> 10); |
| 494 | if (idx > BLKID_BLK_OFFS || idx < 0) |
| 495 | continue; |
| 496 | buf = bufs[idx]; |
| 497 | if (!buf) { |
| 498 | if (lseek(fd, idx << 10, SEEK_SET) < 0) |
| 499 | continue; |
| 500 | |
| 501 | if (!(buf = (unsigned char *)malloc(1024))) |
| 502 | continue; |
| 503 | |
| 504 | if (read(fd, buf, 1024) != 1024) { |
| 505 | free(buf); |
| 506 | continue; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 507 | } |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 508 | bufs[idx] = buf; |
| 509 | } |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 510 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 511 | if (memcmp(id->bim_magic, buf + (id->bim_sboff&0x3ff), |
| 512 | id->bim_len)) |
| 513 | continue; |
| 514 | |
| 515 | if ((id->bim_probe == NULL) || |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 516 | (id->bim_probe(fd, cache, dev, id, buf) == 0)) { |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 517 | type = id->bim_type; |
| 518 | goto found_type; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 519 | } |
| 520 | } |
| 521 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 522 | if (!id->bim_type && dev->bid_type) { |
| 523 | /* |
| 524 | * Zap the device filesystem type and try again |
| 525 | */ |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 526 | blkid_set_tag(dev, "TYPE", 0, 0); |
| 527 | blkid_set_tag(dev, "SEC_TYPE", 0, 0); |
| 528 | blkid_set_tag(dev, "LABEL", 0, 0); |
| 529 | blkid_set_tag(dev, "UUID", 0, 0); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 530 | goto try_again; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 531 | } |
| 532 | |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 533 | if (!dev->bid_type) { |
| 534 | blkid_free_dev(dev); |
| 535 | return NULL; |
| 536 | } |
| 537 | |
| 538 | found_type: |
| 539 | if (dev && type) { |
| 540 | dev->bid_devno = st.st_rdev; |
| 541 | dev->bid_time = time(0); |
| 542 | dev->bid_flags |= BLKID_BID_FL_VERIFIED; |
Theodore Ts'o | ce72b86 | 2003-02-14 01:31:45 -0500 | [diff] [blame] | 543 | cache->bic_flags |= BLKID_BIC_FL_CHANGED; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 544 | |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 545 | blkid_set_tag(dev, "TYPE", type, 0); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 546 | |
Theodore Ts'o | f0a22d0 | 2003-02-22 13:19:53 -0500 | [diff] [blame] | 547 | DBG(DEBUG_PROBE, printf("%s: devno 0x%04Lx, type %s\n", |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 548 | dev->bid_name, st.st_rdev, type)); |
| 549 | } |
| 550 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 551 | close(fd); |
| 552 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 553 | return dev; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 554 | } |
| 555 | |
Theodore Ts'o | 78e2edf | 2003-07-21 19:42:19 -0400 | [diff] [blame] | 556 | int blkid_known_fstype(const char *fstype) |
| 557 | { |
| 558 | struct blkid_magic *id; |
| 559 | |
| 560 | for (id = type_array; id->bim_type; id++) { |
| 561 | if (strcmp(fstype, id->bim_type) == 0) |
| 562 | return 1; |
| 563 | } |
| 564 | return 0; |
| 565 | } |
| 566 | |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 567 | #ifdef TEST_PROGRAM |
| 568 | int main(int argc, char **argv) |
| 569 | { |
Theodore Ts'o | 7a603aa | 2003-01-26 01:54:39 -0500 | [diff] [blame] | 570 | blkid_dev dev; |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 571 | blkid_cache cache; |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 572 | int ret; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 573 | |
Theodore Ts'o | f0a22d0 | 2003-02-22 13:19:53 -0500 | [diff] [blame] | 574 | blkid_debug_mask = DEBUG_ALL; |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 575 | if (argc != 2) { |
| 576 | fprintf(stderr, "Usage: %s device\n" |
| 577 | "Probe a single device to determine type\n", argv[0]); |
| 578 | exit(1); |
| 579 | } |
Theodore Ts'o | 79dd234 | 2003-02-22 17:15:20 -0500 | [diff] [blame] | 580 | if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) { |
| 581 | fprintf(stderr, "%s: error creating cache (%d)\n", |
| 582 | argv[0], ret); |
| 583 | exit(1); |
| 584 | } |
Theodore Ts'o | 98999c3 | 2003-02-16 00:47:07 -0500 | [diff] [blame] | 585 | dev = blkid_get_dev(cache, argv[1], BLKID_DEV_NORMAL); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 586 | if (!dev) { |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 587 | printf("%s: %s has an unsupported type\n", argv[0], argv[1]); |
Theodore Ts'o | 50b380b | 2003-02-12 23:51:21 -0500 | [diff] [blame] | 588 | return (1); |
| 589 | } |
| 590 | printf("%s is type %s\n", argv[1], dev->bid_type ? |
| 591 | dev->bid_type : "(null)"); |
| 592 | if (dev->bid_label) |
| 593 | printf("\tlabel is '%s'\n", dev->bid_label); |
| 594 | if (dev->bid_uuid) |
| 595 | printf("\tuuid is %s\n", dev->bid_uuid); |
| 596 | |
| 597 | blkid_free_dev(dev); |
Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame] | 598 | return (0); |
| 599 | } |
| 600 | #endif |