[PATCH] blk_ioctl() not exported anymore

blk_ioctl() not exported anymore; calls moved from drivers to block_dev.c.

diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index 5a209981436c4e299e7dacca86270a63807ba7db..309fc7c4d47d0cf93b1a905f50da8b86dc4cb8ba 100644 (file)
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -1192,22 +1192,11 @@ static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long a
                        return -EFAULT;
                return 0;
 
-       case BLKSECTGET:
-               return put_user(max_sectors[major][minor], (long *) arg);
-
        case BLKRRPART:
                if (!capable(CAP_SYS_ADMIN))
                        return -EACCES;
                return mfm_reread_partitions(dev);
 
-       case BLKGETSIZE:
-       case BLKGETSIZE64:
-       case BLKFLSBUF:
-       case BLKROSET:
-       case BLKROGET:
-       case BLKPG:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-
        default:
                return -EINVAL;
        }

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 210449ad17151d4fdb10f13360230aeeeb6f6ba4..dc372aa4dbb18e2918ceadaad9de8bc148cb3613 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -2055,29 +2055,20 @@ static void DAC960_ComputeGenericDiskInfo(DAC960_Controller_T *Controller)
 static void DAC960_RegisterDisk(DAC960_Controller_T *Controller,
                                int LogicalDriveNumber)
 {
-  if (Controller->FirmwareType == DAC960_V1_Controller)
-    {
+  long size;
+  if (Controller->FirmwareType == DAC960_V1_Controller) {
       if (LogicalDriveNumber > Controller->LogicalDriveCount - 1) return;
-      register_disk(&Controller->GenericDiskInfo,
-                   DAC960_KernelDevice(Controller->ControllerNumber,
-                                       LogicalDriveNumber, 0),
-                   DAC960_MaxPartitions,
-                   &DAC960_BlockDeviceOperations,
-                   Controller->V1.LogicalDriveInformation
-                                  [LogicalDriveNumber].LogicalDriveSize);
-    }
-  else
-    {
+      size = Controller->V1.LogicalDriveInformation
+                                  [LogicalDriveNumber].LogicalDriveSize;
+  } else {
       DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
        Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
       if (LogicalDeviceInfo == NULL) return;
-      register_disk(&Controller->GenericDiskInfo,
-                   DAC960_KernelDevice(Controller->ControllerNumber,
-                                       LogicalDriveNumber, 0),
-                   DAC960_MaxPartitions,
-                   &DAC960_BlockDeviceOperations,
-                   LogicalDeviceInfo->ConfigurableDeviceSize);
-    }
+      size = LogicalDeviceInfo->ConfigurableDeviceSize;
+  }
+  register_disk(&Controller->GenericDiskInfo,
+    DAC960_KernelDevice(Controller->ControllerNumber, LogicalDriveNumber, 0),
+    DAC960_MaxPartitions, &DAC960_BlockDeviceOperations, size);
 }
 
 
@@ -5399,15 +5390,9 @@ static int DAC960_IOCTL(Inode_T *Inode, File_T *File,
            LogicalDeviceInfo->ConfigurableDeviceSize
            / (Geometry.heads * Geometry.sectors);
        }
-      Geometry.start = get_start_sect(Inode->i_rdev);
+      Geometry.start = get_start_sect(Inode->i_bdev);
       return (copy_to_user(UserGeometry, &Geometry,
                           sizeof(DiskGeometry_T)) ? -EFAULT : 0);
-    case BLKGETSIZE:
-    case BLKGETSIZE64:
-    case BLKFLSBUF:
-    case BLKBSZGET:
-    case BLKBSZSET:
-      return blk_ioctl(Inode->i_bdev, Request, Argument);
 
     case BLKRRPART:
       /* Re-Read Partition Table. */

diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index 7ca3722d8ce97cea5ec55fcc09a66877527b0b27..f616f01847b742fe04eb89f87774c9fce0d5c6bc 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -1105,7 +1105,7 @@ static int acsi_ioctl( struct inode *inode, struct file *file,
            put_user( 64, &geo->heads );
            put_user( 32, &geo->sectors );
            put_user( acsi_info[dev].size >> 11, &geo->cylinders );
-               put_user(get_start_sect(inode->i_rdev), &geo->start);
+               put_user(get_start_sect(inode->i_bdev), &geo->start);
                return 0;
          }
                
