kernel/blk_drv/scsi/sd.c

/* */
This source file includes following definitions.
sd_open
sd_release
sd_geninit
rw_intr
do_sd_request
requeue_sd_request
check_scsidisk_media_change
sd_init_done
sd_init_onedisk
sd_init
sd_init1
sd_attach
revalidate_scsidisk
   1 /*
   2  *      sd.c Copyright (C) 1992 Drew Eckhardt 
   3  *      Linux scsi disk driver by
   4  *              Drew Eckhardt 
   5  *
   6  *      <drew@colorado.edu>
   7  *
   8  *       Modified by Eric Youngdale eric@tantalus.nrl.navy.mil to
   9  *       add scatter-gather, multiple outstanding request, and other
  10  *       enhancements.
  11  */
  12 
  13 #include <linux/fs.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/string.h>
  17 #include <linux/errno.h>
  18 #include <asm/system.h>
  19 
  20 
  21 #define MAJOR_NR 8
  22 
  23 #include "../blk.h"
  24 #include "scsi.h"
  25 #include "hosts.h"
  26 #include "sd.h"
  27 #include "scsi_ioctl.h"
  28 
  29 #include <linux/genhd.h>
  30 
  31 /*
  32 static const char RCSid[] = "$Header:";
  33 */
  34 
  35 #define MAX_RETRIES 5
  36 
  37 /*
  38  *      Time out in seconds
  39  */
  40 
  41 #define SD_TIMEOUT 200
  42 
  43 struct hd_struct * sd;
  44 
  45 int NR_SD=0;
  46 int MAX_SD=0;
  47 Scsi_Disk * rscsi_disks;
  48 int * sd_sizes;
  49 
  50 /* used to re-read partitions. */
  51 extern void resetup_one_dev(struct gendisk *, unsigned int);
  52 
  53 extern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned int);
  54 
  55 static sd_init_onedisk(int);
  56 
  57 static void requeue_sd_request (Scsi_Cmnd * SCpnt);
  58 
  59 static int sd_open(struct inode * inode, struct file * filp)
     /*  */
  60 {
  61         int target;
  62         target =  DEVICE_NR(MINOR(inode->i_rdev));
  63 
  64         if(target >= NR_SD || !rscsi_disks[target].device)
  65           return -EACCES;   /* No such device */
  66         
  67 /* Make sure that only one process can do a check_change_disk at one time.
  68  This is also used to lock out further access when the partition table is being re-read. */
  69 
  70         while (rscsi_disks[target].device->busy);
  71 
  72         if(rscsi_disks[target].device->removable) {
  73           check_disk_change(inode->i_rdev);
  74 
  75           if(!rscsi_disks[target].device->access_count)
  76             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
  77         };
  78         rscsi_disks[target].device->access_count++;
  79         return 0;
  80 }
  81 
  82 static void sd_release(struct inode * inode, struct file * file)
     /*  */
  83 {
  84         int target;
  85         sync_dev(inode->i_rdev);
  86 
  87         target =  DEVICE_NR(MINOR(inode->i_rdev));
  88 
  89         rscsi_disks[target].device->access_count--;
  90 
  91         if(rscsi_disks[target].device->removable) {
  92           if(!rscsi_disks[target].device->access_count)
  93             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
  94         };
  95 }
  96 
  97 static struct gendisk sd_gendisk;
  98 
  99 static void sd_geninit (void) {
     /*  */
 100         int i;
 101         for (i = 0; i < NR_SD; ++i)
 102           sd[i << 4].nr_sects = rscsi_disks[i].capacity;
 103         sd_gendisk.nr_real = NR_SD;
 104 }
 105 
 106 static struct file_operations sd_fops = {
 107         NULL,                   /* lseek - default */
 108         block_read,             /* read - general block-dev read */
 109         block_write,            /* write - general block-dev write */
 110         NULL,                   /* readdir - bad */
 111         NULL,                   /* select */
 112         sd_ioctl,               /* ioctl */
 113         NULL,                   /* mmap */
 114         sd_open,                /* open code */
 115         sd_release              /* release */
 116 };
 117 
 118 static struct gendisk sd_gendisk = {
 119         MAJOR_NR,               /* Major number */
 120         "sd",           /* Major name */
 121         4,              /* Bits to shift to get real from partition */
 122         1 << 4,         /* Number of partitions per real */
 123         0,              /* maximum number of real */
 124         sd_geninit,     /* init function */
 125         NULL,           /* hd struct */
 126         NULL,   /* block sizes */
 127         0,              /* number */
 128         NULL,   /* internal */
 129         NULL            /* next */
 130 };
 131 
 132 /*
 133         rw_intr is the interrupt routine for the device driver.  It will
 134         be notified on the end of a SCSI read / write, and
 135         will take on of several actions based on success or failure.
 136 */
 137 
 138 static void rw_intr (Scsi_Cmnd *SCpnt)
     /*  */
 139 {
 140   int result = SCpnt->result;
 141   int this_count = SCpnt->bufflen >> 9;
 142 
 143 #ifdef DEBUG
 144   printk("sd%d : rw_intr(%d, %x)\n", MINOR(SCpnt->request.dev), SCpnt->host, result);
 145 #endif
 146 
 147 /*
 148   First case : we assume that the command succeeded.  One of two things will
 149   happen here.  Either we will be finished, or there will be more
 150   sectors that we were unable to read last time.
 151 */
 152 
 153   if (!result) {
 154 
 155 #ifdef DEBUG
 156     printk("sd%d : %d sectors remain.\n", MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
 157     printk("use_sg is %d\n ",SCpnt->use_sg);
 158 #endif
 159     if (SCpnt->use_sg) {
 160       struct scatterlist * sgpnt;
 161       int i;
 162       sgpnt = (struct scatterlist *) SCpnt->buffer;
 163       for(i=0; i<SCpnt->use_sg; i++) {
 164 #ifdef DEBUG
 165         printk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 166 #endif
 167         if (sgpnt[i].alt_address) {
 168           if (SCpnt->request.cmd == READ)
 169             memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 170           scsi_free(sgpnt[i].address, sgpnt[i].length);
 171         };
 172       };
 173       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 174     } else {
 175       if (SCpnt->buffer != SCpnt->request.buffer) {
 176 #ifdef DEBUG
 177         printk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 178                    SCpnt->bufflen);
 179 #endif  
 180           if (SCpnt->request.cmd == READ)
 181             memcpy(SCpnt->request.buffer, SCpnt->buffer,
 182                    SCpnt->bufflen);
 183           scsi_free(SCpnt->buffer, SCpnt->bufflen);
 184       };
 185     };
 186 /*
 187  *      If multiple sectors are requested in one buffer, then
 188  *      they will have been finished off by the first command.  If
 189  *      not, then we have a multi-buffer command.
 190  */
 191     if (SCpnt->request.nr_sectors > this_count)
 192       {
 193         SCpnt->request.errors = 0;
 194         
 195         if (!SCpnt->request.bh)
 196           {
 197 #ifdef DEBUG
 198             printk("sd%d : handling page request, no buffer\n",
 199                    MINOR(SCpnt->request.dev));
 200 #endif
 201 /*
 202   The SCpnt->request.nr_sectors field is always done in 512 byte sectors,
 203   even if this really isn't the case.
 204 */
 205             printk("sd.c: linked page request. (%x %x)",
 206                   SCpnt->request.sector, this_count);
 207             panic("Aiiiiiiiiiiiieeeeeeeee");
 208           }
 209       }
 210     end_scsi_request(SCpnt, 1, this_count);
 211     requeue_sd_request(SCpnt);
 212     return;
 213   }
 214 
 215 /* Free up any indirection buffers we allocated for DMA purposes. */
 216     if (SCpnt->use_sg) {
 217       struct scatterlist * sgpnt;
 218       int i;
 219       sgpnt = (struct scatterlist *) SCpnt->buffer;
 220       for(i=0; i<SCpnt->use_sg; i++) {
 221 #ifdef DEBUG
 222         printk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 223                    SCpnt->bufflen);
 224 #endif
 225         if (sgpnt[i].alt_address) {
 226           scsi_free(sgpnt[i].address, sgpnt[i].length);
 227         };
 228       };
 229       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 230     } else {
 231 #ifdef DEBUG
 232       printk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 233                    SCpnt->bufflen);
 234 #endif
 235       if (SCpnt->buffer != SCpnt->request.buffer)
 236         scsi_free(SCpnt->buffer, SCpnt->bufflen);
 237     };
 238 
 239 /*
 240         Now, if we were good little boys and girls, Santa left us a request
 241         sense buffer.  We can extract information from this, so we
 242         can choose a block to remap, etc.
 243 */
 244 
 245         if (driver_byte(result) != 0) {
 246           {
 247             int i;
 248             printk("Dumping sense buffer: ");
 249             for(i=0;i<10;i++) printk(" %d",SCpnt->sense_buffer[i]);
 250           };
 251           if (sugestion(result) == SUGGEST_REMAP) {
 252 #ifdef REMAP
 253 /*
 254         Not yet implemented.  A read will fail after being remapped,
 255         a write will call the strategy routine again.
 256 */
 257             if rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
 258               {
 259                 result = 0;
 260               }
 261             else
 262               
 263 #endif
 264             }
 265 
 266           if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
 267             if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
 268               /* detected disc change.  set a bit and quietly refuse    */
 269               /* further access.                                        */
 270               
 271               rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
 272               end_scsi_request(SCpnt, 0, this_count);
 273               requeue_sd_request(SCpnt);
 274               return;
 275             }
 276           }
 277           
 278 
 279 /*      If we had an ILLEGAL REQUEST returned, then we may have
 280 performed an unsupported command.  The only thing this should be would
 281 be a ten byte read where only a six byte read was supportted.  Also,
 282 on a system where READ CAPACITY failed, we mave have read past the end
 283 of the  disk. 
 284 */
 285 
 286           if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
 287             if (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
 288               rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
 289               requeue_sd_request(SCpnt);
 290               result = 0;
 291             } else {
 292             }
 293           }
 294         }  /* driver byte != 0 */
 295         if (result) {
 296                 printk("SCSI disk error : host %d id %d lun %d return code = %x\n",
 297                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host_no,
 298                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
 299                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
 300 
 301                 if (driver_byte(result) & DRIVER_SENSE)
 302                         printk("\tSense class %x, sense error %x, extended sense %x\n",
 303                                 sense_class(SCpnt->sense_buffer[0]),
 304                                 sense_error(SCpnt->sense_buffer[0]),
 305                                 SCpnt->sense_buffer[2] & 0xf);
 306 
 307                 end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
 308                 requeue_sd_request(SCpnt);
 309                 return;
 310         }
 311 }
 312 
 313 /*
 314         requeue_sd_request() is the request handler function for the sd driver.
 315         Its function in life is to take block device requests, and translate
 316         them to SCSI commands.
 317 */
 318 
 319 static void do_sd_request (void)
     /*  */
 320 {
 321   Scsi_Cmnd * SCpnt = NULL;
 322   struct request * req = NULL;
 323   while (1==1){
 324     if (CURRENT != NULL && CURRENT->dev == -1) return;
 325 
 326     INIT_REQUEST;
 327 
 328     SCpnt = allocate_device(&CURRENT,
 329                             rscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
 330 
 331 /* This is a performance enhancement.  We dig down into the request list and
 332    try and find a queueable request (i.e. device not busy, and host able to
 333    accept another command.  If we find one, then we queue it. This can
 334    make a big difference on systems with more than one disk drive.  We want
 335    to have the interrupts off when monkeying with the request list, because
 336    otherwise the kernel might try and slip in a request inbetween somewhere. */
 337 
 338     if (!SCpnt && NR_SD > 1){
 339       struct request *req1;
 340       req1 = NULL;
 341       cli();
 342       req = CURRENT;
 343       while(req){
 344         SCpnt = request_queueable(req,
 345                                   rscsi_disks[DEVICE_NR(MINOR(req->dev))].device->index);
 346         if(SCpnt) break;
 347         req1 = req;
 348         req = req->next;
 349       };
 350       if (SCpnt) {
 351         if (req == CURRENT) 
 352           CURRENT = CURRENT->next;
 353         else
 354           req1->next = req->next;
 355       };
 356       sti();
 357     };
 358     
 359     if (!SCpnt) return; /* Could not find anything to do */
 360     
 361     wake_up(&wait_for_request);
 362     
 363     /* Queue command */
 364     requeue_sd_request(SCpnt);
 365   };  /* While */
 366 }    
 367 
 368 static void requeue_sd_request (Scsi_Cmnd * SCpnt)
     /*  */
 369 {
 370         int dev, block, this_count;
 371         unsigned char cmd[10];
 372         char * buff;
 373 
 374 repeat:
 375 
 376         if(SCpnt->request.dev <= 0)
 377           return do_sd_request();
 378 
 379         dev =  MINOR(SCpnt->request.dev);
 380         block = SCpnt->request.sector;
 381         this_count = 0;
 382 
 383 #ifdef DEBUG
 384         printk("Doing sd request, dev = %d, block = %d\n", dev, block);
 385 #endif
 386 
 387         if (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
 388                 {
 389                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 390                 goto repeat;
 391                 }
 392 
 393         block += sd[dev].start_sect;
 394         dev = DEVICE_NR(dev);
 395 
 396         if (rscsi_disks[dev].device->changed)
 397                 {
 398 /*
 399  * quietly refuse to do anything to a changed disc until the changed bit has been reset
 400  */
 401                 /* printk("SCSI disk has been changed.  Prohibiting further I/O.\n");   */
 402                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 403                 goto repeat;
 404                 }
 405 
 406 #ifdef DEBUG
 407         printk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
 408 #endif
 409 
 410         switch (SCpnt->request.cmd)
 411                 {
 412                 case WRITE :
 413                         if (!rscsi_disks[dev].device->writeable)
 414                                 {
 415                                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 416                                 goto repeat;
 417                                 }
 418                         cmd[0] = WRITE_6;
 419                         break;
 420                 case READ :
 421                         cmd[0] = READ_6;
 422                         break;
 423                 default :
 424                         printk ("Unknown sd command %d\r\n", SCpnt->request.cmd);
 425                         panic("");
 426                       }
 427 
 428         SCpnt->this_count = 0;
 429 
 430         if (!SCpnt->request.bh || 
 431             (SCpnt->request.nr_sectors == SCpnt->request.current_nr_sectors)) {
 432 
 433           /* case of page request (i.e. raw device), or unlinked buffer */
 434           this_count = SCpnt->request.nr_sectors;
 435           buff = SCpnt->request.buffer;
 436           SCpnt->use_sg = 0;
 437 
 438         } else if (scsi_hosts[SCpnt->host].sg_tablesize == 0 ||
 439                    (need_isa_buffer && 
 440                     dma_free_sectors < 10)) {
 441 
 442           /* Case of host adapter that cannot scatter-gather.  We also
 443            come here if we are running low on DMA buffer memory.  We set
 444            a threshold higher than that we would need for this request so
 445            we leave room for other requests.  Even though we would not need
 446            it all, we need to be conservative, because if we run low enough
 447            we have no choice but to panic. */
 448 
 449           if (scsi_hosts[SCpnt->host].sg_tablesize != 0 &&
 450               need_isa_buffer && 
 451               dma_free_sectors < 10)
 452             printk("Warning: SCSI DMA buffer space running low.  Using non scatter-gather I/O.\n");
 453 
 454           this_count = SCpnt->request.current_nr_sectors;
 455           buff = SCpnt->request.buffer;
 456           SCpnt->use_sg = 0;
 457 
 458         } else {
 459 
 460           /* Scatter-gather capable host adapter */
 461           struct buffer_head * bh;
 462           struct scatterlist * sgpnt;
 463           int count, this_count_max;
 464           bh = SCpnt->request.bh;
 465           this_count = 0;
 466           this_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
 467           count = 0;
 468           while(bh && count < scsi_hosts[SCpnt->host].sg_tablesize) {
 469             if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
 470             this_count += (bh->b_size >> 9);
 471             count++;
 472             bh = bh->b_reqnext;
 473           };
 474           SCpnt->use_sg = count;  /* Number of chains */
 475           count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
 476           while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
 477             count = count << 1;
 478           SCpnt->sglist_len = count;
 479           sgpnt = (struct scatterlist * ) scsi_malloc(count);
 480           if (!sgpnt) {
 481             printk("Warning - running *really* short on DMA buffers\n");
 482             SCpnt->use_sg = 0;  /* No memory left - bail out */
 483             this_count = SCpnt->request.current_nr_sectors;
 484             buff = SCpnt->request.buffer;
 485           } else {
 486             buff = (char *) sgpnt;
 487             count = 0;
 488             bh = SCpnt->request.bh;
 489             for(count = 0, bh = SCpnt->request.bh; count < SCpnt->use_sg; 
 490                 count++, bh = bh->b_reqnext) {
 491               sgpnt[count].address = bh->b_data;
 492               sgpnt[count].alt_address = NULL;
 493               sgpnt[count].length = bh->b_size;
 494               if (((int) sgpnt[count].address) + sgpnt[count].length > 
 495                   ISA_DMA_THRESHOLD & (scsi_hosts[SCpnt->host].unchecked_isa_dma)) {
 496                 sgpnt[count].alt_address = sgpnt[count].address;
 497                 /* We try and avoid exhausting the DMA pool, since it is easier
 498                    to control usage here.  In other places we might have a more
 499                    pressing need, and we would be screwed if we ran out */
 500                 if(dma_free_sectors < (bh->b_size >> 9) + 5) {
 501                   sgpnt[count].address = NULL;
 502                 } else {
 503                   sgpnt[count].address = scsi_malloc(sgpnt[count].length);
 504                 };
 505 /* If we start running low on DMA buffers, we abort the scatter-gather
 506    operation, and free all of the memory we have allocated.  We want to
 507    ensure that all scsi operations are able to do at least a non-scatter/gather
 508    operation */
 509                 if(sgpnt[count].address == NULL){ /* Out of dma memory */
 510                   printk("Warning: Running low on SCSI DMA buffers");
 511                   /* Try switching back to a non scatter-gather operation. */
 512                   while(--count){
 513                     if(sgpnt[count].alt_address) 
 514                       scsi_free(sgpnt[count].address, sgpnt[count].length);
 515                   };
 516                   this_count = SCpnt->request.current_nr_sectors;
 517                   buff = SCpnt->request.buffer;
 518                   SCpnt->use_sg = 0;
 519                   scsi_free(buff, SCpnt->sglist_len);
 520                   break;
 521                 };
 522 
 523                 if (SCpnt->request.cmd == WRITE)
 524                   memcpy(sgpnt[count].address, sgpnt[count].alt_address, 
 525                          sgpnt[count].length);
 526               };
 527             }; /* for loop */
 528           };  /* Able to malloc sgpnt */
 529         };  /* Host adapter capable of scatter-gather */
 530 
 531 /* Now handle the possibility of DMA to addresses > 16Mb */
 532 
 533         if(SCpnt->use_sg == 0){
 534           if (((int) buff) + (this_count << 9) > ISA_DMA_THRESHOLD && 
 535             (scsi_hosts[SCpnt->host].unchecked_isa_dma)) {
 536             buff = scsi_malloc(this_count << 9);
 537             if(buff == NULL) panic("Ran out of DMA buffers.");
 538             if (SCpnt->request.cmd == WRITE)
 539               memcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
 540           };
 541         };
 542 
 543 #ifdef DEBUG
 544         printk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(SCpnt->request.dev),
 545                 (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
 546                 this_count, SCpnt->request.nr_sectors);
 547 #endif
 548 
 549         cmd[1] = (SCpnt->lun << 5) & 0xe0;
 550 
 551         if (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
 552                 {
 553                 if (this_count > 0xffff)
 554                         this_count = 0xffff;
 555 
 556                 cmd[0] += READ_10 - READ_6 ;
 557                 cmd[2] = (unsigned char) (block >> 24) & 0xff;
 558                 cmd[3] = (unsigned char) (block >> 16) & 0xff;
 559                 cmd[4] = (unsigned char) (block >> 8) & 0xff;
 560                 cmd[5] = (unsigned char) block & 0xff;
 561                 cmd[6] = cmd[9] = 0;
 562                 cmd[7] = (unsigned char) (this_count >> 8) & 0xff;
 563                 cmd[8] = (unsigned char) this_count & 0xff;
 564                 }
 565         else
 566                 {
 567                 if (this_count > 0xff)
 568                         this_count = 0xff;
 569 
 570                 cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 571                 cmd[2] = (unsigned char) ((block >> 8) & 0xff);
 572                 cmd[3] = (unsigned char) block & 0xff;
 573                 cmd[4] = (unsigned char) this_count;
 574                 cmd[5] = 0;
 575                 }
 576 
 577         scsi_do_cmd (SCpnt, (void *) cmd, buff, this_count << 9,
 578                      rw_intr, SD_TIMEOUT, MAX_RETRIES);
 579 }
 580 
 581 int check_scsidisk_media_change(int full_dev, int flag){
     /*  */
 582         int retval;
 583         int target;
 584         struct inode inode;
 585 
 586         target =  DEVICE_NR(MINOR(full_dev));
 587 
 588         if (target >= NR_SD) {
 589                 printk("SCSI disk request error: invalid device.\n");
 590                 return 0;
 591         };
 592 
 593         if(!rscsi_disks[target].device->removable) return 0;
 594 
 595         inode.i_rdev = full_dev;  /* This is all we really need here */
 596         retval = sd_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
 597 
 598         if(retval){ /* Unable to test, unit probably not ready.  This usually
 599                      means there is no disc in the drive.  Mark as changed,
 600                      and we will figure it out later once the drive is
 601                      available again.  */
 602 
 603           rscsi_disks[target].device->changed = 1;
 604           return 1; /* This will force a flush, if called from
 605                        check_disk_change */
 606         };
 607 
 608         retval = rscsi_disks[target].device->changed;
 609         if(!flag) rscsi_disks[target].device->changed = 0;
 610         return retval;
 611 }
 612 
 613 static void sd_init_done (Scsi_Cmnd * SCpnt)
     /*  */
 614 {
 615   struct request * req;
 616   struct task_struct * p;
 617   
 618   req = &SCpnt->request;
 619   req->dev = 0xfffe; /* Busy, but indicate request done */
 620   
 621   if ((p = req->waiting) != NULL) {
 622     req->waiting = NULL;
 623     p->state = TASK_RUNNING;
 624     if (p->counter > current->counter)
 625       need_resched = 1;
 626   }
 627 }
 628 
 629 static int sd_init_onedisk(int i)
     /*  */
 630 {
 631   int j = 0;
 632   unsigned char cmd[10];
 633   unsigned char buffer[513];
 634   int the_result, retries;
 635   Scsi_Cmnd * SCpnt;
 636 
 637   /* We need to retry the READ_CAPACITY because a UNIT_ATTENTION is considered
 638      a fatal error, and many devices report such an error just after a scsi
 639      bus reset. */
 640 
 641   SCpnt = allocate_device(NULL, rscsi_disks[i].device->index, 1);
 642 
 643   retries = 3;
 644   do {
 645     cmd[0] = READ_CAPACITY;
 646     cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 647     memset ((void *) &cmd[2], 0, 8);
 648     SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 649     
 650     scsi_do_cmd (SCpnt,
 651                  (void *) cmd, (void *) buffer,
 652                  512, sd_init_done,  SD_TIMEOUT,
 653                  MAX_RETRIES);
 654     
 655     if (current == task[0])
 656       while(SCpnt->request.dev != 0xfffe);
 657     else
 658       if (SCpnt->request.dev != 0xfffe){
 659         SCpnt->request.waiting = current;
 660         current->state = TASK_UNINTERRUPTIBLE;
 661         while (SCpnt->request.dev != 0xfffe) schedule();
 662       };
 663     
 664     the_result = SCpnt->result;
 665     retries--;
 666 
 667   } while(the_result && retries);
 668 
 669   SCpnt->request.dev = -1;  /* Mark as not busy */
 670 
 671   wake_up(&scsi_devices[SCpnt->index].device_wait); 
 672 
 673   /* Wake up a process waiting for device*/
 674 
 675   /*
 676    *    The SCSI standard says "READ CAPACITY is necessary for self confuring software"
 677    *    While not mandatory, support of READ CAPACITY is strongly encouraged.
 678    *    We used to die if we couldn't successfully do a READ CAPACITY.
 679    *    But, now we go on about our way.  The side effects of this are
 680    *
 681    *    1.  We can't know block size with certainty.  I have said "512 bytes is it"
 682    *            as this is most common.
 683    *
 684    *    2.  Recovery from when some one attempts to read past the end of the raw device will
 685    *        be slower.
 686    */
 687 
 688   if (the_result)
 689     {
 690       printk ("sd%d : READ CAPACITY failed.\n"
 691               "sd%d : status = %x, message = %02x, host = %02x, driver = %02x \n",
 692               i,i,
 693               rscsi_disks[i].device->host_no, rscsi_disks[i].device->id,
 694               rscsi_disks[i].device->lun,
 695               status_byte(the_result),
 696               msg_byte(the_result),
 697               host_byte(the_result),
 698               driver_byte(the_result)
 699               );
 700       if (driver_byte(the_result)  & DRIVER_SENSE)
 701         printk("sd%d : extended sense code = %1x \n", i, SCpnt->sense_buffer[2] & 0xf);
 702       else
 703         printk("sd%d : sense not available. \n", i);
 704 
 705       printk("sd%d : block size assumed to be 512 bytes, disk size 1GB.  \n", i);
 706       rscsi_disks[i].capacity = 0xfffff;
 707       rscsi_disks[i].sector_size = 512;
 708     }
 709   else
 710     {
 711       rscsi_disks[i].capacity = (buffer[0] << 24) |
 712         (buffer[1] << 16) |
 713           (buffer[2] << 8) |
 714             buffer[3];
 715 
 716       if ((rscsi_disks[i].sector_size = (buffer[4] << 24) |
 717            (buffer[5] << 16) |
 718            (buffer[6] << 8) |
 719            buffer[7]) != 512)
 720         {
 721           printk ("sd%d : unsupported sector size %d.\n",
 722                   i, rscsi_disks[i].sector_size);
 723           if(rscsi_disks[i].device->removable){
 724             rscsi_disks[i].capacity = 0;
 725           } else {
 726             printk ("scsi : deleting disk entry.\n");
 727             for  (j=i;  j < NR_SD - 1;)
 728               rscsi_disks[j] = rscsi_disks[++j];
 729             --i;
 730             --NR_SD;
 731             return i;
 732           };
 733         }
 734     }
 735 
 736   rscsi_disks[i].ten = 1;
 737   rscsi_disks[i].remap = 1;
 738   return i;
 739 }
 740 
 741 /*
 742         The sd_init() function looks at all SCSI drives present, determines
 743         their size, and reads partition table entries for them.
 744 */
 745 
 746 unsigned long sd_init(unsigned long memory_start, unsigned long memory_end)
     /*  */
 747 {
 748         int i;
 749 
 750         if (MAX_SD == 0) return memory_start;
 751 
 752         sd_sizes = (int *) memory_start;
 753         memory_start += (MAX_SD << 4) * sizeof(int);
 754         memset(sd_sizes, 0, (MAX_SD << 4) * sizeof(int));
 755 
 756         sd = (struct hd_struct *) memory_start;
 757         memory_start += (MAX_SD << 4) * sizeof(struct hd_struct);
 758 
 759         sd_gendisk.max_nr = MAX_SD;
 760         sd_gendisk.part = sd;
 761         sd_gendisk.sizes = sd_sizes;
 762         sd_gendisk.real_devices = (void *) rscsi_disks;
 763 
 764         for (i = 0; i < NR_SD; ++i)
 765           i = sd_init_onedisk(i);
 766 
 767         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
 768         blkdev_fops[MAJOR_NR] = &sd_fops;
 769 
 770         /* If our host adapter is capable of scatter-gather, then we increase
 771            the read-ahead to 8 blocks (16 sectors).  If not, we use
 772            a two block (4 sector) read ahead. */
 773         if(scsi_hosts[rscsi_disks[0].device->host_no].sg_tablesize)
 774           read_ahead[MAJOR_NR] = 16;  /* 16 sector read-ahead */
 775         else
 776           read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
 777         
 778         sd_gendisk.next = gendisk_head;
 779         gendisk_head = &sd_gendisk;
 780         return memory_start;
 781 }
 782 
 783 unsigned long sd_init1(unsigned long mem_start, unsigned long mem_end){
     /*  */
 784   rscsi_disks = (Scsi_Disk *) mem_start;
 785   mem_start += MAX_SD * sizeof(Scsi_Disk);
 786   return mem_start;
 787 };
 788 
 789 void sd_attach(Scsi_Device * SDp){
     /*  */
 790   rscsi_disks[NR_SD++].device = SDp;
 791   if(NR_SD > MAX_SD) panic ("scsi_devices corrupt (sd)");
 792 };
 793 
 794 #define DEVICE_BUSY rscsi_disks[target].device->busy
 795 #define USAGE rscsi_disks[target].device->access_count
 796 #define CAPACITY rscsi_disks[target].capacity
 797 #define MAYBE_REINIT  sd_init_onedisk(target)
 798 #define GENDISK_STRUCT sd_gendisk
 799 
 800 /* This routine is called to flush all partitions and partition tables
 801    for a changed scsi disk, and then re-read the new partition table.
 802    If we are revalidating a disk because of a media change, then we
 803    enter with usage == 0.  If we are using an ioctl, we automatically have
 804    usage == 1 (we need an open channel to use an ioctl :-), so this
 805    is our limit.
 806  */
 807 int revalidate_scsidisk(int dev, int maxusage){
     /*  */
 808           int target, major;
 809           struct gendisk * gdev;
 810           int max_p;
 811           int start;
 812           int i;
 813 
 814           target =  DEVICE_NR(MINOR(dev));
 815           gdev = &GENDISK_STRUCT;
 816 
 817           cli();
 818           if (DEVICE_BUSY || USAGE > maxusage) {
 819             sti();
 820             printk("Device busy for revalidation (usage=%d)\n", USAGE);
 821             return -EBUSY;
 822           };
 823           DEVICE_BUSY = 1;
 824           sti();
 825 
 826           max_p = gdev->max_p;
 827           start = target << gdev->minor_shift;
 828           major = MAJOR_NR << 8;
 829 
 830           for (i=max_p - 1; i >=0 ; i--) {
 831             sync_dev(major | start | i);
 832             invalidate_inodes(major | start | i);
 833             invalidate_buffers(major | start | i);
 834             gdev->part[start+i].start_sect = 0;
 835             gdev->part[start+i].nr_sects = 0;
 836           };
 837 
 838 #ifdef MAYBE_REINIT
 839           MAYBE_REINIT;
 840 #endif
 841 
 842           gdev->part[start].nr_sects = CAPACITY;
 843           resetup_one_dev(gdev, target);
 844 
 845           DEVICE_BUSY = 0;
 846           return 0;
 847 }
/* */
root/kernel/blk_drv/scsi/sd.c

DEFINITIONS
