[PATCH] (24/25) disk capacity helpers

	new helpers - get_capacity(gendisk)/set_capacity(gendisk, sectors).
Drivers switched to these; that eliminates most of the accesses to
disk->part[]... in the drivers (and makes code more readable, while
we are at it).  That had caught several bugs when minor had been
used in place of minor>>minor_shift (acsi.c is especially nasty in
that respect; I don't know if it had ever been used with multiple
devices...)

diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index 38f7dfc9e82ebc4fdb71895d84d2f9612b1a054c..8989984b9bdace54fe515ddeac42470c09baf9d9 100644 (file)
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -882,6 +882,22 @@ static void mfm_rerequest(void)
        mfm_request();
 }
 
+static struct gendisk mfm_gendisk[2] = {
+{
+       .major          = MAJOR_NR,
+       .first_minor    = 0,
+       .major_name     = "mfma",
+       .minor_shift    = 6,
+       .part           = mfm,
+},
+{
+       .major          = MAJOR_NR,
+       .first_minor    = 64,
+       .major_name     = "mfmb",
+       .minor_shift    = 6,
+       .part           = mfm + 64,
+};
+
 static void mfm_request(void)
 {
        DBG("mfm_request CURRENT=%p Busy=%d\n", CURRENT, Busy);
@@ -895,7 +911,7 @@ static void mfm_request(void)
        Busy = 1;
 
        while (1) {
-               unsigned int dev, block, nsect;
+               unsigned int dev, block, nsect, unit;
 
                DBG("mfm_request: loop start\n");
                sti();
@@ -912,26 +928,26 @@ static void mfm_request(void)
                DBG("mfm_request:                 before arg extraction\n");
 
                dev = minor(CURRENT->rq_dev);
+               unit = dev>>6;
                block = CURRENT->sector;
                nsect = CURRENT->nr_sectors;
 #ifdef DEBUG
-               /*if ((dev>>6)==1) */ console_printf("mfm_request:                                raw vals: dev=%d (block=512 bytes) block=%d nblocks=%d\n", dev, block, nsect);
+               /*if (unit==1) */ console_printf("mfm_request:                                raw vals: dev=%d (block=512 bytes) block=%d nblocks=%d\n", dev, block, nsect);
 #endif
-               if (dev >= (mfm_drives << 6) ||
-                   block >= mfm[dev].nr_sects || ((block+nsect) > mfm[dev].nr_sects)) {
-                       if (dev >= (mfm_drives << 6))
+               if (unit >= mfm_drives ||
+                   block >= get_capacity(mfm_gendisk + unit) ||
+                   ((block+nsect) > get_capacity(mfm_gendisk + unit))) {
+                       if (unit >= mfm_drives)
                                printk("mfm: bad minor number: device=%s\n", kdevname(CURRENT->rq_dev));
                        else
-                               printk("mfm%c: bad access: block=%d, count=%d, nr_sects=%ld\n", (dev >> 6)+'a',
-                                      block, nsect, mfm[dev].nr_sects);
+                               printk("mfm%c: bad access: block=%d, count=%d, nr_sects=%ld\n", unit+'a',
+                                      block, nsect, get_capacity(mfm_gendisk+unit));
                        printk("mfm: continue 1\n");
                        end_request(CURRENT, 0);
                        Busy = 0;
                        continue;
                }
 
-               block += mfm[dev].start_sect;
-
                /* DAG: Linux doesn't cope with this - even though it has an array telling
                   it the hardware block size - silly */
                block <<= 1;    /* Now in 256 byte sectors */
@@ -1163,18 +1179,9 @@ static int mfm_initdrives(void)
 static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg)
 {
        struct hd_geometry *geo = (struct hd_geometry *) arg;
-       kdev_t dev;
-       int device, minor, err;
-
-       if (!inode || !(dev = inode->i_rdev))
-               return -EINVAL;
-
-       minor = minor(dev);
-
-       device = DEVICE_NR(minor(inode->i_rdev)), err;
+       int device = DEVICE_NR(minor(inode->i_rdev));
        if (device >= mfm_drives)
                return -EINVAL;
-
        if (cmd != HDIO_GETGEO)
                return -EINVAL;
        if (!arg)
@@ -1185,7 +1192,8 @@ static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long a
                return -EFAULT;
        if (put_user (mfm_info[device].cylinders, &geo->cylinders))
                return -EFAULT;
-       if (put_user (mfm[minor].start_sect, &geo->start))
+       start = get_start_sect(inode->i_bdev);
+       if (put_user (get_start_sect(inode->i_bdev), &geo->start))
                return -EFAULT;
        return 0;
 }
@@ -1237,27 +1245,10 @@ void xd_set_geometry(struct block_device *bdev, unsigned char secsptrack,
                if (raw_cmd.dev == drive)
                        mfm_specify ();
                mfm_geometry (drive);
-               mfm[drive << 6].start_sect = 0;
-               mfm[drive << 6].nr_sects = mfm_info[drive].cylinders * mfm_info[drive].heads * mfm_info[drive].sectors / 2;
+               set_capacity(&mfm_gendisk[drive], mfm_info[drive].cylinders * mfm_info[drive].heads * mfm_info[drive].sectors / 2);
        }
 }
 
-static struct gendisk mfm_gendisk[2] = {
-{
-       .major          = MAJOR_NR,
-       .first_minor    = 0,
-       .major_name     = "mfma",
-       .minor_shift    = 6,
-       .part           = mfm,
-},
-{
-       .major          = MAJOR_NR,
-       .first_minor    = 64,
-       .major_name     = "mfmb",
-       .minor_shift    = 6,
-       .part           = mfm + 64,
-};
-
 static struct block_device_operations mfm_fops =
 {
        .owner          = THIS_MODULE,

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 72d50aa7b8f2de0a6276f5f9fdf9ff931d76f277..58415a08c41b32158915c1a9170dff1e9f17c87a 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -2033,10 +2033,9 @@ static long disk_size(DAC960_Controller_T *Controller, int disk)
 
 static void DAC960_ComputeGenericDiskInfo(DAC960_Controller_T *Controller)
 {
-       struct gendisk *disks = Controller->disks;
        int disk;
        for (disk = 0; disk < DAC960_MaxLogicalDrives; disk++)
-               disks->part[0].nr_sects = disk_size(Controller, disk);
+               set_capacity(Controller->disks + disk, disk_size(Controller, disk));
 }
 
 static int DAC960_revalidate(kdev_t dev)
@@ -2044,7 +2043,7 @@ static int DAC960_revalidate(kdev_t dev)
        int ctlr = DAC960_ControllerNumber(dev);
        int disk = DAC960_LogicalDriveNumber(dev);
        DAC960_Controller_T *p = DAC960_Controllers[ctlr];
-       p->disks[disk].part[0].nr_sects = disk_size(p, disk);
+       set_capacity(&p->disks[disk], disk_size(p, disk));
        return 0;
 }
 
@@ -5276,7 +5275,7 @@ static int DAC960_Open(Inode_T *Inode, File_T *File)
            DAC960_KernelDevice(Controller->ControllerNumber, LogicalDriveNumber, 0),
            DAC960_MaxPartitions, &DAC960_BlockDeviceOperations, size);
     }
-  if (Controller->disks[LogicalDriveNumber].part[0].nr_sects == 0)
+  if (!get_capacity(&Controller->disks[LogicalDriveNumber]))
     return -ENXIO;
   /*
     Increment Controller and Logical Drive Usage Counts.

diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index e333d4d375c7114e2eb38c60dce7ebcae286e1e1..1197c8b3bb8607c3fb33187fb1d5c76e13bd06e1 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -783,7 +783,7 @@ static void read_intr( void )
        
        status = acsi_getstatus();
        if (status != 0) {
-               int dev = minor(CURRENT->rq_dev);
+               int dev = DEVICE_NR(CURRENT->rq_dev);
                printk( KERN_ERR "ad%c: ", dev+'a' );
                if (!acsi_reqsense( acsi_buffer, acsi_info[dev].target, 
                                        acsi_info[dev].lun))
@@ -814,7 +814,7 @@ static void write_intr(void)
 
        status = acsi_getstatus();
        if (status != 0) {
-               int     dev = minor(CURRENT->rq_dev);
+               int     dev = DEVICE_NR(CURRENT->rq_dev);
                printk( KERN_ERR "ad%c: ", dev+'a' );
                if (!acsi_reqsense( acsi_buffer, acsi_info[dev].target,
                                        acsi_info[dev].lun))
@@ -973,15 +973,15 @@ static void redo_acsi_request( void )
                        panic(DEVICE_NAME ": block not locked");
        }
 
-       dev = minor(CURRENT->rq_dev);
+       dev = DEVICE_NR(CURRENT->rq_dev);
        block = CURRENT->sector;
        if (dev >= NDevices ||
-               block+CURRENT->nr_sectors >= acsi_part[dev].nr_sects) {
+               block+CURRENT->nr_sectors >= get_capacity(acsi_gendisk + dev)) {
 #ifdef DEBUG
                printk( "ad%c: attempted access for blocks %d...%ld past end of device at block %ld.\n",
                       dev+'a',
                       block, block + CURRENT->nr_sectors - 1,
-                      acsi_part[dev].nr_sects);
+                      get_capacity(acsi_gendisk + dev));
 #endif
                end_request(CURRENT, 0);
                goto repeat;
@@ -1088,11 +1088,7 @@ static void redo_acsi_request( void )
 static int acsi_ioctl( struct inode *inode, struct file *file,
                                           unsigned int cmd, unsigned long arg )
 {
-       dev_t dev;
-
-       if (!inode)
-               return -EINVAL;
-       dev = minor(inode->i_rdev);
+       int dev = DEVICE_NR(inode->i_rdev);
        if (dev >= NDevices)
                return -EINVAL;
        switch (cmd) {
@@ -1140,7 +1136,7 @@ static int acsi_open( struct inode * inode, struct file * filp )
        int  device;
        struct acsi_info_struct *aip;
 
-       device = minor(inode->i_rdev);
+       device = DEVICE_NR(inode->i_rdev);
        if (device >= NDevices)
                return -ENXIO;
        aip = &acsi_info[device];
@@ -1176,7 +1172,7 @@ static int acsi_open( struct inode * inode, struct file * filp )
 
 static int acsi_release( struct inode * inode, struct file * file )
 {
-       int device = minor(inode->i_rdev);
+       int device = DEVICE_NR(inode->i_rdev);
        if (--access_count[device] == 0 && acsi_info[device].removable)
                acsi_prevent_removal(device, 0);
        return( 0 );
@@ -1204,7 +1200,7 @@ static void acsi_prevent_removal(int device, int flag)
 
 static int acsi_media_change (kdev_t dev)
 {
-       int device = minor(dev);
+       int device = DEVICE_NR(dev);
        struct acsi_info_struct *aip;
 
        aip = &acsi_info[device];
@@ -1807,7 +1803,7 @@ void cleanup_module(void)
 
 static int acsi_revalidate(kdev_t dev)
 {
-       int unit = DEVICE_NR(minor(dev));
+       int unit = DEVICE_NR(dev);
        struct acsi_info_struct *aip = &acsi_info[unit];
        stdma_lock( NULL, NULL );
        if (acsi_devinit(aip) != DEV_SUPPORTED) {
@@ -1821,6 +1817,6 @@ static int acsi_revalidate(kdev_t dev)
 
        ENABLE_IRQ();
        stdma_release();
-       acsi_part[minor(dev)].nr_sects = aip->size;
+       set_capacity(acsi_gendisk + unit, aip->size);
        return 0;
 }

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 73f5888010d2fdd891222f32b761805a88dc4122..969be47e8711154556b54d32b1eae4cfd08c12dc 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -407,8 +407,7 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         driver_geo.sectors = 0x3f;
                         driver_geo.cylinders = hba[ctlr]->drv[dsk].nr_blocks / (0xff*0x3f);
                 }
-                driver_geo.start=
-                        hba[ctlr]->hd[minor(inode->i_rdev)].start_sect;
+                driver_geo.start= get_start_sect(inode->i_bdev);
                 if (copy_to_user((void *) arg, &driver_geo,
                                 sizeof( struct hd_geometry)))
                         return  -EFAULT;
@@ -705,7 +704,7 @@ static int cciss_revalidate(kdev_t dev)
         int ctlr = major(dev) - MAJOR_NR;
        int target = minor(dev) >> NWD_SHIFT;
         struct gendisk *disk = &hba[ctlr]->gendisk[target];
-       disk->part[0].nr_sects = hba[ctlr]->drv[target].nr_blocks;
+       set_capacity(disk, hba[ctlr]->drv[target].nr_blocks);
        return 0;
 }
 

diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 658f201efd0fd49b65320b4ed915378564d0a77a..2d6ff7620e463d0381867593e408df2e8b485ae8 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -1497,7 +1497,7 @@ static int ida_revalidate(kdev_t dev)
         int ctlr = major(dev) - MAJOR_NR;
        int target = DEVICE_NR(dev);
         struct gendisk *gdev = &ida_gendisk[ctlr*NWD+target];
-       gdev->part[minor(dev)].nr_sects = hba[ctlr]->drv[target].nr_blks;
+       set_capacity(gdev, hba[ctlr]->drv[target].nr_blks);
        return 0;
 }
 

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index b100a1faf6b83917d5526026eca51cd0cde1ffcc..bb9c23e6b3641aaeafef2ff5a7420716e23d9552 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -438,9 +438,9 @@ static int pd_revalidate(kdev_t dev)
        if ((unit >= PD_UNITS) || !PD.present)
                return -ENODEV;
        if (pd_identify(unit))
-               pd_hd[minor(dev)].nr_sects = PD.capacity;
+               set_capacity(&PD.gd, PD.capacity);
        else
-               pd_hd[minor(dev)].nr_sects = 0;
+               set_capacity(&PD.gd, 0);
         return 0;
 }
 
@@ -727,7 +727,7 @@ repeat:
         pd_count = CURRENT->current_nr_sectors;
 
         if ((pd_dev >= PD_DEVS) || 
-           ((pd_block+pd_count) > pd_hd[pd_dev].nr_sects)) {
+           ((pd_block+pd_count) > get_capacity(&pd[unit].gd))) {
                 end_request(CURRENT, 0);
                 goto repeat;
         }

diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 0882dd30d940aa1fe770773efecf436e066375fa..0afce2e2ab8fea218298e9dadfd5beb00fb3544c 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -487,6 +487,7 @@ static void __init ps2esdi_get_device_cfg(void)
 static void do_ps2esdi_request(request_queue_t * q)
 {
        u_int block, count;
+       int unit;
        /* since, this routine is called with interrupts cleared - they 
           must be before it finishes  */
 
@@ -503,18 +504,19 @@ static void do_ps2esdi_request(request_queue_t * q)
        if (blk_queue_empty(QUEUE))
                return;
 
+       unit = DEVICE_NR(CURRENT->rq_dev);
        if (isa_virt_to_bus(CURRENT->buffer + CURRENT->current_nr_sectors * 512) > 16 * MB) {
                printk("%s: DMA above 16MB not supported\n", DEVICE_NAME);
                end_request(CURRENT, FAIL);
        }                       /* check for above 16Mb dmas */
-       else if ((DEVICE_NR(CURRENT->rq_dev) < ps2esdi_drives) &&
+       else if ((unit < ps2esdi_drives) &&
            (CURRENT->sector + CURRENT->current_nr_sectors <=
-            ps2esdi[minor(CURRENT->rq_dev)].nr_sects) &&
+            get_capacity(&ps2esdi_gendisk[unit])) &&
                CURRENT->flags & REQ_CMD) {
 #if 0
                printk("%s:got request. device : %d minor : %d command : %d  sector : %ld count : %ld\n",
                       DEVICE_NAME,
-                      DEVICE_NR(CURRENT->rq_dev), minor(CURRENT->rq_dev),
+                      unit, minor(CURRENT->rq_dev),
                       CURRENT->cmd, CURRENT->sector,
                       CURRENT->current_nr_sectors);
 #endif
@@ -524,10 +526,10 @@ static void do_ps2esdi_request(request_queue_t * q)
 
                switch (rq_data_dir(CURRENT)) {
                case READ:
-                       ps2esdi_readwrite(READ, DEVICE_NR(CURRENT->rq_dev), block, count);
+                       ps2esdi_readwrite(READ, unit, block, count);
                        break;
                case WRITE:
-                       ps2esdi_readwrite(WRITE, DEVICE_NR(CURRENT->rq_dev), block, count);
+                       ps2esdi_readwrite(WRITE, unit, block, count);
                        break;
                default:
                        printk("%s: Unknown command\n", DEVICE_NAME);
@@ -538,7 +540,7 @@ static void do_ps2esdi_request(request_queue_t * q)
        /* is request is valid */ 
        else {
                printk("Grrr. error. ps2esdi_drives: %d, %lu %lu\n", ps2esdi_drives,
-                      CURRENT->sector, ps2esdi[minor(CURRENT->rq_dev)].nr_sects);
+                      CURRENT->sector, get_capacity(&ps2esdi_gendisk[unit]));
                end_request(CURRENT, FAIL);
        }
 

diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index c1c872a6e35855679a45072e8e6728c746adadbd..8e71ac89aa8c568601cdbf9634f6b4b86ff71dea 100644 (file)
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -812,7 +812,7 @@ static void del_battery_timer(void)
 static int mm_revalidate(kdev_t i_rdev)
 {
        int card_number = DEVICE_NR(i_rdev);
-       mm_partitions[minor(i_rdev)].nr_sects = cards[card_number].mm_size << 1;
+       set_capacity(mm_gendisk + card_number, cards[card_number].mm_size << 1);
        return 0;
 }
 /*

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 7f30d2df7506de0a8d92962da76bdb069dea802c..9d6bf0ada74d81f306009a6b5e1355779c6c05af 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -279,15 +279,17 @@ static void do_xd_request (request_queue_t * q)
                return;
 
        while (1) {
+               int unit;
                code = 0;
                /* do some checking on the request structure */
                if (blk_queue_empty(QUEUE))
                        return;
 
-               if (DEVICE_NR(CURRENT->rq_dev) < xd_drives
+               unit = DEVICE_NR(CURRENT->rq_dev);
+               if (unit < xd_drives
                    && (CURRENT->flags & REQ_CMD)
                    && CURRENT->sector + CURRENT->nr_sectors
-                        <= xd_struct[minor(CURRENT->rq_dev)].nr_sects) {
+                        <= get_capacity(xd_gendisk + unit)) {
                        block = CURRENT->sector;
                        count = CURRENT->nr_sectors;
 
@@ -295,7 +297,7 @@ static void do_xd_request (request_queue_t * q)
                                case READ:
                                case WRITE:
                                        for (retry = 0; (retry < XD_RETRIES) && !code; retry++)
-                                               code = xd_readwrite(rq_data_dir(CURRENT),DEVICE_NR(CURRENT->rq_dev),
+                                               code = xd_readwrite(rq_data_dir(CURRENT),unit,
                                                        CURRENT->buffer,block,count);
                                        break;
                                default:

diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index 534983a99346085147aee15ff109de1f15c414d6..1bf3df67d0dca5b3698d8c4b428944dd3f4a6928 100644 (file)
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -596,22 +596,21 @@ repeat:
                reset_hd();
                return;
        }
-       dev = minor(CURRENT->rq_dev);
+       dev = DEVICE_NR(CURRENT->rq_dev);
        block = CURRENT->sector;
        nsect = CURRENT->nr_sectors;
-       if (dev >= (NR_HD<<6) || (dev & 0x3f) ||
-           block >= hd[dev].nr_sects || ((block+nsect) > hd[dev].nr_sects)) {
-               if (dev >= (NR_HD<<6) || (dev & 0x3f))
+       if (dev >= NR_HD || block >= get_capacity(hd_gendisk+dev) ||
+           ((block+nsect) > get_capacity(hd_gendisk+unit))) {
+               if (dev >= NR_HD)
                        printk("hd: bad minor number: device=%s\n",
                               kdevname(CURRENT->rq_dev));
                else
                        printk("hd%c: bad access: block=%d, count=%d\n",
-                               (minor(CURRENT->rq_dev)>>6)+'a', block, nsect);
+                               dev+'a', block, nsect);
                end_request(CURRENT, 0);
                goto repeat;
        }
 
-       dev >>= 6;
        if (special_op[dev]) {
                if (do_special_op(dev))
                        goto repeat;
@@ -819,10 +818,11 @@ static void __init hd_geninit(void)
 #endif
 
        for (drive=0 ; drive < NR_HD ; drive++) {
-               hd[drive<<6].nr_sects = hd_info[drive].head *
+               sector_t size = hd_info[drive].head *
                        hd_info[drive].sect * hd_info[drive].cyl;
-               printk ("hd%c: %ldMB, CHS=%d/%d/%d\n", drive+'a',
-                       hd[drive<<6].nr_sects / 2048, hd_info[drive].cyl,
+               set_capacity(hd_gendisk + drive, size);
+               printk ("%s: %ldMB, CHS=%d/%d/%d\n", hd_gendisk[drive].major_name,
+                       size / 2048, hd_info[drive].cyl,
                        hd_info[drive].head, hd_info[drive].sect);
        }
        if (!NR_HD)

diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 81ca240c6be50dbdcad59282e35bb29624e1414d..b293f3e928339e47ea4218a56a756d13a5ec5cd3 100644 (file)
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -2138,7 +2138,7 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
        if (stat)
                toc->capacity = 0x1fffff;
 
-       drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
+       set_capacity(drive->disk, toc->capacity * SECTORS_PER_FRAME);
 
        /* Remember that we've read this stuff. */
        CDROM_STATE_FLAGS (drive)->toc_valid = 1;
@@ -3148,7 +3148,7 @@ static int ide_cdrom_reinit (ide_drive_t *drive)
        add_gendisk(g);
        register_disk(g, mk_kdev(g->major,g->first_minor),
                      1<<g->minor_shift, ide_fops,
-                     g->part[0].nr_sects);
+                     get_capacity(g));
        return 0;
 failed:
        return 1;

diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index c20115bc35f1c0364b686bc0e7039690176be3c1..a2a25a29af58c1e6efc87e83e0af3d7c40b6a1a0 100644 (file)
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -1500,7 +1500,7 @@ static int idefloppy_get_capacity (ide_drive_t *drive)
        drive->bios_cyl = 0;
        drive->bios_head = drive->bios_sect = 0;
        floppy->blocks = floppy->bs_factor = 0;
-       drive->part[0].nr_sects = 0;
+       set_capacity(drive->disk, 0);
 
        idefloppy_create_read_capacity_cmd (&pc);
        if (idefloppy_queue_pc_tail (drive, &pc)) {
@@ -1555,7 +1555,7 @@ static int idefloppy_get_capacity (ide_drive_t *drive)
                (void) idefloppy_get_flexible_disk_page (drive);
        }
 
-       drive->part[0].nr_sects = floppy->blocks * floppy->bs_factor;
+       set_capacity(drive->disk, floppy->blocks * floppy->bs_factor);
        return rc;
 }
 
@@ -2213,7 +2213,7 @@ static int idefloppy_reinit (ide_drive_t *drive)
        add_gendisk(g);
        register_disk(g, mk_kdev(g->major,g->first_minor),
                      1<<g->minor_shift, ide_fops,
-                     g->part[0].nr_sects);
+                     get_capacity(g));
        return 0;
 failed:
        return 1;

diff --git a/drivers/ide/ide-geometry.c b/drivers/ide/ide-geometry.c
index 5f21651c1785ea5a264ed9355ef889b8d4a9fca4..850419f2a0a79eedbe971d144d597ff23a670dac 100644 (file)
--- a/drivers/ide/ide-geometry.c
+++ b/drivers/ide/ide-geometry.c
@@ -214,7 +214,7 @@ int ide_xlate_1024 (kdev_t i_rdev, int xparm, int ptheads, const char *msg)
                ret = 1;
        }
 
-       drive->part[0].nr_sects = current_capacity(drive);
+       set_capacity(drive->disk, current_capacity(drive));
 
        if (ret)
                printk("%s%s [%d/%d/%d]", msg, msg1,

diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 52472f955262ef9c12827ad07bf2eb1d6bd21467..c053036cc2897077b1bd69c19855e6edd7e71b87 100644 (file)
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -1661,7 +1661,7 @@ ide_drive_t *get_info_ptr (kdev_t i_rdev)
                        if (unit < MAX_DRIVES) {
                                ide_drive_t *drive = &hwif->drives[unit];
 #if 0
-                               if ((drive->present) && (drive->part[minor].nr_sects))
+                               if (drive->present && get_capacity(drive->disk))
 #else
                                if (drive->present)
 #endif
@@ -1748,7 +1748,7 @@ int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t actio
 
 void ide_revalidate_drive (ide_drive_t *drive)
 {
-       drive->disk->part[0].nr_sects = current_capacity(drive);
+       set_capacity(drive->disk, current_capacity(drive));
 }
 
 /*
@@ -1975,7 +1975,7 @@ void ide_unregister (unsigned int index)
                        continue;
                minor = drive->select.b.unit << PARTN_BITS;
                for (p = 0; p < (1<<PARTN_BITS); ++p) {
-                       if (drive->part[p].nr_sects > 0) {
+                       if (get_capacity(drive->disk)) {
                                kdev_t devp = mk_kdev(hwif->major, minor+p);
                                invalidate_device(devp, 0);
                        }
@@ -2523,7 +2523,7 @@ static int ide_ioctl (struct inode *inode, struct file *file,
                        if (put_user(drive->bios_head, (byte *) &loc->heads)) return -EFAULT;
                        if (put_user(drive->bios_sect, (byte *) &loc->sectors)) return -EFAULT;
                        if (put_user(bios_cyl, (unsigned short *) &loc->cylinders)) return -EFAULT;
-                       if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
+                       if (put_user((unsigned)get_start_sect(inode->i_bdev),
                                (unsigned long *) &loc->start)) return -EFAULT;
                        return 0;
                }
@@ -2535,7 +2535,7 @@ static int ide_ioctl (struct inode *inode, struct file *file,
                        if (put_user(drive->head, (byte *) &loc->heads)) return -EFAULT;
                        if (put_user(drive->sect, (byte *) &loc->sectors)) return -EFAULT;
                        if (put_user(drive->cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;
-                       if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
+                       if (put_user((unsigned)get_start_sect(inode->i_bdev),
                                (unsigned long *) &loc->start)) return -EFAULT;
                        return 0;
                }

diff --git a/drivers/md/md.c b/drivers/md/md.c
index e50bfe391c01991a9eb1951b81ba0855b1f84cad..b903aa9d18e210de771a1ae1bb89b33b923e7475 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -618,7 +618,7 @@ static void free_mddev(mddev_t *mddev)
 
        export_array(mddev);
        md_size[mdidx(mddev)] = 0;
-       md_hd_struct[mdidx(mddev)].nr_sects = 0;
+       set_capacity(disks[mdidx(mddev)], 0);
 }
 
 #undef BAD_CSUM
@@ -2343,7 +2343,7 @@ static int md_ioctl(struct inode *inode, struct file *file,
                        err = put_user (4, (char *) &loc->sectors);
                        if (err)
                                goto abort_unlock;
-                       err = put_user (md_hd_struct[mdidx(mddev)].nr_sects/8,
+                       err = put_user(get_capacity(disks[mdidx(mddev)])/8,
                                                (short *) &loc->cylinders);
                        if (err)
                                goto abort_unlock;

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index a8cdfb80a95a613c6111160538edc68bef14af33..3928e81ada4d919dd7ad8847418c8af520bd18aa 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -248,7 +248,7 @@ static u32 i2ob_get(struct i2ob_device *dev)
  *     Turn a Linux block request into an I2O block read/write.
  */
 
-static int i2ob_send(u32 m, struct i2ob_device *dev, struct i2ob_request *ireq, u32 base, int unit)
+static int i2ob_send(u32 m, struct i2ob_device *dev, struct i2ob_request *ireq, int unit)
 {
        struct i2o_controller *c = dev->controller;
        int tid = dev->tid;
@@ -279,7 +279,7 @@ static int i2ob_send(u32 m, struct i2ob_device *dev, struct i2ob_request *ireq,
                
        /* This can be optimised later - just want to be sure its right for
           starters */
-       offset = ((u64)(req->sector+base)) << 9;
+       offset = ((u64)req->sector) << 9;
        __raw_writel( offset & 0xFFFFFFFF, msg+24);
        __raw_writel(offset>>32, msg+28);
        mptr=msg+32;
@@ -724,7 +724,7 @@ static int i2ob_evt(void *dummy)
                                register_disk(p,
                                              mk_kdev(p->major, p->first_minor),
                                              1<<p->minor_shift, p->fops,
-                                             i2ob[unit].nr_sects);
+                                             get_capacity(p));
                                break;
                        }
 
@@ -768,7 +768,7 @@ static int i2ob_evt(void *dummy)
                                        i2ob_query_device(&i2ob_dev[unit], 0x0000, 4, &size, 8);
 
                                spin_lock_irqsave(I2O_LOCK(unit), flags);       
-                               i2ob[unit].nr_sects = size>>9;
+                               set_capacity(&i2o_disk[unit>>4], size>>9);
                                spin_unlock_irqrestore(I2O_LOCK(unit), flags);  
                                break;
                        }
@@ -869,7 +869,7 @@ static int i2ob_backlog_request(struct i2o_controller *c, struct i2ob_device *de
                        i2ob_backlog_tail[c->unit] = NULL;
                        
                unit = minor(ireq->req->rq_dev);
-               i2ob_send(m, dev, ireq, i2ob[unit].start_sect, unit);
+               i2ob_send(m, dev, ireq, unit);
        }
        if(i2ob_backlog[c->unit])
                return 1;
@@ -969,7 +969,7 @@ static void i2ob_request(request_queue_t *q)
                i2ob_queues[dev->unit]->i2ob_qhead = ireq->next;
                ireq->req = req;
 
-               i2ob_send(m, dev, ireq, i2ob[unit].start_sect, (unit&0xF0));
+               i2ob_send(m, dev, ireq, (unit&0xF0));
        }
 }
 
@@ -1038,7 +1038,7 @@ static int i2ob_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
        struct hd_geometry g;
-       int u = minor(inode->i_rdev) & 0xF0;
+       int u = minor(inode->i_rdev) >> 4;
        /* Anyone capable of this syscall can do *real bad* things */
 
        if (!capable(CAP_SYS_ADMIN))
@@ -1046,7 +1046,7 @@ static int i2ob_ioctl(struct inode *inode, struct file *file,
 
        if (cmd != HDIO_GETGEO)
                return -EINVAL;
-       i2o_block_biosparam(i2ob[u].nr_sects, 
+       i2o_block_biosparam(get_capacity(&i2o_disk[u]),
                                &g.cylinders, &g.heads, &g.sectors);
        g.start = get_start_sect(inode->i_bdev);
        return copy_to_user((void *)arg, &g, sizeof(g)) ? -EFAULT : 0;
@@ -1222,7 +1222,7 @@ static int i2ob_install_device(struct i2o_controller *c, struct i2o_device *d, i
        
        i2ob_query_device(dev, 0x0000, 5, &flags, 4);
        i2ob_query_device(dev, 0x0000, 6, &status, 4);
-       i2ob[unit].nr_sects = size>>9;
+       set_capacity(&i2o_disk[unit>>4], size>>9);
 
        /* Set limit based on inbound frame size */
        limit = (d->controller->status_block->inbound_frame_size - 8)/2;
@@ -1326,7 +1326,7 @@ static int i2ob_install_device(struct i2o_controller *c, struct i2o_device *d, i
        i2o_event_register(c, d->lct_data.tid, i2ob_context, unit, 
                (I2OB_EVENT_MASK & d->lct_data.event_capabilities));
 
-       i2ob[unit].nr_sects = size>>9;
+       set_capacity(i2o_disk[unit>>4], size>>9);
        return 0;
 }
 
@@ -1471,7 +1471,7 @@ static void i2ob_scan(int bios)
                                        register_disk(p,
                                                      mk_kdev(p->major, p->first_minor),
                                                      1<<p->minor_shift, p->fops,
-                                                     i2ob[scan_unit].nr_sects);
+                                                     get_capacity(p));
                                        scan_unit+=16;
                                        i2ob_dev_count++;
 
@@ -1564,7 +1564,7 @@ void i2ob_new_device(struct i2o_controller *c, struct i2o_device *d)
                register_disk(p,
                              mk_kdev(p->major, p->first_minor),
                              1<<p->minor_shift, p->fops,
-                             i2ob[unit].nr_sects);
+                             get_capacity(p));
                i2ob_dev_count++;
                i2o_device_notify_on(d, &i2o_block_handler);
        }

diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 4d50cf22fc58ec13c76527bb344cddd894677843..9b4758d19f12e2a5b3c81a385faa69ff52d3325c 100644 (file)
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -846,7 +846,7 @@ static int ftl_open(struct inode *inode, struct file *file)
     if (partition->state != FTL_FORMATTED)
        return -ENXIO;
     
-    if (partition->disk->part[0].nr_sects == 0)
+    if (get_capacity(partition->disk) == 0)
        return -ENXIO;
 
     if (!get_mtd_device(partition->mtd, -1))
@@ -1132,8 +1132,8 @@ static int ftl_revalidate(kdev_t dev)
        int unit = minor(dev) >> 4;
        partition_t *part = myparts[unit];
        scan_header(part);
-       part->disk->part[0].nr_sects =
-               le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE);
+       set_capacity(part->disk,
+               le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE));
        return 0;
 }
 

diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index 27cd8b48ca144b7006302ed9977348b698d9b858..26be858d720b7f604bff856a0562d50cd703211c 100644 (file)
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -846,10 +846,10 @@ void nftl_request(RQFUNC_ARG)
                down(&nftl->mutex);
                DEBUG(MTD_DEBUG_LEVEL3, "Got mutex\n");
 
-               if (block + nsect > part_table[dev].nr_sects) {
+               if (block + nsect > get_capacity(nftl->disk)) {
                        /* access past the end of device */
                        printk("nftl%c%d: bad access: block = %d, count = %d\n",
-                              (minor(req->rq_dev)>>6)+'a', dev & 0xf, block, nsect);
+                              unit+'a', dev & 0xf, block, nsect);
                        up(&nftl->mutex);
                        res = 0; /* fail */
                        goto repeat;

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 39112441f969aa4e4280020c86005f4526f7fed3..5bc2dd6e9517cffcd59c55f16d923ac486d0e87b 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -286,6 +286,8 @@ static request_queue_t *sd_find_queue(kdev_t dev)
                return NULL;    /* No such device */
 }
 
+static struct gendisk **sd_disks;
+
 /**
  *     sd_init_command - build a scsi (read or write) command from
  *     information in the request structure.
@@ -321,7 +323,7 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
        /* >>>>> this change is not in the lk 2.5 series */
        if (part_nr >= (sd_template.dev_max << 4) || (part_nr & 0xf) ||
            !sdp || !sdp->online ||
-           block + SCpnt->request->nr_sectors > sd[part_nr].nr_sects) {
+           block + SCpnt->request->nr_sectors > get_capacity(sd_disks[dsk_nr])) {
                SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n", 
                                 SCpnt->request->nr_sectors));
                SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
