Patch from Andries.Brouwer@cwi.nl

The following patch does the following:

- static const char *blkdevs[MAX_BLKDEV]; disappears
- get_blkdev_list, (un)register_blkdev, __bdevname
  are moved from block_dev.c to genhd.c
- the third "fops" parameter of register_blkdev was unused;
  now removed everywhere
- zillions of places had printk("cannot get major") upon
  error return from register_blkdev; removed all of these
  and inserted a single printk in register_blkdev.

Of course the reason for the patch is that one fixed size
array is eliminated.



 Documentation/cdrom/cdrom-standard.tex |    7 -
 arch/m68k/atari/stram.c                |    3 
 arch/um/drivers/ubd_kern.c             |   19 +---
 drivers/acorn/block/fd1772.c           |    6 -
 drivers/acorn/block/mfmhd.c            |    6 -
 drivers/block/DAC960.c                 |   11 --
 drivers/block/acsi.c                   |    4 
 drivers/block/amiflop.c                |    5 -
 drivers/block/ataflop.c                |    4 
 drivers/block/cciss.c                  |    8 -
 drivers/block/cpqarray.c               |    6 -
 drivers/block/floppy.c                 |    3 
 drivers/block/genhd.c                  |  140 ++++++++++++++++++++++++++++++++-
 drivers/block/loop.c                   |    5 -
 drivers/block/nbd.c                    |    4 
 drivers/block/paride/pcd.c             |    3 
 drivers/block/paride/pd.c              |    5 -
 drivers/block/paride/pf.c              |    4 
 drivers/block/ps2esdi.c                |    9 --
 drivers/block/rd.c                     |    3 
 drivers/block/swim3.c                  |    4 
 drivers/block/swim_iop.c               |    9 --
 drivers/block/umem.c                   |    6 -
 drivers/block/xd.c                     |    9 --
 drivers/block/z2ram.c                  |   13 +--
 drivers/cdrom/aztcd.c                  |    8 -
 drivers/cdrom/cdu31a.c                 |    5 -
 drivers/cdrom/cm206.c                  |    6 -
 drivers/cdrom/gscd.c                   |    5 -
 drivers/cdrom/mcd.c                    |    3 
 drivers/cdrom/mcdx.c                   |    4 
 drivers/cdrom/optcd.c                  |    3 
 drivers/cdrom/sbpcd.c                  |    5 -
 drivers/cdrom/sjcd.c                   |    7 -
 drivers/cdrom/sonycd535.c              |    4 
 drivers/ide/ide-probe.c                |    5 -
 drivers/ide/legacy/hd.c                |    6 -
 drivers/md/dm.c                        |    3 
 drivers/md/md.c                        |    9 --
 drivers/message/i2o/i2o_block.c        |    6 -
 drivers/mtd/ftl.c                      |    6 -
 drivers/mtd/mtdblock.c                 |    7 -
 drivers/mtd/mtdblock_ro.c              |   15 ---
 drivers/mtd/nftlcore.c                 |    4 
 drivers/s390/block/dasd_genhd.c        |    5 -
 drivers/s390/block/xpram.c             |    9 --
 drivers/s390/char/tape_block.c         |    8 -
 drivers/sbus/char/jsflash.c            |    4 
 drivers/scsi/sd.c                      |   11 --
 drivers/scsi/sr.c                      |    2 
 drivers/scsi/sym53c8xx_2/sym_hipd.c    |    2 
 fs/block_dev.c                         |   62 --------------
 include/linux/fs.h                     |    2 
 53 files changed, 242 insertions(+), 270 deletions(-)

diff -puN arch/m68k/atari/stram.c~register_blkdev-cleanups arch/m68k/atari/stram.c
--- 25/arch/m68k/atari/stram.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/arch/m68k/atari/stram.c	2003-03-07 12:24:11.000000000 -0800
@@ -1052,8 +1052,7 @@ int __init stram_device_init(void)
 	if (!stram_disk)
 		return -ENOMEM;
 
