kern/disk.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2002,2003,2004,2006,2007,2008  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/disk.h>
  20 #include <grub/err.h>
  21 #include <grub/mm.h>
  22 #include <grub/types.h>
  23 #include <grub/partition.h>
  24 #include <grub/misc.h>
  25 #include <grub/time.h>
  26 #include <grub/file.h>
  27
  28 #define GRUB_CACHE_TIMEOUT      2
  29
  30 /* The last time the disk was used.  */
  31 static grub_uint64_t grub_last_time = 0;
  32
  33
  34 /* Disk cache.  */
  35 struct grub_disk_cache
  36 {
  37   unsigned long dev_id;
  38   unsigned long disk_id;
  39   grub_disk_addr_t sector;
  40   char *data;
  41   int lock;
  42 };
  43
  44 static struct grub_disk_cache grub_disk_cache_table[GRUB_DISK_CACHE_NUM];
  45
  46 void (*grub_disk_firmware_fini) (void);
  47 int grub_disk_firmware_is_tainted;
  48
  49 #if 0
  50 static unsigned long grub_disk_cache_hits;
  51 static unsigned long grub_disk_cache_misses;
  52
  53 void
  54 grub_disk_cache_get_performance (unsigned long *hits, unsigned long *misses)
  55 {
  56   *hits = grub_disk_cache_hits;
  57   *misses = grub_disk_cache_misses;
  58 }
  59 #endif
  60
  61 static unsigned
  62 grub_disk_cache_get_index (unsigned long dev_id, unsigned long disk_id,
  63                            grub_disk_addr_t sector)
  64 {
  65   return ((dev_id * 524287UL + disk_id * 2606459UL
  66            + ((unsigned) (sector >> GRUB_DISK_CACHE_BITS)))
  67           % GRUB_DISK_CACHE_NUM);
  68 }
  69
  70 static void
  71 grub_disk_cache_invalidate (unsigned long dev_id, unsigned long disk_id,
  72                             grub_disk_addr_t sector)
  73 {
  74   unsigned index;
  75   struct grub_disk_cache *cache;
  76
  77   sector &= ~(GRUB_DISK_CACHE_SIZE - 1);
  78   index = grub_disk_cache_get_index (dev_id, disk_id, sector);
  79   cache = grub_disk_cache_table + index;
  80
  81   if (cache->dev_id == dev_id && cache->disk_id == disk_id
  82       && cache->sector == sector && cache->data)
  83     {
  84       cache->lock = 1;
  85       grub_free (cache->data);
  86       cache->data = 0;
  87       cache->lock = 0;
  88     }
  89 }
  90
  91 void
  92 grub_disk_cache_invalidate_all (void)
  93 {
  94   unsigned i;
  95
  96   for (i = 0; i < GRUB_DISK_CACHE_NUM; i++)
  97     {
  98       struct grub_disk_cache *cache = grub_disk_cache_table + i;
  99
 100       if (cache->data && ! cache->lock)
 101         {
 102           grub_free (cache->data);
 103           cache->data = 0;
 104         }
 105     }
 106 }
 107
 108 static char *
 109 grub_disk_cache_fetch (unsigned long dev_id, unsigned long disk_id,
 110                        grub_disk_addr_t sector)
 111 {
 112   struct grub_disk_cache *cache;
 113   unsigned index;
 114
 115   index = grub_disk_cache_get_index (dev_id, disk_id, sector);
 116   cache = grub_disk_cache_table + index;
 117
 118   if (cache->dev_id == dev_id && cache->disk_id == disk_id
 119       && cache->sector == sector)
 120     {
 121       cache->lock = 1;
 122 #if 0
 123       grub_disk_cache_hits++;
 124 #endif
 125       return cache->data;
 126     }
 127
 128 #if 0
 129   grub_disk_cache_misses++;
 130 #endif
 131
 132   return 0;
 133 }
 134
 135 static void
 136 grub_disk_cache_unlock (unsigned long dev_id, unsigned long disk_id,
 137                         grub_disk_addr_t sector)
 138 {
 139   struct grub_disk_cache *cache;
 140   unsigned index;
 141
 142   index = grub_disk_cache_get_index (dev_id, disk_id, sector);
 143   cache = grub_disk_cache_table + index;
 144
 145   if (cache->dev_id == dev_id && cache->disk_id == disk_id
 146       && cache->sector == sector)
 147     cache->lock = 0;
 148 }
 149
 150 static grub_err_t
 151 grub_disk_cache_store (unsigned long dev_id, unsigned long disk_id,
 152                        grub_disk_addr_t sector, const char *data)
 153 {
 154   unsigned index;
 155   struct grub_disk_cache *cache;
 156
 157   grub_disk_cache_invalidate (dev_id, disk_id, sector);
 158
 159   index = grub_disk_cache_get_index (dev_id, disk_id, sector);
 160   cache = grub_disk_cache_table + index;
 161
 162   cache->data = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
 163   if (! cache->data)
 164     return grub_errno;
 165
 166   grub_memcpy (cache->data, data,
 167                GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
 168   cache->dev_id = dev_id;
 169   cache->disk_id = disk_id;
 170   cache->sector = sector;
 171
 172   return GRUB_ERR_NONE;
 173 }
 174
 175 \f
 176
 177 static grub_disk_dev_t grub_disk_dev_list;
 178
 179 void
 180 grub_disk_dev_register (grub_disk_dev_t dev)
 181 {
 182   dev->next = grub_disk_dev_list;
 183   grub_disk_dev_list = dev;
 184 }
 185
 186 void
 187 grub_disk_dev_unregister (grub_disk_dev_t dev)
 188 {
 189   grub_disk_dev_t *p, q;
 190
 191   for (p = &grub_disk_dev_list, q = *p; q; p = &(q->next), q = q->next)
 192     if (q == dev)
 193       {
 194         *p = q->next;
 195         break;
 196       }
 197 }
 198
 199 int
 200 grub_disk_dev_iterate (int (*hook) (const char *name))
 201 {
 202   grub_disk_dev_t p;
 203
 204   for (p = grub_disk_dev_list; p; p = p->next)
 205     if (p->iterate && (p->iterate) (hook))
 206       return 1;
 207
 208   return 0;
 209 }
 210
 211 grub_disk_t
 212 grub_disk_open (const char *name)
 213 {
 214   char *p;
 215   grub_disk_t disk;
 216   grub_disk_dev_t dev;
 217   char *raw = (char *) name;
 218   grub_uint64_t current_time;
 219
 220   grub_dprintf ("disk", "Opening `%s'...\n", name);
 221
 222   disk = (grub_disk_t) grub_malloc (sizeof (*disk));
 223   if (! disk)
 224     return 0;
 225
 226   disk->dev = 0;
 227   disk->read_hook = 0;
 228   disk->partition = 0;
 229   disk->data = 0;
 230   disk->name = grub_strdup (name);
 231   if (! disk->name)
 232     goto fail;
 233
 234   p = grub_strchr (name, ',');
 235   if (p)
 236     {
 237       grub_size_t len = p - name;
 238
 239       raw = grub_malloc (len + 1);
 240       if (! raw)
 241         goto fail;
 242
 243       grub_memcpy (raw, name, len);
 244       raw[len] = '\0';
 245     }
 246
 247   for (dev = grub_disk_dev_list; dev; dev = dev->next)
 248     {
 249       if ((dev->open) (raw, disk) == GRUB_ERR_NONE)
 250         break;
 251       else if (grub_errno == GRUB_ERR_UNKNOWN_DEVICE)
 252         grub_errno = GRUB_ERR_NONE;
 253       else
 254         goto fail;
 255     }
 256
 257   if (! dev)
 258     {
 259       grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such disk");
 260       goto fail;
 261     }
 262
 263   if (p && ! disk->has_partitions)
 264     {
 265       grub_error (GRUB_ERR_BAD_DEVICE, "no partition on this disk");
 266       goto fail;
 267     }
 268
 269   disk->dev = dev;
 270
 271   if (p)
 272     {
 273       disk->partition = grub_partition_probe (disk, p + 1);
 274       if (! disk->partition)
 275         {
 276           grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such partition");
 277           goto fail;
 278         }
 279     }
 280
 281   /* The cache will be invalidated about 2 seconds after a device was
 282      closed.  */
 283   current_time = grub_get_time_ms ();
 284
 285   if (current_time > (grub_last_time
 286                       + GRUB_CACHE_TIMEOUT * 1000))
 287     grub_disk_cache_invalidate_all ();
 288
 289   grub_last_time = current_time;
 290
 291  fail:
 292
 293   if (raw && raw != name)
 294     grub_free (raw);
 295
 296   if (grub_errno != GRUB_ERR_NONE)
 297     {
 298       grub_error_push ();
 299       grub_dprintf ("disk", "Opening `%s' failed.\n", name);
 300       grub_error_pop ();
 301
 302       grub_disk_close (disk);
 303       return 0;
 304     }
 305
 306   return disk;
 307 }
 308
 309 void
 310 grub_disk_close (grub_disk_t disk)
 311 {
 312   grub_dprintf ("disk", "Closing `%s'.\n", disk->name);
 313
 314   if (disk->dev && disk->dev->close)
 315     (disk->dev->close) (disk);
 316
 317   /* Reset the timer.  */
 318   grub_last_time = grub_get_time_ms ();
 319
 320   grub_free (disk->partition);
 321   grub_free ((void *) disk->name);
 322   grub_free (disk);
 323 }
 324
 325 /* This function performs three tasks:
 326    - Make sectors disk relative from partition relative.
 327    - Normalize offset to be less than the sector size.
 328    - Verify that the range is inside the partition.  */
 329 static grub_err_t
 330 grub_disk_adjust_range (grub_disk_t disk, grub_disk_addr_t *sector,
 331                        grub_off_t *offset, grub_size_t size)
 332 {
 333   *sector += *offset >> GRUB_DISK_SECTOR_BITS;
 334   *offset &= GRUB_DISK_SECTOR_SIZE - 1;
 335
 336   if (disk->partition)
 337     {
 338       grub_disk_addr_t start;
 339       grub_uint64_t len;
 340
 341       start = grub_partition_get_start (disk->partition);
 342       len = grub_partition_get_len (disk->partition);
 343
 344       if (*sector >= len
 345           || len - *sector < ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
 346                               >> GRUB_DISK_SECTOR_BITS))
 347         return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of partition");
 348
 349       *sector += start;
 350     }
 351
 352   if (disk->total_sectors <= *sector
 353       || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
 354           >> GRUB_DISK_SECTOR_BITS) > disk->total_sectors - *sector)
 355     return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of disk");
 356
 357   return GRUB_ERR_NONE;
 358 }
 359
 360 /* Read data from the disk.  */
 361 grub_err_t
 362 grub_disk_read (grub_disk_t disk, grub_disk_addr_t sector,
 363                 grub_off_t offset, grub_size_t size, char *buf)
 364 {
 365   char *tmp_buf;
 366   unsigned real_offset;
 367
 368   grub_dprintf ("disk", "Reading `%s'...\n", disk->name);
 369
 370   /* First of all, check if the region is within the disk.  */
 371   if (grub_disk_adjust_range (disk, &sector, &offset, size) != GRUB_ERR_NONE)
 372     {
 373       grub_error_push ();
 374       grub_dprintf ("disk", "Read out of range: sector 0x%llx (%s).\n",
 375                     (unsigned long long) sector, grub_errmsg);
 376       grub_error_pop ();
 377       return grub_errno;
 378     }
 379
 380   real_offset = offset;
 381
 382   /* Allocate a temporary buffer.  */
 383   tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
 384   if (! tmp_buf)
 385     return grub_errno;
 386
 387   /* Until SIZE is zero...  */
 388   while (size)
 389     {
 390       char *data;
 391       grub_disk_addr_t start_sector;
 392       grub_size_t len;
 393       grub_size_t pos;
 394
 395       /* For reading bulk data.  */
 396       start_sector = sector & ~(GRUB_DISK_CACHE_SIZE - 1);
 397       pos = (sector - start_sector) << GRUB_DISK_SECTOR_BITS;
 398       len = ((GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS)
 399              - pos - real_offset);
 400       if (len > size)
 401         len = size;
 402
 403       /* Fetch the cache.  */
 404       data = grub_disk_cache_fetch (disk->dev->id, disk->id, start_sector);
 405       if (data)
 406         {
 407           /* Just copy it!  */
 408           grub_memcpy (buf, data + pos + real_offset, len);
 409           grub_disk_cache_unlock (disk->dev->id, disk->id, start_sector);
 410         }
 411       else
 412         {
 413           /* Otherwise read data from the disk actually.  */
 414           if ((disk->dev->read) (disk, start_sector,
 415                                  GRUB_DISK_CACHE_SIZE, tmp_buf)
 416               != GRUB_ERR_NONE)
 417             {
 418               /* Uggh... Failed. Instead, just read necessary data.  */
 419               unsigned num;
 420               char *p;
 421
 422               grub_errno = GRUB_ERR_NONE;
 423
 424               num = ((size + GRUB_DISK_SECTOR_SIZE - 1)
 425                      >> GRUB_DISK_SECTOR_BITS);
 426
 427               p = grub_realloc (tmp_buf, num << GRUB_DISK_SECTOR_BITS);
 428               if (!p)
 429                 goto finish;
 430
 431               tmp_buf = p;
 432
 433               if ((disk->dev->read) (disk, sector, num, tmp_buf))
 434                 {
 435                   grub_error_push ();
 436                   grub_dprintf ("disk", "%s read failed\n", disk->name);
 437                   grub_error_pop ();
 438                   goto finish;
 439                 }
 440
 441               grub_memcpy (buf, tmp_buf + real_offset, size);
 442
 443               /* Call the read hook, if any.  */
 444               if (disk->read_hook)
 445                 while (size)
 446                   {
 447                     (disk->read_hook) (sector, real_offset,
 448                                        ((size > GRUB_DISK_SECTOR_SIZE)
 449                                         ? GRUB_DISK_SECTOR_SIZE
 450                                         : size));
 451                     sector++;
 452                     size -= GRUB_DISK_SECTOR_SIZE - real_offset;
 453                     real_offset = 0;
 454                   }
 455
 456               /* This must be the end.  */
 457               goto finish;
 458             }
 459
 460           /* Copy it and store it in the disk cache.  */
 461           grub_memcpy (buf, tmp_buf + pos + real_offset, len);
 462           grub_disk_cache_store (disk->dev->id, disk->id,
 463                                  start_sector, tmp_buf);
 464         }
 465
 466       /* Call the read hook, if any.  */
 467       if (disk->read_hook)
 468         {
 469           grub_disk_addr_t s = sector;
 470           grub_size_t l = len;
 471
 472           while (l)
 473             {
 474               (disk->read_hook) (s, real_offset,
 475                                  ((l > GRUB_DISK_SECTOR_SIZE)
 476                                   ? GRUB_DISK_SECTOR_SIZE
 477                                   : l));
 478
 479               if (l < GRUB_DISK_SECTOR_SIZE - real_offset)
 480                 break;
 481
 482               s++;
 483               l -= GRUB_DISK_SECTOR_SIZE - real_offset;
 484               real_offset = 0;
 485             }
 486         }
 487
 488       sector = start_sector + GRUB_DISK_CACHE_SIZE;
 489       buf += len;
 490       size -= len;
 491       real_offset = 0;
 492     }
 493
 494  finish:
 495
 496   grub_free (tmp_buf);
 497
 498   return grub_errno;
 499 }
 500
 501 grub_err_t
 502 grub_disk_write (grub_disk_t disk, grub_disk_addr_t sector,
 503                  grub_off_t offset, grub_size_t size, const char *buf)
 504 {
 505   unsigned real_offset;
 506
 507   grub_dprintf ("disk", "Writing `%s'...\n", disk->name);
 508
 509   if (grub_disk_adjust_range (disk, &sector, &offset, size) != GRUB_ERR_NONE)
 510     return -1;
 511
 512   real_offset = offset;
 513
 514   while (size)
 515     {
 516       if (real_offset != 0 || (size < GRUB_DISK_SECTOR_SIZE && size != 0))
 517         {
 518           char tmp_buf[GRUB_DISK_SECTOR_SIZE];
 519           grub_size_t len;
 520
 521           if (grub_disk_read (disk, sector, 0, GRUB_DISK_SECTOR_SIZE, tmp_buf)
 522               != GRUB_ERR_NONE)
 523             goto finish;
 524
 525           len = GRUB_DISK_SECTOR_SIZE - real_offset;
 526           if (len > size)
 527             len = size;
 528
 529           grub_memcpy (tmp_buf + real_offset, buf, len);
 530
 531           grub_disk_cache_invalidate (disk->dev->id, disk->id, sector);
 532
 533           if ((disk->dev->write) (disk, sector, 1, tmp_buf) != GRUB_ERR_NONE)
 534             goto finish;
 535
 536           sector++;
 537           buf += len;
 538           size -= len;
 539           real_offset = 0;
 540         }
 541       else
 542         {
 543           grub_size_t len;
 544           grub_size_t n;
 545
 546           len = size & ~(GRUB_DISK_SECTOR_SIZE - 1);
 547           n = size >> GRUB_DISK_SECTOR_BITS;
 548
 549           if ((disk->dev->write) (disk, sector, n, buf) != GRUB_ERR_NONE)
 550             goto finish;
 551
 552           while (n--)
 553             grub_disk_cache_invalidate (disk->dev->id, disk->id, sector++);
 554
 555           buf += len;
 556           size -= len;
 557         }
 558     }
 559
 560  finish:
 561
 562   return grub_errno;
 563 }
 564
 565 grub_uint64_t
 566 grub_disk_get_size (grub_disk_t disk)
 567 {
 568   if (disk->partition)
 569     return grub_partition_get_len (disk->partition);
 570   else
 571     return disk->total_sectors;
 572 }