pintos-os.org Git - pintos-anon/blob - src/devices/disk.c

   1 #include "devices/disk.h"
   2 #include <ctype.h>
   3 #include <debug.h>
   4 #include <stdbool.h>
   5 #include <stdio.h>
   6 #include "devices/timer.h"
   7 #include "threads/io.h"
   8 #include "threads/interrupt.h"
   9 #include "threads/synch.h"
  10
  11 /* The code in this file is an interface to an ATA (IDE)
  12    controller.  It attempts to comply to [ATA-3]. */
  13
  14 /* ATA command block port addresses. */
  15 #define reg_data(CHANNEL) ((CHANNEL)->reg_base + 0)     /* Data. */
  16 #define reg_error(CHANNEL) ((CHANNEL)->reg_base + 1)    /* Error. */
  17 #define reg_nsect(CHANNEL) ((CHANNEL)->reg_base + 2)    /* Sector Count. */
  18 #define reg_lbal(CHANNEL) ((CHANNEL)->reg_base + 3)     /* LBA 0:7. */
  19 #define reg_lbam(CHANNEL) ((CHANNEL)->reg_base + 4)     /* LBA 15:8. */
  20 #define reg_lbah(CHANNEL) ((CHANNEL)->reg_base + 5)     /* LBA 23:16. */
  21 #define reg_device(CHANNEL) ((CHANNEL)->reg_base + 6)   /* Device/LBA 27:24. */
  22 #define reg_status(CHANNEL) ((CHANNEL)->reg_base + 7)   /* Status (r/o). */
  23 #define reg_command(CHANNEL) reg_status (CHANNEL)       /* Command (w/o). */
  24
  25 /* ATA control block port addresses.
  26    (If we supported non-legacy ATA controllers this would not be
  27    flexible enough, but it's fine for what we do.) */
  28 #define reg_ctl(CHANNEL) ((CHANNEL)->reg_base + 0x206)  /* Control (w/o). */
  29 #define reg_alt_status(CHANNEL) reg_ctl (CHANNEL)       /* Alt Status (r/o). */
  30
  31 /* Alternate Status Register bits. */
  32 #define STA_BSY 0x80            /* Busy. */
  33 #define STA_DRDY 0x40           /* Device Ready. */
  34 #define STA_DRQ 0x08            /* Data Request. */
  35
  36 /* Control Register bits. */
  37 #define CTL_SRST 0x04           /* Software Reset. */
  38
  39 /* Device Register bits. */
  40 #define DEV_MBS 0xa0            /* Must be set. */
  41 #define DEV_LBA 0x40            /* Linear based addressing. */
  42 #define DEV_DEV 0x10            /* Select device: 0=master, 1=slave. */
  43
  44 /* Commands.
  45    Many more are defined but this is the small subset that we
  46    use. */
  47 #define CMD_IDENTIFY_DEVICE 0xec        /* IDENTIFY DEVICE. */
  48 #define CMD_READ_SECTOR_RETRY 0x20      /* READ SECTOR with retries. */
  49 #define CMD_WRITE_SECTOR_RETRY 0x30     /* WRITE SECTOR with retries. */
  50
  51 /* An ATA device. */
  52 struct disk
  53   {
  54     char name[8];               /* Name, e.g. "hd0:1". */
  55     struct channel *channel;    /* Channel disk is on. */
  56     int dev_no;                 /* Device 0 or 1 for master or slave. */
  57
  58     bool is_ata;                /* 1=This device is an ATA disk. */
  59     disk_sector_t capacity;     /* Capacity in sectors (if is_ata). */
  60
  61     long long read_cnt;         /* Number of sectors read. */
  62     long long write_cnt;        /* Number of sectors written. */
  63   };
  64
  65 /* An ATA channel (aka controller).
  66    Each channel can control up to two disks. */
  67 struct channel
  68   {
  69     char name[8];               /* Name, e.g. "hd0". */
  70     uint16_t reg_base;          /* Base I/O port. */
  71     uint8_t irq;                /* Interrupt in use. */
  72
  73     struct lock lock;           /* Must acquire to access the controller. */
  74     bool expecting_interrupt;   /* True if an interrupt is expected, false if
  75                                    any interrupt would be spurious. */
  76     struct semaphore completion_wait;   /* Up'd by interrupt handler. */
  77
  78     struct disk devices[2];     /* The devices on this channel. */
  79   };
  80
  81 /* We support the two "legacy" ATA channels found in a standard PC. */
  82 #define CHANNEL_CNT 2
  83 static struct channel channels[CHANNEL_CNT];
  84
  85 static void reset_channel (struct channel *);
  86 static bool check_device_type (struct disk *);
  87 static void identify_ata_device (struct disk *);
  88
  89 static void select_sector (struct disk *, disk_sector_t);
  90 static void issue_pio_command (struct channel *, uint8_t command);
  91 static void input_sector (struct channel *, void *);
  92 static void output_sector (struct channel *, const void *);
  93
  94 static void wait_until_idle (const struct disk *);
  95 static bool wait_while_busy (const struct disk *);
  96 static void select_device (const struct disk *);
  97 static void select_device_wait (const struct disk *);
  98
  99 static void interrupt_handler (struct intr_frame *);
 100
 101 /* Initialize the disk subsystem and detect disks. */
 102 void
 103 disk_init (void)
 104 {
 105   size_t chan_no;
 106
 107   for (chan_no = 0; chan_no < CHANNEL_CNT; chan_no++)
 108     {
 109       struct channel *c = &channels[chan_no];
 110       int dev_no;
 111
 112       /* Initialize channel. */
 113       snprintf (c->name, sizeof c->name, "hd%zu", chan_no);
 114       switch (chan_no)
 115         {
 116         case 0:
 117           c->reg_base = 0x1f0;
 118           c->irq = 14 + 0x20;
 119           break;
 120         case 1:
 121           c->reg_base = 0x170;
 122           c->irq = 15 + 0x20;
 123           break;
 124         default:
 125           NOT_REACHED ();
 126         }
 127       lock_init (&c->lock);
 128       c->expecting_interrupt = false;
 129       sema_init (&c->completion_wait, 0);
 130
 131       /* Initialize devices. */
 132       for (dev_no = 0; dev_no < 2; dev_no++)
 133         {
 134           struct disk *d = &c->devices[dev_no];
 135           snprintf (d->name, sizeof d->name, "%s:%d", c->name, dev_no);
 136           d->channel = c;
 137           d->dev_no = dev_no;
 138
 139           d->is_ata = false;
 140           d->capacity = 0;
 141
 142           d->read_cnt = d->write_cnt = 0;
 143         }
 144
 145       /* Register interrupt handler. */
 146       intr_register_ext (c->irq, interrupt_handler, c->name);
 147
 148       /* Reset hardware. */
 149       reset_channel (c);
 150
 151       /* Distinguish ATA hard disks from other devices. */
 152       if (check_device_type (&c->devices[0]))
 153         check_device_type (&c->devices[1]);
 154
 155       /* Read hard disk identity information. */
 156       for (dev_no = 0; dev_no < 2; dev_no++)
 157         if (c->devices[dev_no].is_ata)
 158           identify_ata_device (&c->devices[dev_no]);
 159     }
 160 }
 161
 162 /* Prints disk statistics. */
 163 void
 164 disk_print_stats (void)
 165 {
 166   int chan_no;
 167
 168   for (chan_no = 0; chan_no < CHANNEL_CNT; chan_no++)
 169     {
 170       int dev_no;
 171
 172       for (dev_no = 0; dev_no < 2; dev_no++)
 173         {
 174           struct disk *d = disk_get (chan_no, dev_no);
 175           if (d != NULL && d->is_ata)
 176             printf ("%s: %lld reads, %lld writes\n",
 177                     d->name, d->read_cnt, d->write_cnt);
 178         }
 179     }
 180 }
 181
 182 /* Returns the disk numbered DEV_NO--either 0 or 1 for master or
 183    slave, respectively--within the channel numbered CHAN_NO.
 184
 185    Pintos uses disks this way:
 186         0:0 - boot loader, command line args, and operating system kernel
 187         0:1 - file system
 188         1:0 - scratch
 189         1:1 - swap
 190 */
 191 struct disk *
 192 disk_get (int chan_no, int dev_no)
 193 {
 194   ASSERT (dev_no == 0 || dev_no == 1);
 195
 196   if (chan_no < (int) CHANNEL_CNT)
 197     {
 198       struct disk *d = &channels[chan_no].devices[dev_no];
 199       if (d->is_ata)
 200         return d;
 201     }
 202   return NULL;
 203 }
 204
 205 /* Returns the size of disk D, measured in DISK_SECTOR_SIZE-byte
 206    sectors. */
 207 disk_sector_t
 208 disk_size (struct disk *d)
 209 {
 210   ASSERT (d != NULL);
 211
 212   return d->capacity;
 213 }
 214
 215 /* Reads sector SEC_NO from disk D into BUFFER, which must have
 216    room for DISK_SECTOR_SIZE bytes.
 217    Internally synchronizes accesses to disks, so external
 218    per-disk locking is unneeded. */
 219 void
 220 disk_read (struct disk *d, disk_sector_t sec_no, void *buffer)
 221 {
 222   struct channel *c;
 223
 224   ASSERT (d != NULL);
 225   ASSERT (buffer != NULL);
 226
 227   c = d->channel;
 228   lock_acquire (&c->lock);
 229   select_sector (d, sec_no);
 230   issue_pio_command (c, CMD_READ_SECTOR_RETRY);
 231   sema_down (&c->completion_wait);
 232   if (!wait_while_busy (d))
 233     PANIC ("%s: disk read failed, sector=%"PRDSNu, d->name, sec_no);
 234   input_sector (c, buffer);
 235   d->read_cnt++;
 236   lock_release (&c->lock);
 237 }
 238
 239 /* Write sector SEC_NO to disk D from BUFFER, which must contain
 240    DISK_SECTOR_SIZE bytes.  Returns after the disk has
 241    acknowledged receiving the data.
 242    Internally synchronizes accesses to disks, so external
 243    per-disk locking is unneeded. */
 244 void
 245 disk_write (struct disk *d, disk_sector_t sec_no, const void *buffer)
 246 {
 247   struct channel *c;
 248
 249   ASSERT (d != NULL);
 250   ASSERT (buffer != NULL);
 251
 252   c = d->channel;
 253   lock_acquire (&c->lock);
 254   select_sector (d, sec_no);
 255   issue_pio_command (c, CMD_WRITE_SECTOR_RETRY);
 256   if (!wait_while_busy (d))
 257     PANIC ("%s: disk write failed, sector=%"PRDSNu, d->name, sec_no);
 258   output_sector (c, buffer);
 259   sema_down (&c->completion_wait);
 260   d->write_cnt++;
 261   lock_release (&c->lock);
 262 }
 263 \f
 264 /* Disk detection and identification. */
 265
 266 static void print_ata_string (char *string, size_t size);
 267
 268 /* Resets an ATA channel and waits for any devices present on it
 269    to finish the reset. */
 270 static void
 271 reset_channel (struct channel *c)
 272 {
 273   bool present[2];
 274   int dev_no;
 275
 276   /* The ATA reset sequence depends on which devices are present,
 277      so we start by detecting device presence. */
 278   for (dev_no = 0; dev_no < 2; dev_no++)
 279     {
 280       struct disk *d = &c->devices[dev_no];
 281
 282       select_device (d);
 283
 284       outb (reg_nsect (c), 0x55);
 285       outb (reg_lbal (c), 0xaa);
 286
 287       outb (reg_nsect (c), 0xaa);
 288       outb (reg_lbal (c), 0x55);
 289
 290       outb (reg_nsect (c), 0x55);
 291       outb (reg_lbal (c), 0xaa);
 292
 293       present[dev_no] = (inb (reg_nsect (c)) == 0x55
 294                          && inb (reg_lbal (c)) == 0xaa);
 295     }
 296
 297   /* Issue soft reset sequence, which selects device 0 as a side effect.
 298      Also enable interrupts. */
 299   outb (reg_ctl (c), 0);
 300   timer_usleep (10);
 301   outb (reg_ctl (c), CTL_SRST);
 302   timer_usleep (10);
 303   outb (reg_ctl (c), 0);
 304
 305   timer_msleep (150);
 306
 307   /* Wait for device 0 to clear BSY. */
 308   if (present[0])
 309     {
 310       select_device (&c->devices[0]);
 311       wait_while_busy (&c->devices[0]);
 312     }
 313
 314   /* Wait for device 1 to clear BSY. */
 315   if (present[1])
 316     {
 317       int i;
 318
 319       select_device (&c->devices[1]);
 320       for (i = 0; i < 3000; i++)
 321         {
 322           if (inb (reg_nsect (c)) == 1 && inb (reg_lbal (c)) == 1)
 323             break;
 324           timer_msleep (10);
 325         }
 326       wait_while_busy (&c->devices[1]);
 327     }
 328 }
 329
 330 /* Checks whether device D is an ATA disk and sets D's is_ata
 331    member appropriately.  If D is device 0 (master), returns true
 332    if it's possible that a slave (device 1) exists on this
 333    channel.  If D is device 1 (slave), the return value is not
 334    meaningful. */
 335 static bool
 336 check_device_type (struct disk *d)
 337 {
 338   struct channel *c = d->channel;
 339   uint8_t error, lbam, lbah, status;
 340
 341   select_device (d);
 342
 343   error = inb (reg_error (c));
 344   lbam = inb (reg_lbam (c));
 345   lbah = inb (reg_lbah (c));
 346   status = inb (reg_status (c));
 347
 348   if ((error != 1 && (error != 0x81 || d->dev_no == 1))
 349       || (status & STA_DRDY) == 0
 350       || (status & STA_BSY) != 0)
 351     {
 352       d->is_ata = false;
 353       return error != 0x81;
 354     }
 355   else
 356     {
 357       d->is_ata = (lbam == 0 && lbah == 0) || (lbam == 0x3c && lbah == 0xc3);
 358       return true;
 359     }
 360 }
 361
 362 /* Sends an IDENTIFY DEVICE command to disk D and reads the
 363    response.  Initializes D's capacity member based on the result
 364    and prints a message describing the disk to the console. */
 365 static void
 366 identify_ata_device (struct disk *d)
 367 {
 368   struct channel *c = d->channel;
 369   uint16_t id[DISK_SECTOR_SIZE / 2];
 370
 371   ASSERT (d->is_ata);
 372
 373   /* Send the IDENTIFY DEVICE command, wait for an interrupt
 374      indicating the device's response is ready, and read the data
 375      into our buffer. */
 376   select_device_wait (d);
 377   issue_pio_command (c, CMD_IDENTIFY_DEVICE);
 378   sema_down (&c->completion_wait);
 379   if (!wait_while_busy (d))
 380     {
 381       d->is_ata = false;
 382       return;
 383     }
 384   input_sector (c, id);
 385
 386   /* Calculate capacity. */
 387   d->capacity = id[60] | ((uint32_t) id[61] << 16);
 388
 389   /* Print identification message. */
 390   printf ("%s: detected %'"PRDSNu" sector (", d->name, d->capacity);
 391   if (d->capacity > 1024 / DISK_SECTOR_SIZE * 1024 * 1024)
 392     printf ("%"PRDSNu" GB",
 393             d->capacity / (1024 / DISK_SECTOR_SIZE * 1024 * 1024));
 394   else if (d->capacity > 1024 / DISK_SECTOR_SIZE * 1024)
 395     printf ("%"PRDSNu" MB", d->capacity / (1024 / DISK_SECTOR_SIZE * 1024));
 396   else if (d->capacity > 1024 / DISK_SECTOR_SIZE)
 397     printf ("%"PRDSNu" kB", d->capacity / (1024 / DISK_SECTOR_SIZE));
 398   else
 399     printf ("%"PRDSNu" byte", d->capacity * DISK_SECTOR_SIZE);
 400   printf (") disk, model \"");
 401   print_ata_string ((char *) &id[27], 40);
 402   printf ("\", serial \"");
 403   print_ata_string ((char *) &id[10], 20);
 404   printf ("\"\n");
 405 }
 406
 407 /* Prints STRING, which consists of SIZE bytes in a funky format:
 408    each pair of bytes is in reverse order.  Does not print
 409    trailing whitespace and/or nulls. */
 410 static void
 411 print_ata_string (char *string, size_t size)
 412 {
 413   size_t i;
 414
 415   /* Find the last non-white, non-null character. */
 416   for (; size > 0; size--)
 417     {
 418       int c = string[(size - 1) ^ 1];
 419       if (c != '\0' && !isspace (c))
 420         break;
 421     }
 422
 423   /* Print. */
 424   for (i = 0; i < size; i++)
 425     printf ("%c", string[i ^ 1]);
 426 }
 427 \f
 428 /* Selects device D, waiting for it to become ready, and then
 429    writes SEC_NO to the disk's sector selection registers.  (We
 430    use LBA mode.) */
 431 static void
 432 select_sector (struct disk *d, disk_sector_t sec_no)
 433 {
 434   struct channel *c = d->channel;
 435
 436   ASSERT (sec_no < d->capacity);
 437   ASSERT (sec_no < (1UL << 28));
 438
 439   select_device_wait (d);
 440   outb (reg_nsect (c), 1);
 441   outb (reg_lbal (c), sec_no);
 442   outb (reg_lbam (c), sec_no >> 8);
 443   outb (reg_lbah (c), (sec_no >> 16));
 444   outb (reg_device (c),
 445         DEV_MBS | DEV_LBA | (d->dev_no == 1 ? DEV_DEV : 0) | (sec_no >> 24));
 446 }
 447
 448 /* Writes COMMAND to channel C and prepares for receiving a
 449    completion interrupt. */
 450 static void
 451 issue_pio_command (struct channel *c, uint8_t command)
 452 {
 453   /* Interrupts must be enabled or our semaphore will never be
 454      up'd by the completion handler. */
 455   ASSERT (intr_get_level () == INTR_ON);
 456
 457   c->expecting_interrupt = true;
 458   outb (reg_command (c), command);
 459 }
 460
 461 /* Reads a sector from channel C's data register in PIO mode into
 462    SECTOR, which must have room for DISK_SECTOR_SIZE bytes. */
 463 static void
 464 input_sector (struct channel *c, void *sector)
 465 {
 466   insw (reg_data (c), sector, DISK_SECTOR_SIZE / 2);
 467 }
 468
 469 /* Writes SECTOR to channel C's data register in PIO mode.
 470    SECTOR must contain DISK_SECTOR_SIZE bytes. */
 471 static void
 472 output_sector (struct channel *c, const void *sector)
 473 {
 474   outsw (reg_data (c), sector, DISK_SECTOR_SIZE / 2);
 475 }
 476 \f
 477 /* Low-level ATA primitives. */
 478
 479 /* Wait up to 10 seconds for the controller to become idle, that
 480    is, for the BSY and DRQ bits to clear in the status register.
 481
 482    As a side effect, reading the status register clears any
 483    pending interrupt. */
 484 static void
 485 wait_until_idle (const struct disk *d)
 486 {
 487   int i;
 488
 489   for (i = 0; i < 1000; i++)
 490     {
 491       if ((inb (reg_status (d->channel)) & (STA_BSY | STA_DRQ)) == 0)
 492         return;
 493       timer_usleep (10);
 494     }
 495
 496   printf ("%s: idle timeout\n", d->name);
 497 }
 498
 499 /* Wait up to 30 seconds for disk D to clear BSY,
 500    and then return the status of the DRQ bit.
 501    The ATA standards say that a disk may take as long as that to
 502    complete its reset. */
 503 static bool
 504 wait_while_busy (const struct disk *d)
 505 {
 506   struct channel *c = d->channel;
 507   int i;
 508
 509   for (i = 0; i < 3000; i++)
 510     {
 511       if (i == 700)
 512         printf ("%s: busy, waiting...", d->name);
 513       if (!(inb (reg_alt_status (c)) & STA_BSY))
 514         {
 515           if (i >= 700)
 516             printf ("ok\n");
 517           return (inb (reg_alt_status (c)) & STA_DRQ) != 0;
 518         }
 519       timer_msleep (10);
 520     }
 521
 522   printf ("failed\n");
 523   return false;
 524 }
 525
 526 /* Program D's channel so that D is now the selected disk. */
 527 static void
 528 select_device (const struct disk *d)
 529 {
 530   struct channel *c = d->channel;
 531   uint8_t dev = DEV_MBS;
 532   if (d->dev_no == 1)
 533     dev |= DEV_DEV;
 534   outb (reg_device (c), dev);
 535   inb (reg_alt_status (c));
 536   timer_nsleep (400);
 537 }
 538
 539 /* Select disk D in its channel, as select_device(), but wait for
 540    the channel to become idle before and after. */
 541 static void
 542 select_device_wait (const struct disk *d)
 543 {
 544   wait_until_idle (d);
 545   select_device (d);
 546   wait_until_idle (d);
 547 }
 548 \f
 549 /* ATA interrupt handler. */
 550 static void
 551 interrupt_handler (struct intr_frame *f)
 552 {
 553   struct channel *c;
 554
 555   for (c = channels; c < channels + CHANNEL_CNT; c++)
 556     if (f->vec_no == c->irq)
 557       {
 558         if (c->expecting_interrupt)
 559           {
 560             inb (reg_status (c));               /* Acknowledge interrupt. */
 561             sema_up (&c->completion_wait);      /* Wake up waiter. */
 562           }
 563         else
 564           printf ("%s: unexpected interrupt\n", c->name);
 565         return;
 566       }
 567
 568   NOT_REACHED ();
 569 }
 570
 571