lib/blkid/probe.c

   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
   6  * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o
   7  * Copyright (C) 2001 by Andreas Dilger
   8  * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
   9  *
  10  * %Begin-Header%
  11  * This file may be redistributed under the terms of the
  12  * GNU Lesser General Public License.
  13  * %End-Header%
  14  */
  15
  16 #include "config.h"
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <ctype.h>
  23 #include <sys/types.h>
  24 #ifdef HAVE_SYS_STAT_H
  25 #include <sys/stat.h>
  26 #endif
  27 #ifdef HAVE_SYS_MKDEV_H
  28 #include <sys/mkdev.h>
  29 #endif
  30 #ifdef __linux__
  31 #include <sys/utsname.h>
  32 #endif
  33 #ifdef HAVE_ERRNO_H
  34 #include <errno.h>
  35 #endif
  36 #include "blkidP.h"
  37 #include "uuid/uuid.h"
  38 #include "probe.h"
  39
  40 static int figure_label_len(const unsigned char *label, int len)
  41 {
  42         const unsigned char *end = label + len - 1;
  43
  44         while (end >= label && (*end == ' ' || *end == 0))
  45                 --end;
  46         if (end >= label)
  47                 return end - label + 1;
  48         return 0;
  49 }
  50
  51 static unsigned char *get_buffer(struct blkid_probe *pr,
  52                           blkid_loff_t off, size_t len)
  53 {
  54         ssize_t         ret_read;
  55         unsigned char   *newbuf;
  56
  57         if (off + len <= SB_BUFFER_SIZE) {
  58                 if (!pr->sbbuf) {
  59                         pr->sbbuf = malloc(SB_BUFFER_SIZE);
  60                         if (!pr->sbbuf)
  61                                 return NULL;
  62                         if (lseek(pr->fd, 0, SEEK_SET) < 0)
  63                                 return NULL;
  64                         ret_read = read(pr->fd, pr->sbbuf, SB_BUFFER_SIZE);
  65                         if (ret_read < 0)
  66                                 ret_read = 0;
  67                         pr->sb_valid = ret_read;
  68                 }
  69                 if (off+len > pr->sb_valid)
  70                         return NULL;
  71                 return pr->sbbuf + off;
  72         } else {
  73                 if (len > pr->buf_max) {
  74                         newbuf = realloc(pr->buf, len);
  75                         if (newbuf == NULL)
  76                                 return NULL;
  77                         pr->buf = newbuf;
  78                         pr->buf_max = len;
  79                 }
  80                 if (blkid_llseek(pr->fd, off, SEEK_SET) < 0)
  81                         return NULL;
  82                 ret_read = read(pr->fd, pr->buf, len);
  83                 if (ret_read != (ssize_t) len)
  84                         return NULL;
  85                 return pr->buf;
  86         }
  87 }
  88
  89
  90 /*
  91  * This is a special case code to check for an MDRAID device.  We do
  92  * this special since it requires checking for a superblock at the end
  93  * of the device.
  94  */
  95 static int check_mdraid(int fd, unsigned char *ret_uuid)
  96 {
  97         struct mdp_superblock_s *md;
  98         blkid_loff_t            offset;
  99         char                    buf[4096];
 100
 101         if (fd < 0)
 102                 return -BLKID_ERR_PARAM;
 103
 104         offset = (blkid_get_dev_size(fd) & ~((blkid_loff_t)65535)) - 65536;
 105
 106         if (blkid_llseek(fd, offset, 0) < 0 ||
 107             read(fd, buf, 4096) != 4096)
 108                 return -BLKID_ERR_IO;
 109         /* Check for magic number */
 110         if (memcmp("\251+N\374", buf, 4) && memcmp("\374N+\251", buf, 4))
 111                 return -BLKID_ERR_PARAM;
 112
 113         if (!ret_uuid)
 114                 return 0;
 115         *ret_uuid = 0;
 116
 117         /* The MD UUID is not contiguous in the superblock, make it so */
 118         md = (struct mdp_superblock_s *)buf;
 119         if (md->set_uuid0 || md->set_uuid1 || md->set_uuid2 || md->set_uuid3) {
 120                 memcpy(ret_uuid, &md->set_uuid0, 4);
 121                 memcpy(ret_uuid + 4, &md->set_uuid1, 12);
 122         }
 123         return 0;
 124 }
 125
 126 static void set_uuid(blkid_dev dev, uuid_t uuid, const char *tag)
 127 {
 128         char    str[37];
 129
 130         if (!uuid_is_null(uuid)) {
 131                 uuid_unparse(uuid, str);
 132                 blkid_set_tag(dev, tag ? tag : "UUID", str, sizeof(str));
 133         }
 134 }
 135
 136 static void get_ext2_info(blkid_dev dev, struct blkid_magic *id,
 137                           unsigned char *buf)
 138 {
 139         struct ext2_super_block *es = (struct ext2_super_block *) buf;
 140         const char *label = 0;
 141
 142         DBG(DEBUG_PROBE, printf("ext2_sb.compat = %08X:%08X:%08X\n",
 143                    blkid_le32(es->s_feature_compat),
 144                    blkid_le32(es->s_feature_incompat),
 145                    blkid_le32(es->s_feature_ro_compat)));
 146
 147         if (strlen(es->s_volume_name))
 148                 label = es->s_volume_name;
 149         blkid_set_tag(dev, "LABEL", label, sizeof(es->s_volume_name));
 150
 151         set_uuid(dev, es->s_uuid, 0);
 152
 153         if ((es->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
 154             !uuid_is_null(es->s_journal_uuid))
 155                 set_uuid(dev, es->s_journal_uuid, "EXT_JOURNAL");
 156
 157         if (strcmp(id->bim_type, "ext2") &&
 158             ((blkid_le32(es->s_feature_incompat) &
 159               EXT2_FEATURE_INCOMPAT_UNSUPPORTED) == 0))
 160                 blkid_set_tag(dev, "SEC_TYPE", "ext2", sizeof("ext2"));
 161 }
 162
 163 /*
 164  * Check to see if a filesystem is in /proc/filesystems.
 165  * Returns 1 if found, 0 if not
 166  */
 167 static int fs_proc_check(const char *fs_name)
 168 {
 169         FILE    *f;
 170         char    buf[80], *cp, *t;
 171
 172         f = fopen("/proc/filesystems", "r");
 173         if (!f)
 174                 return (0);
 175         while (!feof(f)) {
 176                 if (!fgets(buf, sizeof(buf), f))
 177                         break;
 178                 cp = buf;
 179                 if (!isspace(*cp)) {
 180                         while (*cp && !isspace(*cp))
 181                                 cp++;
 182                 }
 183                 while (*cp && isspace(*cp))
 184                         cp++;
 185                 if ((t = strchr(cp, '\n')) != NULL)
 186                         *t = 0;
 187                 if ((t = strchr(cp, '\t')) != NULL)
 188                         *t = 0;
 189                 if ((t = strchr(cp, ' ')) != NULL)
 190                         *t = 0;
 191                 if (!strcmp(fs_name, cp)) {
 192                         fclose(f);
 193                         return (1);
 194                 }
 195         }
 196         fclose(f);
 197         return (0);
 198 }
 199
 200 /*
 201  * Check to see if a filesystem is available as a module
 202  * Returns 1 if found, 0 if not
 203  */
 204 static int check_for_modules(const char *fs_name)
 205 {
 206 #ifdef __linux__
 207         struct utsname  uts;
 208         FILE            *f;
 209         char            buf[1024], *cp;
 210         int             namesz;
 211
 212         if (uname(&uts))
 213                 return (0);
 214         snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
 215
 216         f = fopen(buf, "r");
 217         if (!f)
 218                 return (0);
 219
 220         namesz = strlen(fs_name);
 221
 222         while (!feof(f)) {
 223                 if (!fgets(buf, sizeof(buf), f))
 224                         break;
 225                 if ((cp = strchr(buf, ':')) != NULL)
 226                         *cp = 0;
 227                 else
 228                         continue;
 229                 if ((cp = strrchr(buf, '/')) != NULL)
 230                         cp++;
 231                 else
 232                         cp = buf;
 233                 if (!strncmp(cp, fs_name, namesz) &&
 234                     (!strcmp(cp + namesz, ".ko") ||
 235                      !strcmp(cp + namesz, ".ko.gz"))) {
 236                         fclose(f);
 237                         return (1);
 238                 }
 239         }
 240         fclose(f);
 241 #endif
 242         return (0);
 243 }
 244
 245 static int linux_version_code(void)
 246 {
 247 #ifdef __linux__
 248         struct utsname  ut;
 249         static int      version_code = -1;
 250         int             major, minor, rev;
 251         char            *endptr;
 252         const char      *cp;
 253
 254         if (version_code > 0)
 255                 return version_code;
 256
 257         if (uname(&ut))
 258                 return 0;
 259         cp = ut.release;
 260
 261         major = strtol(cp, &endptr, 10);
 262         if (cp == endptr || *endptr != '.')
 263                 return 0;
 264         cp = endptr + 1;
 265         minor = strtol(cp, &endptr, 10);
 266         if (cp == endptr || *endptr != '.')
 267                 return 0;
 268         cp = endptr + 1;
 269         rev = strtol(cp, &endptr, 10);
 270         if (cp == endptr)
 271                 return 0;
 272         version_code = (((major * 256) + minor) * 256) + rev;
 273         return version_code;
 274 #else
 275         return 0;
 276 #endif
 277 }
 278
 279 #define EXT4_SUPPORTS_EXT2 (2 * 65536 + 6*256 + 29)
 280
 281 static int system_supports_ext2(void)
 282 {
 283         static time_t   last_check = 0;
 284         static int      ret = -1;
 285         time_t          now = time(0);
 286
 287         if (ret != -1 || (now - last_check) < 5)
 288                 return ret;
 289         last_check = now;
 290         ret = (fs_proc_check("ext2") || check_for_modules("ext2"));
 291         return ret;
 292 }
 293
 294 static int system_supports_ext4(void)
 295 {
 296         static time_t   last_check = 0;
 297         static int      ret = -1;
 298         time_t          now = time(0);
 299
 300         if (ret != -1 || (now - last_check) < 5)
 301                 return ret;
 302         last_check = now;
 303         ret = (fs_proc_check("ext4") || check_for_modules("ext4"));
 304         return ret;
 305 }
 306
 307 static int system_supports_ext4dev(void)
 308 {
 309         static time_t   last_check = 0;
 310         static int      ret = -1;
 311         time_t          now = time(0);
 312
 313         if (ret != -1 || (now - last_check) < 5)
 314                 return ret;
 315         last_check = now;
 316         ret = (fs_proc_check("ext4dev") || check_for_modules("ext4dev"));
 317         return ret;
 318 }
 319
 320 static int probe_ext4dev(struct blkid_probe *probe,
 321                          struct blkid_magic *id,
 322                          unsigned char *buf)
 323 {
 324         struct ext2_super_block *es;
 325         es = (struct ext2_super_block *)buf;
 326
 327         /* Distinguish from jbd */
 328         if (blkid_le32(es->s_feature_incompat) &
 329             EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 330                 return -BLKID_ERR_PARAM;
 331
 332         /*
 333          * If the filesystem does not have a journal and ext2 and ext4
 334          * is not present, then force this to be detected as an
 335          * ext4dev filesystem.
 336          */
 337         if (!(blkid_le32(es->s_feature_compat) &
 338               EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
 339             !system_supports_ext2() && !system_supports_ext4() &&
 340             system_supports_ext4dev() &&
 341             linux_version_code() >= EXT4_SUPPORTS_EXT2)
 342                 goto force_ext4dev;
 343
 344         /*
 345          * If the filesystem is marked as OK for use by in-development
 346          * filesystem code, but ext4dev is not supported, and ext4 is,
 347          * then don't call ourselves ext4dev, since we should be
 348          * detected as ext4 in that case.
 349          *
 350          * If the filesystem is marked as in use by production
 351          * filesystem, then it can only be used by ext4 and NOT by
 352          * ext4dev, so always disclaim we are ext4dev in that case.
 353          */
 354         if (blkid_le32(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) {
 355                 if (!system_supports_ext4dev() && system_supports_ext4())
 356                         return -BLKID_ERR_PARAM;
 357         } else
 358                 return -BLKID_ERR_PARAM;
 359
 360 force_ext4dev:
 361         get_ext2_info(probe->dev, id, buf);
 362         return 0;
 363 }
 364
 365 static int probe_ext4(struct blkid_probe *probe, struct blkid_magic *id,
 366                       unsigned char *buf)
 367 {
 368         struct ext2_super_block *es;
 369         es = (struct ext2_super_block *)buf;
 370
 371         /* Distinguish from jbd */
 372         if (blkid_le32(es->s_feature_incompat) &
 373             EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 374                 return -BLKID_ERR_PARAM;
 375
 376         /*
 377          * If the filesystem does not have a journal and ext2 is not
 378          * present, then force this to be detected as an ext2
 379          * filesystem.
 380          */
 381         if (!(blkid_le32(es->s_feature_compat) &
 382               EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
 383             !system_supports_ext2() && system_supports_ext4() &&
 384             linux_version_code() >= EXT4_SUPPORTS_EXT2)
 385                 goto force_ext4;
 386
 387         /* Ext4 has at least one feature which ext3 doesn't understand */
 388         if (!(blkid_le32(es->s_feature_ro_compat) &
 389               EXT3_FEATURE_RO_COMPAT_UNSUPPORTED) &&
 390             !(blkid_le32(es->s_feature_incompat) &
 391               EXT3_FEATURE_INCOMPAT_UNSUPPORTED))
 392                 return -BLKID_ERR_PARAM;
 393
 394 force_ext4:
 395         /*
 396          * If the filesystem is a OK for use by in-development
 397          * filesystem code, and ext4dev is supported or ext4 is not
 398          * supported, then don't call ourselves ext4, so we can redo
 399          * the detection and mark the filesystem as ext4dev.
 400          *
 401          * If the filesystem is marked as in use by production
 402          * filesystem, then it can only be used by ext4 and NOT by
 403          * ext4dev.
 404          */
 405         if (blkid_le32(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) {
 406                 if (system_supports_ext4dev() || !system_supports_ext4())
 407                         return -BLKID_ERR_PARAM;
 408         }
 409         get_ext2_info(probe->dev, id, buf);
 410         return 0;
 411 }
 412
 413 static int probe_ext3(struct blkid_probe *probe, struct blkid_magic *id,
 414                       unsigned char *buf)
 415 {
 416         struct ext2_super_block *es;
 417         es = (struct ext2_super_block *)buf;
 418
 419         /* ext3 requires journal */
 420         if (!(blkid_le32(es->s_feature_compat) &
 421               EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 422                 return -BLKID_ERR_PARAM;
 423
 424         /* Any features which ext3 doesn't understand */
 425         if ((blkid_le32(es->s_feature_ro_compat) &
 426              EXT3_FEATURE_RO_COMPAT_UNSUPPORTED) ||
 427             (blkid_le32(es->s_feature_incompat) &
 428              EXT3_FEATURE_INCOMPAT_UNSUPPORTED))
 429                 return -BLKID_ERR_PARAM;
 430
 431         get_ext2_info(probe->dev, id, buf);
 432         return 0;
 433 }
 434
 435 static int probe_ext2(struct blkid_probe *probe, struct blkid_magic *id,
 436                       unsigned char *buf)
 437 {
 438         struct ext2_super_block *es;
 439
 440         es = (struct ext2_super_block *)buf;
 441
 442         /* Distinguish between ext3 and ext2 */
 443         if ((blkid_le32(es->s_feature_compat) &
 444               EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 445                 return -BLKID_ERR_PARAM;
 446
 447         /* Any features which ext2 doesn't understand */
 448         if ((blkid_le32(es->s_feature_ro_compat) &
 449              EXT2_FEATURE_RO_COMPAT_UNSUPPORTED) ||
 450             (blkid_le32(es->s_feature_incompat) &
 451              EXT2_FEATURE_INCOMPAT_UNSUPPORTED))
 452                 return -BLKID_ERR_PARAM;
 453
 454         /*
 455          * If ext2 is not present, but ext4 or ext4dev are, then
 456          * disclaim we are ext2
 457          */
 458         if (!system_supports_ext2() &&
 459             (system_supports_ext4() || system_supports_ext4dev()) &&
 460             linux_version_code() >= EXT4_SUPPORTS_EXT2)
 461                 return -BLKID_ERR_PARAM;
 462
 463         get_ext2_info(probe->dev, id, buf);
 464         return 0;
 465 }
 466
 467 static int probe_jbd(struct blkid_probe *probe, struct blkid_magic *id,
 468                      unsigned char *buf)
 469 {
 470         struct ext2_super_block *es = (struct ext2_super_block *) buf;
 471
 472         if (!(blkid_le32(es->s_feature_incompat) &
 473               EXT3_FEATURE_INCOMPAT_JOURNAL_DEV))
 474                 return -BLKID_ERR_PARAM;
 475
 476         get_ext2_info(probe->dev, id, buf);
 477
 478         return 0;
 479 }
 480
 481 #define FAT_ATTR_VOLUME_ID              0x08
 482 #define FAT_ATTR_DIR                    0x10
 483 #define FAT_ATTR_LONG_NAME              0x0f
 484 #define FAT_ATTR_MASK                   0x3f
 485 #define FAT_ENTRY_FREE                  0xe5
 486
 487 static const char *no_name = "NO NAME    ";
 488
 489 static unsigned char *search_fat_label(struct vfat_dir_entry *dir, int count)
 490 {
 491         int i;
 492
 493         for (i = 0; i < count; i++) {
 494                 if (dir[i].name[0] == 0x00)
 495                         break;
 496
 497                 if ((dir[i].name[0] == FAT_ENTRY_FREE) ||
 498                     (dir[i].cluster_high != 0 || dir[i].cluster_low != 0) ||
 499                     ((dir[i].attr & FAT_ATTR_MASK) == FAT_ATTR_LONG_NAME))
 500                         continue;
 501
 502                 if ((dir[i].attr & (FAT_ATTR_VOLUME_ID | FAT_ATTR_DIR)) ==
 503                     FAT_ATTR_VOLUME_ID) {
 504                         return dir[i].name;
 505                 }
 506         }
 507         return 0;
 508 }
 509
 510 /* FAT label extraction from the root directory taken from Kay
 511  * Sievers's volume_id library */
 512 static int probe_fat(struct blkid_probe *probe,
 513                       struct blkid_magic *id __BLKID_ATTR((unused)),
 514                       unsigned char *buf)
 515 {
 516         struct vfat_super_block *vs = (struct vfat_super_block *) buf;
 517         struct msdos_super_block *ms = (struct msdos_super_block *) buf;
 518         struct vfat_dir_entry *dir;
 519         char serno[10];
 520         const unsigned char *label = 0, *vol_label = 0, *tmp;
 521         unsigned char   *vol_serno;
 522         int label_len = 0, maxloop = 100;
 523         __u16 sector_size, dir_entries, reserved;
 524         __u32 sect_count, fat_size, dir_size, cluster_count, fat_length;
 525         __u32 buf_size, start_data_sect, next, root_start, root_dir_entries;
 526
 527         /* sector size check */
 528         tmp = (unsigned char *)&ms->ms_sector_size;
 529         sector_size = tmp[0] + (tmp[1] << 8);
 530         if (sector_size != 0x200 && sector_size != 0x400 &&
 531             sector_size != 0x800 && sector_size != 0x1000)
 532                 return 1;
 533
 534         tmp = (unsigned char *)&ms->ms_dir_entries;
 535         dir_entries = tmp[0] + (tmp[1] << 8);
 536         reserved =  blkid_le16(ms->ms_reserved);
 537         tmp = (unsigned char *)&ms->ms_sectors;
 538         sect_count = tmp[0] + (tmp[1] << 8);
 539         if (sect_count == 0)
 540                 sect_count = blkid_le32(ms->ms_total_sect);
 541
 542         fat_length = blkid_le16(ms->ms_fat_length);
 543         if (fat_length == 0)
 544                 fat_length = blkid_le32(vs->vs_fat32_length);
 545
 546         fat_size = fat_length * ms->ms_fats;
 547         dir_size = ((dir_entries * sizeof(struct vfat_dir_entry)) +
 548                         (sector_size-1)) / sector_size;
 549
 550         cluster_count = sect_count - (reserved + fat_size + dir_size);
 551         if (ms->ms_cluster_size == 0)
 552                 return 1;
 553         cluster_count /= ms->ms_cluster_size;
 554
 555         if (cluster_count > FAT32_MAX)
 556                 return 1;
 557
 558         if (ms->ms_fat_length) {
 559                 /* the label may be an attribute in the root directory */
 560                 root_start = (reserved + fat_size) * sector_size;
 561                 root_dir_entries = vs->vs_dir_entries[0] +
 562                         (vs->vs_dir_entries[1] << 8);
 563
 564                 buf_size = root_dir_entries * sizeof(struct vfat_dir_entry);
 565                 dir = (struct vfat_dir_entry *) get_buffer(probe, root_start,
 566                                                            buf_size);
 567                 if (dir)
 568                         vol_label = search_fat_label(dir, root_dir_entries);
 569
 570                 if (!vol_label || !memcmp(vol_label, no_name, 11))
 571                         vol_label = ms->ms_label;
 572                 vol_serno = ms->ms_serno;
 573
 574                 blkid_set_tag(probe->dev, "SEC_TYPE", "msdos",
 575                               sizeof("msdos"));
 576         } else {
 577                 /* Search the FAT32 root dir for the label attribute */
 578                 buf_size = vs->vs_cluster_size * sector_size;
 579                 start_data_sect = reserved + fat_size;
 580
 581                 next = blkid_le32(vs->vs_root_cluster);
 582                 while (next && --maxloop) {
 583                         __u32 next_sect_off;
 584                         __u64 next_off, fat_entry_off;
 585                         int count;
 586
 587                         next_sect_off = (next - 2) * vs->vs_cluster_size;
 588                         next_off = (__u64) (start_data_sect + next_sect_off) *
 589                                 sector_size;
 590
 591                         dir = (struct vfat_dir_entry *)
 592                                 get_buffer(probe, next_off, buf_size);
 593                         if (dir == NULL)
 594                                 break;
 595
 596                         count = buf_size / sizeof(struct vfat_dir_entry);
 597
 598                         vol_label = search_fat_label(dir, count);
 599                         if (vol_label)
 600                                 break;
 601
 602                         /* get FAT entry */
 603                         fat_entry_off =
 604                                 ((unsigned int) reserved *
 605                                  (unsigned int) sector_size) +
 606                                 (next * sizeof(__u32));
 607                         buf = get_buffer(probe, fat_entry_off, buf_size);
 608                         if (buf == NULL)
 609                                 break;
 610
 611                         /* set next cluster */
 612                         next = blkid_le32(*((__u32 *) buf) & 0x0fffffff);
 613                 }
 614
 615                 if (!vol_label || !memcmp(vol_label, no_name, 11))
 616                         vol_label = vs->vs_label;
 617                 vol_serno = vs->vs_serno;
 618         }
 619
 620         if (vol_label && memcmp(vol_label, no_name, 11)) {
 621                 if ((label_len = figure_label_len(vol_label, 11)))
 622                         label = vol_label;
 623         }
 624
 625         /* We can't just print them as %04X, because they are unaligned */
 626         sprintf(serno, "%02X%02X-%02X%02X", vol_serno[3], vol_serno[2],
 627                 vol_serno[1], vol_serno[0]);
 628
 629         blkid_set_tag(probe->dev, "LABEL", (const char *) label, label_len);
 630         blkid_set_tag(probe->dev, "UUID", serno, sizeof(serno)-1);
 631
 632         return 0;
 633 }
 634
 635 /*
 636  * The FAT filesystem could be without a magic string in superblock
 637  * (e.g. old floppies).  This heuristic for FAT detection is inspired
 638  * by http://vrfy.org/projects/volume_id/ and Linux kernel.
 639  * [7-Jul-2005, Karel Zak <kzak@redhat.com>]
 640  */
 641 static int probe_fat_nomagic(struct blkid_probe *probe,
 642                              struct blkid_magic *id __BLKID_ATTR((unused)),
 643                              unsigned char *buf)
 644 {
 645         struct msdos_super_block *ms;
 646
 647         ms = (struct msdos_super_block *)buf;
 648
 649         /* heads check */
 650         if (ms->ms_heads == 0)
 651                 return 1;
 652
 653         /* cluster size check*/
 654         if (ms->ms_cluster_size == 0 ||
 655             (ms->ms_cluster_size & (ms->ms_cluster_size-1)))
 656                 return 1;
 657
 658         /* media check */
 659         if (ms->ms_media < 0xf8 && ms->ms_media != 0xf0)
 660                 return 1;
 661
 662         /* fat counts(Linux kernel expects at least 1 FAT table) */
 663         if (!ms->ms_fats)
 664                 return 1;
 665
 666         /*
 667          * OS/2 and apparently DFSee will place a FAT12/16-like
 668          * pseudo-superblock in the first 512 bytes of non-FAT
 669          * filesystems --- at least JFS and HPFS, and possibly others.
 670          * So we explicitly check for those filesystems at the
 671          * FAT12/16 filesystem magic field identifier, and if they are
 672          * present, we rule this out as a FAT filesystem, despite the
 673          * FAT-like pseudo-header.
 674          */
 675         if ((memcmp(ms->ms_magic, "JFS     ", 8) == 0) ||
 676             (memcmp(ms->ms_magic, "HPFS    ", 8) == 0))
 677                 return 1;
 678
 679         return probe_fat(probe, id, buf);
 680 }
 681
 682 static int probe_ntfs(struct blkid_probe *probe,
 683                       struct blkid_magic *id __BLKID_ATTR((unused)),
 684                       unsigned char *buf)
 685 {
 686         struct ntfs_super_block *ns;
 687         struct master_file_table_record *mft;
 688         struct file_attribute *attr;
 689         char            uuid_str[17], label_str[129], *cp;
 690         int             bytes_per_sector, sectors_per_cluster;
 691         int             mft_record_size, attr_off, attr_len;
 692         unsigned int    i, attr_type, val_len;
 693         int             val_off;
 694         __u64           nr_clusters;
 695         blkid_loff_t off;
 696         unsigned char *buf_mft, *val;
 697
 698         ns = (struct ntfs_super_block *) buf;
 699
 700         bytes_per_sector = ns->bios_parameter_block[0] +
 701                 (ns->bios_parameter_block[1]  << 8);
 702         sectors_per_cluster = ns->bios_parameter_block[2];
 703
 704         if ((bytes_per_sector < 512) || (sectors_per_cluster == 0))
 705                 return 1;
 706
 707         if (ns->cluster_per_mft_record < 0)
 708                 mft_record_size = 1 << (0-ns->cluster_per_mft_record);
 709         else
 710                 mft_record_size = ns->cluster_per_mft_record *
 711                         sectors_per_cluster * bytes_per_sector;
 712         nr_clusters = blkid_le64(ns->number_of_sectors) / sectors_per_cluster;
 713
 714         if ((blkid_le64(ns->mft_cluster_location) > nr_clusters) ||
 715             (blkid_le64(ns->mft_mirror_cluster_location) > nr_clusters))
 716                 return 1;
 717
 718         off = blkid_le64(ns->mft_mirror_cluster_location) *
 719                 bytes_per_sector * sectors_per_cluster;
 720
 721         buf_mft = get_buffer(probe, off, mft_record_size);
 722         if (!buf_mft)
 723                 return 1;
 724
 725         if (memcmp(buf_mft, "FILE", 4))
 726                 return 1;
 727
 728         off = blkid_le64(ns->mft_cluster_location) * bytes_per_sector *
 729                 sectors_per_cluster;
 730
 731         buf_mft = get_buffer(probe, off, mft_record_size);
 732         if (!buf_mft)
 733                 return 1;
 734
 735         if (memcmp(buf_mft, "FILE", 4))
 736                 return 1;
 737
 738         off += MFT_RECORD_VOLUME * mft_record_size;
 739
 740         buf_mft = get_buffer(probe, off, mft_record_size);
 741         if (!buf_mft)
 742                 return 1;
 743
 744         if (memcmp(buf_mft, "FILE", 4))
 745                 return 1;
 746
 747         mft = (struct master_file_table_record *) buf_mft;
 748
 749         attr_off = blkid_le16(mft->attrs_offset);
 750         label_str[0] = 0;
 751
 752         while (1) {
 753                 attr = (struct file_attribute *) (buf_mft + attr_off);
 754                 attr_len = blkid_le16(attr->len);
 755                 attr_type = blkid_le32(attr->type);
 756                 val_off = blkid_le16(attr->value_offset);
 757                 val_len = blkid_le32(attr->value_len);
 758
 759                 attr_off += attr_len;
 760
 761                 if ((attr_off > mft_record_size) ||
 762                     (attr_len == 0))
 763                         break;
 764
 765                 if (attr_type == MFT_RECORD_ATTR_END)
 766                         break;
 767
 768                 if (attr_type == MFT_RECORD_ATTR_VOLUME_NAME) {
 769                         if (val_len > sizeof(label_str))
 770                                 val_len = sizeof(label_str)-1;
 771
 772                         for (i=0, cp=label_str; i < val_len; i+=2,cp++) {
 773                                 val = ((__u8 *) attr) + val_off + i;
 774                                 *cp = val[0];
 775                                 if (val[1])
 776                                         *cp = '?';
 777                         }
 778                         *cp = 0;
 779                 }
 780         }
 781
 782         sprintf(uuid_str, "%016llX", blkid_le64(ns->volume_serial));
 783         blkid_set_tag(probe->dev, "UUID", uuid_str, 0);
 784         if (label_str[0])
 785                 blkid_set_tag(probe->dev, "LABEL", label_str, 0);
 786         return 0;
 787 }
 788
 789
 790 static int probe_xfs(struct blkid_probe *probe,
 791                      struct blkid_magic *id __BLKID_ATTR((unused)),
 792                      unsigned char *buf)
 793 {
 794         struct xfs_super_block *xs;
 795         const char *label = 0;
 796
 797         xs = (struct xfs_super_block *)buf;
 798
 799         if (strlen(xs->xs_fname))
 800                 label = xs->xs_fname;
 801         blkid_set_tag(probe->dev, "LABEL", label, sizeof(xs->xs_fname));
 802         set_uuid(probe->dev, xs->xs_uuid, 0);
 803         return 0;
 804 }
 805
 806 static int probe_reiserfs(struct blkid_probe *probe,
 807                           struct blkid_magic *id, unsigned char *buf)
 808 {
 809         struct reiserfs_super_block *rs = (struct reiserfs_super_block *) buf;
 810         unsigned int blocksize;
 811         const char *label = 0;
 812
 813         blocksize = blkid_le16(rs->rs_blocksize);
 814
 815         /* The blocksize must be at least 1k */
 816         if ((blocksize >> 10) == 0)
 817                 return -BLKID_ERR_PARAM;
 818
 819         /* If the superblock is inside the journal, we have the wrong one */
 820         if (id->bim_kboff/(blocksize>>10) > blkid_le32(rs->rs_journal_block))
 821                 return -BLKID_ERR_BIG;
 822
 823         /* LABEL/UUID are only valid for later versions of Reiserfs v3.6. */
 824         if (id->bim_magic[6] == '2' || id->bim_magic[6] == '3') {
 825                 if (strlen(rs->rs_label))
 826                         label = rs->rs_label;
 827                 set_uuid(probe->dev, rs->rs_uuid, 0);
 828         }
 829         blkid_set_tag(probe->dev, "LABEL", label, sizeof(rs->rs_label));
 830
 831         return 0;
 832 }
 833
 834 static int probe_reiserfs4(struct blkid_probe *probe,
 835                            struct blkid_magic *id __BLKID_ATTR((unused)),
 836                            unsigned char *buf)
 837 {
 838         struct reiser4_super_block *rs4 = (struct reiser4_super_block *) buf;
 839         const unsigned char *label = 0;
 840
 841         if (strlen((char *) rs4->rs4_label))
 842                 label = rs4->rs4_label;
 843         set_uuid(probe->dev, rs4->rs4_uuid, 0);
 844         blkid_set_tag(probe->dev, "LABEL", (const char *) label,
 845                       sizeof(rs4->rs4_label));
 846
 847         return 0;
 848 }
 849
 850 static int probe_jfs(struct blkid_probe *probe,
 851                      struct blkid_magic *id __BLKID_ATTR((unused)),
 852                      unsigned char *buf)
 853 {
 854         struct jfs_super_block *js;
 855         const char *label = 0;
 856
 857         js = (struct jfs_super_block *)buf;
 858
 859         if (blkid_le32(js->js_bsize) != (1U << blkid_le16(js->js_l2bsize)))
 860                 return 1;
 861
 862         if (blkid_le32(js->js_pbsize) != (1U << blkid_le16(js->js_l2pbsize)))
 863                 return 1;
 864
 865         if ((blkid_le16(js->js_l2bsize) - blkid_le16(js->js_l2pbsize)) !=
 866             blkid_le16(js->js_l2bfactor))
 867                 return 1;
 868
 869         if (strlen((char *) js->js_label))
 870                 label = (char *) js->js_label;
 871         blkid_set_tag(probe->dev, "LABEL", label, sizeof(js->js_label));
 872         set_uuid(probe->dev, js->js_uuid, 0);
 873         return 0;
 874 }
 875
 876 static int probe_zfs(struct blkid_probe *probe __BLKID_ATTR((unused)),
 877                      struct blkid_magic *id __BLKID_ATTR((unused)),
 878                      unsigned char *buf __BLKID_ATTR((unused)))
 879 {
 880 #if 0
 881         char *vdev_label;
 882         const char *pool_name = 0;
 883
 884         /* read nvpair data for pool name, pool GUID (complex) */
 885         blkid_set_tag(probe->dev, "LABEL", pool_name, sizeof(pool_name));
 886         set_uuid(probe->dev, pool_guid, 0);
 887 #endif
 888         return 0;
 889 }
 890
 891 static int probe_luks(struct blkid_probe *probe,
 892                        struct blkid_magic *id __BLKID_ATTR((unused)),
 893                        unsigned char *buf)
 894 {
 895         char uuid[40];
 896
 897         /* 168 is the offset to the 40 character uuid:
 898          * http://luks.endorphin.org/LUKS-on-disk-format.pdf */
 899         strncpy(uuid, (char *) buf+168, 40);
 900         blkid_set_tag(probe->dev, "UUID", uuid, sizeof(uuid));
 901         return 0;
 902 }
 903
 904 static int probe_romfs(struct blkid_probe *probe,
 905                        struct blkid_magic *id __BLKID_ATTR((unused)),
 906                        unsigned char *buf)
 907 {
 908         struct romfs_super_block *ros;
 909         const char *label = 0;
 910
 911         ros = (struct romfs_super_block *)buf;
 912
 913         if (strlen((char *) ros->ros_volume))
 914                 label = (char *) ros->ros_volume;
 915         blkid_set_tag(probe->dev, "LABEL", label, 0);
 916         return 0;
 917 }
 918
 919 static int probe_cramfs(struct blkid_probe *probe,
 920                         struct blkid_magic *id __BLKID_ATTR((unused)),
 921                         unsigned char *buf)
 922 {
 923         struct cramfs_super_block *csb;
 924         const char *label = 0;
 925
 926         csb = (struct cramfs_super_block *)buf;
 927
 928         if (strlen((char *) csb->name))
 929                 label = (char *) csb->name;
 930         blkid_set_tag(probe->dev, "LABEL", label, 0);
 931         return 0;
 932 }
 933
 934 static int probe_swap0(struct blkid_probe *probe,
 935                        struct blkid_magic *id __BLKID_ATTR((unused)),
 936                        unsigned char *buf __BLKID_ATTR((unused)))
 937 {
 938         blkid_set_tag(probe->dev, "UUID", 0, 0);
 939         blkid_set_tag(probe->dev, "LABEL", 0, 0);
 940         return 0;
 941 }
 942
 943 static int probe_swap1(struct blkid_probe *probe,
 944                        struct blkid_magic *id,
 945                        unsigned char *buf __BLKID_ATTR((unused)))
 946 {
 947         struct swap_id_block *sws;
 948
 949         probe_swap0(probe, id, buf);
 950         /*
 951          * Version 1 swap headers are always located at offset of 1024
 952          * bytes, although the swap signature itself is located at the
 953          * end of the page (which may vary depending on hardware
 954          * pagesize).
 955          */
 956         sws = (struct swap_id_block *) get_buffer(probe, 1024, 1024);
 957         if (!sws)
 958                 return 1;
 959
 960         /* check for wrong version or zeroed pagecount, for sanity */
 961         if (!memcmp(id->bim_magic, "SWAPSPACE2", id->bim_len) &&
 962                         (sws->sws_version != 1 || sws->sws_lastpage == 0))
 963                 return 1;
 964
 965         /* arbitrary sanity check.. is there any garbage down there? */
 966         if (sws->sws_pad[32] == 0 && sws->sws_pad[33] == 0)  {
 967                 if (sws->sws_volume[0])
 968                         blkid_set_tag(probe->dev, "LABEL", sws->sws_volume,
 969                                       sizeof(sws->sws_volume));
 970                 if (sws->sws_uuid[0])
 971                         set_uuid(probe->dev, sws->sws_uuid, 0);
 972         }
 973         return 0;
 974 }
 975
 976 static int probe_iso9660(struct blkid_probe *probe,
 977                          struct blkid_magic *id __BLKID_ATTR((unused)),
 978                          unsigned char *buf)
 979 {
 980         struct iso_volume_descriptor *iso;
 981         const unsigned char *label;
 982
 983         iso = (struct iso_volume_descriptor *) buf;
 984         label = iso->volume_id;
 985
 986         blkid_set_tag(probe->dev, "LABEL", (const char *) label,
 987                       figure_label_len(label, 32));
 988         return 0;
 989 }
 990
 991
 992 static const char
 993 *udf_magic[] = { "BEA01", "BOOT2", "CD001", "CDW02", "NSR02",
 994                  "NSR03", "TEA01", 0 };
 995
 996 static int probe_udf(struct blkid_probe *probe,
 997                      struct blkid_magic *id __BLKID_ATTR((unused)),
 998                      unsigned char *buf __BLKID_ATTR((unused)))
 999 {
1000         int j, bs;
1001         struct iso_volume_descriptor *isosb;
1002         const char ** m;
1003
1004         /* determine the block size by scanning in 2K increments
1005            (block sizes larger than 2K will be null padded) */
1006         for (bs = 1; bs < 16; bs++) {
1007                 isosb = (struct iso_volume_descriptor *)
1008                         get_buffer(probe, (blkid_loff_t) bs*2048+32768,
1009                                    sizeof(*isosb));
1010                 if (!isosb)
1011                         return 1;
1012                 if (isosb->vd_id[0])
1013                         break;
1014         }
1015
1016         /* Scan up to another 64 blocks looking for additional VSD's */
1017         for (j = 1; j < 64; j++) {
1018                 if (j > 1) {
1019                         isosb = (struct iso_volume_descriptor *)
1020                                 get_buffer(probe, j*bs*2048+32768,
1021                                            sizeof(*isosb));
1022                         if (!isosb)
1023                                 return 1;
1024                 }
1025                 /* If we find NSR0x then call it udf:
1026                    NSR01 for UDF 1.00
1027                    NSR02 for UDF 1.50
1028                    NSR03 for UDF 2.00 */
1029                 if (!memcmp(isosb->vd_id, "NSR0", 4))
1030                         return probe_iso9660(probe, id, buf);
1031                 for (m = udf_magic; *m; m++)
1032                         if (!memcmp(*m, isosb->vd_id, 5))
1033                                 break;
1034                 if (*m == 0)
1035                         return 1;
1036         }
1037         return 1;
1038 }
1039
1040 static int probe_ocfs(struct blkid_probe *probe,
1041                       struct blkid_magic *id __BLKID_ATTR((unused)),
1042                       unsigned char *buf)
1043 {
1044         struct ocfs_volume_header ovh;
1045         struct ocfs_volume_label ovl;
1046         __u32 major;
1047
1048         memcpy(&ovh, buf, sizeof(ovh));
1049         memcpy(&ovl, buf+512, sizeof(ovl));
1050
1051         major = ocfsmajor(ovh);
1052         if (major == 1)
1053                 blkid_set_tag(probe->dev,"SEC_TYPE","ocfs1",sizeof("ocfs1"));
1054         else if (major >= 9)
1055                 blkid_set_tag(probe->dev,"SEC_TYPE","ntocfs",sizeof("ntocfs"));
1056
1057         blkid_set_tag(probe->dev, "LABEL", ovl.label, ocfslabellen(ovl));
1058         blkid_set_tag(probe->dev, "MOUNT", ovh.mount, ocfsmountlen(ovh));
1059         set_uuid(probe->dev, ovl.vol_id, 0);
1060         return 0;
1061 }
1062
1063 static int probe_ocfs2(struct blkid_probe *probe,
1064                        struct blkid_magic *id __BLKID_ATTR((unused)),
1065                        unsigned char *buf)
1066 {
1067         struct ocfs2_super_block *osb;
1068
1069         osb = (struct ocfs2_super_block *)buf;
1070
1071         blkid_set_tag(probe->dev, "LABEL", osb->s_label, sizeof(osb->s_label));
1072         set_uuid(probe->dev, osb->s_uuid, 0);
1073         return 0;
1074 }
1075
1076 static int probe_oracleasm(struct blkid_probe *probe,
1077                            struct blkid_magic *id __BLKID_ATTR((unused)),
1078                            unsigned char *buf)
1079 {
1080         struct oracle_asm_disk_label *dl;
1081
1082         dl = (struct oracle_asm_disk_label *)buf;
1083
1084         blkid_set_tag(probe->dev, "LABEL", dl->dl_id, sizeof(dl->dl_id));
1085         return 0;
1086 }
1087
1088 static int probe_gfs(struct blkid_probe *probe,
1089                      struct blkid_magic *id __BLKID_ATTR((unused)),
1090                      unsigned char *buf)
1091 {
1092         struct gfs2_sb *sbd;
1093         const char *label = 0;
1094
1095         sbd = (struct gfs2_sb *)buf;
1096
1097         if (blkid_be32(sbd->sb_fs_format) == GFS_FORMAT_FS &&
1098             blkid_be32(sbd->sb_multihost_format) == GFS_FORMAT_MULTI)
1099         {
1100                 blkid_set_tag(probe->dev, "UUID", 0, 0);
1101
1102                 if (strlen(sbd->sb_locktable))
1103                         label = sbd->sb_locktable;
1104                 blkid_set_tag(probe->dev, "LABEL", label, sizeof(sbd->sb_locktable));
1105                 return 0;
1106         }
1107         return 1;
1108 }
1109
1110 static int probe_gfs2(struct blkid_probe *probe,
1111                      struct blkid_magic *id __BLKID_ATTR((unused)),
1112                      unsigned char *buf)
1113 {
1114         struct gfs2_sb *sbd;
1115         const char *label = 0;
1116
1117         sbd = (struct gfs2_sb *)buf;
1118
1119         if (blkid_be32(sbd->sb_fs_format) == GFS2_FORMAT_FS &&
1120             blkid_be32(sbd->sb_multihost_format) == GFS2_FORMAT_MULTI)
1121         {
1122                 blkid_set_tag(probe->dev, "UUID", 0, 0);
1123
1124                 if (strlen(sbd->sb_locktable))
1125                         label = sbd->sb_locktable;
1126                 blkid_set_tag(probe->dev, "LABEL", label, sizeof(sbd->sb_locktable));
1127                 return 0;
1128         }
1129         return 1;
1130 }
1131
1132 static void unicode_16be_to_utf8(unsigned char *str, int out_len,
1133                                  const unsigned char *buf, int in_len)
1134 {
1135         int i, j;
1136         unsigned int c;
1137
1138         for (i = j = 0; i + 2 <= in_len; i += 2) {
1139                 c = (buf[i] << 8) | buf[i+1];
1140                 if (c == 0) {
1141                         str[j] = '\0';
1142                         break;
1143                 } else if (c < 0x80) {
1144                         if (j+1 >= out_len)
1145                                 break;
1146                         str[j++] = (unsigned char) c;
1147                 } else if (c < 0x800) {
1148                         if (j+2 >= out_len)
1149                                 break;
1150                         str[j++] = (unsigned char) (0xc0 | (c >> 6));
1151                         str[j++] = (unsigned char) (0x80 | (c & 0x3f));
1152                 } else {
1153                         if (j+3 >= out_len)
1154                                 break;
1155                         str[j++] = (unsigned char) (0xe0 | (c >> 12));
1156                         str[j++] = (unsigned char) (0x80 | ((c >> 6) & 0x3f));
1157                         str[j++] = (unsigned char) (0x80 | (c & 0x3f));
1158                 }
1159         }
1160         str[j] = '\0';
1161 }
1162
1163 static void unicode_16le_to_utf8(unsigned char *str, int out_len,
1164                                  const unsigned char *buf, int in_len)
1165 {
1166         int i, j;
1167         unsigned int c;
1168
1169         for (i = j = 0; i + 2 <= in_len; i += 2) {
1170                 c = (buf[i+1] << 8) | buf[i];
1171                 if (c == 0) {
1172                         str[j] = '\0';
1173                         break;
1174                 } else if (c < 0x80) {
1175                         if (j+1 >= out_len)
1176                                 break;
1177                         str[j++] = (unsigned char) c;
1178                 } else if (c < 0x800) {
1179                         if (j+2 >= out_len)
1180                                 break;
1181                         str[j++] = (unsigned char) (0xc0 | (c >> 6));
1182                         str[j++] = (unsigned char) (0x80 | (c & 0x3f));
1183                 } else {
1184                         if (j+3 >= out_len)
1185                                 break;
1186                         str[j++] = (unsigned char) (0xe0 | (c >> 12));
1187                         str[j++] = (unsigned char) (0x80 | ((c >> 6) & 0x3f));
1188                         str[j++] = (unsigned char) (0x80 | (c & 0x3f));
1189                 }
1190         }
1191         str[j] = '\0';
1192 }
1193
1194 static int probe_hfs(struct blkid_probe *probe __BLKID_ATTR((unused)),
1195                          struct blkid_magic *id __BLKID_ATTR((unused)),
1196                          unsigned char *buf)
1197 {
1198         struct hfs_mdb *hfs = (struct hfs_mdb *)buf;
1199         unsigned long long *uuid_ptr;
1200         char    uuid_str[17];
1201         __u64   uuid;
1202
1203         if ((memcmp(hfs->embed_sig, "H+", 2) == 0) ||
1204             (memcmp(hfs->embed_sig, "HX", 2) == 0))
1205                 return 1;       /* Not hfs, but an embedded HFS+ */
1206
1207         uuid_ptr = (unsigned long long *)hfs->finder_info.id;
1208         uuid = blkid_le64(*uuid_ptr);
1209         if (uuid) {
1210                 sprintf(uuid_str, "%016llX", uuid);
1211                 blkid_set_tag(probe->dev, "UUID", uuid_str, 0);
1212         }
1213         blkid_set_tag(probe->dev, "LABEL", (char *)hfs->label, hfs->label_len);
1214         return 0;
1215 }
1216
1217
1218 #define HFSPLUS_SECTOR_SIZE        512
1219
1220 static int probe_hfsplus(struct blkid_probe *probe,
1221                          struct blkid_magic *id,
1222                          unsigned char *buf)
1223 {
1224         struct hfsplus_extent extents[HFSPLUS_EXTENT_COUNT];
1225         struct hfsplus_bnode_descriptor *descr;
1226         struct hfsplus_bheader_record *bnode;
1227         struct hfsplus_catalog_key *key;
1228         struct hfsplus_vol_header *hfsplus;
1229         struct hfs_mdb *sbd = (struct hfs_mdb *) buf;
1230         unsigned int alloc_block_size;
1231         unsigned int alloc_first_block;
1232         unsigned int embed_first_block;
1233         unsigned int off = 0;
1234         unsigned int blocksize;
1235         unsigned int cat_block;
1236         unsigned int ext_block_start;
1237         unsigned int ext_block_count;
1238         unsigned int record_count;
1239         unsigned int leaf_node_head;
1240         unsigned int leaf_node_count;
1241         unsigned int leaf_node_size;
1242         unsigned int leaf_block;
1243         unsigned int label_len;
1244         unsigned long long *uuid_ptr;
1245         __u64 leaf_off, uuid;
1246         char    uuid_str[17], label[512];
1247         int ext;
1248
1249         /* Check for a HFS+ volume embedded in a HFS volume */
1250         if (memcmp(sbd->signature, "BD", 2) == 0) {
1251                 if ((memcmp(sbd->embed_sig, "H+", 2) != 0) &&
1252                     (memcmp(sbd->embed_sig, "HX", 2) != 0))
1253                         /* This must be an HFS volume, so fail */
1254                         return 1;
1255
1256                 alloc_block_size = blkid_be32(sbd->al_blk_size);
1257                 alloc_first_block = blkid_be16(sbd->al_bl_st);
1258                 embed_first_block = blkid_be16(sbd->embed_startblock);
1259                 off = (alloc_first_block * 512) +
1260                         (embed_first_block * alloc_block_size);
1261                 buf = get_buffer(probe, off + (id->bim_kboff * 1024),
1262                                  sizeof(*sbd));
1263                 if (!buf)
1264                         return 1;
1265
1266                 hfsplus = (struct hfsplus_vol_header *) buf;
1267         }
1268
1269         hfsplus = (struct hfsplus_vol_header *) buf;
1270
1271         if ((memcmp(hfsplus->signature, "H+", 2) != 0) &&
1272             (memcmp(hfsplus->signature, "HX", 2) != 0))
1273                 return 1;
1274
1275         uuid_ptr = (unsigned long long *)hfsplus->finder_info.id;
1276         uuid = blkid_le64(*uuid_ptr);
1277         if (uuid) {
1278                 sprintf(uuid_str, "%016llX", uuid);
1279                 blkid_set_tag(probe->dev, "UUID", uuid_str, 0);
1280         }
1281
1282         blocksize = blkid_be32(hfsplus->blocksize);
1283         if (blocksize < HFSPLUS_SECTOR_SIZE)
1284                 return 1;
1285
1286         memcpy(extents, hfsplus->cat_file.extents, sizeof(extents));
1287         cat_block = blkid_be32(extents[0].start_block);
1288
1289         buf = get_buffer(probe, off + ((__u64) cat_block * blocksize), 0x2000);
1290         if (!buf)
1291                 return 0;
1292
1293         bnode = (struct hfsplus_bheader_record *)
1294                 &buf[sizeof(struct hfsplus_bnode_descriptor)];
1295
1296         leaf_node_head = blkid_be32(bnode->leaf_head);
1297         leaf_node_size = blkid_be16(bnode->node_size);
1298         leaf_node_count = blkid_be32(bnode->leaf_count);
1299         if (leaf_node_count == 0)
1300                 return 0;
1301
1302         leaf_block = (leaf_node_head * leaf_node_size) / blocksize;
1303
1304         /* get physical location */
1305         for (ext = 0; ext < HFSPLUS_EXTENT_COUNT; ext++) {
1306                 ext_block_start = blkid_be32(extents[ext].start_block);
1307                 ext_block_count = blkid_be32(extents[ext].block_count);
1308                 if (ext_block_count == 0)
1309                         return 0;
1310
1311                 /* this is our extent */
1312                 if (leaf_block < ext_block_count)
1313                         break;
1314
1315                 leaf_block -= ext_block_count;
1316         }
1317         if (ext == HFSPLUS_EXTENT_COUNT)
1318                 return 0;
1319
1320         leaf_off = (__u64) (ext_block_start + leaf_block) * blocksize;
1321
1322         buf = get_buffer(probe, off + leaf_off, leaf_node_size);
1323         if (!buf)
1324                 return 0;
1325
1326         descr = (struct hfsplus_bnode_descriptor *) buf;
1327         record_count = blkid_be16(descr->num_recs);
1328         if (record_count == 0)
1329                 return 0;
1330
1331         if (descr->type != HFS_NODE_LEAF)
1332                 return 0;
1333
1334         key = (struct hfsplus_catalog_key *)
1335                 &buf[sizeof(struct hfsplus_bnode_descriptor)];
1336
1337         if (blkid_be32(key->parent_id) != HFSPLUS_POR_CNID)
1338                 return 0;
1339
1340         label_len = blkid_be16(key->unicode_len) * 2;
1341         unicode_16be_to_utf8((unsigned char *)label, sizeof(label),
1342                              key->unicode, label_len);
1343         blkid_set_tag(probe->dev, "LABEL", label, 0);
1344         return 0;
1345 }
1346
1347 #define LVM2_LABEL_SIZE 512
1348 static unsigned int lvm2_calc_crc(const void *buf, unsigned int size)
1349 {
1350         static const unsigned int crctab[] = {
1351                 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
1352                 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
1353                 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
1354                 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
1355         };
1356         unsigned int i, crc = 0xf597a6cf;
1357         const __u8 *data = (const __u8 *) buf;
1358
1359         for (i = 0; i < size; i++) {
1360                 crc ^= *data++;
1361                 crc = (crc >> 4) ^ crctab[crc & 0xf];
1362                 crc = (crc >> 4) ^ crctab[crc & 0xf];
1363         }
1364         return crc;
1365 }
1366
1367 static int probe_lvm2(struct blkid_probe *probe,
1368                         struct blkid_magic *id,
1369                         unsigned char *buf)
1370 {
1371         int sector = (id->bim_kboff) << 1;
1372         struct lvm2_pv_label_header *label= (struct lvm2_pv_label_header *)buf;
1373         char *p, *q, uuid[40];
1374         unsigned int i, b;
1375
1376         /* buf is at 0k or 1k offset; find label inside */
1377         if (memcmp(buf, "LABELONE", 8) == 0) {
1378                 label = (struct lvm2_pv_label_header *)buf;
1379         } else if (memcmp(buf + 512, "LABELONE", 8) == 0) {
1380                 label = (struct lvm2_pv_label_header *)(buf + 512);
1381                 sector++;
1382         } else {
1383                 return 1;
1384         }
1385
1386         if (blkid_le64(label->sector_xl) != (unsigned) sector) {
1387                 DBG(DEBUG_PROBE,
1388                     printf("LVM2: label for sector %llu found at sector %d\n",
1389                            blkid_le64(label->sector_xl), sector));
1390                 return 1;
1391         }
1392
1393         if (lvm2_calc_crc(&label->offset_xl, LVM2_LABEL_SIZE -
1394                           ((char *)&label->offset_xl - (char *)label)) !=
1395                         blkid_le32(label->crc_xl)) {
1396                 DBG(DEBUG_PROBE,
1397                     printf("LVM2: label checksum incorrect at sector %d\n",
1398                            sector));
1399                 return 1;
1400         }
1401
1402         for (i=0, b=1, p=uuid, q= (char *) label->pv_uuid; i < LVM2_ID_LEN;
1403              i++, b <<= 1) {
1404                 if (b & 0x4444440)
1405                         *p++ = '-';
1406                 *p++ = *q++;
1407         }
1408
1409         blkid_set_tag(probe->dev, "UUID", uuid, LVM2_ID_LEN+6);
1410
1411         return 0;
1412 }
1413
1414 static int probe_btrfs(struct blkid_probe *probe,
1415                         struct blkid_magic *id __BLKID_ATTR((unused)),
1416                         unsigned char *buf)
1417 {
1418         struct btrfs_super_block *bs;
1419         const char *label = 0;
1420
1421         bs = (struct btrfs_super_block *)buf;
1422
1423         if (strlen(bs->label))
1424                 label = bs->label;
1425         blkid_set_tag(probe->dev, "LABEL", label, sizeof(bs->label));
1426         set_uuid(probe->dev, bs->fsid, 0);
1427         return 0;
1428 }
1429
1430 static int probe_f2fs(struct blkid_probe *probe,
1431             struct blkid_magic *id __BLKID_ATTR((unused)),
1432             unsigned char *buf)
1433 {
1434     struct f2fs_super_block *bs;
1435
1436     bs = (struct f2fs_super_block *)buf;
1437     set_uuid(probe->dev, bs->uuid, 0);
1438     return 0;
1439 }
1440
1441 static uint64_t exfat_block_to_offset(const struct exfat_super_block *sb,
1442                                       uint64_t block)
1443 {
1444     return block << sb->block_bits;
1445 }
1446
1447 static uint64_t exfat_cluster_to_block(const struct exfat_super_block *sb,
1448                                        uint32_t cluster)
1449 {
1450     return sb->cluster_block_start +
1451             ((uint64_t)(cluster - EXFAT_FIRST_DATA_CLUSTER) << sb->bpc_bits);
1452 }
1453
1454 static uint64_t exfat_cluster_to_offset(const struct exfat_super_block *sb,
1455                                         uint32_t cluster)
1456 {
1457     return exfat_block_to_offset(sb, exfat_cluster_to_block(sb, cluster));
1458 }
1459
1460 static uint32_t exfat_next_cluster(struct blkid_probe *probe,
1461                                    const struct exfat_super_block *sb,
1462                                    uint32_t cluster)
1463 {
1464     uint32_t *next;
1465     uint64_t offset;
1466
1467     offset = exfat_block_to_offset(sb, sb->fat_block_start)
1468             + (uint64_t) cluster * sizeof (cluster);
1469     next = (uint32_t *)get_buffer(probe, offset, sizeof (uint32_t));
1470
1471     return next ? *next : 0;
1472 }
1473
1474 static struct exfat_entry_label *find_exfat_entry_label(
1475     struct blkid_probe *probe, const struct exfat_super_block *sb)
1476 {
1477     uint32_t cluster = sb->rootdir_cluster;
1478     uint64_t offset = exfat_cluster_to_offset(sb, cluster);
1479     uint8_t *entry;
1480     const size_t max_iter = 10000;
1481     size_t i = 0;
1482
1483     for (; i < max_iter; ++i) {
1484         entry = (uint8_t *)get_buffer(probe, offset, EXFAT_ENTRY_SIZE);
1485         if (!entry)
1486             return NULL;
1487         if (entry[0] == EXFAT_ENTRY_EOD)
1488             return NULL;
1489         if (entry[0] == EXFAT_ENTRY_LABEL)
1490             return (struct exfat_entry_label*) entry;
1491
1492         offset += EXFAT_ENTRY_SIZE;
1493         if (offset % CLUSTER_SIZE(sb) == 0) {
1494             cluster = exfat_next_cluster(probe, sb, cluster);
1495             if (cluster < EXFAT_FIRST_DATA_CLUSTER)
1496                 return NULL;
1497             if (cluster > EXFAT_LAST_DATA_CLUSTER)
1498                 return NULL;
1499             offset = exfat_cluster_to_offset(sb, cluster);
1500         }
1501     }
1502
1503     return NULL;
1504 }
1505
1506 static int probe_exfat(struct blkid_probe *probe, struct blkid_magic *id,
1507                        unsigned char *buf)
1508 {
1509     struct exfat_super_block *sb;
1510     struct exfat_entry_label *label;
1511     uuid_t uuid;
1512
1513     sb = (struct exfat_super_block *)buf;
1514     if (!sb || !CLUSTER_SIZE(sb)) {
1515         DBG(DEBUG_PROBE, printf("bad exfat superblock.\n"));
1516         return errno ? - errno : 1;
1517     }
1518
1519     label = find_exfat_entry_label(probe, sb);
1520     if (label) {
1521         char utf8_label[128];
1522         unicode_16le_to_utf8(utf8_label, sizeof(utf8_label), label->name, label->length * 2);
1523         blkid_set_tag(probe->dev, "LABEL", utf8_label, 0);
1524     } else {
1525         blkid_set_tag(probe->dev, "LABEL", "disk", 4);
1526     }
1527
1528     memset(uuid, 0, sizeof (uuid));
1529     snprintf(uuid, sizeof (uuid), "%02hhX%02hhX-%02hhX%02hhX",
1530              sb->volume_serial[3], sb->volume_serial[2],
1531              sb->volume_serial[1], sb->volume_serial[0]);
1532     blkid_set_tag(probe->dev, "UUID", uuid, strlen(uuid));
1533
1534     return 0;
1535 }
1536
1537 /*
1538  * Various filesystem magics that we can check for.  Note that kboff and
1539  * sboff are in kilobytes and bytes respectively.  All magics are in
1540  * byte strings so we don't worry about endian issues.
1541  */
1542 static struct blkid_magic type_array[] = {
1543 /*  type     kboff   sboff len  magic                   probe */
1544   { "oracleasm", 0,     32,  8, "ORCLDISK",             probe_oracleasm },
1545   { "ntfs",      0,      3,  8, "NTFS    ",             probe_ntfs },
1546   { "jbd",       1,   0x38,  2, "\123\357",             probe_jbd },
1547   { "ext4dev",   1,   0x38,  2, "\123\357",             probe_ext4dev },
1548   { "ext4",      1,   0x38,  2, "\123\357",             probe_ext4 },
1549   { "ext3",      1,   0x38,  2, "\123\357",             probe_ext3 },
1550   { "ext2",      1,   0x38,  2, "\123\357",             probe_ext2 },
1551   { "reiserfs",  8,   0x34,  8, "ReIsErFs",             probe_reiserfs },
1552   { "reiserfs", 64,   0x34,  9, "ReIsEr2Fs",            probe_reiserfs },
1553   { "reiserfs", 64,   0x34,  9, "ReIsEr3Fs",            probe_reiserfs },
1554   { "reiserfs", 64,   0x34,  8, "ReIsErFs",             probe_reiserfs },
1555   { "reiserfs",  8,     20,  8, "ReIsErFs",             probe_reiserfs },
1556   { "reiser4",  64,      0,  7, "ReIsEr4",              probe_reiserfs4 },
1557   { "gfs2",     64,      0,  4, "\x01\x16\x19\x70",     probe_gfs2 },
1558   { "gfs",      64,      0,  4, "\x01\x16\x19\x70",     probe_gfs },
1559   { "vfat",      0,   0x52,  5, "MSWIN",                probe_fat },
1560   { "vfat",      0,   0x52,  8, "FAT32   ",             probe_fat },
1561   { "vfat",      0,   0x36,  5, "MSDOS",                probe_fat },
1562   { "vfat",      0,   0x36,  8, "FAT16   ",             probe_fat },
1563   { "vfat",      0,   0x36,  8, "FAT12   ",             probe_fat },
1564   { "vfat",      0,      0,  1, "\353",                 probe_fat_nomagic },
1565   { "vfat",      0,      0,  1, "\351",                 probe_fat_nomagic },
1566   { "vfat",      0,  0x1fe,  2, "\125\252",             probe_fat_nomagic },
1567   { "minix",     1,   0x10,  2, "\177\023",             0 },
1568   { "minix",     1,   0x10,  2, "\217\023",             0 },
1569   { "minix",     1,   0x10,  2, "\150\044",             0 },
1570   { "minix",     1,   0x10,  2, "\170\044",             0 },
1571   { "vxfs",      1,      0,  4, "\365\374\001\245",     0 },
1572   { "xfs",       0,      0,  4, "XFSB",                 probe_xfs },
1573   { "romfs",     0,      0,  8, "-rom1fs-",             probe_romfs },
1574   { "bfs",       0,      0,  4, "\316\372\173\033",     0 },
1575   { "cramfs",    0,      0,  4, "E=\315\050",           probe_cramfs },
1576   { "qnx4",      0,      4,  6, "QNX4FS",               0 },
1577   { "udf",      32,      1,  5, "BEA01",                probe_udf },
1578   { "udf",      32,      1,  5, "BOOT2",                probe_udf },
1579   { "udf",      32,      1,  5, "CD001",                probe_udf },
1580   { "udf",      32,      1,  5, "CDW02",                probe_udf },
1581   { "udf",      32,      1,  5, "NSR02",                probe_udf },
1582   { "udf",      32,      1,  5, "NSR03",                probe_udf },
1583   { "udf",      32,      1,  5, "TEA01",                probe_udf },
1584   { "iso9660",  32,      1,  5, "CD001",                probe_iso9660 },
1585   { "iso9660",  32,      9,  5, "CDROM",                probe_iso9660 },
1586   { "jfs",      32,      0,  4, "JFS1",                 probe_jfs },
1587   /* ZFS has 128 root blocks (#4 is the first used), check only 6 of them */
1588   { "zfs",     128,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1589   { "zfs",     128,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1590   { "zfs",     132,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1591   { "zfs",     132,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1592   { "zfs",     136,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1593   { "zfs",     136,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1594   { "zfs",     384,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1595   { "zfs",     384,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1596   { "zfs",     388,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1597   { "zfs",     388,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1598   { "zfs",     392,      0,  8, "\0\0\0\0\0\xba\xb1\x0c", probe_zfs },
1599   { "zfs",     392,      0,  8, "\x0c\xb1\xba\0\0\0\0\0", probe_zfs },
1600   { "hfsplus",   1,      0,  2, "BD",                   probe_hfsplus },
1601   { "hfsplus",   1,      0,  2, "H+",                   probe_hfsplus },
1602   { "hfsplus",   1,      0,  2, "HX",                   probe_hfsplus },
1603   { "hfs",       1,      0,  2, "BD",                   probe_hfs },
1604   { "ufs",       8,  0x55c,  4, "T\031\001\000",        0 },
1605   { "hpfs",      8,      0,  4, "I\350\225\371",        0 },
1606   { "sysv",      0,  0x3f8,  4, "\020~\030\375",        0 },
1607   { "swap",      0,  0xff6, 10, "SWAP-SPACE",           probe_swap0 },
1608   { "swap",      0,  0xff6, 10, "SWAPSPACE2",           probe_swap1 },
1609   { "swsuspend", 0,  0xff6,  9, "S1SUSPEND",            probe_swap1 },
1610   { "swsuspend", 0,  0xff6,  9, "S2SUSPEND",            probe_swap1 },
1611   { "swsuspend", 0,  0xff6,  9, "ULSUSPEND",            probe_swap1 },
1612   { "swap",      0, 0x1ff6, 10, "SWAP-SPACE",           probe_swap0 },
1613   { "swap",      0, 0x1ff6, 10, "SWAPSPACE2",           probe_swap1 },
1614   { "swsuspend", 0, 0x1ff6,  9, "S1SUSPEND",            probe_swap1 },
1615   { "swsuspend", 0, 0x1ff6,  9, "S2SUSPEND",            probe_swap1 },
1616   { "swsuspend", 0, 0x1ff6,  9, "ULSUSPEND",            probe_swap1 },
1617   { "swap",      0, 0x3ff6, 10, "SWAP-SPACE",           probe_swap0 },
1618   { "swap",      0, 0x3ff6, 10, "SWAPSPACE2",           probe_swap1 },
1619   { "swsuspend", 0, 0x3ff6,  9, "S1SUSPEND",            probe_swap1 },
1620   { "swsuspend", 0, 0x3ff6,  9, "S2SUSPEND",            probe_swap1 },
1621   { "swsuspend", 0, 0x3ff6,  9, "ULSUSPEND",            probe_swap1 },
1622   { "swap",      0, 0x7ff6, 10, "SWAP-SPACE",           probe_swap0 },
1623   { "swap",      0, 0x7ff6, 10, "SWAPSPACE2",           probe_swap1 },
1624   { "swsuspend", 0, 0x7ff6,  9, "S1SUSPEND",            probe_swap1 },
1625   { "swsuspend", 0, 0x7ff6,  9, "S2SUSPEND",            probe_swap1 },
1626   { "swsuspend", 0, 0x7ff6,  9, "ULSUSPEND",            probe_swap1 },
1627   { "swap",      0, 0xfff6, 10, "SWAP-SPACE",           probe_swap0 },
1628   { "swap",      0, 0xfff6, 10, "SWAPSPACE2",           probe_swap1 },
1629   { "swsuspend", 0, 0xfff6,  9, "S1SUSPEND",            probe_swap1 },
1630   { "swsuspend", 0, 0xfff6,  9, "S2SUSPEND",            probe_swap1 },
1631   { "swsuspend", 0, 0xfff6,  9, "ULSUSPEND",            probe_swap1 },
1632   { "ocfs",      0,      8,  9, "OracleCFS",            probe_ocfs },
1633   { "ocfs2",     1,      0,  6, "OCFSV2",               probe_ocfs2 },
1634   { "ocfs2",     2,      0,  6, "OCFSV2",               probe_ocfs2 },
1635   { "ocfs2",     4,      0,  6, "OCFSV2",               probe_ocfs2 },
1636   { "ocfs2",     8,      0,  6, "OCFSV2",               probe_ocfs2 },
1637   { "crypt_LUKS", 0,     0,  6, "LUKS\xba\xbe",         probe_luks },
1638   { "squashfs",  0,      0,  4, "sqsh",                 0 },
1639   { "squashfs",  0,      0,  4, "hsqs",                 0 },
1640   { "lvm2pv",    0,  0x218,  8, "LVM2 001",             probe_lvm2 },
1641   { "lvm2pv",    0,  0x018,  8, "LVM2 001",             probe_lvm2 },
1642   { "lvm2pv",    1,  0x018,  8, "LVM2 001",             probe_lvm2 },
1643   { "lvm2pv",    1,  0x218,  8, "LVM2 001",             probe_lvm2 },
1644   { "btrfs",     64,  0x40,  8, "_BHRfS_M",             probe_btrfs },
1645   { "f2fs",      1,      0,  4, "\x10\x20\xf5\xf2",     probe_f2fs },
1646   { "exfat",     0,      3,  8, "EXFAT   ",             probe_exfat },
1647   {   NULL,      0,      0,  0, NULL,                   NULL }
1648 };
1649
1650 /*
1651  * Verify that the data in dev is consistent with what is on the actual
1652  * block device (using the devname field only).  Normally this will be
1653  * called when finding items in the cache, but for long running processes
1654  * is also desirable to revalidate an item before use.
1655  *
1656  * If we are unable to revalidate the data, we return the old data and
1657  * do not set the BLKID_BID_FL_VERIFIED flag on it.
1658  */
1659 blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev)
1660 {
1661         struct blkid_magic *id;
1662         struct blkid_probe probe;
1663         blkid_tag_iterate iter;
1664         unsigned char *buf;
1665         const char *type, *value;
1666         struct stat st;
1667         time_t now;
1668         double diff;
1669         int idx;
1670
1671         if (!dev)
1672                 return NULL;
1673
1674         now = time(0);
1675         diff = difftime(now, dev->bid_time);
1676
1677         if (stat(dev->bid_name, &st) < 0) {
1678                 DBG(DEBUG_PROBE,
1679                     printf("blkid_verify: error %s (%d) while "
1680                            "trying to stat %s\n", strerror(errno), errno,
1681                            dev->bid_name));
1682         open_err:
1683                 if ((errno == EPERM) || (errno == EACCES) || (errno == ENOENT)) {
1684                         /* We don't have read permission, just return cache data. */
1685                         DBG(DEBUG_PROBE, printf("returning unverified data for %s\n",
1686                                                 dev->bid_name));
1687                         return dev;
1688                 }
1689                 blkid_free_dev(dev);
1690                 return NULL;
1691         }
1692
1693         if ((now >= dev->bid_time) &&
1694             (st.st_mtime <= dev->bid_time) &&
1695             ((diff < BLKID_PROBE_MIN) ||
1696              (dev->bid_flags & BLKID_BID_FL_VERIFIED &&
1697               diff < BLKID_PROBE_INTERVAL)))
1698                 return dev;
1699
1700         DBG(DEBUG_PROBE,
1701             printf("need to revalidate %s (cache time %lu, stat time %lu,\n\t"
1702                    "time since last check %lu)\n",
1703                    dev->bid_name, (unsigned long)dev->bid_time,
1704                    (unsigned long)st.st_mtime, (unsigned long)diff));
1705
1706         if ((probe.fd = open(dev->bid_name, O_RDONLY)) < 0) {
1707                 DBG(DEBUG_PROBE, printf("blkid_verify: error %s (%d) while "
1708                                         "opening %s\n", strerror(errno), errno,
1709                                         dev->bid_name));
1710                 goto open_err;
1711         }
1712
1713         probe.cache = cache;
1714         probe.dev = dev;
1715         probe.sbbuf = 0;
1716         probe.buf = 0;
1717         probe.buf_max = 0;
1718
1719         /*
1720          * Iterate over the type array.  If we already know the type,
1721          * then try that first.  If it doesn't work, then blow away
1722          * the type information, and try again.
1723          *
1724          */
1725 try_again:
1726         type = 0;
1727         if (!dev->bid_type || !strcmp(dev->bid_type, "mdraid")) {
1728                 uuid_t  uuid;
1729
1730                 if (check_mdraid(probe.fd, uuid) == 0) {
1731                         set_uuid(dev, uuid, 0);
1732                         type = "mdraid";
1733                         goto found_type;
1734                 }
1735         }
1736         for (id = type_array; id->bim_type; id++) {
1737                 if (dev->bid_type &&
1738                     strcmp(id->bim_type, dev->bid_type))
1739                         continue;
1740
1741                 idx = id->bim_kboff + (id->bim_sboff >> 10);
1742                 buf = get_buffer(&probe, (__u64) idx << 10, 1024);
1743                 if (!buf)
1744                         continue;
1745
1746                 if (memcmp(id->bim_magic, buf + (id->bim_sboff & 0x3ff),
1747                            id->bim_len))
1748                         continue;
1749
1750                 if ((id->bim_probe == NULL) ||
1751                     (id->bim_probe(&probe, id, buf) == 0)) {
1752                         type = id->bim_type;
1753                         goto found_type;
1754                 }
1755         }
1756
1757         if (!id->bim_type && dev->bid_type) {
1758                 /*
1759                  * Zap the device filesystem information and try again
1760                  */
1761                 DBG(DEBUG_PROBE,
1762                     printf("previous fs type %s not valid, "
1763                            "trying full probe\n", dev->bid_type));
1764                 iter = blkid_tag_iterate_begin(dev);
1765                 while (blkid_tag_next(iter, &type, &value) == 0)
1766                         blkid_set_tag(dev, type, 0, 0);
1767                 blkid_tag_iterate_end(iter);
1768                 goto try_again;
1769         }
1770
1771         if (!dev->bid_type) {
1772                 blkid_free_dev(dev);
1773                 dev = 0;
1774                 goto found_type;
1775         }
1776
1777 found_type:
1778         if (dev && type) {
1779                 dev->bid_devno = st.st_rdev;
1780                 dev->bid_time = time(0);
1781                 dev->bid_flags |= BLKID_BID_FL_VERIFIED;
1782                 cache->bic_flags |= BLKID_BIC_FL_CHANGED;
1783
1784                 blkid_set_tag(dev, "TYPE", type, 0);
1785
1786                 DBG(DEBUG_PROBE, printf("%s: devno 0x%04llx, type %s\n",
1787                            dev->bid_name, (long long)st.st_rdev, type));
1788         }
1789
1790         free(probe.sbbuf);
1791         free(probe.buf);
1792         if (probe.fd >= 0)
1793                 close(probe.fd);
1794
1795         return dev;
1796 }
1797
1798 int blkid_known_fstype(const char *fstype)
1799 {
1800         struct blkid_magic *id;
1801
1802         for (id = type_array; id->bim_type; id++) {
1803                 if (strcmp(fstype, id->bim_type) == 0)
1804                         return 1;
1805         }
1806         return 0;
1807 }
1808
1809 #ifdef TEST_PROGRAM
1810 int main(int argc, char **argv)
1811 {
1812         blkid_dev dev;
1813         blkid_cache cache;
1814         int ret;
1815
1816         if (argc != 2) {
1817                 fprintf(stderr, "Usage: %s device\n"
1818                         "Probe a single device to determine type\n", argv[0]);
1819                 exit(1);
1820         }
1821         if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) {
1822                 fprintf(stderr, "%s: error creating cache (%d)\n",
1823                         argv[0], ret);
1824                 exit(1);
1825         }
1826         dev = blkid_get_dev(cache, argv[1], BLKID_DEV_NORMAL);
1827         if (!dev) {
1828                 printf("%s: %s has an unsupported type\n", argv[0], argv[1]);
1829                 return (1);
1830         }
1831         printf("TYPE='%s'\n", dev->bid_type ? dev->bid_type : "(null)");
1832         if (dev->bid_label)
1833                 printf("LABEL='%s'\n", dev->bid_label);
1834         if (dev->bid_uuid)
1835                 printf("UUID='%s'\n", dev->bid_uuid);
1836
1837         blkid_free_dev(dev);
1838         return (0);
1839 }
1840 #endif