@@ -1116,14 +1116,6 @@ static int acsi_ioctl( struct inode *inode, struct file *file,
                put_user( 0, &((Scsi_Idlun *) arg)->host_unique_id );
                return 0;
                
-         case BLKGETSIZE:
-         case BLKGETSIZE64:
-         case BLKROSET:
-         case BLKROGET:
-         case BLKFLSBUF:
-         case BLKPG:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-
          case BLKRRPART: /* Re-read partition tables */
                if (!capable(CAP_SYS_ADMIN)) 
                        return -EACCES;

diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index af8f966f4eb36c35759a8f0e538a529a052562d4..04a8ce00c6a7671411961582b26aebf5be5e6e35 100644 (file)
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1559,12 +1559,6 @@ static int fd_ioctl(struct inode *inode, struct file *filp,
        struct floppy_struct setprm;
 
        device = inode->i_rdev;
-       switch (cmd) {
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-                       return blk_ioctl(inode->i_bdev, cmd, param);
-       }
        drive = minor (device);
        type  = drive >> 2;
        drive &= 3;

diff --git a/drivers/block/blkpg.c b/drivers/block/blkpg.c
index 37e244777963e3d1fe837949b08da6eaad2ea872..83826af84b6a9b176be1a123aabf66df8654cdc8 100644 (file)
--- a/drivers/block/blkpg.c
+++ b/drivers/block/blkpg.c
@@ -69,8 +69,9 @@ int add_partition(struct block_device *bdev, struct blkpg_partition *p)
        struct gendisk *g;
        long long ppstart, pplength;
        long pstart, plength;
-       int i, drive, first_minor, end_minor, minor;
+       int i;
        kdev_t dev = to_kdev_t(bdev->bd_dev);
+       struct hd_struct *part;
 
        /* convert bytes to sectors, check for fit in a hd_struct */
        ppstart = (p->start >> 9);
@@ -85,37 +86,32 @@ int add_partition(struct block_device *bdev, struct blkpg_partition *p)
        g = get_gendisk(dev);
        if (!g)
                return -ENXIO;
+       part = g->part + minor(dev);
 
        /* existing drive? */
-       drive = (minor(dev) >> g->minor_shift);
-       first_minor = (drive << g->minor_shift);
-       end_minor   = first_minor + (1 << g->minor_shift);
-       if (drive >= g->nr_real)
-               return -ENXIO;
 
        /* drive and partition number OK? */
-       if (first_minor != minor(dev))
+       if (bdev != bdev->bd_contains)
                return -EINVAL;
        if (p->pno <= 0 || p->pno >= (1 << g->minor_shift))
                return -EINVAL;
 
        /* partition number in use? */
-       minor = first_minor + p->pno;
-       if (g->part[minor].nr_sects != 0)
+       if (part[p->pno].nr_sects != 0)
                return -EBUSY;
 
        /* overlap? */
-       for (i=first_minor+1; i<end_minor; i++)
-               if (!(pstart+plength <= g->part[i].start_sect ||
-                     pstart >= g->part[i].start_sect + g->part[i].nr_sects))
+       for (i = 1; i < (1<<g->minor_shift); i++)
+               if (!(pstart+plength <= part[i].start_sect ||
+                     pstart >= part[i].start_sect + part[i].nr_sects))
                        return -EBUSY;
 
        /* all seems OK */
-       g->part[minor].start_sect = pstart;
-       g->part[minor].nr_sects = plength;
+       part[p->pno].start_sect = pstart;
+       part[p->pno].nr_sects = plength;
        if (g->sizes)
-               g->sizes[minor] = (plength >> (BLOCK_SIZE_BITS - 9));
-       devfs_register_partitions (g, first_minor, 0);
+               g->sizes[minor(dev)+p->pno] = (plength >> (BLOCK_SIZE_BITS-9));
+       devfs_register_partitions (g, minor(dev), 0);
        return 0;
 }
 
@@ -133,33 +129,27 @@ int del_partition(struct block_device *bdev, struct blkpg_partition *p)
 {
        kdev_t dev = to_kdev_t(bdev->bd_dev);
        struct gendisk *g;
-       kdev_t devp;
        struct block_device *bdevp;
-       int drive, first_minor, minor;
+       struct hd_struct *part;
        int holder;
 
        /* find the drive major */
        g = get_gendisk(dev);
        if (!g)
                return -ENXIO;
+       part = g->part + minor(dev);
 
-       /* drive and partition number OK? */
-       drive = (minor(dev) >> g->minor_shift);
-       first_minor = (drive << g->minor_shift);
-
-       if (first_minor != minor(dev))
+       if (bdev != bdev->bd_contains)
                return -EINVAL;
        if (p->pno <= 0 || p->pno >= (1 << g->minor_shift))
                return -EINVAL;
 
        /* existing drive and partition? */
-       minor = first_minor + p->pno;
-       if (drive >= g->nr_real || g->part[minor].nr_sects == 0)
+       if (part[p->pno].nr_sects == 0)
                return -ENXIO;
 
        /* partition in use? Incomplete check for now. */
-       devp = mk_kdev(major(dev), minor);
-       bdevp = bdget(kdev_t_to_nr(devp));
+       bdevp = bdget(MKDEV(major(dev), minor(dev) + p->pno));
        if (!bdevp)
                return -ENOMEM;
        if (bd_claim(bdevp, &holder) < 0) {
@@ -171,11 +161,11 @@ int del_partition(struct block_device *bdev, struct blkpg_partition *p)
        fsync_bdev(bdevp);
        invalidate_bdev(bdevp, 0);
 
-       g->part[minor].start_sect = 0;
-       g->part[minor].nr_sects = 0;
+       part[p->pno].start_sect = 0;
+       part[p->pno].nr_sects = 0;
        if (g->sizes)
-               g->sizes[minor] = 0;
-       devfs_register_partitions (g, first_minor, 0);
+               g->sizes[minor(dev) + p->pno] = 0;
+       devfs_register_partitions (g, minor(dev), 0);
        bd_release(bdevp);
        bdput(bdevp);
 
@@ -223,10 +213,6 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
        int holder;
        struct backing_dev_info *bdi;
 
-       intval = block_ioctl(bdev, cmd, arg);
-       if (intval != -ENOTTY)
-               return intval;
-
        switch (cmd) {
                case BLKROSET:
                        if (!capable(CAP_SYS_ADMIN))
@@ -296,14 +282,6 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
 
                case BLKPG:
                        return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg *) arg);
-                       
-               /*
-                * deprecated, use the /proc/iosched interface instead
-                */
-               case BLKELVGET:
-               case BLKELVSET:
-                       return -ENOTTY;
-
                case BLKBSZGET:
                        /* get the logical block size (cf. BLKSSZGET) */
                        intval = block_size(bdev);
@@ -330,5 +308,3 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
                        return -EINVAL;
        }
 }