@@ -588,8 +590,6 @@ static struct block_device_operations sd_fops =
        revalidate:             sd_revalidate
 };
 
-static struct gendisk **sd_disks;
-
 /**
  *     sd_rw_intr - bottom half handler: called when the lower level
  *     driver has completed (successfully or otherwise) a scsi command.
@@ -1374,7 +1374,7 @@ static int sd_revalidate(kdev_t dev)
                return -ENODEV;
 
        sd_init_onedisk(sdkp, dsk_nr);
-       sd_disks[dsk_nr]->part[0].nr_sects = sdkp->capacity;
+       set_capacity(sd_disks[dsk_nr], sdkp->capacity);
        return 0;
 }
 

diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 2ced09b36ad56a69b98052e747df66db6421e957..e201e29df2ddb4fc5039bbbdc471b1130feba3cd 100644 (file)
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -234,9 +234,9 @@ static void rw_intr(Scsi_Cmnd * SCpnt)
                 * block.  Therefore, if we hit a medium error within the last
                 * 75 2K sectors, we decrease the saved size value.
                 */
-               if (error_sector < cd->disk->part[0].nr_sects &&
+               if (error_sector < get_capacity(cd->disk) &&
                    cd->capacity - error_sector < 4 * 75)
-                       cd->disk->part[0].nr_sects = error_sector;
+                       set_capacity(cd->disk, error_sector);
        }
 
        /*
@@ -555,7 +555,7 @@ static void get_sectorsize(Scsi_CD *cd)
                 * what the device is capable of.
                 */
                cd->needs_sector_size = 0;
