drivers/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_finish
sd_detect
sd_attach
revalidate_scsidisk
fop_revalidate_scsidisk
sd_detach
   1 /*
   2  *      sd.c Copyright (C) 1992 Drew Eckhardt 
   3  *           Copyright (C) 1993, 1994, 1995 Eric Youngdale
   4  *
   5  *      Linux scsi disk driver
   6  *              Initial versions: Drew Eckhardt 
   7  *              Subsequent revisions: Eric Youngdale
   8  *
   9  *      <drew@colorado.edu>
  10  *
  11  *       Modified by Eric Youngdale ericy@cais.com to
  12  *       add scatter-gather, multiple outstanding request, and other
  13  *       enhancements.
  14  *
  15  *       Modified by Eric Youngdale eric@aib.com to support loadable
  16  *       low-level scsi drivers.
  17  */
  18 
  19 #include <linux/fs.h>
  20 #include <linux/kernel.h>
  21 #include <linux/sched.h>
  22 #include <linux/mm.h>
  23 #include <linux/string.h>
  24 #include <linux/errno.h>
  25 #include <asm/system.h>
  26 
  27 #define MAJOR_NR SCSI_DISK_MAJOR
  28 #include "../block/blk.h"
  29 #include "scsi.h"
  30 #include "hosts.h"
  31 #include "sd.h"
  32 #include "scsi_ioctl.h"
  33 #include "constants.h"
  34 
  35 #include <linux/genhd.h>
  36 
  37 /*
  38 static const char RCSid[] = "$Header:";
  39 */
  40 
  41 #define MAX_RETRIES 5
  42 
  43 /*
  44  *      Time out in seconds for disks and Magneto-opticals (which are slower).
  45  */
  46 
  47 #define SD_TIMEOUT 600
  48 #define SD_MOD_TIMEOUT 750
  49 
  50 #define CLUSTERABLE_DEVICE(SC) (SC->host->hostt->use_clustering && \
  51                             SC->device->type != TYPE_MOD)
  52 
  53 struct hd_struct * sd;
  54 int revalidate_scsidisk(int dev, int maxusage);
  55 
  56 Scsi_Disk * rscsi_disks = NULL;
  57 static int * sd_sizes;
  58 static int * sd_blocksizes;
  59 static int * sd_hardsizes;              /* Hardware sector size */
  60 
  61 extern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
  62 
  63 static int check_scsidisk_media_change(dev_t);
  64 static int fop_revalidate_scsidisk(dev_t);
  65 
  66 static sd_init_onedisk(int);
  67 
  68 static void requeue_sd_request (Scsi_Cmnd * SCpnt);
  69 
  70 static void sd_init(void);
  71 static void sd_finish(void);
  72 static int sd_attach(Scsi_Device *);
  73 static int sd_detect(Scsi_Device *);
  74 static void sd_detach(Scsi_Device *);
  75 
  76 struct Scsi_Device_Template sd_template = {NULL, "disk", "sd", TYPE_DISK, 
  77                                              SCSI_DISK_MAJOR, 0, 0, 0, 1,
  78                                              sd_detect, sd_init,
  79                                              sd_finish, sd_attach, sd_detach};
  80 
  81 static int sd_open(struct inode * inode, struct file * filp)
     /*  */
  82 {
  83         int target;
  84         target =  DEVICE_NR(MINOR(inode->i_rdev));
  85 
  86         if(target >= sd_template.dev_max || !rscsi_disks[target].device)
  87           return -ENXIO;   /* No such device */
  88         
  89 /* Make sure that only one process can do a check_change_disk at one time.
  90  This is also used to lock out further access when the partition table is being re-read. */
  91 
  92         while (rscsi_disks[target].device->busy);
  93 
  94         if(rscsi_disks[target].device->removable) {
  95           check_disk_change(inode->i_rdev);
  96 
  97           if(!rscsi_disks[target].device->access_count)
  98             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
  99         };
 100         /*
 101          * See if we are requesting a non-existent partition.  Do this
 102          * after checking for disk change.
 103          */
 104         if(sd_sizes[MINOR(inode->i_rdev)] == 0)
 105           return -ENXIO;
 106 
 107         rscsi_disks[target].device->access_count++;
 108         if (rscsi_disks[target].device->host->hostt->usage_count)
 109           (*rscsi_disks[target].device->host->hostt->usage_count)++;
 110         return 0;
 111 }
 112 
 113 static void sd_release(struct inode * inode, struct file * file)
     /*  */
 114 {
 115         int target;
 116         sync_dev(inode->i_rdev);
 117 
 118         target =  DEVICE_NR(MINOR(inode->i_rdev));
 119 
 120         rscsi_disks[target].device->access_count--;
 121         if (rscsi_disks[target].device->host->hostt->usage_count)
 122           (*rscsi_disks[target].device->host->hostt->usage_count)--;
 123 
 124         if(rscsi_disks[target].device->removable) {
 125           if(!rscsi_disks[target].device->access_count)
 126             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
 127         };
 128 }
 129 
 130 static void sd_geninit(void);
 131 
 132 static struct file_operations sd_fops = {
 133         NULL,                   /* lseek - default */
 134         block_read,             /* read - general block-dev read */
 135         block_write,            /* write - general block-dev write */
 136         NULL,                   /* readdir - bad */
 137         NULL,                   /* select */
 138         sd_ioctl,               /* ioctl */
 139         NULL,                   /* mmap */
 140         sd_open,                /* open code */
 141         sd_release,             /* release */
 142         block_fsync,            /* fsync */
 143         NULL,                   /* fasync */
 144         check_scsidisk_media_change,  /* Disk change */
 145         fop_revalidate_scsidisk     /* revalidate */
 146 };
 147 
 148 static struct gendisk sd_gendisk = {
 149         MAJOR_NR,               /* Major number */
 150         "sd",           /* Major name */
 151         4,              /* Bits to shift to get real from partition */
 152         1 << 4,         /* Number of partitions per real */
 153         0,              /* maximum number of real */
 154         sd_geninit,     /* init function */
 155         NULL,           /* hd struct */
 156         NULL,   /* block sizes */
 157         0,              /* number */
 158         NULL,   /* internal */
 159         NULL            /* next */
 160 };
 161 
 162 static void sd_geninit (void)
     /*  */
 163 {
 164         int i;
 165 
 166         for (i = 0; i < sd_template.dev_max; ++i)
 167           if(rscsi_disks[i].device) 
 168             sd[i << 4].nr_sects = rscsi_disks[i].capacity;
 169 #if 0
 170         /* No longer needed - we keep track of this as we attach/detach */
 171         sd_gendisk.nr_real = sd_template.dev_max;
 172 #endif
 173 }
 174 
 175 /*
 176         rw_intr is the interrupt routine for the device driver.  It will
 177         be notified on the end of a SCSI read / write, and
 178         will take on of several actions based on success or failure.
 179 */
 180 
 181 static void rw_intr (Scsi_Cmnd *SCpnt)
     /*  */
 182 {
 183   int result = SCpnt->result;
 184   int this_count = SCpnt->bufflen >> 9;
 185 
 186 #ifdef DEBUG
 187   printk("sd%c : rw_intr(%d, %d)\n", 'a' + MINOR(SCpnt->request.dev), SCpnt->host->host_no, result);
 188 #endif
 189 
 190 /*
 191   First case : we assume that the command succeeded.  One of two things will
 192   happen here.  Either we will be finished, or there will be more
 193   sectors that we were unable to read last time.
 194 */
 195 
 196   if (!result) {
 197 
 198 #ifdef DEBUG
 199     printk("sd%c : %d sectors remain.\n", 'a' + MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
 200     printk("use_sg is %d\n ",SCpnt->use_sg);
 201 #endif
 202     if (SCpnt->use_sg) {
 203       struct scatterlist * sgpnt;
 204       int i;
 205       sgpnt = (struct scatterlist *) SCpnt->buffer;
 206       for(i=0; i<SCpnt->use_sg; i++) {
 207 #ifdef DEBUG
 208         printk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 209 #endif
 210         if (sgpnt[i].alt_address) {
 211           if (SCpnt->request.cmd == READ)
 212             memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 213           scsi_free(sgpnt[i].address, sgpnt[i].length);
 214         };
 215       };
 216       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 217     } else {
 218       if (SCpnt->buffer != SCpnt->request.buffer) {
 219 #ifdef DEBUG
 220         printk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 221                    SCpnt->bufflen);
 222 #endif  
 223           if (SCpnt->request.cmd == READ)
 224             memcpy(SCpnt->request.buffer, SCpnt->buffer,
 225                    SCpnt->bufflen);
 226           scsi_free(SCpnt->buffer, SCpnt->bufflen);
 227       };
 228     };
 229 /*
 230  *      If multiple sectors are requested in one buffer, then
 231  *      they will have been finished off by the first command.  If
 232  *      not, then we have a multi-buffer command.
 233  */
 234     if (SCpnt->request.nr_sectors > this_count)
 235       {
 236         SCpnt->request.errors = 0;
 237         
 238         if (!SCpnt->request.bh)
 239           {
 240 #ifdef DEBUG
 241             printk("sd%c : handling page request, no buffer\n",
 242                    'a' + MINOR(SCpnt->request.dev));
 243 #endif
 244 /*
 245   The SCpnt->request.nr_sectors field is always done in 512 byte sectors,
 246   even if this really isn't the case.
 247 */
 248             panic("sd.c: linked page request (%lx %x)",
 249                   SCpnt->request.sector, this_count);
 250           }
 251       }
 252     SCpnt = end_scsi_request(SCpnt, 1, this_count);
 253     requeue_sd_request(SCpnt);
 254     return;
 255   }
 256 
 257 /* Free up any indirection buffers we allocated for DMA purposes. */
 258     if (SCpnt->use_sg) {
 259       struct scatterlist * sgpnt;
 260       int i;
 261       sgpnt = (struct scatterlist *) SCpnt->buffer;
 262       for(i=0; i<SCpnt->use_sg; i++) {
 263 #ifdef DEBUG
 264         printk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 265                    SCpnt->bufflen);
 266 #endif
 267         if (sgpnt[i].alt_address) {
 268           scsi_free(sgpnt[i].address, sgpnt[i].length);
 269         };
 270       };
 271       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 272     } else {
 273 #ifdef DEBUG
 274       printk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 275                    SCpnt->bufflen);
 276 #endif
 277       if (SCpnt->buffer != SCpnt->request.buffer)
 278         scsi_free(SCpnt->buffer, SCpnt->bufflen);
 279     };
 280 
 281 /*
 282         Now, if we were good little boys and girls, Santa left us a request
 283         sense buffer.  We can extract information from this, so we
 284         can choose a block to remap, etc.
 285 */
 286 
 287         if (driver_byte(result) != 0) {
 288           if (suggestion(result) == SUGGEST_REMAP) {
 289 #ifdef REMAP
 290 /*
 291         Not yet implemented.  A read will fail after being remapped,
 292         a write will call the strategy routine again.
 293 */
 294             if rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
 295               {
 296                 result = 0;
 297               }
 298             else
 299               
 300 #endif
 301             }
 302 
 303           if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
 304             if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
 305               if(rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->removable) {
 306               /* detected disc change.  set a bit and quietly refuse    */
 307               /* further access.                                        */
 308               
 309                 rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
 310                 SCpnt = end_scsi_request(SCpnt, 0, this_count);
 311                 requeue_sd_request(SCpnt);
 312                 return;
 313               }
 314             }
 315           }
 316           
 317 
 318 /*      If we had an ILLEGAL REQUEST returned, then we may have
 319 performed an unsupported command.  The only thing this should be would
 320 be a ten byte read where only a six byte read was supported.  Also,
 321 on a system where READ CAPACITY failed, we have have read past the end
 322 of the  disk. 
 323 */
 324 
 325           if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
 326             if (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
 327               rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
 328               requeue_sd_request(SCpnt);
 329               result = 0;
 330             } else {
 331             }
 332           }
 333         }  /* driver byte != 0 */
 334         if (result) {
 335                 printk("SCSI disk error : host %d id %d lun %d return code = %x\n",
 336                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host->host_no,
 337                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
 338                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
 339 
 340                 if (driver_byte(result) & DRIVER_SENSE)
 341                         print_sense("sd", SCpnt);
 342                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
 343                 requeue_sd_request(SCpnt);
 344                 return;
 345         }
 346 }
 347 
 348 /*
 349         requeue_sd_request() is the request handler function for the sd driver.
 350         Its function in life is to take block device requests, and translate
 351         them to SCSI commands.
 352 */
 353 
 354 static void do_sd_request (void)
     /*  */
 355 {
 356   Scsi_Cmnd * SCpnt = NULL;
 357   struct request * req = NULL;
 358   unsigned long flags;
 359   int flag = 0;
 360 
 361   while (1==1){
 362     save_flags(flags);
 363     cli();
 364     if (CURRENT != NULL && CURRENT->dev == -1) {
 365       restore_flags(flags);
 366       return;
 367     };
 368 
 369     INIT_SCSI_REQUEST;
 370 
 371 
 372 /* We have to be careful here.  allocate_device will get a free pointer, but
 373    there is no guarantee that it is queueable.  In normal usage, we want to
 374    call this, because other types of devices may have the host all tied up,
 375    and we want to make sure that we have at least one request pending for this
 376    type of device.   We can also come through here while servicing an
 377    interrupt, because of the need to start another command.  If we call
 378    allocate_device more than once, then the system can wedge if the command
 379    is not queueable.  The request_queueable function is safe because it checks
 380    to make sure that the host is able to take another command before it returns
 381    a pointer.  */
 382 
 383     if (flag++ == 0)
 384       SCpnt = allocate_device(&CURRENT,
 385                               rscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
 386     else SCpnt = NULL;
 387 
 388     /*
 389      * The following restore_flags leads to latency problems.  FIXME.
 390      */
 391 #if 0
 392     restore_flags(flags);
 393 #else
 394     sti();
 395 #endif
 396 
 397 /* This is a performance enhancement.  We dig down into the request list and
 398    try and find a queueable request (i.e. device not busy, and host able to
 399    accept another command.  If we find one, then we queue it. This can
 400    make a big difference on systems with more than one disk drive.  We want
 401    to have the interrupts off when monkeying with the request list, because
 402    otherwise the kernel might try and slip in a request in between somewhere. */
 403 
 404     if (!SCpnt && sd_template.nr_dev > 1){
 405       struct request *req1;
 406       req1 = NULL;
 407       save_flags(flags);
 408       cli();
 409       req = CURRENT;
 410       while(req){
 411         SCpnt = request_queueable(req,
 412                                   rscsi_disks[DEVICE_NR(MINOR(req->dev))].device);
 413         if(SCpnt) break;
 414         req1 = req;
 415         req = req->next;
 416       };
 417       if (SCpnt && req->dev == -1) {
 418         if (req == CURRENT) 
 419           CURRENT = CURRENT->next;
 420         else
 421           req1->next = req->next;
 422       };
 423       restore_flags(flags);
 424     };
 425     
 426     if (!SCpnt) return; /* Could not find anything to do */
 427         
 428     /* Queue command */
 429     requeue_sd_request(SCpnt);
 430   };  /* While */
 431 }    
 432 
 433 static void requeue_sd_request (Scsi_Cmnd * SCpnt)
     /*  */
 434 {
 435         int dev, block, this_count;
 436         unsigned char cmd[10];
 437         int bounce_size, contiguous;
 438         int max_sg;
 439         struct buffer_head * bh, *bhp;
 440         char * buff, *bounce_buffer;
 441 
 442 repeat:
 443 
 444         if(!SCpnt || SCpnt->request.dev <= 0) {
 445           do_sd_request();
 446           return;
 447         }
 448 
 449         dev =  MINOR(SCpnt->request.dev);
 450         block = SCpnt->request.sector;
 451         this_count = 0;
 452 
 453 #ifdef DEBUG
 454         printk("Doing sd request, dev = %d, block = %d\n", dev, block);
 455 #endif
 456 
 457         if (dev >= (sd_template.dev_max << 4) || 
 458             !rscsi_disks[DEVICE_NR(dev)].device ||
 459             block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
 460                 {
 461                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 462                 goto repeat;
 463                 }
 464 
 465         block += sd[dev].start_sect;
 466         dev = DEVICE_NR(dev);
 467 
 468         if (rscsi_disks[dev].device->changed)
 469                 {
 470 /*
 471  * quietly refuse to do anything to a changed disc until the changed bit has been reset
 472  */
 473                 /* printk("SCSI disk has been changed.  Prohibiting further I/O.\n");   */
 474                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 475                 goto repeat;
 476                 }
 477 
 478 #ifdef DEBUG
 479         printk("sd%c : real dev = /dev/sd%c, block = %d\n", 'a' + MINOR(SCpnt->request.dev), dev, block);
 480 #endif
 481 
 482         /*
 483          * If we have a 1K hardware sectorsize, prevent access to single
 484          * 512 byte sectors.  In theory we could handle this - in fact
 485          * the scsi cdrom driver must be able to handle this because
 486          * we typically use 1K blocksizes, and cdroms typically have
 487          * 2K hardware sectorsizes.  Of course, things are simpler
 488          * with the cdrom, since it is read-only.  For performance
 489          * reasons, the filesystems should be able to handle this
 490          * and not force the scsi disk driver to use bounce buffers
 491          * for this.
 492          */
 493         if (rscsi_disks[dev].sector_size == 1024)
 494           if((block & 1) || (SCpnt->request.nr_sectors & 1)) {
 495                 printk("sd.c:Bad block number requested");
 496                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 497                 goto repeat;
 498         }
 499         
 500         switch (SCpnt->request.cmd)
 501                 {
 502                 case WRITE :
 503                         if (!rscsi_disks[dev].device->writeable)
 504                                 {
 505                                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 506                                 goto repeat;
 507                                 }
 508                         cmd[0] = WRITE_6;
 509                         break;
 510                 case READ :
 511                         cmd[0] = READ_6;
 512                         break;
 513                 default :
 514                         panic ("Unknown sd command %d\n", SCpnt->request.cmd);
 515                       }
 516 
 517         SCpnt->this_count = 0;
 518 
 519         /* If the host adapter can deal with very large scatter-gather
 520            requests, it is a waste of time to cluster */
 521         contiguous = (!CLUSTERABLE_DEVICE(SCpnt) ? 0 :1);
 522         bounce_buffer = NULL;
 523         bounce_size = (SCpnt->request.nr_sectors << 9);
 524 
 525         /* First see if we need a bounce buffer for this request.  If we do, make sure
 526            that we can allocate a buffer.  Do not waste space by allocating a bounce
 527            buffer if we are straddling the 16Mb line */
 528 
 529         
 530         if (contiguous && SCpnt->request.bh &&
 531             ((long) SCpnt->request.bh->b_data) + (SCpnt->request.nr_sectors << 9) - 1 > 
 532             ISA_DMA_THRESHOLD && SCpnt->host->unchecked_isa_dma) {
 533           if(((long) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
 534             bounce_buffer = (char *) scsi_malloc(bounce_size);
 535           if(!bounce_buffer) contiguous = 0;
 536         };
 537 
 538         if(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
 539           for(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
 540               bhp = bhp->b_reqnext) {
 541             if(!CONTIGUOUS_BUFFERS(bh,bhp)) { 
 542               if(bounce_buffer) scsi_free(bounce_buffer, bounce_size);
 543               contiguous = 0;
 544               break;
 545             } 
 546           };
 547         if (!SCpnt->request.bh || contiguous) {
 548 
 549           /* case of page request (i.e. raw device), or unlinked buffer */
 550           this_count = SCpnt->request.nr_sectors;
 551           buff = SCpnt->request.buffer;
 552           SCpnt->use_sg = 0;
 553 
 554         } else if (SCpnt->host->sg_tablesize == 0 ||
 555                    (need_isa_buffer && 
 556                     dma_free_sectors <= 10)) {
 557 
 558           /* Case of host adapter that cannot scatter-gather.  We also
 559            come here if we are running low on DMA buffer memory.  We set
 560            a threshold higher than that we would need for this request so
 561            we leave room for other requests.  Even though we would not need
 562            it all, we need to be conservative, because if we run low enough
 563            we have no choice but to panic. */
 564 
 565           if (SCpnt->host->sg_tablesize != 0 &&
 566               need_isa_buffer && 
 567               dma_free_sectors <= 10)
 568             printk("Warning: SCSI DMA buffer space running low.  Using non scatter-gather I/O.\n");
 569 
 570           this_count = SCpnt->request.current_nr_sectors;
 571           buff = SCpnt->request.buffer;
 572           SCpnt->use_sg = 0;
 573 
 574         } else {
 575 
 576           /* Scatter-gather capable host adapter */
 577           struct scatterlist * sgpnt;
 578           int count, this_count_max;
 579           int counted;
 580 
 581           bh = SCpnt->request.bh;
 582           this_count = 0;
 583           this_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
 584           count = 0;
 585           bhp = NULL;
 586           while(bh) {
 587             if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
 588             if(!bhp || !CONTIGUOUS_BUFFERS(bhp,bh) ||
 589                !CLUSTERABLE_DEVICE(SCpnt) ||
 590                (SCpnt->host->unchecked_isa_dma &&
 591                ((unsigned long) bh->b_data-1) == ISA_DMA_THRESHOLD)) {
 592               if (count < SCpnt->host->sg_tablesize) count++;
 593               else break;
 594             };
 595             this_count += (bh->b_size >> 9);
 596             bhp = bh;
 597             bh = bh->b_reqnext;
 598           };
 599 #if 0
 600           if(SCpnt->host->unchecked_isa_dma &&
 601              ((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
 602 #endif
 603           SCpnt->use_sg = count;  /* Number of chains */
 604           count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
 605           while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
 606             count = count << 1;
 607           SCpnt->sglist_len = count;
 608           max_sg = count / sizeof(struct scatterlist);
 609           if(SCpnt->host->sg_tablesize < max_sg) max_sg = SCpnt->host->sg_tablesize;
 610           sgpnt = (struct scatterlist * ) scsi_malloc(count);
 611           memset(sgpnt, 0, count);  /* Zero so it is easy to fill */
 612           if (!sgpnt) {
 613             printk("Warning - running *really* short on DMA buffers\n");
 614             SCpnt->use_sg = 0;  /* No memory left - bail out */
 615             this_count = SCpnt->request.current_nr_sectors;
 616             buff = SCpnt->request.buffer;
 617           } else {
 618             buff = (char *) sgpnt;
 619             counted = 0;
 620             for(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
 621                 count < SCpnt->use_sg && bh; 
 622                 count++, bh = bhp) {
 623 
 624               bhp = bh->b_reqnext;
 625 
 626               if(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
 627               sgpnt[count].length += bh->b_size;
 628               counted += bh->b_size >> 9;
 629 
 630               if (((long) sgpnt[count].address) + sgpnt[count].length - 1 > 
 631                   ISA_DMA_THRESHOLD && (SCpnt->host->unchecked_isa_dma) &&
 632                   !sgpnt[count].alt_address) {
 633                 sgpnt[count].alt_address = sgpnt[count].address;
 634                 /* We try and avoid exhausting the DMA pool, since it is easier
 635                    to control usage here.  In other places we might have a more
 636                    pressing need, and we would be screwed if we ran out */
 637                 if(dma_free_sectors < (sgpnt[count].length >> 9) + 10) {
 638                   sgpnt[count].address = NULL;
 639                 } else {
 640                   sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
 641                 };
 642 /* If we start running low on DMA buffers, we abort the scatter-gather
 643    operation, and free all of the memory we have allocated.  We want to
 644    ensure that all scsi operations are able to do at least a non-scatter/gather
 645    operation */
 646                 if(sgpnt[count].address == NULL){ /* Out of dma memory */
 647 #if 0
 648                   printk("Warning: Running low on SCSI DMA buffers");
 649                   /* Try switching back to a non scatter-gather operation. */
 650                   while(--count >= 0){
 651                     if(sgpnt[count].alt_address) 
 652                       scsi_free(sgpnt[count].address, sgpnt[count].length);
 653                   };
 654                   this_count = SCpnt->request.current_nr_sectors;
 655                   buff = SCpnt->request.buffer;
 656                   SCpnt->use_sg = 0;
 657                   scsi_free(sgpnt, SCpnt->sglist_len);
 658 #endif
 659                   SCpnt->use_sg = count;
 660                   this_count = counted -= bh->b_size >> 9;
 661                   break;
 662                 };
 663 
 664               };
 665 
 666               /* Only cluster buffers if we know that we can supply DMA buffers
 667                  large enough to satisfy the request.  Do not cluster a new
 668                  request if this would mean that we suddenly need to start
 669                  using DMA bounce buffers */
 670               if(bhp && CONTIGUOUS_BUFFERS(bh,bhp) && CLUSTERABLE_DEVICE(SCpnt)) {
 671                 char * tmp;
 672 
 673                 if (((long) sgpnt[count].address) + sgpnt[count].length +
 674                     bhp->b_size - 1 > ISA_DMA_THRESHOLD && 
 675                     (SCpnt->host->unchecked_isa_dma) &&
 676                     !sgpnt[count].alt_address) continue;
 677 
 678                 if(!sgpnt[count].alt_address) {count--; continue; }
 679                 if(dma_free_sectors > 10)
 680                   tmp = (char *) scsi_malloc(sgpnt[count].length + bhp->b_size);
 681                 else {
 682                   tmp = NULL;
 683                   max_sg = SCpnt->use_sg;
 684                 };
 685                 if(tmp){
 686                   scsi_free(sgpnt[count].address, sgpnt[count].length);
 687                   sgpnt[count].address = tmp;
 688                   count--;
 689                   continue;
 690                 };
 691 
 692                 /* If we are allowed another sg chain, then increment counter so we
 693                    can insert it.  Otherwise we will end up truncating */
 694 
 695                 if (SCpnt->use_sg < max_sg) SCpnt->use_sg++;
 696               };  /* contiguous buffers */
 697             }; /* for loop */
 698 
 699             this_count = counted; /* This is actually how many we are going to transfer */
 700 
 701             if(count < SCpnt->use_sg || SCpnt->use_sg > SCpnt->host->sg_tablesize){
 702               bh = SCpnt->request.bh;
 703               printk("Use sg, count %d %x %d\n", SCpnt->use_sg, count, dma_free_sectors);
 704               printk("maxsg = %x, counted = %d this_count = %d\n", max_sg, counted, this_count);
 705               while(bh){
 706                 printk("[%p %lx] ", bh->b_data, bh->b_size);
 707                 bh = bh->b_reqnext;
 708               };
 709               if(SCpnt->use_sg < 16)
 710                 for(count=0; count<SCpnt->use_sg; count++)
 711                   printk("{%d:%p %p %d}  ", count,
 712                          sgpnt[count].address,
 713                          sgpnt[count].alt_address,
 714                          sgpnt[count].length);
 715               panic("Ooops");
 716             };
 717 
 718             if (SCpnt->request.cmd == WRITE)
 719               for(count=0; count<SCpnt->use_sg; count++)
 720                 if(sgpnt[count].alt_address)
 721                   memcpy(sgpnt[count].address, sgpnt[count].alt_address, 
 722                          sgpnt[count].length);
 723           };  /* Able to malloc sgpnt */
 724         };  /* Host adapter capable of scatter-gather */
 725 
 726 /* Now handle the possibility of DMA to addresses > 16Mb */
 727 
 728         if(SCpnt->use_sg == 0){
 729           if (((long) buff) + (this_count << 9) - 1 > ISA_DMA_THRESHOLD && 
 730             (SCpnt->host->unchecked_isa_dma)) {
 731             if(bounce_buffer)
 732               buff = bounce_buffer;
 733             else
 734               buff = (char *) scsi_malloc(this_count << 9);
 735             if(buff == NULL) {  /* Try backing off a bit if we are low on mem*/
 736               this_count = SCpnt->request.current_nr_sectors;
 737               buff = (char *) scsi_malloc(this_count << 9);
 738               if(!buff) panic("Ran out of DMA buffers.");
 739             };
 740             if (SCpnt->request.cmd == WRITE)
 741               memcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
 742           };
 743         };
 744 #ifdef DEBUG
 745         printk("sd%c : %s %d/%d 512 byte blocks.\n", 'a' + MINOR(SCpnt->request.dev),
 746                 (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
 747                 this_count, SCpnt->request.nr_sectors);
 748 #endif
 749 
 750         cmd[1] = (SCpnt->lun << 5) & 0xe0;
 751 
 752         if (rscsi_disks[dev].sector_size == 1024){
 753           if(block & 1) panic("sd.c:Bad block number requested");
 754           if(this_count & 1) panic("sd.c:Bad block number requested");
 755           block = block >> 1;
 756           this_count = this_count >> 1;
 757         };
 758 
 759         if (rscsi_disks[dev].sector_size == 256){
 760           block = block << 1;
 761           this_count = this_count << 1;
 762         };
 763 
 764         if (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
 765                 {
 766                 if (this_count > 0xffff)
 767                         this_count = 0xffff;
 768 
 769                 cmd[0] += READ_10 - READ_6 ;
 770                 cmd[2] = (unsigned char) (block >> 24) & 0xff;
 771                 cmd[3] = (unsigned char) (block >> 16) & 0xff;
 772                 cmd[4] = (unsigned char) (block >> 8) & 0xff;
 773                 cmd[5] = (unsigned char) block & 0xff;
 774                 cmd[6] = cmd[9] = 0;
 775                 cmd[7] = (unsigned char) (this_count >> 8) & 0xff;
 776                 cmd[8] = (unsigned char) this_count & 0xff;
 777                 }
 778         else
 779                 {
 780                 if (this_count > 0xff)
 781                         this_count = 0xff;
 782 
 783                 cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 784                 cmd[2] = (unsigned char) ((block >> 8) & 0xff);
 785                 cmd[3] = (unsigned char) block & 0xff;
 786                 cmd[4] = (unsigned char) this_count;
 787                 cmd[5] = 0;
 788                 }
 789 
 790 /*
 791  * We shouldn't disconnect in the middle of a sector, so with a dumb 
 792  * host adapter, it's safe to assume that we can at least transfer 
 793  * this many bytes between each connect / disconnect.  
 794  */
 795 
 796         SCpnt->transfersize = rscsi_disks[dev].sector_size;
 797         SCpnt->underflow = this_count << 9; 
 798         scsi_do_cmd (SCpnt, (void *) cmd, buff, 
 799                      this_count * rscsi_disks[dev].sector_size,
 800                      rw_intr, 
 801                      (SCpnt->device->type == TYPE_DISK ? 
 802                                      SD_TIMEOUT : SD_MOD_TIMEOUT),
 803                      MAX_RETRIES);
 804 }
 805 
 806 static int check_scsidisk_media_change(dev_t full_dev){
     /*  */
 807         int retval;
 808         int target;
 809         struct inode inode;
 810         int flag = 0;
 811 
 812         target =  DEVICE_NR(MINOR(full_dev));
 813 
 814         if (target >= sd_template.dev_max ||
 815             !rscsi_disks[target].device) {
 816                 printk("SCSI disk request error: invalid device.\n");
 817                 return 0;
 818         };
 819 
 820         if(!rscsi_disks[target].device->removable) return 0;
 821 
 822         inode.i_rdev = full_dev;  /* This is all we really need here */
 823         retval = sd_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
 824 
 825         if(retval){ /* Unable to test, unit probably not ready.  This usually
 826                      means there is no disc in the drive.  Mark as changed,
 827                      and we will figure it out later once the drive is
 828                      available again.  */
 829 
 830           rscsi_disks[target].device->changed = 1;
 831           return 1; /* This will force a flush, if called from
 832                        check_disk_change */
 833         };
 834 
 835         retval = rscsi_disks[target].device->changed;
 836         if(!flag) rscsi_disks[target].device->changed = 0;
 837         return retval;
 838 }
 839 
 840 static void sd_init_done (Scsi_Cmnd * SCpnt)
     /*  */
 841 {
 842   struct request * req;
 843   
 844   req = &SCpnt->request;
 845   req->dev = 0xfffe; /* Busy, but indicate request done */
 846   
 847   if (req->sem != NULL) {
 848     up(req->sem);
 849   }
 850 }
 851 
 852 static int sd_init_onedisk(int i)
     /*  */
 853 {
 854   unsigned char cmd[10];
 855   unsigned char *buffer;
 856   char spintime;
 857   int the_result, retries;
 858   Scsi_Cmnd * SCpnt;
 859 
 860   /* We need to retry the READ_CAPACITY because a UNIT_ATTENTION is considered
 861      a fatal error, and many devices report such an error just after a scsi
 862      bus reset. */
 863 
 864   SCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
 865   buffer = (unsigned char *) scsi_malloc(512);
 866 
 867   spintime = 0;
 868 
 869   /* Spin up drives, as required.  Only do this at boot time */
 870   if (current == task[0]){
 871     do{
 872       cmd[0] = TEST_UNIT_READY;
 873       cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 874       memset ((void *) &cmd[2], 0, 8);
 875       SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 876       SCpnt->cmd_len = 0;
 877       SCpnt->sense_buffer[0] = 0;
 878       SCpnt->sense_buffer[2] = 0;
 879       
 880       scsi_do_cmd (SCpnt,
 881                    (void *) cmd, (void *) buffer,
 882                    512, sd_init_done,  SD_TIMEOUT,
 883                    MAX_RETRIES);
 884       
 885       while(SCpnt->request.dev != 0xfffe);
 886       
 887       the_result = SCpnt->result;
 888       
 889       /* Look for non-removable devices that return NOT_READY.  Issue command
 890          to spin up drive for these cases. */
 891       if(the_result && !rscsi_disks[i].device->removable && 
 892          SCpnt->sense_buffer[2] == NOT_READY) {
 893         int time1;
 894         if(!spintime){
 895           printk( "sd%c: Spinning up disk...", 'a' + i );
 896           cmd[0] = START_STOP;
 897           cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 898           cmd[1] |= 1;  /* Return immediately */
 899           memset ((void *) &cmd[2], 0, 8);
 900           cmd[4] = 1; /* Start spin cycle */
 901           SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 902           SCpnt->cmd_len = 0;
 903           SCpnt->sense_buffer[0] = 0;
 904           SCpnt->sense_buffer[2] = 0;
 905           
 906           scsi_do_cmd (SCpnt,
 907                        (void *) cmd, (void *) buffer,
 908                        512, sd_init_done,  SD_TIMEOUT,
 909                        MAX_RETRIES);
 910           
 911           while(SCpnt->request.dev != 0xfffe);
 912 
 913           spintime = jiffies;
 914         };
 915 
 916         time1 = jiffies;
 917         while(jiffies < time1 + HZ); /* Wait 1 second for next try */
 918         printk( "." );
 919       };
 920     } while(the_result && spintime && spintime+5000 > jiffies);
 921     if (spintime) {
 922        if (the_result)
 923            printk( "not responding...\n" );
 924        else
 925            printk( "ready\n" );
 926     }
 927   };  /* current == task[0] */
 928 
 929 
 930   retries = 3;
 931   do {
 932     cmd[0] = READ_CAPACITY;
 933     cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 934     memset ((void *) &cmd[2], 0, 8);
 935     memset ((void *) buffer, 0, 8);
 936     SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 937     SCpnt->cmd_len = 0;
 938     SCpnt->sense_buffer[0] = 0;
 939     SCpnt->sense_buffer[2] = 0;
 940     
 941     scsi_do_cmd (SCpnt,
 942                  (void *) cmd, (void *) buffer,
 943                  8, sd_init_done,  SD_TIMEOUT,
 944                  MAX_RETRIES);
 945     
 946     if (current == task[0])
 947       while(SCpnt->request.dev != 0xfffe);
 948     else
 949       if (SCpnt->request.dev != 0xfffe){
 950         struct semaphore sem = MUTEX_LOCKED;
 951         SCpnt->request.sem = &sem;
 952         down(&sem);
 953         /* Hmm.. Have to ask about this one.. */
 954         while (SCpnt->request.dev != 0xfffe) schedule();
 955       };
 956     
 957     the_result = SCpnt->result;
 958     retries--;
 959 
 960   } while(the_result && retries);
 961 
 962   SCpnt->request.dev = -1;  /* Mark as not busy */
 963 
 964   wake_up(&SCpnt->device->device_wait); 
 965 
 966   /* Wake up a process waiting for device*/
 967 
 968   /*
 969    *    The SCSI standard says "READ CAPACITY is necessary for self configuring software"
 970    *    While not mandatory, support of READ CAPACITY is strongly encouraged.
 971    *    We used to die if we couldn't successfully do a READ CAPACITY.
 972    *    But, now we go on about our way.  The side effects of this are
 973    *
 974    *    1.  We can't know block size with certainty.  I have said "512 bytes is it"
 975    *            as this is most common.
 976    *
 977    *    2.  Recovery from when some one attempts to read past the end of the raw device will
 978    *        be slower.
 979    */
 980 
 981   if (the_result)
 982     {
 983       printk ("sd%c : READ CAPACITY failed.\n"
 984               "sd%c : status = %x, message = %02x, host = %d, driver = %02x \n",
 985               'a' + i, 'a' + i,
 986               status_byte(the_result),
 987               msg_byte(the_result),
 988               host_byte(the_result),
 989               driver_byte(the_result)
 990               );
 991       if (driver_byte(the_result)  & DRIVER_SENSE)
 992         printk("sd%c : extended sense code = %1x \n", 'a' + i, SCpnt->sense_buffer[2] & 0xf);
 993       else
 994         printk("sd%c : sense not available. \n", 'a' + i);
 995 
 996       printk("sd%c : block size assumed to be 512 bytes, disk size 1GB.  \n", 'a' + i);
 997       rscsi_disks[i].capacity = 0x1fffff;
 998       rscsi_disks[i].sector_size = 512;
 999 
1000       /* Set dirty bit for removable devices if not ready - sometimes drives
1001          will not report this properly. */
1002       if(rscsi_disks[i].device->removable && 
1003          SCpnt->sense_buffer[2] == NOT_READY)
1004         rscsi_disks[i].device->changed = 1;
1005 
1006     }
1007   else
1008     {
1009       rscsi_disks[i].capacity = (buffer[0] << 24) |
1010         (buffer[1] << 16) |
1011           (buffer[2] << 8) |
1012             buffer[3];
1013 
1014       rscsi_disks[i].sector_size = (buffer[4] << 24) |
1015         (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
1016 
1017       if (rscsi_disks[i].sector_size != 512 &&
1018           rscsi_disks[i].sector_size != 1024 &&
1019           rscsi_disks[i].sector_size != 256)
1020         {
1021           printk ("sd%c : unsupported sector size %d.\n",
1022                   'a' + i, rscsi_disks[i].sector_size);
1023           if(rscsi_disks[i].device->removable){
1024             rscsi_disks[i].capacity = 0;
1025           } else {
1026             printk ("scsi : deleting disk entry.\n");
1027             rscsi_disks[i].device = NULL;
1028             sd_template.nr_dev--;
1029             return i;
1030           };
1031         }
1032     {
1033        /*
1034           The msdos fs need to know the hardware sector size
1035           So I have created this table. See ll_rw_blk.c
1036           Jacques Gelinas (Jacques@solucorp.qc.ca)
1037        */
1038        int m;
1039        int hard_sector = rscsi_disks[i].sector_size;
1040        /* There is 16 minor allocated for each devices */
1041        for (m=i<<4; m<((i+1)<<4); m++){
1042          sd_hardsizes[m] = hard_sector;
1043        }
1044        printk ("SCSI Hardware sector size is %d bytes on device sd%c\n"
1045          ,hard_sector,i+'a');
1046     }
1047       if(rscsi_disks[i].sector_size == 1024)
1048         rscsi_disks[i].capacity <<= 1;  /* Change this into 512 byte sectors */
1049       if(rscsi_disks[i].sector_size == 256)
1050         rscsi_disks[i].capacity >>= 1;  /* Change this into 512 byte sectors */
1051     }
1052 
1053   rscsi_disks[i].ten = 1;
1054   rscsi_disks[i].remap = 1;
1055   scsi_free(buffer, 512);
1056   return i;
1057 }
1058 
1059 /*
1060         The sd_init() function looks at all SCSI drives present, determines
1061         their size, and reads partition table entries for them.
1062 */
1063 
1064 
1065 static void sd_init()
     /*  */
1066 {
1067         int i;
1068         static int sd_registered = 0;
1069 
1070         if (sd_template.dev_noticed == 0) return;
1071 
1072         if(!sd_registered) {
1073           if (register_blkdev(MAJOR_NR,"sd",&sd_fops)) {
1074             printk("Unable to get major %d for SCSI disk\n",MAJOR_NR);
1075             return;
1076           }
1077           sd_registered++;
1078         }
1079 
1080         /* We do not support attaching loadable devices yet. */
1081         if(rscsi_disks) return;
1082 
1083         sd_template.dev_max = sd_template.dev_noticed + SD_EXTRA_DEVS;
1084 
1085         rscsi_disks = (Scsi_Disk *) 
1086           scsi_init_malloc(sd_template.dev_max * sizeof(Scsi_Disk), GFP_ATOMIC);
1087         memset(rscsi_disks, 0, sd_template.dev_max * sizeof(Scsi_Disk));
1088 
1089         sd_sizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1090                                             sizeof(int), GFP_ATOMIC);
1091         memset(sd_sizes, 0, (sd_template.dev_max << 4) * sizeof(int));
1092 
1093         sd_blocksizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1094                                                  sizeof(int), GFP_ATOMIC);
1095 
1096         sd_hardsizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1097                                                    sizeof(struct hd_struct), GFP_ATOMIC);
1098 
1099         for(i=0;i<(sd_template.dev_max << 4);i++){
1100                 sd_blocksizes[i] = 1024;
1101                 sd_hardsizes[i] = 512;
1102         }
1103         blksize_size[MAJOR_NR] = sd_blocksizes;
1104         hardsect_size[MAJOR_NR] = sd_hardsizes;
1105         sd = (struct hd_struct *) scsi_init_malloc((sd_template.dev_max << 4) *
1106                                                    sizeof(struct hd_struct),
1107                                                    GFP_ATOMIC);
1108 
1109 
1110         sd_gendisk.max_nr = sd_template.dev_max;
1111         sd_gendisk.part = sd;
1112         sd_gendisk.sizes = sd_sizes;
1113         sd_gendisk.real_devices = (void *) rscsi_disks;
1114 
1115 }
1116 
1117 static void sd_finish()
     /*  */
1118 {
1119         int i;
1120 
1121         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
1122 
1123         sd_gendisk.next = gendisk_head;
1124         gendisk_head = &sd_gendisk;
1125 
1126         for (i = 0; i < sd_template.dev_max; ++i)
1127             if (!rscsi_disks[i].capacity && 
1128                   rscsi_disks[i].device)
1129               {
1130                 i = sd_init_onedisk(i);
1131                 if (scsi_loadable_module_flag 
1132                     && !rscsi_disks[i].has_part_table) {
1133                   sd_sizes[i << 4] = rscsi_disks[i].capacity;
1134                   revalidate_scsidisk(i << 4, 0);
1135                 }
1136                 rscsi_disks[i].has_part_table = 1;
1137               }
1138 
1139         /* If our host adapter is capable of scatter-gather, then we increase
1140            the read-ahead to 16 blocks (32 sectors).  If not, we use
1141            a two block (4 sector) read ahead. */
1142         if(rscsi_disks[0].device && rscsi_disks[0].device->host->sg_tablesize)
1143           read_ahead[MAJOR_NR] = 120;
1144         /* 64 sector read-ahead */
1145         else
1146           read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
1147         
1148         return;
1149 }
1150 
1151 static int sd_detect(Scsi_Device * SDp){
     /*  */
1152   if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
1153 
1154   printk("Detected scsi disk sd%c at scsi%d, id %d, lun %d\n", 
1155          'a'+ (sd_template.dev_noticed++),
1156          SDp->host->host_no , SDp->id, SDp->lun); 
1157 
1158          return 1;
1159 
1160 }
1161 
1162 static int sd_attach(Scsi_Device * SDp){
     /*  */
1163    Scsi_Disk * dpnt;
1164    int i;
1165 
1166    if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
1167 
1168    if(sd_template.nr_dev >= sd_template.dev_max) {
1169         SDp->attached--;
1170         return 1;
1171    }
1172    
1173    for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
1174      if(!dpnt->device) break;
1175 
1176    if(i >= sd_template.dev_max) panic ("scsi_devices corrupt (sd)");
1177 
1178    SDp->scsi_request_fn = do_sd_request;
1179    rscsi_disks[i].device = SDp;
1180    rscsi_disks[i].has_part_table = 0;
1181    sd_template.nr_dev++;
1182    sd_gendisk.nr_real++;
1183    return 0;
1184 }
1185 
1186 #define DEVICE_BUSY rscsi_disks[target].device->busy
1187 #define USAGE rscsi_disks[target].device->access_count
1188 #define CAPACITY rscsi_disks[target].capacity
1189 #define MAYBE_REINIT  sd_init_onedisk(target)
1190 #define GENDISK_STRUCT sd_gendisk
1191 
1192 /* This routine is called to flush all partitions and partition tables
1193    for a changed scsi disk, and then re-read the new partition table.
1194    If we are revalidating a disk because of a media change, then we
1195    enter with usage == 0.  If we are using an ioctl, we automatically have
1196    usage == 1 (we need an open channel to use an ioctl :-), so this
1197    is our limit.
1198  */
1199 int revalidate_scsidisk(int dev, int maxusage){
     /*  */
1200           int target, major;
1201           struct gendisk * gdev;
1202           unsigned long flags;
1203           int max_p;
1204           int start;
1205           int i;
1206 
1207           target =  DEVICE_NR(MINOR(dev));
1208           gdev = &GENDISK_STRUCT;
1209 
1210           save_flags(flags);
1211           cli();
1212           if (DEVICE_BUSY || USAGE > maxusage) {
1213             restore_flags(flags);
1214             printk("Device busy for revalidation (usage=%d)\n", USAGE);
1215             return -EBUSY;
1216           };
1217           DEVICE_BUSY = 1;
1218           restore_flags(flags);
1219 
1220           max_p = gdev->max_p;
1221           start = target << gdev->minor_shift;
1222           major = MAJOR_NR << 8;
1223 
1224           for (i=max_p - 1; i >=0 ; i--) {
1225             sync_dev(major | start | i);
1226             invalidate_inodes(major | start | i);
1227             invalidate_buffers(major | start | i);
1228             gdev->part[start+i].start_sect = 0;
1229             gdev->part[start+i].nr_sects = 0;
1230           };
1231 
1232 #ifdef MAYBE_REINIT
1233           MAYBE_REINIT;
1234 #endif
1235 
1236           gdev->part[start].nr_sects = CAPACITY;
1237           resetup_one_dev(gdev, target);
1238 
1239           DEVICE_BUSY = 0;
1240           return 0;
1241 }
1242 
1243 static int fop_revalidate_scsidisk(dev_t dev){
     /*  */
1244   return revalidate_scsidisk(dev, 0);
1245 }
1246 
1247 
1248 static void sd_detach(Scsi_Device * SDp)
     /*  */
1249 {
1250   Scsi_Disk * dpnt;
1251   int i;
1252   int max_p;
1253   int major;
1254   int start;
1255   
1256   for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
1257     if(dpnt->device == SDp) {
1258 
1259       /* If we are disconnecting a disk driver, sync and invalidate everything */
1260       max_p = sd_gendisk.max_p;
1261       start = i << sd_gendisk.minor_shift;
1262       major = MAJOR_NR << 8;
1263 
1264       for (i=max_p - 1; i >=0 ; i--) {
1265         sync_dev(major | start | i);
1266         invalidate_inodes(major | start | i);
1267         invalidate_buffers(major | start | i);
1268         sd_gendisk.part[start+i].start_sect = 0;
1269         sd_gendisk.part[start+i].nr_sects = 0;
1270         sd_sizes[start+i] = 0;
1271       };
1272       
1273       dpnt->has_part_table = 0;
1274       dpnt->device = NULL;
1275       dpnt->capacity = 0;
1276       SDp->attached--;
1277       sd_template.dev_noticed--;
1278       sd_template.nr_dev--;
1279       sd_gendisk.nr_real--;
1280       return;
1281     }
1282   return;
1283 }
1284 
1285 /*
1286  * Overrides for Emacs so that we follow Linus's tabbing style.
1287  * Emacs will notice this stuff at the end of the file and automatically
1288  * adjust the settings for this buffer only.  This must remain at the end
1289  * of the file.
1290  * ---------------------------------------------------------------------------
1291  * Local variables:
1292  * c-indent-level: 8
1293  * c-brace-imaginary-offset: 0
1294  * c-brace-offset: -8
1295  * c-argdecl-indent: 8
1296  * c-label-offset: -8
1297  * c-continued-statement-offset: 8
1298  * c-continued-brace-offset: 0
1299  * End:
1300  */
/* */
root/drivers/scsi/sd.c

DEFINITIONS