-
-EXPORT_SYMBOL(blk_ioctl);

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 8c7033f3220be7a0be45104b0d918e41b8a9db4b..939d7026941586e168af24fe6dbf2db861f3c453 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -440,15 +440,6 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 
        case BLKRRPART:
                return revalidate_logvol(inode->i_rdev, 1);
-       case BLKGETSIZE:
-       case BLKGETSIZE64:
-       case BLKFLSBUF:
-       case BLKBSZSET:
-       case BLKBSZGET:
-       case BLKROSET:
-       case BLKROGET:
-       case BLKPG:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
        case CCISS_GETPCIINFO:
        {
                cciss_pci_info_struct pciinfo;

diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 124cbf046ce3596d075ec8504cc1505171040ffb..31276ef0e87c700150d991d3037fb71834a03587 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -1116,7 +1116,7 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
                put_user(diskinfo[0], &geo->heads);
                put_user(diskinfo[1], &geo->sectors);
                put_user(diskinfo[2], &geo->cylinders);
-               put_user(get_start_sect(inode->i_rdev), &geo->start);
+               put_user(get_start_sect(inode->i_bdev), &geo->start);
                return 0;
        case IDAGETDRVINFO:
                if (copy_to_user(&io->c.drv, &hba[ctlr]->drv[dsk],
@@ -1157,16 +1157,6 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
                return(0);
        }       
 
-       case BLKGETSIZE:
-       case BLKGETSIZE64:
-       case BLKFLSBUF:
-       case BLKBSZSET:
-       case BLKBSZGET:
-       case BLKROSET:
-       case BLKROGET:
-       case BLKPG:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-
        default:
                return -EINVAL;
        }

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index aff8acff0ef3a6983c16d3aaad35924e4e5600d6..fdc6e904464a54fafdf326720867876abb0bb5f6 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3468,12 +3468,6 @@ static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
        const char *outparam; /* parameters passed back to user space */
 
        device = inode->i_rdev;
-       switch (cmd) {
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-                       return blk_ioctl(inode->i_bdev, cmd, param);
-       }
        type = TYPE(device);
        drive = DRIVE(device);
 

diff --git a/drivers/block/genhd.c b/drivers/block/genhd.c
index 7c30fbe37c164126d33ab1779f07bc5a294a4607..6bb06af389805274264dac1843f82b04377c4571 100644 (file)
--- a/drivers/block/genhd.c
+++ b/drivers/block/genhd.c
@@ -117,31 +117,6 @@ get_gendisk(kdev_t dev)
 
 EXPORT_SYMBOL(get_gendisk);
 
-
-unsigned long
-get_start_sect(kdev_t dev)
-{
-       struct gendisk *gp;
-
-       gp = get_gendisk(dev);
-       if (gp)
-               return gp->part[minor(dev)].start_sect;
-       return 0;
-}
-
-EXPORT_SYMBOL(get_start_sect);
-
-unsigned long
-get_nr_sects(kdev_t dev)
-{
-       struct gendisk *gp;
-
-       gp = get_gendisk(dev);
-       if (gp)
-               return gp->part[minor(dev)].nr_sects;
-       return 0;
-}
-
 #ifdef CONFIG_PROC_FS
 /* iterator */
 static void *part_start(struct seq_file *part, loff_t *pos)

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 982604ff6bfd37e566af2f0f96f2f593a2fdc854..50c1052cae74f75d20debe08b4b4ad37ce4d6d6c 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -912,10 +912,6 @@ static int lo_ioctl(struct inode * inode, struct file * file,
                }
                err = put_user((u64)loop_sizes[lo->lo_number] << 10, (u64*)arg);
                break;
-       case BLKBSZGET:
-       case BLKBSZSET:
-               err = blk_ioctl(inode->i_bdev, cmd, arg);
-               break;
        default:
                err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
        }

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 6e661e064da0bd5fe07df1077e0437445c195cab..3c1492428a3c6ed077685cea7872500833c5c843 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -460,19 +460,12 @@ static int pd_ioctl(struct inode *inode,struct file *file,
                    put_user(PD.heads, (char *) &geo->heads);
                    put_user(PD.sectors, (char *) &geo->sectors);
                }
