[PATCH] register_blkdev cleanups

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.

diff --git a/Documentation/cdrom/cdrom-standard.tex b/Documentation/cdrom/cdrom-standard.tex
index 61becaf07f4662cbdba5a6da9d8fd07d41869374..af1c93a32780bfe221d50514b4b5914821ded060 100644 (file)
--- a/Documentation/cdrom/cdrom-standard.tex
+++ b/Documentation/cdrom/cdrom-standard.tex
@@ -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 --git a/arch/m68k/atari/stram.c b/arch/m68k/atari/stram.c
index 0e73a2738505028cdba6c14f96b79d2168145a89..f1aa429b55b946a59cca06c8fe02f45e368a2d4b 100644 (file)
--- a/arch/m68k/atari/stram.c
+++ b/arch/m68k/atari/stram.c
@@ -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 --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index a58e43236476ae3e03157503ee5819513925c069..578e1c257b1448cf46868aacf884d21a4f124304 100644 (file)
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -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 --git a/drivers/acorn/block/fd1772.c b/drivers/acorn/block/fd1772.c
index 2802dc2e84e08a043c727002f7c7c35603ac3781..2a344695c35b61887cf1ca914bc0e99aaaa6b513 100644 (file)
--- a/drivers/acorn/block/fd1772.c
+++ b/drivers/acorn/block/fd1772.c
@@ -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 --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index fa97305e4c5bf391edc6f9ff0e4e5f48a05ff928..172b48006da3bff198cc3e17a0540d0c5f95cbd0 100644 (file)
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -1267,11 +1267,9 @@ static int mfm_do_init(unsigned char irqmask)
        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 --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 3582ba2fcca094b8f7882b7ada2d1c397c6ea19a..ecad76d1065b57641e61fb05352075c55ac63d1f 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -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_RegisterBlockDevice(DAC960_Controller_T *Controller)
   /*
     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 --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index 958ef4898971d0e4dbcc0e9617fe5119ee5a0c66..ea581f6547d4c085d971859e808452e7ba06b72b 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -1613,7 +1613,6 @@ void acsi_attach_SLMs( int (*attach_func)( int, int ) )
 
 
 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 --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 85728c00645f2c0f42463512674716ebc9995ab6..92421246412339a882adf02a930bf979fa9e82d1 100644 (file)
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -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 --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index c9dc16a8059ec98c94bdf792cfe4ab7046a13b83..f0f36de7fcda8554ac6dae31189d0bc64e0879eb 100644 (file)
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -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 --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 57e19f868bad69875f3738d72e8f35b46e60792e..734ae3817430a1a57d0624f62c84888be67ae234 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2451,14 +2451,12 @@ static int __init cciss_init_one(struct pci_dev *pdev,
                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 --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index fdb49eb4cb4c867d0b1ea472106871094b347231..8c125708b5827995ee6e843625787897e43cf75d 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -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 --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 74f15dc320d332eb6d2ca499188585e81bb739e8..d3d20c946e306717b317c1dc21db895c3fa2a829 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -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 --git a/drivers/block/genhd.c b/drivers/block/genhd.c
index dabb8fa2d211882d0a90f424b2809084cfc55c5c..7d7af54b0ba5dc6b1d55d8820b6d92c0c5845701 100644 (file)
--- a/drivers/block/genhd.c
+++ b/drivers/block/genhd.c
@@ -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, unsigned long range, struct module *module,
        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 *data)
 
 /**
  * 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 --git a/drivers/block/loop.c b/drivers/block/loop.c
index 6c841086ed2ec3c9890abcdd03c7c84c44b503aa..349d1341c1a97b002a41e90edfd2f2058afc0703 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -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 --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 8aa52f3e5a73471b7b35452742c7ea1642ea373b..001b2f98267efd12afaa2e46c7e206bce0fe93e7 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -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 --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 474a73cf10cbf081676e4351fd64aaf90d7b9feb..4e2335b6fc724e17bf3529824903f7d2ab207f73 100644 (file)
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -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 --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 8de1dd1740050a31d8e2501e2bceffa6974d8847..144c42fbca50f000df28a1a57adf0131ba2ccced 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -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 --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 89f101ef19360c917f6cdc92e23d4ca093221535..73a3703b3c1d1ba35e5ad6d11c5950dbb74bbed1 100644 (file)
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -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 --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 0520b009068490f9c5bd5da653532d6215e95aa8..b71b02fabdf1dfdef7298df3dae259ef4ef8bef0 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -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 --git a/drivers/block/rd.c b/drivers/block/rd.c
index 198c8f13b7e61a921d363d79b8f6f4721a9f2bc3..2bab480f3db9af84bac25a7e8611cf561ddebe3a 100644 (file)
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -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 --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 98d75f23f0b1a15c468491c129d039cd1eb60e1d..307adb947b39a9d9a15231f2b5dbc2328b6c7b43 100644 (file)
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -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 --git a/drivers/block/swim_iop.c b/drivers/block/swim_iop.c
index 755fc9c3a81f142e6c74a8f2b3ab0bff1e72c194..e96d4362b24cc108e038d9c81770662d3d62cbe3 100644 (file)
--- a/drivers/block/swim_iop.c
+++ b/drivers/block/swim_iop.c
@@ -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 --git a/drivers/block/umem.c b/drivers/block/umem.c
index a2b27e67197cc8c9db2f59ad07de40ec9821e548..9de1ff737e3b56819c19646bce268a1324ef7d2e 100644 (file)
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -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 --git a/drivers/block/xd.c b/drivers/block/xd.c
index ccc5c181d5b0429f9086958a5478b108b5e7f6c1..a3a7eb9a1969ee4f784125a040bdf3b17e8e182d 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -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 --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 263772c3ae1a747b3d33ab28abff2201004558e9..cac3ee05bfb099e576efe0635d941598e1f814c8 100644 (file)
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -331,21 +331,18 @@ static struct gendisk *z2_find(dev_t dev, int *part, void *data)
 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 --git a/drivers/cdrom/aztcd.c b/drivers/cdrom/aztcd.c
index 82fcdacc42cf6462c556a8eea9ac262d55507dbe..0171a9ea0b405a22f6d134d9602c7843da0bede3 100644 (file)
--- a/drivers/cdrom/aztcd.c
+++ b/drivers/cdrom/aztcd.c
@@ -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 --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index 686fe183eb1bb3af86f2361e7bcff8e0006b86d6..f25d9ff0fda21737857a0f01cd24a7fa14c246fe 100644 (file)
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -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 --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index adb364c76b6db77c04f9371bf23f353e417d8ad7..3fb0301e028de1907b6e2b43a3d65ca087185fff 100644 (file)
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -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 --git a/drivers/cdrom/gscd.c b/drivers/cdrom/gscd.c
index e73f26688ee143886400e6be5c4aa353c119627a..209e5c2eb5165b3eb9662289743aa84533240aee 100644 (file)
--- a/drivers/cdrom/gscd.c
+++ b/drivers/cdrom/gscd.c
@@ -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 --git a/drivers/cdrom/mcd.c b/drivers/cdrom/mcd.c
index a7525648f0b6aa44d68d3158dd3f66c6852188a4..48cbb70d3ccf006b5b80b09f9f81670f800396a6 100644 (file)
--- a/drivers/cdrom/mcd.c
+++ b/drivers/cdrom/mcd.c
@@ -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 --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index 797e722db5f03d03abbefa4913b435de3cfa4cce..8abd7a0de3119fccb723c9109208fc4f5fcca705 100644 (file)
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -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 --git a/drivers/cdrom/optcd.c b/drivers/cdrom/optcd.c
index aee471e57900273c5e13626a111f280bb69120e2..c7486e2f44f598f5a2f3440059f454238f16b344 100644 (file)
--- a/drivers/cdrom/optcd.c
+++ b/drivers/cdrom/optcd.c
@@ -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 --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index 2a4916d5d380a3cc460f9c14cd4f9b6609506c64..367c12200fe184091e42599dbd29857247af077a 100644 (file)
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -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 --git a/drivers/cdrom/sjcd.c b/drivers/cdrom/sjcd.c
index 02586e173fd3445d213e87d2729023b408ef3322..63e909879b9fe08fb38b10b41e322d8956160567 100644 (file)
--- a/drivers/cdrom/sjcd.c
+++ b/drivers/cdrom/sjcd.c
@@ -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 --git a/drivers/cdrom/sonycd535.c b/drivers/cdrom/sonycd535.c
index b423426342059f17f11435ed3c1b246880827d9e..4a5730de8af69982833048dc1299eadbdf8fbdb5 100644 (file)
--- a/drivers/cdrom/sonycd535.c
+++ b/drivers/cdrom/sonycd535.c
@@ -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 --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 5b5dbabe1f311154e6d58d4580fd3ddfb7004376..01dc2731c613489c511ac3ed62af762baa2478f9 100644 (file)
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -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 --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index 2aecdfba56c70a5c65a38a552c902e1a65ba27b8..d4e6dbbb929b200fed1167a85188151a365fc27c 100644 (file)
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -708,10 +708,10 @@ static struct block_device_operations hd_fops = {
 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 --git a/drivers/md/dm.c b/drivers/md/dm.c
index 53bca757a52341c2d3b36fe0311dc77e8f85452e..60bd488baece2b15d3c6d8219c2956ee05e4ca31 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -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 --git a/drivers/md/md.c b/drivers/md/md.c
index c5314a2c3719678d561dabf558d9c948f1d3e252..a3d5a2a29bd614ff32fd2958ee68a480436d6715 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -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 --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 24adce65bd114dc5a0b3fe2c57c1604cb23a967d..3d4437cc2512dec91556c5bc3c166672fd116047 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -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 --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 0ffe4751e857ea1c60bb169138373e00514fa078..fa7ab618f07fb37117a2ac0eefd73770d4eae7a1 100644 (file)
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -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 --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index af065e4af4cff931cb4e043b623157ed3fac5492..f9b011626309669a8c746039db8e2fa509daf5fa 100644 (file)
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -570,11 +570,10 @@ static spinlock_t mtddev_lock = SPIN_LOCK_UNLOCKED;
 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 --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index 297672ef1271979496dc979be81b63032e06d0fa..950d2f5650da0b36da39d69eef0dfe6e7114ceb3 100644 (file)
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -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 --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index b4d8d5599986451a062cf14fc531cdd6743fdc6f..1b99e2a0c07048b7283b1132ac05bf74fda5abe0 100644 (file)
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -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 --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 3a150a9ee099406194e025950f89d00ef8ee4dbc..441ae4bd369d168689bba06e8d516759fceb6138 100644 (file)
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -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 --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index e57cbccb59b02aa9d8fef9e20cca0151adca3c7c..727030ba524c37359f080c3b7a89de1ba7a2fc9f 100644 (file)
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -430,13 +430,11 @@ static int __init xpram_setup_blkdev(void)
        /*
         * 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(void)
        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 --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 10c6de10d4906e58c7c912d92b17179ff3ab4d37..6731a38d82be6cb9885c78e73d172ff75a7877ea 100644 (file)
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -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 --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index 015f43841377fe0b9c531ccd850079b6ec68e219..81cdfbfa47b114a4becc12884574e6ba625ca76d 100644 (file)
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -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 --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index ab2c022e717f5e1e7a63a07346d202a15ec3c7d0..12803f527e33fe64bd14254b10b63d97844b51b5 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -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 --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index e7bd41baaad4943d08ffd553281875a0228c0435..89d24606238833bb1a5340bbdeca16f21290d13a 100644 (file)
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -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 --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index 53b204acda751ae6fb74f3b233a3273fb610780c..4f3445f214a1483116fd072990bba2ad82f713dd 100644 (file)
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -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 --git a/fs/block_dev.c b/fs/block_dev.c
index 7fe897e0013dd5e0759942935d8c509570169c1d..d46f44fb0d47b011548b9ebf83fb2f7a12b86697 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -436,56 +436,6 @@ void bd_release(struct block_device *bdev)
        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 *bdev, unsigned cmd, unsigned long arg)
        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 --git a/include/linux/fs.h b/include/linux/fs.h
index 85e915b19ec12b5fa503725d4c0ce49e6e700e47..e7706105ac86f51fac847bdc31cae55e77f7f7fe 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1033,7 +1033,7 @@ extern void vfs_caches_init(unsigned long);
 #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);