[PATCH] blk_ioctl() not exported anymore

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

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;
 	}

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. */

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;

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;

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);

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;

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;
 	}

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);
 

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)

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;
 	}

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);

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;
         }

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);
 }

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;

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 */

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;
 	}

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;

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;
 	}

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;
 	};

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.
 		 */

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;

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);

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;
 	}

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;
 	}

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;
     }

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;
 	}

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 }

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;

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;

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;

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];

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, 

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__  */