-               put_user(get_start_sect(inode->i_rdev), (long *)&geo->start);
+               put_user(get_start_sect(inode->i_bdev), (long *)&geo->start);
                return 0;
            case BLKRRPART:
                if (!capable(CAP_SYS_ADMIN))
                        return -EACCES;
                return pd_revalidate(inode->i_rdev);
-           case BLKGETSIZE:
-           case BLKGETSIZE64:
-           case BLKROSET:
-           case BLKROGET:
-           case BLKFLSBUF:
-           case BLKPG:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
            default:
                return -EINVAL;
        }
@@ -515,7 +508,7 @@ static int pd_revalidate(kdev_t dev)
        if ((unit >= PD_UNITS) || !PD.present)
                return -ENODEV;
 
-       res = dev_part_lock(device);
+       res = dev_lock_part(device);
        if (res < 0)
                return res;
        res = wipe_partitions(device);

diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 578feaadbb3807496e14fe22d27e974e12c2a7ce..b60847f9f25e037702379e6f7c5e9fe4fb868036 100644 (file)
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -423,10 +423,6 @@ static int pf_ioctl(struct inode *inode,struct file *file,
                 return put_user(PF.capacity,(long *) arg);
             case BLKGETSIZE64:
                 return put_user((u64)PF.capacity << 9,(u64 *)arg);
-           case BLKROSET:
-           case BLKROGET:
-           case BLKFLSBUF:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
             default:
                 return -EINVAL;
         }

diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 65b7d9999e6ce173ce2b832aba89580eb613d38a..1d734f15cab2a98f07ff7ac0d218ae53f65373f9 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -1096,7 +1096,7 @@ static int ps2esdi_ioctl(struct inode *inode,
                                put_user(ps2esdi_info[dev].head, (char *) &geometry->heads);
                                put_user(ps2esdi_info[dev].sect, (char *) &geometry->sectors);
                                put_user(ps2esdi_info[dev].cyl, (short *) &geometry->cylinders);
-                               put_user(get_start_sect(inode->i_rdev),
+                               put_user(get_start_sect(inode->b_rdev),
                                            (long *) &geometry->start);
 
                                return 0;
@@ -1107,16 +1107,6 @@ static int ps2esdi_ioctl(struct inode *inode,
                         if (!capable(CAP_SYS_ADMIN)) 
                                return -EACCES;
                        return (ps2esdi_reread_partitions(inode->i_rdev));
-
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-               case BLKBSZGET:
-               case BLKBSZSET:
-               case BLKPG:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
                }
        return (-EINVAL);
 }

diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 7b60e75d5584aa457fc2c986947e857f88f6466b..662020429ba6b4dfce70d85d2f6d2e6994c5935c 100644 (file)
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -303,12 +303,6 @@ static int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                        }
                        up(&inode->i_bdev->bd_sem);
                        break;
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKSSZGET:
-                       error = blk_ioctl(inode->i_bdev, cmd, arg);
        }
 out:
        return error;

diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 719a7a6a6261fd16f3caacac0dafeb45daf303c4..a1575eb830b045f942c690730fa2d03406da29db 100644 (file)
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -848,16 +848,6 @@ static int mm_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned
 
 
        switch(cmd) {
-
-       case BLKGETSIZE:
-               /* Return the device size, expressed in sectors */
-               err = ! access_ok (VERIFY_WRITE, arg, sizeof(long));
-               if (err) return -EFAULT;
-               size = mm_gendisk.part[minor].nr_sects;
-               if (copy_to_user((long *) arg, &size, sizeof (long)))
-                       return -EFAULT;
-               return 0;
-
        case BLKRRPART:
                return (mm_revalidate(i->i_rdev));
 
@@ -872,16 +862,15 @@ static int mm_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned
                size = cards[card_number].mm_size * (1024 / MM_HARDSECT);
                geo.heads     = 64;
                geo.sectors   = 32;
-               geo.start     = mm_gendisk.part[minor].start_sect;
+               geo.start     = get_start_sect(inode->i_bdev);
                geo.cylinders = size / (geo.heads * geo.sectors);
 
                if (copy_to_user((void *) arg, &geo, sizeof(geo)))
                        return -EFAULT;
                return 0;
 
-
        default:
-               return blk_ioctl(i->i_bdev, cmd, arg);
+               return -EINVAL;
        }
 
        return -ENOTTY; /* unknown command */

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 0474a027190c1eaf1c94c431aa49930a07c40a0c..a1166a4e13940edb1d0561d294764be153ea0bcc 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -315,7 +315,7 @@ static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
                        g.heads = xd_info[dev].heads;
                        g.sectors = xd_info[dev].sectors;
                        g.cylinders = xd_info[dev].cylinders;
-                       g.start = get_start_sect(inode->i_rdev);
+                       g.start = get_start_sect(inode->i_bdev);
                        return copy_to_user(geometry, &g, sizeof g) ? -EFAULT : 0;
                }
                case HDIO_SET_DMA:
@@ -337,14 +337,6 @@ static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
                                return -EACCES;
                        return xd_reread_partitions(inode->i_rdev);
 
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKFLSBUF:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKPG:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
-
                default:
                        return -EINVAL;
        }

diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 494aa03dc27368224f55e080df473d3fe4e09d6f..7b6dbbee9d95196ea5dabcfc660cf2915026f89d 100644 (file)
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1732,11 +1732,6 @@ int cdrom_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
           because they fill up the sys log when CD players poll
           the drive. */
        switch (cmd) {
-       case BLKROSET:
-       case BLKROGET:
-       case BLKFLSBUF:
-       case BLKSSZGET:
-               return blk_ioctl(ip->i_bdev, cmd, arg);
        case CDROMSUBCHNL: {
                struct cdrom_subchnl q;
                u_char requested, back;

diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index 689933665d171a88d2a6d86750f58ab159b9c10e..f5fb26632eb29c5195f2626bdfaf170a7d50f1e9 100644 (file)
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -641,7 +641,7 @@ static int hd_ioctl(struct inode * inode, struct file * file,
                        g.heads = hd_info[dev].head;
                        g.sectors = hd_info[dev].sect;
                        g.cylinders = hd_info[dev].cyl;
-                       g.start = get_start_sect(inode->i_rdev);
+                       g.start = get_start_sect(inode->i_bdev);
                        return copy_to_user(loc, &g, sizeof g) ? -EFAULT : 0; 
                }
 
@@ -650,14 +650,6 @@ static int hd_ioctl(struct inode * inode, struct file * file,
                                return -EACCES;
                        return revalidate_hddisk(inode->i_rdev, 1);
 
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-               case BLKPG:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
-
                default:
                        return -EINVAL;
        }

diff --git a/drivers/ide/hptraid.c b/drivers/ide/hptraid.c
index 9e8e07b35a2fa74a60180f34e50c61d1a99389a0..43b45c6e06eb499f7aaf35e92b350e5757bc5e97 100644 (file)
--- a/drivers/ide/hptraid.c
+++ b/drivers/ide/hptraid.c
@@ -122,11 +122,6 @@ static int hptraid_ioctl(struct inode *inode, struct file *file,
                        return 0;
                }
 
-       case BLKROSET:
-       case BLKROGET:
-       case BLKSSZGET:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-
        default:
                return -EINVAL;
        };

diff --git a/drivers/ide/ioctl.c b/drivers/ide/ioctl.c
index 1c86cbc9c177c4f457347017675a5b64bd2567f8..003b743b47726fb9964fa0bc5af99bd75f1e4c9d 100644 (file)
--- a/drivers/ide/ioctl.c
+++ b/drivers/ide/ioctl.c
@@ -343,19 +343,6 @@ int ata_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned
                case BLKRRPART: /* Re-read partition tables */
                        return ata_revalidate(inode->i_rdev);
 
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-               case BLKSSZGET:
-               case BLKPG:
-               case BLKELVGET:
-               case BLKELVSET:
-               case BLKBSZGET:
-               case BLKBSZSET:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
-
                /* Now check whatever this particular ioctl has a device type
                 * specific implementation.
                 */

diff --git a/drivers/ide/pdcraid.c b/drivers/ide/pdcraid.c
index 4d6f81507582467314989b2709f06c18b35c3534..d1bd67ba7f45c8bfd6b6672919b258d3c2040ca2 100644 (file)
--- a/drivers/ide/pdcraid.c
+++ b/drivers/ide/pdcraid.c
@@ -152,11 +152,6 @@ static int pdcraid_ioctl(struct inode *inode, struct file *file,
                        return 0;
                }
 
-       case BLKROSET:
-       case BLKROGET:
-       case BLKSSZGET:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-
        default:
                printk("Invalid ioctl \n");
                return -EINVAL;

diff --git a/drivers/md/lvm.c b/drivers/md/lvm.c
index c44a1b8a74b276184b873b43a4487329edcc3e7f..ab05b01ee4ced35617997e6eec855ef111effaf9 100644 (file)
--- a/drivers/md/lvm.c
+++ b/drivers/md/lvm.c
@@ -872,17 +872,6 @@ static int lvm_blk_ioctl(struct inode *inode, struct file *file,
                        return -EFAULT;
                break;
 
-
-       case BLKFLSBUF:
-               /* flush buffer cache */
-               if (!capable(CAP_SYS_ADMIN)) return -EACCES;
-
-               P_IOCTL("BLKFLSBUF\n");
-
-               fsync_bdev(inode->i_bdev);
-               invalidate_buffers(inode->i_rdev);
-               break;
-
        case HDIO_GETGEO:
                /* get disk geometry */
                P_IOCTL("%s -- lvm_blk_ioctl -- HDIO_GETGEO\n", lvm_name);

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 5490639484265fa6d42df13b237f119df397cb18..d08613aea3bb1d44898c12febac975aff42186bb 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2241,28 +2241,6 @@ static int md_ioctl(struct inode *inode, struct file *file,
                        autostart_arrays();
                        goto done;
 #endif
-
-               case BLKGETSIZE:        /* Return device size */
-                       if (!arg) {
-                               err = -EINVAL;
-                               MD_BUG();
-                               goto abort;
-                       }
-                       err = put_user(md_hd_struct[minor].nr_sects,
-                                               (unsigned long *) arg);
-                       goto done;
-
-               case BLKGETSIZE64:      /* Return device size */
-                       err = put_user((u64)md_hd_struct[minor].nr_sects << 9,
-                                               (u64 *) arg);
-                       goto done;
-
-               case BLKFLSBUF:
-               case BLKBSZGET:
-               case BLKBSZSET:
-                       err = blk_ioctl(inode->i_bdev, cmd, arg);
-                       goto abort;
-
                default:;
        }
 
@@ -2386,7 +2364,7 @@ static int md_ioctl(struct inode *inode, struct file *file,
                                                (short *) &loc->cylinders);
                        if (err)
                                goto abort_unlock;
-                       err = put_user (get_start_sect(dev),
+                       err = put_user (get_start_sect(inode->i_bdev),
                                                (long *) &loc->start);
                        goto done_unlock;
        }

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 73c17cf22699faa25717946e4eb99617cfac72df..b82610655b493912d9009d31b3744cbe0326fdf0 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -1083,7 +1083,7 @@ static int i2ob_ioctl(struct inode *inode, struct file *file,
                        int u = minor(inode->i_rdev) & 0xF0;
                        i2o_block_biosparam(i2ob_sizes[u]<<1, 
                                &g.cylinders, &g.heads, &g.sectors);
-                       g.start = get_start_sect(inode->i_rdev);
+                       g.start = get_start_sect(inode->i_bdev);
                        return copy_to_user((void *)arg, &g, sizeof(g))
                                ? -EFAULT : 0;
                }
@@ -1093,14 +1093,6 @@ static int i2ob_ioctl(struct inode *inode, struct file *file,
                                return -EACCES;
                        return do_i2ob_revalidate(inode->i_rdev,1);
                        
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKFLSBUF:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKPG:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
-                       
                default:
                        return -EINVAL;
        }

diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 34ecf2f82ccb59c21fb702ed715af9605aa9c13e..c68d10d829f9198c491e102eb050bbc66019550f 100644 (file)
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -1123,22 +1123,11 @@ static int ftl_ioctl(struct inode *inode, struct file *file,
        put_user(1, (char *)&geo->heads);
        put_user(8, (char *)&geo->sectors);
        put_user((sect>>3), (short *)&geo->cylinders);
-       put_user(get_start_sect(inode->i_rdev), (u_long *)&geo->start);
-       break;
-    case BLKGETSIZE:
-       ret = put_user(ftl_hd[minor].nr_sects, (unsigned long *)arg);
-       break;
-    case BLKGETSIZE64:
-       ret = put_user((u64)ftl_hd[minor].nr_sects << 9, (u64 *)arg);
+       put_user(get_start_sect(inode->i_bdev), (u_long *)&geo->start);
        break;
     case BLKRRPART:
        ret = ftl_reread_partitions(inode->i_rdev);
        break;
-    case BLKROSET:
-    case BLKROGET:
-    case BLKFLSBUF:
-       ret = blk_ioctl(inode->i_bdev, cmd, arg);
-       break;
     default:
        ret = -EINVAL;
     }

diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index 9560e5a30faa144a942ae6632d1bb08a465ffb57..f54e17f14540ab6cdce0fb339aae22c729d55e5c 100644 (file)
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -787,7 +787,7 @@ static int nftl_ioctl(struct inode * inode, struct file * file, unsigned int cmd
                g.heads = nftl->heads;
                g.sectors = nftl->sectors;
                g.cylinders = nftl->cylinders;
-               g.start = get_start_sect(inode->i_rdev);
+               g.start = get_start_sect(inode->i_bdev);
                return copy_to_user((void *)arg, &g, sizeof g) ? -EFAULT : 0;
        }
        case BLKFLSBUF:
@@ -812,18 +812,6 @@ static int nftl_ioctl(struct inode * inode, struct file * file, unsigned int cmd
                dev_unlock_part(device);
                }
                return res;
-
-#if (LINUX_VERSION_CODE < 0x20303)             
-       RO_IOCTLS(inode->i_rdev, arg);  /* ref. linux/blk.h */
-#else
-       case BLKGETSIZE:
-       case BLKGETSIZE64:
-       case BLKROSET:
-       case BLKROGET:
-       case BLKSSZGET:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-#endif
-
        default:
                return -EINVAL;
        }

diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index ca62073e100972cb5081d121c5b9379afe13fb4f..beea10ab977d3964e3c09eff65c8c5faab4a94df 100644 (file)
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -447,11 +447,6 @@ static int dasd_ioctl_set_ro(void *inp, int no, long args)
        return 0;
 }
 
