util/getroot.c

   1 /* getroot.c - Get root device */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2006,2007,2008,2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <sys/stat.h>
  22 #include <unistd.h>
  23 #include <string.h>
  24 #include <dirent.h>
  25
  26 #ifdef __CYGWIN__
  27 # include <sys/fcntl.h>
  28 # include <sys/cygwin.h>
  29 # include <limits.h>
  30 # define DEV_CYGDRIVE_MAJOR 98
  31 #endif
  32
  33 #include <grub/util/misc.h>
  34 #include <grub/util/hostdisk.h>
  35 #include <grub/util/getroot.h>
  36
  37 static void
  38 strip_extra_slashes (char *dir)
  39 {
  40   char *p = dir;
  41
  42   while ((p = strchr (p, '/')) != 0)
  43     {
  44       if (p[1] == '/')
  45         {
  46           memmove (p, p + 1, strlen (p));
  47           continue;
  48         }
  49       else if (p[1] == '\0')
  50         {
  51           if (p > dir)
  52             p[0] = '\0';
  53           break;
  54         }
  55
  56       p++;
  57     }
  58 }
  59
  60 static char *
  61 xgetcwd (void)
  62 {
  63   size_t size = 10;
  64   char *path;
  65
  66   path = xmalloc (size);
  67   while (! getcwd (path, size))
  68     {
  69       size <<= 1;
  70       path = xrealloc (path, size);
  71     }
  72
  73   return path;
  74 }
  75
  76 #ifdef __CYGWIN__
  77 /* Convert POSIX path to Win32 path,
  78    remove drive letter, replace backslashes.  */
  79 static char *
  80 get_win32_path (const char *path)
  81 {
  82   char winpath[PATH_MAX];
  83   cygwin_conv_to_full_win32_path (path, winpath);
  84
  85   int len = strlen (winpath);
  86   if (len > 2 && winpath[1] == ':')
  87     {
  88       len -= 2;
  89       memmove (winpath, winpath + 2, len + 1);
  90     }
  91
  92   int i;
  93   for (i = 0; i < len; i++)
  94     if (winpath[i] == '\\')
  95       winpath[i] = '/';
  96   return xstrdup (winpath);
  97 }
  98 #endif
  99
 100 char *
 101 grub_get_prefix (const char *dir)
 102 {
 103   char *saved_cwd;
 104   char *abs_dir, *prev_dir;
 105   char *prefix;
 106   struct stat st, prev_st;
 107
 108   /* Save the current directory.  */
 109   saved_cwd = xgetcwd ();
 110
 111   if (chdir (dir) < 0)
 112     grub_util_error ("Cannot change directory to `%s'", dir);
 113
 114   abs_dir = xgetcwd ();
 115   strip_extra_slashes (abs_dir);
 116   prev_dir = xstrdup (abs_dir);
 117
 118   if (stat (".", &prev_st) < 0)
 119     grub_util_error ("Cannot stat `%s'", dir);
 120
 121   if (! S_ISDIR (prev_st.st_mode))
 122     grub_util_error ("`%s' is not a directory", dir);
 123
 124   while (1)
 125     {
 126       if (chdir ("..") < 0)
 127         grub_util_error ("Cannot change directory to the parent");
 128
 129       if (stat (".", &st) < 0)
 130         grub_util_error ("Cannot stat current directory");
 131
 132       if (! S_ISDIR (st.st_mode))
 133         grub_util_error ("Current directory is not a directory???");
 134
 135       if (prev_st.st_dev != st.st_dev || prev_st.st_ino == st.st_ino)
 136         break;
 137
 138       free (prev_dir);
 139       prev_dir = xgetcwd ();
 140       prev_st = st;
 141     }
 142
 143   strip_extra_slashes (prev_dir);
 144   prefix = xmalloc (strlen (abs_dir) - strlen (prev_dir) + 2);
 145   prefix[0] = '/';
 146   strcpy (prefix + 1, abs_dir + strlen (prev_dir));
 147   strip_extra_slashes (prefix);
 148
 149   if (chdir (saved_cwd) < 0)
 150     grub_util_error ("Cannot change directory to `%s'", dir);
 151
 152 #ifdef __CYGWIN__
 153   if (st.st_dev != (DEV_CYGDRIVE_MAJOR << 16))
 154     {
 155       /* Reached some mount point not below /cygdrive.
 156          GRUB does not know Cygwin's emulated mounts,
 157          convert to Win32 path.  */
 158       grub_util_info ("Cygwin prefix = %s", prefix);
 159       char * wprefix = get_win32_path (prefix);
 160       free (prefix);
 161       prefix = wprefix;
 162     }
 163 #endif
 164
 165   free (saved_cwd);
 166   free (abs_dir);
 167   free (prev_dir);
 168
 169   grub_util_info ("prefix = %s", prefix);
 170   return prefix;
 171 }
 172
 173 #ifdef __MINGW32__
 174
 175 static char *
 176 find_root_device (const char *dir __attribute__ ((unused)),
 177                   dev_t dev __attribute__ ((unused)))
 178 {
 179   return 0;
 180 }
 181
 182 #elif ! defined(__CYGWIN__)
 183
 184 static char *
 185 find_root_device (const char *dir, dev_t dev)
 186 {
 187   DIR *dp;
 188   char *saved_cwd;
 189   struct dirent *ent;
 190
 191   dp = opendir (dir);
 192   if (! dp)
 193     return 0;
 194
 195   saved_cwd = xgetcwd ();
 196
 197   grub_util_info ("changing current directory to %s", dir);
 198   if (chdir (dir) < 0)
 199     {
 200       free (saved_cwd);
 201       closedir (dp);
 202       return 0;
 203     }
 204
 205   while ((ent = readdir (dp)) != 0)
 206     {
 207       struct stat st;
 208
 209       /* Avoid:
 210          - dotfiles (like "/dev/.tmp.md0") since they could be duplicates.
 211          - dotdirs (like "/dev/.static") since they could contain duplicates.  */
 212       if (ent->d_name[0] == '.')
 213         continue;
 214
 215       if (lstat (ent->d_name, &st) < 0)
 216         /* Ignore any error.  */
 217         continue;
 218
 219       if (S_ISLNK (st.st_mode))
 220         /* Don't follow symbolic links.  */
 221         continue;
 222
 223       if (S_ISDIR (st.st_mode))
 224         {
 225           /* Find it recursively.  */
 226           char *res;
 227
 228           res = find_root_device (ent->d_name, dev);
 229
 230           if (res)
 231             {
 232               if (chdir (saved_cwd) < 0)
 233                 grub_util_error ("Cannot restore the original directory");
 234
 235               free (saved_cwd);
 236               closedir (dp);
 237               return res;
 238             }
 239         }
 240
 241 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__APPLE__)
 242       if (S_ISCHR (st.st_mode) && st.st_rdev == dev)
 243 #else
 244       if (S_ISBLK (st.st_mode) && st.st_rdev == dev)
 245 #endif
 246         {
 247 #ifdef __linux__
 248           /* Skip device names like /dev/dm-0, which are short-hand aliases
 249              to more descriptive device names, e.g. those under /dev/mapper */
 250           if (ent->d_name[0] == 'd' &&
 251               ent->d_name[1] == 'm' &&
 252               ent->d_name[2] == '-' &&
 253               ent->d_name[3] >= '0' &&
 254               ent->d_name[3] <= '9')
 255             continue;
 256 #endif
 257
 258           /* Found!  */
 259           char *res;
 260           char *cwd;
 261
 262           cwd = xgetcwd ();
 263           res = xmalloc (strlen (cwd) + strlen (ent->d_name) + 2);
 264           sprintf (res, "%s/%s", cwd, ent->d_name);
 265           strip_extra_slashes (res);
 266           free (cwd);
 267
 268           /* /dev/root is not a real block device keep looking, takes care
 269              of situation where root filesystem is on the same partition as
 270              grub files */
 271
 272           if (strcmp(res, "/dev/root") == 0)
 273                 continue;
 274
 275           if (chdir (saved_cwd) < 0)
 276             grub_util_error ("Cannot restore the original directory");
 277
 278           free (saved_cwd);
 279           closedir (dp);
 280           return res;
 281         }
 282     }
 283
 284   if (chdir (saved_cwd) < 0)
 285     grub_util_error ("Cannot restore the original directory");
 286
 287   free (saved_cwd);
 288   closedir (dp);
 289   return 0;
 290 }
 291
 292 #else /* __CYGWIN__ */
 293
 294 /* Read drive/partition serial number from mbr/boot sector,
 295    return 0 on read error, ~0 on unknown serial.  */
 296 static unsigned
 297 get_bootsec_serial (const char *os_dev, int mbr)
 298 {
 299   /* Read boot sector.  */
 300   int fd = open (os_dev, O_RDONLY);
 301   if (fd < 0)
 302     return 0;
 303   unsigned char buf[0x200];
 304   int n = read (fd, buf, sizeof (buf));
 305   close (fd);
 306   if (n != sizeof(buf))
 307     return 0;
 308
 309   /* Check signature.  */
 310   if (!(buf[0x1fe] == 0x55 && buf[0x1ff] == 0xaa))
 311     return ~0;
 312
 313   /* Serial number offset depends on boot sector type.  */
 314   if (mbr)
 315     n = 0x1b8;
 316   else if (memcmp (buf + 0x03, "NTFS", 4) == 0)
 317     n = 0x048;
 318   else if (memcmp (buf + 0x52, "FAT32", 5) == 0)
 319     n = 0x043;
 320   else if (memcmp (buf + 0x36, "FAT", 3) == 0)
 321     n = 0x027;
 322   else
 323     return ~0;
 324
 325   unsigned serial = *(unsigned *)(buf + n);
 326   if (serial == 0)
 327     return ~0;
 328   return serial;
 329 }
 330
 331 static char *
 332 find_cygwin_root_device (const char *path, dev_t dev)
 333 {
 334   /* No root device for /cygdrive.  */
 335   if (dev == (DEV_CYGDRIVE_MAJOR << 16))
 336     return 0;
 337
 338   /* Convert to full POSIX and Win32 path.  */
 339   char fullpath[PATH_MAX], winpath[PATH_MAX];
 340   cygwin_conv_to_full_posix_path (path, fullpath);
 341   cygwin_conv_to_full_win32_path (fullpath, winpath);
 342
 343   /* If identical, this is no real filesystem path.  */
 344   if (strcmp (fullpath, winpath) == 0)
 345     return 0;
 346
 347   /* Check for floppy drive letter.  */
 348   if (winpath[0] && winpath[1] == ':' && strchr ("AaBb", winpath[0]))
 349     return xstrdup (strchr ("Aa", winpath[0]) ? "/dev/fd0" : "/dev/fd1");
 350
 351   /* Cygwin returns the partition serial number in stat.st_dev.
 352      This is never identical to the device number of the emulated
 353      /dev/sdXN device, so above find_root_device () does not work.
 354      Search the partition with the same serial in boot sector instead.  */
 355   char devpath[sizeof ("/dev/sda15") + 13]; /* Size + Paranoia.  */
 356   int d;
 357   for (d = 'a'; d <= 'z'; d++)
 358     {
 359       sprintf (devpath, "/dev/sd%c", d);
 360       if (get_bootsec_serial (devpath, 1) == 0)
 361         continue;
 362       int p;
 363       for (p = 1; p <= 15; p++)
 364         {
 365           sprintf (devpath, "/dev/sd%c%d", d, p);
 366           unsigned ser = get_bootsec_serial (devpath, 0);
 367           if (ser == 0)
 368             break;
 369           if (ser != (unsigned)~0 && dev == (dev_t)ser)
 370             return xstrdup (devpath);
 371         }
 372     }
 373   return 0;
 374 }
 375
 376 #endif /* __CYGWIN__ */
 377
 378 char *
 379 grub_guess_root_device (const char *dir)
 380 {
 381   struct stat st;
 382   char *os_dev;
 383
 384   if (stat (dir, &st) < 0)
 385     grub_util_error ("Cannot stat `%s'", dir);
 386
 387 #ifdef __CYGWIN__
 388   /* Cygwin specific function.  */
 389   os_dev = find_cygwin_root_device (dir, st.st_dev);
 390
 391 #else
 392
 393   /* This might be truly slow, but is there any better way?  */
 394   os_dev = find_root_device ("/dev", st.st_dev);
 395 #endif
 396
 397   return os_dev;
 398 }
 399
 400 int
 401 grub_util_get_dev_abstraction (const char *os_dev UNUSED)
 402 {
 403 #ifdef __linux__
 404   /* Check for LVM.  */
 405   if (!strncmp (os_dev, "/dev/mapper/", 12))
 406     return GRUB_DEV_ABSTRACTION_LVM;
 407
 408   /* Check for RAID.  */
 409   if (!strncmp (os_dev, "/dev/md", 7))
 410     return GRUB_DEV_ABSTRACTION_RAID;
 411 #endif
 412
 413   /* No abstraction found.  */
 414   return GRUB_DEV_ABSTRACTION_NONE;
 415 }
 416
 417 char *
 418 grub_util_get_grub_dev (const char *os_dev)
 419 {
 420   char *grub_dev;
 421
 422   switch (grub_util_get_dev_abstraction (os_dev))
 423     {
 424     case GRUB_DEV_ABSTRACTION_LVM:
 425
 426       {
 427         unsigned short i, len;
 428         grub_size_t offset = sizeof ("/dev/mapper/") - 1;
 429
 430         len = strlen (os_dev) - offset + 1;
 431         grub_dev = xmalloc (len);
 432
 433         for (i = 0; i < len; i++, offset++)
 434           {
 435             grub_dev[i] = os_dev[offset];
 436             if (os_dev[offset] == '-' && os_dev[offset + 1] == '-')
 437               offset++;
 438           }
 439       }
 440
 441       break;
 442
 443     case GRUB_DEV_ABSTRACTION_RAID:
 444
 445       if (os_dev[7] == '_' && os_dev[8] == 'd')
 446         {
 447           /* This a partitionable RAID device of the form /dev/md_dNNpMM. */
 448
 449           char *p, *q;
 450
 451           p = strdup (os_dev + sizeof ("/dev/md_d") - 1);
 452
 453           q = strchr (p, 'p');
 454           if (q)
 455             *q = ',';
 456
 457           asprintf (&grub_dev, "md%s", p);
 458           free (p);
 459         }
 460       else if (os_dev[7] == '/' && os_dev[8] == 'd')
 461         {
 462           /* This a partitionable RAID device of the form /dev/md/dNNpMM. */
 463
 464           char *p, *q;
 465
 466           p = strdup (os_dev + sizeof ("/dev/md/d") - 1);
 467
 468           q = strchr (p, 'p');
 469           if (q)
 470             *q = ',';
 471
 472           asprintf (&grub_dev, "md%s", p);
 473           free (p);
 474         }
 475       else if (os_dev[7] >= '0' && os_dev[7] <= '9')
 476         {
 477           char *p , *q;
 478
 479           p = strdup (os_dev + sizeof ("/dev/md") - 1);
 480
 481           q = strchr (p, 'p');
 482           if (q)
 483             *q = ',';
 484
 485           asprintf (&grub_dev, "md%s", p);
 486           free (p);
 487         }
 488       else if (os_dev[7] == '/' && os_dev[8] >= '0' && os_dev[8] <= '9')
 489         {
 490           char *p , *q;
 491
 492           p = strdup (os_dev + sizeof ("/dev/md/") - 1);
 493
 494           q = strchr (p, 'p');
 495           if (q)
 496             *q = ',';
 497
 498           asprintf (&grub_dev, "md%s", p);
 499           free (p);
 500         }
 501       else
 502         grub_util_error ("Unknown kind of RAID device `%s'", os_dev);
 503
 504       break;
 505
 506     default:  /* GRUB_DEV_ABSTRACTION_NONE */
 507       grub_dev = grub_util_biosdisk_get_grub_dev (os_dev);
 508     }
 509
 510   return grub_dev;
 511 }
 512
 513 const char *
 514 grub_util_check_block_device (const char *blk_dev)
 515 {
 516   struct stat st;
 517
 518   if (stat (blk_dev, &st) < 0)
 519     grub_util_error ("Cannot stat `%s'", blk_dev);
 520
 521   if (S_ISBLK (st.st_mode))
 522     return (blk_dev);
 523   else
 524     return 0;
 525 }
 526
 527 const char *
 528 grub_util_check_char_device (const char *blk_dev)
 529 {
 530   struct stat st;
 531
 532   if (stat (blk_dev, &st) < 0)
 533     grub_util_error ("Cannot stat `%s'", blk_dev);
 534
 535   if (S_ISCHR (st.st_mode))
 536     return (blk_dev);
 537   else
 538     return 0;
 539 }
 540