-               cd->disk->part[0].nr_sects = cd->capacity;
+               set_capacity(cd->disk, cd->capacity);
        }
 
        queue = &cd->device->request_queue;

diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 8927d25ef60d91283c4b8522dae34e585fdefde5..67ce47f76946e471e6a07715f26b2833fd811042 100644 (file)
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -338,13 +338,11 @@ void register_disk(struct gendisk *disk, kdev_t dev, unsigned minors,
        struct block_device_operations *ops, long size)
 {
        struct block_device *bdev;
-       struct hd_struct *p;
 
        if (!disk)
                return;
 
-       p = disk->part;
-       p[0].nr_sects = size;
+       set_capacity(disk, size);
 
        /* No minors to use for partitions */
        if (!disk->minor_shift)
@@ -410,7 +408,7 @@ int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
        }
        if (bdev->bd_op->revalidate)
                bdev->bd_op->revalidate(dev);
-       if (disk->part[0].nr_sects)
+       if (get_capacity(disk))
                check_partition(disk, bdev);
        for (p = 1; p < (1<<disk->minor_shift); p++)
                update_partition(disk, p);

diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 6474393eff5ea4f59bc1180acd4bf175b28ce2ad..0bd31339d6f5e8239ef7e62207b1206397e93d2a 100644 (file)
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -95,6 +95,14 @@ static inline unsigned long get_start_sect(struct block_device *bdev)
 {
        return bdev->bd_offset;
 }
+static inline sector_t get_capacity(struct gendisk *disk)
+{
+       return disk->part[0].nr_sects;
+}
+static inline void set_capacity(struct gendisk *disk, sector_t size)
+{
+       disk->part[0].nr_sects = size;
+}
 
 #endif  /*  __KERNEL__  */