-static int dasd_ioctl_blkioctl(void *inp, int no, long args)
-{
-       return blk_ioctl(((struct inode *) inp)->i_bdev, no, args);
-}
-
 /*
  * Return device size in number of sectors.
  */
@@ -517,12 +512,12 @@ static int dasd_ioctl_rr_partition(void *inp, int no, long args)
 static int dasd_ioctl_getgeo(void *inp, int no, long args)
 {
        struct hd_geometry geo = { 0, };
+       struct inode *inode = inp;
        dasd_devmap_t *devmap;
        dasd_device_t *device;
-       kdev_t kdev;
+       kdev_t kdev = inode->i_rdev;
        int rc;
 
-       kdev = ((struct inode *) inp)->i_rdev;
        devmap = dasd_devmap_from_kdev(kdev);
        device = (devmap != NULL) ?
                dasd_get_device(devmap) : ERR_PTR(-ENODEV);
@@ -532,7 +527,7 @@ static int dasd_ioctl_getgeo(void *inp, int no, long args)
        if (device != NULL && device->discipline != NULL &&
            device->discipline->fill_geometry != NULL) {
                device->discipline->fill_geometry(device, &geo);
-               geo.start = get_start_sect(kdev);
+               geo.start = get_start_sect(inode->i_bdev);
                if (copy_to_user((struct hd_geometry *) args, &geo,
                                 sizeof (struct hd_geometry)))
                        rc = -EFAULT;
@@ -554,16 +549,10 @@ static struct { int no; dasd_ioctl_fn_t fn; } dasd_ioctls[] =
        { BIODASDINFO2, dasd_ioctl_information },
        { BIODASDPRRD, dasd_ioctl_read_profile },
        { BIODASDPRRST, dasd_ioctl_reset_profile },
-       { BLKELVGET, dasd_ioctl_blkioctl },
-       { BLKELVSET, dasd_ioctl_blkioctl },
-       { BLKFLSBUF, dasd_ioctl_blkioctl },
        { BLKGETSIZE, dasd_ioctl_blkgetsize },
        { BLKGETSIZE64, dasd_ioctl_blkgetsize64 },
-       { BLKPG, dasd_ioctl_blkioctl },
-       { BLKROGET, dasd_ioctl_blkioctl },
        { BLKROSET, dasd_ioctl_set_ro },
        { BLKRRPART, dasd_ioctl_rr_partition },
-       { BLKSSZGET, dasd_ioctl_blkioctl },
        { DASDAPIVER, dasd_ioctl_api_version },
        { HDIO_GETGEO, dasd_ioctl_getgeo },
        { -1, NULL }

diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index be899c77943a4c8dabd5c7982460427b6d0a7bc6..3985f4274eacca0a17b3782125ea4fb27950aea4 100644 (file)
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -342,14 +342,6 @@ static int xpram_ioctl (struct inode *inode, struct file *filp,
        if (idx >= xpram_devs)
                return -ENODEV;
        switch (cmd) {
-       case BLKGETSIZE:
-               /* Return the device size, expressed in sectors */
-               return put_user(xpram_sizes[idx] << 1, (unsigned long *) arg);
-       case BLKGETSIZE64:
-               /* Return the device size, expressed in bytes */
-               return put_user((u64) xpram_sizes[idx] << 10, (u64 *) arg);
-       case BLKFLSBUF:
-               return blk_ioctl(((struct inode *) inode)->i_bdev, cmd, arg);
        case BLKRRPART:
                /* re-read partition table: can't do it */
                return -EINVAL;

diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index a2c58e179445f5e7c1ba749c3b0fdb7c4e08c580..c7d5306043c67cb56185b988f69567859370bb18 100644 (file)
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -464,14 +464,6 @@ static int jsfd_ioctl(struct inode *inode, struct file *file,
        case BLKGETSIZE64:
                return put_user(jsfd_bytesizes[dev], (u64 *) arg);
 
-#if 0
-       case BLKROSET:
-       case BLKROGET:
-       case BLKSSZGET:
-               return blk_ioctl(inode->i_bdev, cmd, arg);
-#endif
-
-       /* case BLKFLSBUF: */   /* Program, then read, what happens? Stale? */
        default: ;
        }
        return -ENOTTY;

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 1ca2ac95292f1523447bfc363f3d397e01057ae2..7ab403cf98487943b26840088875657034d9b7fc 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -241,25 +241,12 @@ static int sd_ioctl(struct inode * inode, struct file * filp,
                                put_user(diskinfo[1], &loc->sectors) ||
                                put_user(diskinfo[2], &loc->cylinders) ||
                                put_user((unsigned) 
-                                            get_start_sect(inode->i_rdev),
+                                            get_start_sect(inode->i_bdev),
                                         (unsigned long *) &loc->start))
                                return -EFAULT;
                        return 0;
                }
 
-               case BLKGETSIZE:
-               case BLKGETSIZE64:
-               case BLKROSET:
-               case BLKROGET:
-               case BLKFLSBUF:
-               case BLKSSZGET:
-               case BLKPG:
-                case BLKELVGET:
-                case BLKELVSET:
-               case BLKBSZGET:
-               case BLKBSZSET:
-                       return blk_ioctl(inode->i_bdev, cmd, arg);
-
                case BLKRRPART: /* Re-read partition tables */
                        if (!capable(CAP_SYS_ADMIN))
                                return -EACCES;

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 8166aea9be6a8411816b60a38f09b1d3f9f40fe8..2a0304c00c7751dca3661a7397aa0fa2f9e592a2 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -514,19 +514,6 @@ int check_disk_change(kdev_t dev)
        return 1;
 }
 
-int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
-{
-       int res;
-       mm_segment_t old_fs = get_fs();
-
-       if (!bdev->bd_op->ioctl)
-               return -EINVAL;
-       set_fs(KERNEL_DS);
-       res = bdev->bd_op->ioctl(bdev->bd_inode, NULL, cmd, arg);
-       set_fs(old_fs);
-       return res;
-}
-
 static int do_open(struct block_device *bdev, struct inode *inode, struct file *file)
 {
        int ret = -ENXIO;
@@ -731,15 +718,37 @@ static int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
 {
        int ret = -EINVAL;
        switch (cmd) {
+       /*
+        * deprecated, use the /proc/iosched interface instead
+        */
+       case BLKELVGET:
+       case BLKELVSET:
+               ret = -ENOTTY;
+               break;
        case BLKRAGET:
+       case BLKROGET:
+       case BLKBSZGET:
+       case BLKSSZGET:
        case BLKFRAGET:
+       case BLKSECTGET:
        case BLKRASET:
        case BLKFRASET:
+       case BLKBSZSET:
+       case BLKPG:
                ret = blk_ioctl(inode->i_bdev, cmd, arg);
                break;
        default:
                if (inode->i_bdev->bd_op->ioctl)
                        ret =inode->i_bdev->bd_op->ioctl(inode, file, cmd, arg);
+               if (ret == -EINVAL) {
+                       switch (cmd) {
+                               case BLKGETSIZE:
+                               case BLKGETSIZE64:
+                               case BLKFLSBUF:
+                               case BLKROSET:
+                                       ret = blk_ioctl(inode->i_bdev,cmd,arg);
+                       }
+               }
                break;
        }
        return ret;
@@ -767,6 +776,16 @@ struct file_operations def_blk_fops = {
        ioctl:          blkdev_ioctl,
 };
 
+int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
+{
+       int res;
+       mm_segment_t old_fs = get_fs();
+       set_fs(KERNEL_DS);
+       res = blkdev_ioctl(bdev->bd_inode, NULL, cmd, arg);
+       set_fs(old_fs);
+       return res;
+}
+
 const char *__bdevname(kdev_t dev)
 {
        static char buffer[32];

diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 8192096fad163e3c97405f3c859a93c3ac5d0461..462405eabad80a9ca76b7ddffacde6e5b35c061e 100644 (file)
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -236,6 +236,7 @@ void driverfs_create_partitions(struct gendisk *hd, int minor)
        int max_p;
        int part;
        devfs_handle_t dir = 0;
+       struct hd_struct *p = hd->part + minor;
        
        /* get parent driverfs device structure */
        if (hd->driverfs_dev_arr)
@@ -260,9 +261,9 @@ void driverfs_create_partitions(struct gendisk *hd, int minor)
        
        /* for all partitions setup parents and device node names */
        for(part=0; part < max_p; part++) {
-               if ((part == 0) || (hd->part[minor + part].nr_sects >= 1)) {
+               if ((part == 0) || (p[part].nr_sects >= 1)) {
                        struct device * current_driverfs_dev = 
-                               &hd->part[minor+part].hd_driverfs_dev;
+                               &p[part].hd_driverfs_dev;
                        current_driverfs_dev->parent = parent;
                        /* handle disc case */
                        current_driverfs_dev->driver_data =
@@ -300,7 +301,6 @@ void driverfs_create_partitions(struct gendisk *hd, int minor)
                                        &partition_device_kdev_file);
                }
        }
-       return;
 }
 
 void driverfs_remove_partitions(struct gendisk *hd, int minor)
@@ -308,14 +308,14 @@ void driverfs_remove_partitions(struct gendisk *hd, int minor)
        int max_p;
        int part;
        struct device * current_driverfs_dev;
+       struct hd_struct *p = hd->part + minor;
        
        max_p=(1 << hd->minor_shift);
        
        /* for all parts setup parent relationships and device node names */
        for(part=1; part < max_p; part++) {
-               if ((hd->part[minor + part].nr_sects >= 1)) {
-                       current_driverfs_dev = 
-                               &hd->part[minor + part].hd_driverfs_dev;
+               if ((p[part].nr_sects >= 1)) {
+                       current_driverfs_dev = &p[part].hd_driverfs_dev;
                        device_remove_file(current_driverfs_dev,
                                        partition_device_type_file.name);
                        device_remove_file(current_driverfs_dev,
@@ -323,7 +323,7 @@ void driverfs_remove_partitions(struct gendisk *hd, int minor)
                        put_device(current_driverfs_dev);       
                }
        }
-       current_driverfs_dev = &hd->part[minor].hd_driverfs_dev;
+       current_driverfs_dev = &p->hd_driverfs_dev;
        device_remove_file(current_driverfs_dev, 
                                partition_device_type_file.name);
        device_remove_file(current_driverfs_dev, 

diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 44a954b2c3706381f9bcc862d144894a5b8c7fdd..93755fee7f36ff16c2f0932f8f6adcb8e9b3e085 100644 (file)
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -90,8 +90,10 @@ struct gendisk {
 extern void add_gendisk(struct gendisk *gp);
 extern void del_gendisk(struct gendisk *gp);
 extern struct gendisk *get_gendisk(kdev_t dev);
-extern unsigned long get_start_sect(kdev_t dev);
-extern unsigned long get_nr_sects(kdev_t dev);
+static inline unsigned long get_start_sect(struct block_device *bdev)
+{
+       return bdev->bd_offset;
+}
 
 #endif  /*  __KERNEL__  */