-	if (register_blkdev( STRAM_MAJOR, "stram", &stram_fops)) {
-		printk(KERN_ERR "stram: Unable to get major %d\n", STRAM_MAJOR);
+	if (register_blkdev(STRAM_MAJOR, "stram")) {
 		put_disk(stram_disk);
 		return -ENXIO;
 	}
diff -puN arch/um/drivers/ubd_kern.c~register_blkdev-cleanups arch/um/drivers/ubd_kern.c
--- 25/arch/um/drivers/ubd_kern.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/arch/um/drivers/ubd_kern.c	2003-03-07 12:24:11.000000000 -0800
@@ -673,7 +673,7 @@ static struct mc_device ubd_mc = {
 static int ubd_mc_init(void)
 {
 	mconsole_register_dev(&ubd_mc);
-	return(0);
+	return 0;
 }
 
 __initcall(ubd_mc_init);
@@ -682,29 +682,24 @@ int ubd_init(void)
 {
         int i;
 
-	ubd_dir_handle = devfs_mk_dir (NULL, "ubd", NULL);
-	if(register_blkdev(MAJOR_NR, "ubd", &ubd_blops)){
-		printk(KERN_ERR "ubd: unable to get major %d\n", MAJOR_NR);
+	ubd_dir_handle = devfs_mk_dir(NULL, "ubd", NULL);
+	if (register_blkdev(MAJOR_NR, "ubd"))
 		return -1;
-	}
 
 	blk_init_queue(&ubd_queue, do_ubd_request, &ubd_io_lock);
 	elevator_init(&ubd_queue, &elevator_noop);
 
-	if(fake_major != 0){
+	if (fake_major != 0) {
 		char name[sizeof("ubd_nnn\0")];
 
 		snprintf(name, sizeof(name), "ubd_%d", fake_major);
 		ubd_fake_dir_handle = devfs_mk_dir(NULL, name, NULL);
-		if(register_blkdev(fake_major, "ubd", &ubd_blops)){
-			printk(KERN_ERR "ubd: unable to get major %d\n",
-			       fake_major);
+		if (register_blkdev(fake_major, "ubd"))
 			return -1;
-		}
 	}
-	for(i = 0; i < MAX_DEV; i++) 
+	for (i = 0; i < MAX_DEV; i++) 
 		ubd_add(i);
-	return(0);
+	return 0;
 }
 
 late_initcall(ubd_init);
diff -puN Documentation/cdrom/cdrom-standard.tex~register_blkdev-cleanups Documentation/cdrom/cdrom-standard.tex
--- 25/Documentation/cdrom/cdrom-standard.tex~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/Documentation/cdrom/cdrom-standard.tex	2003-03-07 12:24:11.000000000 -0800
@@ -758,11 +758,8 @@ merged back into \cdromh.
 \subsection{$Struct\ file_operations\ cdrom_fops$}
 
 The contents of this structure were described in section~\ref{cdrom.c}.
-As already stated, this structure should be used to register block
-devices with the kernel:
-$$
-register_blkdev(major, <name>, \&cdrom_fops);
-$$
+A pointer to this structure is assigned to the $fops$ field
+of the $struct gendisk$.
 
 \subsection{$Int\ register_cdrom( struct\ cdrom_device_info\ * cdi)$}
 
diff -puN drivers/acorn/block/fd1772.c~register_blkdev-cleanups drivers/acorn/block/fd1772.c
--- 25/drivers/acorn/block/fd1772.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/acorn/block/fd1772.c	2003-03-07 12:24:11.000000000 -0800
@@ -1539,11 +1539,9 @@ int fd1772_init(void)
 			goto err_disk;
 	}
 
-	err = register_blkdev(MAJOR_NR, "fd", &floppy_fops);
-	if (err) {
-		printk("Unable to get major %d for floppy\n", MAJOR_NR);
+	err = register_blkdev(MAJOR_NR, "fd");
+	if (err)
 		goto err_disk;
-	}
 
 	err = -EBUSY;
 	if (request_dma(FLOPPY_DMA, "fd1772")) {
diff -puN drivers/acorn/block/mfmhd.c~register_blkdev-cleanups drivers/acorn/block/mfmhd.c
--- 25/drivers/acorn/block/mfmhd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/acorn/block/mfmhd.c	2003-03-07 12:24:11.000000000 -0800
@@ -1267,11 +1267,9 @@ static int mfm_do_init(unsigned char irq
 	if (!request_region (mfm_addr, 10, "mfm"))
 		goto out1;
 
-	ret = register_blkdev(MAJOR_NR, "mfm", &mfm_fops);
-	if (ret) {
-		printk("mfm_init: unable to get major number %d\n", MAJOR_NR);
+	ret = register_blkdev(MAJOR_NR, "mfm");
+	if (ret)
 		goto out2;
-	}
 
 	/* Stuff for the assembler routines to get to */
 	hdc63463_baseaddress	= ioaddr(mfm_addr);
diff -puN drivers/block/acsi.c~register_blkdev-cleanups drivers/block/acsi.c
--- 25/drivers/block/acsi.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/acsi.c	2003-03-07 12:24:11.000000000 -0800
@@ -1613,7 +1613,6 @@ void acsi_attach_SLMs( int (*attach_func
 
 
 int acsi_init( void )
-
 {
 	int err = 0;
 	int i, target, lun;
@@ -1623,8 +1622,7 @@ int acsi_init( void )
 #endif
 	if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ACSI))
 		return 0;
-	if (register_blkdev( ACSI_MAJOR, "ad", &acsi_fops )) {
-		printk( KERN_ERR "Unable to get major %d for ACSI\n", ACSI_MAJOR );
+	if (register_blkdev(ACSI_MAJOR, "ad")) {
 		err = -EBUSY;
 		goto out1;
 	}
diff -puN drivers/block/amiflop.c~register_blkdev-cleanups drivers/block/amiflop.c
--- 25/drivers/block/amiflop.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/amiflop.c	2003-03-07 12:24:11.000000000 -0800
@@ -1754,10 +1754,9 @@ int __init amiga_floppy_init(void)
 	if (!AMIGAHW_PRESENT(AMI_FLOPPY))
 		return -ENXIO;
 
-	if (register_blkdev(FLOPPY_MAJOR,"fd",&floppy_fops)) {
-		printk("fd: Unable to get major %d for floppy\n",FLOPPY_MAJOR);
+	if (register_blkdev(FLOPPY_MAJOR,"fd"))
 		return -EBUSY;
-	}
+
 	/*
 	 *  We request DSKPTR, DSKLEN and DSKDATA only, because the other
 	 *  floppy registers are too spreaded over the custom register space
diff -puN drivers/block/ataflop.c~register_blkdev-cleanups drivers/block/ataflop.c
--- 25/drivers/block/ataflop.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/ataflop.c	2003-03-07 12:24:11.000000000 -0800
@@ -1929,10 +1929,8 @@ int __init atari_floppy_init (void)
 		/* Hades doesn't have Atari-compatible floppy */
 		return -ENXIO;
 
-	if (register_blkdev(FLOPPY_MAJOR,"fd",&floppy_fops)) {
-		printk(KERN_ERR "Unable to get major %d for floppy\n",FLOPPY_MAJOR);
+	if (register_blkdev(FLOPPY_MAJOR,"fd"))
 		return -EBUSY;
-	}
 
 	for (i = 0; i < FD_MAX_UNITS; i++) {
 		unit[i].disk = alloc_disk(1);
diff -puN drivers/block/cciss.c~register_blkdev-cleanups drivers/block/cciss.c
--- 25/drivers/block/cciss.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/cciss.c	2003-03-07 12:24:11.000000000 -0800
@@ -2451,14 +2451,12 @@ static int __init cciss_init_one(struct 
 		return -ENODEV;
 	}
 
-	if( register_blkdev(COMPAQ_CISS_MAJOR+i, hba[i]->devname, &cciss_fops))
-	{
-		printk(KERN_ERR "cciss:  Unable to get major number "
-			"%d for %s\n", COMPAQ_CISS_MAJOR+i, hba[i]->devname);
+	if (register_blkdev(COMPAQ_CISS_MAJOR+i, hba[i]->devname)) {
 		release_io_mem(hba[i]);
 		free_hba(i);
-		return(-1);
+		return -1;
 	}
+
 	/* make sure the board interrupts are off */
 	hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
 	if( request_irq(hba[i]->intr, do_cciss_intr, 
diff -puN drivers/block/cpqarray.c~register_blkdev-cleanups drivers/block/cpqarray.c
--- 25/drivers/block/cpqarray.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/cpqarray.c	2003-03-07 12:24:11.000000000 -0800
@@ -339,11 +339,9 @@ static int __init cpqarray_init(void)
 	for(i=0; i < nr_ctlr; i++) {
 	  	/* If this successful it should insure that we are the only */
 		/* instance of the driver */	
-		if (register_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname, &ida_fops)) {
-                        printk(KERN_ERR "cpqarray: Unable to get major number %d for ida\n",
-                                COMPAQ_SMART2_MAJOR+i);
+		if (register_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname))
                         continue;
-                }
+
 		hba[i]->access.set_intr_mask(hba[i], 0);
 		if (request_irq(hba[i]->intr, do_ida_intr,
 			SA_INTERRUPT|SA_SHIRQ, hba[i]->devname, hba[i])) {
diff -puN drivers/block/DAC960.c~register_blkdev-cleanups drivers/block/DAC960.c
--- 25/drivers/block/DAC960.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/DAC960.c	2003-03-07 12:24:11.000000000 -0800
@@ -13,9 +13,6 @@
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for complete details.
 
-  The author respectfully requests that any modifications to this software be
-  sent directly to him for evaluation and testing.
-
 */
 
 
@@ -2381,13 +2378,9 @@ static boolean DAC960_RegisterBlockDevic
   /*
     Register the Block Device Major Number for this DAC960 Controller.
   */
-  if (register_blkdev(MajorNumber, "dac960",
-			    &DAC960_BlockDeviceOperations) < 0)
-    {
-      DAC960_Error("UNABLE TO ACQUIRE MAJOR NUMBER %d - DETACHING\n",
-		   Controller, MajorNumber);
+  if (register_blkdev(MajorNumber, "dac960") < 0)
       return false;
-    }
+
   /*
     Initialize the I/O Request Queue.
   */
diff -puN drivers/block/floppy.c~register_blkdev-cleanups drivers/block/floppy.c
--- 25/drivers/block/floppy.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/floppy.c	2003-03-07 12:24:11.000000000 -0800
@@ -4232,8 +4232,7 @@ int __init floppy_init(void)
 	}
 
 	devfs_mk_dir (NULL, "floppy", NULL);
-	if (register_blkdev(FLOPPY_MAJOR,"fd",&floppy_fops)) {
-		printk("Unable to get major %d for floppy\n",FLOPPY_MAJOR);
+	if (register_blkdev(FLOPPY_MAJOR,"fd")) {
 		err = -EBUSY;
 		goto out;
 	}
diff -puN drivers/block/genhd.c~register_blkdev-cleanups drivers/block/genhd.c
--- 25/drivers/block/genhd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/genhd.c	2003-03-07 12:24:11.000000000 -0800
@@ -14,10 +14,16 @@
 #include <linux/slab.h>
 #include <linux/kmod.h>
 
+#define MAX_PROBE_HASH 255	/* random */
 
 static struct subsystem block_subsys;
 
-#define MAX_PROBE_HASH 23	/* random */
+/* Can be merged with blk_probe or deleted altogether. Later. */
+static struct blk_major_name {
+	struct blk_major_name *next;
+	int major;
+	char name[16];
+} *major_names[MAX_PROBE_HASH];
 
 static struct blk_probe {
 	struct blk_probe *next;
@@ -30,9 +36,132 @@ static struct blk_probe {
 } *probes[MAX_PROBE_HASH];
 
 /* index in the above - for now: assume no multimajor ranges */
+static inline int major_to_index(int major)
+{
+	return major % MAX_PROBE_HASH;
+}
+
 static inline int dev_to_index(dev_t dev)
 {
-	return MAJOR(dev) % MAX_PROBE_HASH;
+	return major_to_index(MAJOR(dev));
+}
+
+const char *__bdevname(dev_t dev)
+{
+	static char buffer[40];
+	char *name = "unknown-block";
+	unsigned int major = MAJOR(dev);
+	unsigned int minor = MINOR(dev);
+	int index = major_to_index(major);
+	struct blk_major_name *n;
+
+	down_read(&block_subsys.rwsem);
+	for (n = major_names[index]; n; n = n->next)
+		if (n->major == major)
+			break;
+	if (n)
+		name = &(n->name[0]);
+	sprintf(buffer, "%s(%u,%u)", name, major, minor);
+	up_read(&block_subsys.rwsem);
+
+	return buffer;
+}
+
+/* get block device names in somewhat random order */
+int get_blkdev_list(char *p)
+{
+	struct blk_major_name *n;
+	int i, len;
+
+	len = sprintf(p, "\nBlock devices:\n");
+
+	down_read(&block_subsys.rwsem);
+	for (i = 0; i < ARRAY_SIZE(major_names); i++) {
+		for (n = major_names[i]; n; n = n->next)
+			len += sprintf(p+len, "%3d %s\n",
+				       n->major, n->name);
+	}
+	up_read(&block_subsys.rwsem);
+
+	return len;
+}
+
+int register_blkdev(unsigned int major, const char *name)
+{
+	struct blk_major_name **n, *p;
+	int index, ret = 0;
+
+	if (devfs_only())
+		return 0;
+
+	/* temporary */
+	if (major == 0) {
+		down_read(&block_subsys.rwsem);
+		for (index = ARRAY_SIZE(major_names)-1; index > 0; index--)
+			if (major_names[index] == NULL)
+				break;
+		up_read(&block_subsys.rwsem);
+
+		if (index == 0) {
+			printk("register_blkdev: failed to get major for %s\n",
+			       name);
+			return -EBUSY;
+		}
+		ret = major = index;
+	}
+
+	p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
+	if (p == NULL)
+		return -ENOMEM;
+
+	p->major = major;
+	strncpy(p->name, name, sizeof(p->name)-1);
+	p->name[sizeof(p->name)-1] = 0;
+	p->next = 0;
+	index = major_to_index(major);
+
+	down_write(&block_subsys.rwsem);
+	for (n = &major_names[index]; *n; n = &(*n)->next)
+		if ((*n)->major == major)
+			break;
+	if (!*n)
+		*n = p;
+	else
+		ret = -EBUSY;
+	up_write(&block_subsys.rwsem);
+
+	if (ret < 0)
+		printk("register_blkdev: cannot get major %d for %s\n",
+		       major, name);
+
+	return ret;
+}
+
+/* todo: make void - error printk here */
+int unregister_blkdev(unsigned int major, const char *name)
+{
+	struct blk_major_name **n, *p;
+	int index;
+	int ret = 0;
+
+	if (devfs_only())
+		return 0;
+	index = major_to_index(major);
+
+	down_write(&block_subsys.rwsem);
+	for (n = &major_names[index]; *n; n = &(*n)->next)
+		if ((*n)->major == major)
+			break;
+	if (!*n || strcmp((*n)->name, name))
+		ret = -EINVAL;
+	else {
+		p = *n;
+		*n = p->next;
+		kfree(p);
+	}
+	up_write(&block_subsys.rwsem);
+
+	return ret;
 }
 
 /*
@@ -48,6 +177,9 @@ void blk_register_region(dev_t dev, unsi
 	struct blk_probe *p = kmalloc(sizeof(struct blk_probe), GFP_KERNEL);
 	struct blk_probe **s;
 
+	if (p == NULL)
+		return;
+
 	p->owner = module;
 	p->get = probe;
 	p->lock = lock;
@@ -98,9 +230,9 @@ static int exact_lock(dev_t dev, void *d
 
 /**
  * add_gendisk - add partitioning information to kernel list
- * @gp: per-device partitioning information
+ * @disk: per-device partitioning information
  *
- * This function registers the partitioning information in @gp
+ * This function registers the partitioning information in @disk
  * with the kernel.
  */
 void add_disk(struct gendisk *disk)
diff -puN drivers/block/loop.c~register_blkdev-cleanups drivers/block/loop.c
--- 25/drivers/block/loop.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/loop.c	2003-03-07 12:24:11.000000000 -0800
@@ -1017,11 +1017,8 @@ int __init loop_init(void) 
 		max_loop = 8;
 	}
 
-	if (register_blkdev(LOOP_MAJOR, "loop", &lo_fops)) {
-		printk(KERN_WARNING "Unable to get major number %d for loop"
-				    " device\n", LOOP_MAJOR);
+	if (register_blkdev(LOOP_MAJOR, "loop"))
 		return -EIO;
-	}
 
 	devfs_mk_dir(NULL, "loop", NULL);
 
diff -puN drivers/block/nbd.c~register_blkdev-cleanups drivers/block/nbd.c
--- 25/drivers/block/nbd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/nbd.c	2003-03-07 12:24:11.000000000 -0800
@@ -564,9 +564,7 @@ static int __init nbd_init(void)
 		nbd_dev[i].disk = disk;
 	}
 
-	if (register_blkdev(NBD_MAJOR, "nbd", &nbd_fops)) {
-		printk("Unable to get major number %d for NBD\n",
-		       NBD_MAJOR);
+	if (register_blkdev(NBD_MAJOR, "nbd")) {
 		err = -EIO;
 		goto out;
 	}
diff -puN drivers/block/paride/pcd.c~register_blkdev-cleanups drivers/block/paride/pcd.c
--- 25/drivers/block/paride/pcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/paride/pcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -942,8 +942,7 @@ static int __init pcd_init(void)
 	/* get the atapi capabilities page */
 	pcd_probe_capabilities();
 
-	if (register_blkdev(major, name, &pcd_bdops)) {
-		printk("pcd: unable to get major number %d\n", major);
+	if (register_blkdev(major, name)) {
 		for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
 			put_disk(cd->disk);
 		return -1;
diff -puN drivers/block/paride/pd.c~register_blkdev-cleanups drivers/block/paride/pd.c
--- 25/drivers/block/paride/pd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/paride/pd.c	2003-03-07 12:24:11.000000000 -0800
@@ -890,10 +890,9 @@ static int __init pd_init(void)
 {
 	if (disable)
 		return -1;
-	if (register_blkdev(major, name, &pd_fops)) {
-		printk("%s: unable to get major number %d\n", name, major);
+	if (register_blkdev(major, name))
 		return -1;
-	}
+
 	blk_init_queue(&pd_queue, do_pd_request, &pd_lock);
 	blk_queue_max_sectors(&pd_queue, cluster);
 
diff -puN drivers/block/paride/pf.c~register_blkdev-cleanups drivers/block/paride/pf.c
--- 25/drivers/block/paride/pf.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/paride/pf.c	2003-03-07 12:24:11.000000000 -0800
@@ -957,8 +957,7 @@ static int __init pf_init(void)
 		return -1;
 	pf_busy = 0;
 
-	if (register_blkdev(major, name, &pf_fops)) {
-		printk("pf_init: unable to get major number %d\n", major);
+	if (register_blkdev(major, name)) {
 		for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
 			put_disk(pf->disk);
 		return -1;
@@ -969,6 +968,7 @@ static int __init pf_init(void)
 
 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
 		struct gendisk *disk = pf->disk;
+
 		if (!pf->present)
 			continue;
 		disk->private_data = pf;
diff -puN drivers/block/ps2esdi.c~register_blkdev-cleanups drivers/block/ps2esdi.c
--- 25/drivers/block/ps2esdi.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/ps2esdi.c	2003-03-07 12:24:11.000000000 -0800
@@ -146,13 +146,10 @@ int __init ps2esdi_init(void)
 
 	int error = 0;
 
-	/* register the device - pass the name, major number and operations
-	   vector .                                                 */
-	if (register_blkdev(PS2ESDI_MAJOR, "ed", &ps2esdi_fops)) {
-		printk("%s: Unable to get major number %d\n", DEVICE_NAME,
-				PS2ESDI_MAJOR);
+	/* register the device - pass the name and major number */
+	if (register_blkdev(PS2ESDI_MAJOR, "ed"))
 		return -1;
-	}
+
 	/* set up some global information - indicating device specific info */
 	blk_init_queue(&ps2esdi_queue, do_ps2esdi_request, &ps2esdi_lock);
 
diff -puN drivers/block/rd.c~register_blkdev-cleanups drivers/block/rd.c
--- 25/drivers/block/rd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/rd.c	2003-03-07 12:24:11.000000000 -0800
@@ -409,8 +409,7 @@ static int __init rd_init (void)
 			goto out;
 	}
 
-	if (register_blkdev(RAMDISK_MAJOR, "ramdisk", &rd_bd_op)) {
-		printk("RAMDISK: Could not get major %d", RAMDISK_MAJOR);
+	if (register_blkdev(RAMDISK_MAJOR, "ramdisk")) {
 		err = -EIO;
 		goto out;
 	}
diff -puN drivers/block/swim3.c~register_blkdev-cleanups drivers/block/swim3.c
--- 25/drivers/block/swim3.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/swim3.c	2003-03-07 12:24:11.000000000 -0800
@@ -1004,9 +1004,7 @@ int swim3_init(void)
 			goto out;
 	}
 
-	if (register_blkdev(FLOPPY_MAJOR, "fd", &floppy_fops)) {
-		printk(KERN_ERR"Unable to get major %d for floppy\n",
-				FLOPPY_MAJOR);
+	if (register_blkdev(FLOPPY_MAJOR, "fd")) {
 		err = -EBUSY;
 		goto out;
 	}
diff -puN drivers/block/swim_iop.c~register_blkdev-cleanups drivers/block/swim_iop.c
--- 25/drivers/block/swim_iop.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/swim_iop.c	2003-03-07 12:24:11.000000000 -0800
@@ -137,13 +137,12 @@ int swimiop_init(void)
 	current_req = NULL;
 	floppy_count = 0;
 
-	if (!iop_ism_present) return -ENODEV;
+	if (!iop_ism_present)
+		return -ENODEV;
 
-	if (register_blkdev(FLOPPY_MAJOR, "fd", &floppy_fops)) {
-		printk(KERN_ERR "SWIM-IOP: Unable to get major %d for floppy\n",
-		       FLOPPY_MAJOR);
+	if (register_blkdev(FLOPPY_MAJOR, "fd"))
 		return -EBUSY;
-	}
+
 	blk_init_queue(&swim_queue, do_fd_request, &swim_iop_lock);
 	printk("SWIM-IOP: %s by Joshua M. Thompson (funaho@jurai.org)\n",
 		DRIVER_VERSION);
diff -puN drivers/block/umem.c~register_blkdev-cleanups drivers/block/umem.c
--- 25/drivers/block/umem.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/umem.c	2003-03-07 12:24:11.000000000 -0800
@@ -1145,11 +1145,9 @@ int __init mm_init(void)
 	if (retval)
 		return -ENOMEM;
 
-	err = major_nr = register_blkdev(0, "umem", &mm_fops);
-	if (err < 0) {
-		printk(KERN_ERR "MM: Could not register block device\n");
+	err = major_nr = register_blkdev(0, "umem");
+	if (err < 0)
 		return -EIO;
-	}
 
 	for (i = 0; i < num_cards; i++) {
 		mm_gendisk[i] = alloc_disk(1 << MM_SHIFT);
diff -puN drivers/block/xd.c~register_blkdev-cleanups drivers/block/xd.c
--- 25/drivers/block/xd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/xd.c	2003-03-07 12:24:11.000000000 -0800
@@ -154,9 +154,9 @@ static int __init xd_init(void)
 
 #ifdef MODULE
 	for (i = 4; i > 0; i--)
-		if(((xd[i] = xd[i-1]) >= 0) && !count)
+		if (((xd[i] = xd[i-1]) >= 0) && !count)
 			count = i;
-	if((xd[0] = count))
+	if ((xd[0] = count))
 		do_xd_setup(xd);
 #endif
 
@@ -170,10 +170,9 @@ static int __init xd_init(void)
 	}
 
 	err = -EBUSY;
-	if (register_blkdev(XT_DISK_MAJOR,"xd",&xd_fops)) {
-		printk("xd: Unable to get major number %d\n",XT_DISK_MAJOR);
+	if (register_blkdev(XT_DISK_MAJOR, "xd"))
 		goto out1;
-	}
+
 	devfs_mk_dir(NULL, "xd", NULL);
 	blk_init_queue(&xd_queue, do_xd_request, &xd_lock);
 	if (xd_detect(&controller,&address)) {
diff -puN drivers/block/z2ram.c~register_blkdev-cleanups drivers/block/z2ram.c
--- 25/drivers/block/z2ram.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/block/z2ram.c	2003-03-07 12:24:11.000000000 -0800
@@ -331,21 +331,18 @@ static struct gendisk *z2_find(dev_t dev
 static struct request_queue z2_queue;
 
 int __init 
-z2_init( void )
+z2_init(void)
 {
 
-    if ( !MACH_IS_AMIGA )
+    if (!MACH_IS_AMIGA)
 	return -ENXIO;
 
-    if ( register_blkdev( Z2RAM_MAJOR, DEVICE_NAME, &z2_fops ) )
-    {
-	printk( KERN_ERR DEVICE_NAME ": Unable to get major %d\n",
-	    Z2RAM_MAJOR );
+    if (register_blkdev(Z2RAM_MAJOR, DEVICE_NAME))
 	return -EBUSY;
-    }
+
     z2ram_gendisk = alloc_disk(1);
     if (!z2ram_gendisk) {
-	unregister_blkdev( Z2RAM_MAJOR, DEVICE_NAME );
+	unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
 	return -ENOMEM;
     }
     z2ram_gendisk->major = Z2RAM_MAJOR;
diff -puN drivers/cdrom/aztcd.c~register_blkdev-cleanups drivers/cdrom/aztcd.c
--- 25/drivers/cdrom/aztcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/aztcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -1910,12 +1910,12 @@ static int __init aztcd_init(void)
 	azt_disk = alloc_disk(1);
 	if (!azt_disk)
 		goto err_out;
-	if (register_blkdev(MAJOR_NR, "aztcd", &azt_fops) != 0) {
-		printk(KERN_WARNING "aztcd: Unable to get major %d for Aztech"
-		       " CD-ROM\n", MAJOR_NR);
+
+	if (register_blkdev(MAJOR_NR, "aztcd")) {
 		ret = -EIO;
 		goto err_out2;
 	}
+
 	blk_init_queue(&azt_queue, do_aztcd_request, &aztSpin);
 	blk_queue_hardsect_size(&azt_queue, 2048);
 	azt_disk->major = MAJOR_NR;
@@ -1931,7 +1931,7 @@ static int __init aztcd_init(void)
 	azt_invalidate_buffers();
 	aztPresent = 1;
 	aztCloseDoor();
-	return (0);
+	return 0;
 err_out2:
 	put_disk(azt_disk);
 err_out:
diff -puN drivers/cdrom/cdu31a.c~register_blkdev-cleanups drivers/cdrom/cdu31a.c
--- 25/drivers/cdrom/cdu31a.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/cdu31a.c	2003-03-07 12:24:11.000000000 -0800
@@ -3368,11 +3368,8 @@ int __init cdu31a_init(void)
 	if (!request_region(cdu31a_port, 4, "cdu31a"))
 		goto errout3;
 
-	if (register_blkdev(MAJOR_NR, "cdu31a", &scd_bdops)) {
-		printk("Unable to get major %d for CDU-31a\n",
-		       MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "cdu31a"))
 		goto errout2;
-	}
 
 	disk = alloc_disk(1);
 	if (!disk)
diff -puN drivers/cdrom/cm206.c~register_blkdev-cleanups drivers/cdrom/cm206.c
--- 25/drivers/cdrom/cm206.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/cm206.c	2003-03-07 12:24:11.000000000 -0800
@@ -1489,10 +1489,10 @@ int __init cm206_init(void)
 		goto out_probe;
 	}
 	printk(".\n");
-	if (register_blkdev(MAJOR_NR, "cm206", &cm206_bdops) != 0) {
-		printk(KERN_INFO "Cannot register for major %d!\n", MAJOR_NR);
+
+	if (register_blkdev(MAJOR_NR, "cm206"))
 		goto out_blkdev;
-	}
+
 	disk = alloc_disk(1);
 	if (!disk)
 		goto out_disk;
diff -puN drivers/cdrom/gscd.c~register_blkdev-cleanups drivers/cdrom/gscd.c
--- 25/drivers/cdrom/gscd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/gscd.c	2003-03-07 12:24:11.000000000 -0800
@@ -959,12 +959,11 @@ static int __init gscd_init(void)
 	gscd_disk->fops = &gscd_fops;
 	sprintf(gscd_disk->disk_name, "gscd");
 
-	if (register_blkdev(MAJOR_NR, "gscd", &gscd_fops) != 0) {
-		printk(KERN_WARNING "GSCD: Unable to get major %d for GoldStar "
-		       "CD-ROM\n", MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "gscd")) {
 		ret = -EIO;
 		goto err_out2;
 	}
+
 	devfs_register(NULL, "gscd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
 		       S_IFBLK | S_IRUGO | S_IWUGO, &gscd_fops, NULL);
 
diff -puN drivers/cdrom/mcd.c~register_blkdev-cleanups drivers/cdrom/mcd.c
--- 25/drivers/cdrom/mcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/mcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -1068,8 +1068,7 @@ int __init mcd_init(void)
 		put_disk(disk);
 		return -EIO;
 	}
-	if (register_blkdev(MAJOR_NR, "mcd", &mcd_bdops) != 0) {
-		printk(KERN_ERR "mcd: Unable to get major %d for Mitsumi CD-ROM\n", MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "mcd")) {
 		put_disk(disk);
 		return -EIO;
 	}
diff -puN drivers/cdrom/mcdx.c~register_blkdev-cleanups drivers/cdrom/mcdx.c
--- 25/drivers/cdrom/mcdx.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/mcdx.c	2003-03-07 12:24:11.000000000 -0800
@@ -1193,11 +1193,9 @@ int __init mcdx_init_drive(int drive)
 	}
 
 	xtrace(INIT, "init() register blkdev\n");
-	if (register_blkdev(MAJOR_NR, "mcdx", &mcdx_bdops) != 0) {
+	if (register_blkdev(MAJOR_NR, "mcdx")) {
 		release_region((unsigned long) stuffp->wreg_data,
 			       MCDX_IO_SIZE);
-		xwarn("%s=0x%3p,%d: Init failed. Can't get major %d.\n",
-		      MCDX, stuffp->wreg_data, stuffp->irq, MAJOR_NR);
 		kfree(stuffp);
 		put_disk(disk);
 		return 1;
diff -puN drivers/cdrom/optcd.c~register_blkdev-cleanups drivers/cdrom/optcd.c
--- 25/drivers/cdrom/optcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/optcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -2047,8 +2047,7 @@ static int __init optcd_init(void)
 		put_disk(optcd_disk);
 		return -EIO;
 	}
-	if (register_blkdev(MAJOR_NR, "optcd", &opt_fops) != 0) {
-		printk(KERN_ERR "optcd: unable to get major %d\n", MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "optcd")) {
 		release_region(optcd_port, 4);
 		put_disk(optcd_disk);
 		return -EIO;
diff -puN drivers/cdrom/sbpcd.c~register_blkdev-cleanups drivers/cdrom/sbpcd.c
--- 25/drivers/cdrom/sbpcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/sbpcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -5795,15 +5795,14 @@ int __init sbpcd_init(void)
 	OUT(MIXER_data,0xCC); /* one nibble per channel, max. value: 0xFF */
 #endif /* SOUND_BASE */
 
-	if (register_blkdev(MAJOR_NR, major_name, &sbpcd_bdops) != 0)
-	{
-		msg(DBG_INF, "Can't get MAJOR %d for Matsushita CDROM\n", MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, major_name)) {
 #ifdef MODULE
 		return -EIO;
 #else
 		goto init_done;
 #endif /* MODULE */
 	}
+
 	blk_init_queue(&sbpcd_queue, do_sbpcd_request, &sbpcd_lock);
 
 	devfs_mk_dir (NULL, "sbp", NULL);
diff -puN drivers/cdrom/sjcd.c~register_blkdev-cleanups drivers/cdrom/sjcd.c
--- 25/drivers/cdrom/sjcd.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/sjcd.c	2003-03-07 12:24:11.000000000 -0800
@@ -1677,11 +1677,8 @@ static int __init sjcd_init(void)
 	printk("SJCD: sjcd=0x%x: ", sjcd_base);
 #endif
 
-	if (register_blkdev(MAJOR_NR, "sjcd", &sjcd_fops) != 0) {
-		printk("SJCD: Unable to get major %d for Sanyo CD-ROM\n",
-		       MAJOR_NR);
-		return (-EIO);
-	}
+	if (register_blkdev(MAJOR_NR, "sjcd"))
+		return -EIO;
 
 	blk_init_queue(&sjcd_queue, do_sjcd_request, &sjcd_lock);
 	blk_queue_hardsect_size(&sjcd_queue, 2048);
diff -puN drivers/cdrom/sonycd535.c~register_blkdev-cleanups drivers/cdrom/sonycd535.c
--- 25/drivers/cdrom/sonycd535.c~register_blkdev-cleanups	2003-03-07 12:24:10.000000000 -0800
+++ 25-akpm/drivers/cdrom/sonycd535.c	2003-03-07 12:24:11.000000000 -0800
@@ -1546,9 +1546,7 @@ static int __init sony535_init(void)
 		printk("IRQ%d, ", tmp_irq);
 	printk("using %d byte buffer\n", sony_buffer_size);
 
-	if (register_blkdev(MAJOR_NR, CDU535_HANDLE, &cdu_fops)) {
-		printk("Unable to get major %d for %s\n",
-				MAJOR_NR, CDU535_MESSAGE_NAME);
+	if (register_blkdev(MAJOR_NR, CDU535_HANDLE)) {
 		err = -EIO;
 		goto out1;
 	}
diff -puN drivers/ide/ide-probe.c~register_blkdev-cleanups drivers/ide/ide-probe.c
--- 25/drivers/ide/ide-probe.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/ide/ide-probe.c	2003-03-07 12:24:11.000000000 -0800
@@ -1292,11 +1292,8 @@ int hwif_init (ide_hwif_t *hwif)
 	/* we set it back to 1 if all is ok below */	
 	hwif->present = 0;
 
-	if (register_blkdev (hwif->major, hwif->name, ide_fops)) {
-		printk("%s: UNABLE TO GET MAJOR NUMBER %d\n",
-			hwif->name, hwif->major);
+	if (register_blkdev(hwif->major, hwif->name))
 		return 0;
-	}
 
 	if (alloc_disks(hwif) < 0)
 		goto out;
diff -puN drivers/ide/legacy/hd.c~register_blkdev-cleanups drivers/ide/legacy/hd.c
--- 25/drivers/ide/legacy/hd.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/ide/legacy/hd.c	2003-03-07 12:24:11.000000000 -0800
@@ -708,10 +708,10 @@ static struct block_device_operations hd
 static int __init hd_init(void)
 {
 	int drive;
-	if (register_blkdev(MAJOR_NR,"hd",&hd_fops)) {
-		printk("hd: unable to get major %d for hard disk\n",MAJOR_NR);
+
+	if (register_blkdev(MAJOR_NR,"hd"))
 		return -1;
-	}
+
 	blk_init_queue(&hd_queue, do_hd_request, &hd_lock);
 	blk_queue_max_sectors(&hd_queue, 255);
 	init_timer(&device_timer);
diff -puN drivers/md/dm.c~register_blkdev-cleanups drivers/md/dm.c
--- 25/drivers/md/dm.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/md/dm.c	2003-03-07 12:24:11.000000000 -0800
@@ -79,9 +79,8 @@ static __init int local_init(void)
 		return -ENOMEM;
 
 	_major = major;
-	r = register_blkdev(_major, _name, &dm_blk_dops);
+	r = register_blkdev(_major, _name);
 	if (r < 0) {
-		DMERR("register_blkdev failed");
 		kmem_cache_destroy(_io_cache);
 		return r;
 	}
diff -puN drivers/md/md.c~register_blkdev-cleanups drivers/md/md.c
--- 25/drivers/md/md.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/md/md.c	2003-03-07 12:24:11.000000000 -0800
@@ -3214,11 +3214,10 @@ int __init md_init(void)
 			MD_MAJOR_VERSION, MD_MINOR_VERSION,
 			MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
 
-	if (register_blkdev (MAJOR_NR, "md", &md_fops)) {
-		printk(KERN_ALERT "md: Unable to get major %d for md\n", MAJOR_NR);
-		return (-1);
-	}
-	devfs_mk_dir (NULL, "md", NULL);
+	if (register_blkdev(MAJOR_NR, "md"))
+		return -1;
+
+	devfs_mk_dir(NULL, "md", NULL);
 	blk_register_region(MKDEV(MAJOR_NR, 0), MAX_MD_DEVS, THIS_MODULE,
 				md_probe, NULL, NULL);
 	for (minor=0; minor < MAX_MD_DEVS; ++minor) {
diff -puN drivers/message/i2o/i2o_block.c~register_blkdev-cleanups drivers/message/i2o/i2o_block.c
--- 25/drivers/message/i2o/i2o_block.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/message/i2o/i2o_block.c	2003-03-07 12:24:11.000000000 -0800
@@ -1608,12 +1608,8 @@ static int i2o_block_init(void)
 	/*
 	 *	Register the block device interfaces
 	 */
-
-	if (register_blkdev(MAJOR_NR, "i2o_block", &i2ob_fops)) {
-		printk(KERN_ERR "Unable to get major number %d for i2o_block\n",
-		       MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "i2o_block"))
 		return -EIO;
-	}
 
 	for (i = 0; i < MAX_I2OB; i++) {
 		struct gendisk *disk = alloc_disk(16);
diff -puN drivers/mtd/ftl.c~register_blkdev-cleanups drivers/mtd/ftl.c
--- 25/drivers/mtd/ftl.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/mtd/ftl.c	2003-03-07 12:24:11.000000000 -0800
@@ -1281,11 +1281,9 @@ int init_ftl(void)
 	static spinlock_t lock = SPIN_LOCK_UNLOCKED;
 	DEBUG(0, "$Id: ftl.c,v 1.39 2001/10/02 15:05:11 dwmw2 Exp $\n");
 
-	if (register_blkdev(FTL_MAJOR, "ftl", &ftl_blk_fops)) {
-		printk(KERN_NOTICE "ftl_cs: unable to grab major "
-		       "device number!\n");
+	if (register_blkdev(FTL_MAJOR, "ftl"))
 		return -EAGAIN;
-	}
+
 	blk_init_queue(&ftl_queue, &do_ftl_request, &lock);
 	register_mtd_user(&ftl_notifier);
 	return 0;
diff -puN drivers/mtd/mtdblock.c~register_blkdev-cleanups drivers/mtd/mtdblock.c
--- 25/drivers/mtd/mtdblock.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/mtd/mtdblock.c	2003-03-07 12:24:11.000000000 -0800
@@ -570,11 +570,10 @@ static spinlock_t mtddev_lock = SPIN_LOC
 int __init init_mtdblock(void)
 {
 	spin_lock_init(&mtdblks_lock);
-	if (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) {
-		printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
-		       MTD_BLOCK_MAJOR);
+
+	if (register_blkdev(MAJOR_NR, DEVICE_NAME))
 		return -EAGAIN;
-	}
+
 #ifdef CONFIG_DEVFS_FS
 	devfs_mk_dir(NULL, DEVICE_NAME, NULL);
 #endif
diff -puN drivers/mtd/mtdblock_ro.c~register_blkdev-cleanups drivers/mtd/mtdblock_ro.c
--- 25/drivers/mtd/mtdblock_ro.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/mtd/mtdblock_ro.c	2003-03-07 12:24:11.000000000 -0800
@@ -240,20 +240,13 @@ static struct mtd_notifier notifier = {
 
 int __init init_mtdblock(void)
 {
-	int err;
-
-	if (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) {
-		printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
-		       MTD_BLOCK_MAJOR);
-		err = -EAGAIN;
-		goto out;
-	}
+	if (register_blkdev(MAJOR_NR, DEVICE_NAME))
+		return -EAGAIN;
 
 	blk_init_queue(&mtdro_queue, &mtdblock_request, &mtdro_lock);
 	register_mtd_user(&notifier);
-	err = 0;
- out:
-	return err;
+
+	return 0;
 }
 
 static void __exit cleanup_mtdblock(void)
diff -puN drivers/mtd/nftlcore.c~register_blkdev-cleanups drivers/mtd/nftlcore.c
--- 25/drivers/mtd/nftlcore.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/mtd/nftlcore.c	2003-03-07 12:24:11.000000000 -0800
@@ -928,10 +928,8 @@ int __init init_nftl(void)
 	printk(KERN_INFO "NFTL driver: nftlcore.c $Revision: 1.82 $, nftlmount.c %s\n", nftlmountrev);
 #endif
 
-	if (register_blkdev(MAJOR_NR, "nftl", &nftl_fops)) {
-		printk("unable to register NFTL block device on major %d\n", MAJOR_NR);
+	if (register_blkdev(MAJOR_NR, "nftl"))
 		return -EBUSY;
-	}
 
 	blk_register_region(MKDEV(MAJOR_NR, 0), 256,
 			THIS_MODULE, nftl_probe, NULL, NULL);
diff -puN drivers/s390/block/dasd_genhd.c~register_blkdev-cleanups drivers/s390/block/dasd_genhd.c
--- 25/drivers/s390/block/dasd_genhd.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/s390/block/dasd_genhd.c	2003-03-07 12:24:11.000000000 -0800
@@ -60,11 +60,8 @@ dasd_register_major(int major)
 	}
 
 	/* Register block device. */
-	new_major = register_blkdev(major, "dasd", &dasd_device_operations);
+	new_major = register_blkdev(major, "dasd");
 	if (new_major < 0) {
-		MESSAGE(KERN_WARNING,
-			"Cannot register to major no %d, rc = %d",
-			major, new_major);
 		kfree(mi);
 		return new_major;
 	}
diff -puN drivers/s390/block/xpram.c~register_blkdev-cleanups drivers/s390/block/xpram.c
--- 25/drivers/s390/block/xpram.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/s390/block/xpram.c	2003-03-07 12:24:11.000000000 -0800
@@ -430,13 +430,11 @@ static int __init xpram_setup_blkdev(voi
 	/*
 	 * Register xpram major.
 	 */
-	rc = register_blkdev(XPRAM_MAJOR, XPRAM_NAME, &xpram_devops);
-	if (rc < 0) {
-		PRINT_ERR("Can't get xpram major %d\n", XPRAM_MAJOR);
+	rc = register_blkdev(XPRAM_MAJOR, XPRAM_NAME);
+	if (rc < 0)
 		goto out;
-	}
 
-	devfs_mk_dir (NULL, "slram", NULL);
+	devfs_mk_dir(NULL, "slram", NULL);
 
 	/*
 	 * Assign the other needed values: make request function, sizes and
@@ -452,6 +450,7 @@ static int __init xpram_setup_blkdev(voi
 	for (i = 0; i < xpram_devs; i++) {
 		struct gendisk *disk = xpram_disks[i];
 		char name[16];
+
 		xpram_devices[i].size = xpram_sizes[i] / 4;
 		xpram_devices[i].offset = offset;
 		offset += xpram_devices[i].size;
diff -puN drivers/s390/char/tape_block.c~register_blkdev-cleanups drivers/s390/char/tape_block.c
--- 25/drivers/s390/char/tape_block.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/s390/char/tape_block.c	2003-03-07 12:24:11.000000000 -0800
@@ -333,12 +333,10 @@ tapeblock_init(void)
 	int rc;
 
 	/* Register the tape major number to the kernel */
-	rc = register_blkdev(tapeblock_major, "tBLK", &tapeblock_fops);
-	if (rc < 0) {
-		PRINT_ERR("can't get major %d for block device\n",
-			  tapeblock_major);
+	rc = register_blkdev(tapeblock_major, "tBLK");
+	if (rc < 0)
 		return rc;
-	}
+
 	if (tapeblock_major == 0)
 		tapeblock_major = rc;
 	PRINT_INFO("tape gets major %d for block device\n", tapeblock_major);
diff -puN drivers/sbus/char/jsflash.c~register_blkdev-cleanups drivers/sbus/char/jsflash.c
--- 25/drivers/sbus/char/jsflash.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/sbus/char/jsflash.c	2003-03-07 12:24:11.000000000 -0800
@@ -570,9 +570,7 @@ static int jsfd_init(void)
 		jsfd_disk[i] = disk;
 	}
 
-	if (register_blkdev(JSFD_MAJOR, "jsfd", &jsfd_fops)) {
-		printk("jsfd_init: unable to get major number %d\n",
-		    JSFD_MAJOR);
+	if (register_blkdev(JSFD_MAJOR, "jsfd")) {
 		err = -EIO;
 		goto out;
 	}
diff -puN drivers/scsi/sd.c~register_blkdev-cleanups drivers/scsi/sd.c
--- 25/drivers/scsi/sd.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/scsi/sd.c	2003-03-07 12:24:11.000000000 -0800
@@ -1389,14 +1389,9 @@ static int __init init_sd(void)
 
 	SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
 
-	for (i = 0; i < SD_MAJORS; i++) {
-		if (register_blkdev(sd_major(i), "sd", &sd_fops))
-			printk(KERN_NOTICE
-			       "Unable to get major %d for SCSI disk\n",
-			       sd_major(i));
-		else
+	for (i = 0; i < SD_MAJORS; i++)
+		if (register_blkdev(sd_major(i), "sd") == 0)
 			majors++;
-	}
 
 	if (!majors)
 		return -ENODEV;
@@ -1409,7 +1404,7 @@ static int __init init_sd(void)
 }
 
 /**
- *	exit_sd - exit point for this driver (when it is	a module).
+ *	exit_sd - exit point for this driver (when it is a module).
  *
  *	Note: this function unregisters this driver from the scsi mid-level.
  **/
diff -puN drivers/scsi/sr.c~register_blkdev-cleanups drivers/scsi/sr.c
--- 25/drivers/scsi/sr.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/scsi/sr.c	2003-03-07 12:24:11.000000000 -0800
@@ -835,7 +835,7 @@ static int __init init_sr(void)
 {
 	int rc;
 
-	rc = register_blkdev(SCSI_CDROM_MAJOR, "sr", &sr_bdops);
+	rc = register_blkdev(SCSI_CDROM_MAJOR, "sr");
 	if (rc)
 		return rc;
 	return scsi_register_device(&sr_template);
diff -puN drivers/scsi/sym53c8xx_2/sym_hipd.c~register_blkdev-cleanups drivers/scsi/sym53c8xx_2/sym_hipd.c
--- 25/drivers/scsi/sym53c8xx_2/sym_hipd.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/drivers/scsi/sym53c8xx_2/sym_hipd.c	2003-03-07 12:24:11.000000000 -0800
@@ -221,7 +221,7 @@ static void sym_chip_reset (hcb_p np)
  */
 static void sym_soft_reset (hcb_p np)
 {
-	u_char istat;
+	u_char istat = 0;
 	int i;
 
 	if (!(np->features & FE_ISTAT1) || !(INB (nc_istat1) & SCRUN))
diff -puN fs/block_dev.c~register_blkdev-cleanups fs/block_dev.c
--- 25/fs/block_dev.c~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/fs/block_dev.c	2003-03-07 12:24:11.000000000 -0800
@@ -436,56 +436,6 @@ void bd_release(struct block_device *bde
 	spin_unlock(&bdev_lock);
 }
 
-static const char *blkdevs[MAX_BLKDEV];
-
-int get_blkdev_list(char * p)
-{
-	int i;
-	int len;
-
-	len = sprintf(p, "\nBlock devices:\n");
-	for (i = 0; i < MAX_BLKDEV ; i++) {
-		if (blkdevs[i])
-			len += sprintf(p+len, "%3d %s\n", i, blkdevs[i]);
-	}
-	return len;
-}
-
-int register_blkdev(unsigned int major, const char * name, struct block_device_operations *bdops)
-{
-	if (devfs_only())
-		return 0;
-	if (major == 0) {
-		for (major = MAX_BLKDEV-1; major > 0; major--) {
-			if (blkdevs[major] == NULL) {
-				blkdevs[major] = name;
-				return major;
-			}
-		}
-		return -EBUSY;
-	}
-	if (major >= MAX_BLKDEV)
-		return -EINVAL;
-	if (blkdevs[major])
-		return -EBUSY;
-	blkdevs[major] = name;
-	return 0;
-}
-
-int unregister_blkdev(unsigned int major, const char * name)
-{
-	if (devfs_only())
-		return 0;
-	if (major >= MAX_BLKDEV)
-		return -EINVAL;
-	if (!blkdevs[major])
-		return -EINVAL;
-	if (strcmp(blkdevs[major], name))
-		return -EINVAL;
-	blkdevs[major] = NULL;
-	return 0;
-}
-
 /*
  * This routine checks whether a removable media has been changed,
  * and invalidates all buffer-cache-entries in that case. This
@@ -786,18 +736,6 @@ int ioctl_by_bdev(struct block_device *b
 	return res;
 }
 
-const char *__bdevname(dev_t dev)
-{
-	static char buffer[32];
-	const char * name = blkdevs[MAJOR(dev)];
-
-	if (!name)
-		name = "unknown-block";
-
-	sprintf(buffer, "%s(%d,%d)", name, MAJOR(dev), MINOR(dev));
-	return buffer;
-}
-
 /**
  * lookup_bdev  - lookup a struct block_device by name
  *
diff -puN include/linux/fs.h~register_blkdev-cleanups include/linux/fs.h
--- 25/include/linux/fs.h~register_blkdev-cleanups	2003-03-07 12:24:11.000000000 -0800
+++ 25-akpm/include/linux/fs.h	2003-03-07 12:24:11.000000000 -0800
@@ -1033,7 +1033,7 @@ extern void vfs_caches_init(unsigned lon
 #define putname(name)	kmem_cache_free(names_cachep, (void *)(name))
 
 enum {BDEV_FILE, BDEV_SWAP, BDEV_FS, BDEV_RAW};
-extern int register_blkdev(unsigned int, const char *, struct block_device_operations *);
+extern int register_blkdev(unsigned int, const char *);
 extern int unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern int bd_acquire(struct inode *inode);

_