Removed devfs_register_blkdev and devfs_unregister_blkdev.

Use register_blkdev and unregister_blkdev as before, and everything will work just fine.

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 59e4b53dfce532f37f930475848266b6bf09acf4..be68e7e539bca9736ac1bd5575ab2c4d5246d851 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -1934,7 +1934,7 @@ static boolean DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
   /*
     Register the Block Device Major Number for this DAC960 Controller.
   */
-  if (devfs_register_blkdev(MajorNumber, "dac960",
+  if (register_blkdev(MajorNumber, "dac960",
                            &DAC960_BlockDeviceOperations) < 0)
     {
       DAC960_Error("UNABLE TO ACQUIRE MAJOR NUMBER %d - DETACHING\n",
@@ -1993,7 +1993,7 @@ static void DAC960_UnregisterBlockDevice(DAC960_Controller_T *Controller)
   /*
     Unregister the Block Device Major Number for this DAC960 Controller.
   */
-  devfs_unregister_blkdev(MajorNumber, "dac960");
+  unregister_blkdev(MajorNumber, "dac960");
   /*
     Remove the I/O Request Queue.
   */

diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index 48c250892cde98fe27ed362612fc906eb04032d8..0e1aa84e691b08d01216beec537856aef1f1e766 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -56,7 +56,6 @@
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/genhd.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
 #include <linux/major.h>
@@ -1741,14 +1740,14 @@ int acsi_init( void )
        int err = 0;
        if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ACSI))
                return 0;
-       if (devfs_register_blkdev( MAJOR_NR, "ad", &acsi_fops )) {
+       if (register_blkdev( MAJOR_NR, "ad", &acsi_fops )) {
                printk( KERN_ERR "Unable to get major %d for ACSI\n", MAJOR_NR );
                return -EBUSY;
        }
        if (!(acsi_buffer =
                  (char *)atari_stram_alloc(ACSI_BUFFER_SIZE, "acsi"))) {
                printk( KERN_ERR "Unable to get ACSI ST-Ram buffer.\n" );
-               devfs_unregister_blkdev( MAJOR_NR, "ad" );
+               unregister_blkdev( MAJOR_NR, "ad" );
                return -ENOMEM;
        }
        phys_acsi_buffer = virt_to_phys( acsi_buffer );
@@ -1786,7 +1785,7 @@ void cleanup_module(void)
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
        atari_stram_free( acsi_buffer );
 
-       if (devfs_unregister_blkdev( MAJOR_NR, "ad" ) != 0)
+       if (unregister_blkdev( MAJOR_NR, "ad" ) != 0)
                printk( KERN_ERR "acsi: cleanup_module failed\n");
 
        del_gendisk(&acsi_gendisk);

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 262808665d82f80d1cb5b2ca6d698bc602d75fd7..97e1b16e16fad5e492a9bb56432d5291704c2706 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4233,7 +4233,7 @@ int __init floppy_init(void)
        raw_cmd = NULL;
 
        devfs_handle = devfs_mk_dir (NULL, "floppy", NULL);
-       if (devfs_register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
+       if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
                printk("Unable to get major %d for floppy\n",MAJOR_NR);
                return -EBUSY;
        }
@@ -4266,7 +4266,7 @@ int __init floppy_init(void)
        use_virtual_dma = can_use_virtual_dma & 1;
        fdc_state[0].address = FDC1;
        if (fdc_state[0].address == -1) {
-               devfs_unregister_blkdev(MAJOR_NR,"fd");
+               unregister_blkdev(MAJOR_NR,"fd");
                del_timer(&fd_timeout);
                blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
                return -ENODEV;
@@ -4279,7 +4279,7 @@ int __init floppy_init(void)
        if (floppy_grab_irq_and_dma()){
                del_timer(&fd_timeout);
                blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
-               devfs_unregister_blkdev(MAJOR_NR,"fd");
+               unregister_blkdev(MAJOR_NR,"fd");
                return -EBUSY;
        }
 
@@ -4342,7 +4342,7 @@ int __init floppy_init(void)
                if (usage_count)
                        floppy_release_irq_and_dma();
                blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
-               devfs_unregister_blkdev(MAJOR_NR,"fd");
+               unregister_blkdev(MAJOR_NR,"fd");
        }
        
        for (drive = 0; drive < N_DRIVE; drive++) {
@@ -4539,7 +4539,7 @@ void cleanup_module(void)
        int dummy;
                
        devfs_unregister (devfs_handle);
-       devfs_unregister_blkdev(MAJOR_NR, "fd");
+       unregister_blkdev(MAJOR_NR, "fd");
 
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
        /* eject disk, if any */

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 50c1052cae74f75d20debe08b4b4ad37ce4d6d6c..8235f3e205ff74349904aad1a5a6c42b51333366 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1027,7 +1027,7 @@ int __init loop_init(void)
                max_loop = 8;
        }
 
-       if (devfs_register_blkdev(MAJOR_NR, "loop", &lo_fops)) {
+       if (register_blkdev(MAJOR_NR, "loop", &lo_fops)) {
                printk(KERN_WARNING "Unable to get major number %d for loop"
                                    " device\n", MAJOR_NR);
                return -EIO;
@@ -1078,7 +1078,7 @@ out_mem:
 void loop_exit(void) 
 {
        devfs_unregister(devfs_handle);
-       if (devfs_unregister_blkdev(MAJOR_NR, "loop"))
+       if (unregister_blkdev(MAJOR_NR, "loop"))
                printk(KERN_WARNING "loop: cannot unregister blkdev\n");
 
        kfree(loop_dev);

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index f9b681ac6b868c657cb20ce2d510f2e4576e831e..a54a532bc70c3d7388480cfae182790423347573 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -940,7 +940,7 @@ static int __init pd_init(void)
        int unit;
 
        if (disable) return -1;
-        if (devfs_register_blkdev(MAJOR_NR,name,&pd_fops)) {
+        if (register_blkdev(MAJOR_NR,name,&pd_fops)) {
                 printk("%s: unable to get major number %d\n",
                         name,major);
                 return -1;
@@ -958,7 +958,7 @@ static int __init pd_init(void)
        pd_init_units();
        pd_gendisk.nr_real = pd_detect();
         if (!pd_gendisk.nr_real) {
-               devfs_unregister_blkdev(MAJOR_NR, name);
+               unregister_blkdev(MAJOR_NR, name);
                del_gendisk(&pd_gendisk);
                for (unit=0; unit<PD_UNITS; unit++) 
                        if (PD.present)
@@ -971,7 +971,7 @@ static int __init pd_init(void)
 static void __exit pd_exit(void)
 {
        int unit;
-       devfs_unregister_blkdev(MAJOR_NR, name);
+       unregister_blkdev(MAJOR_NR, name);
        del_gendisk(&pd_gendisk);
        for (unit=0; unit<PD_UNITS; unit++) 
                if (PD.present)

diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 1d734f15cab2a98f07ff7ac0d218ae53f65373f9..93d5bcf5cb12b909ff90ad894ccf7400e0043118 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -43,7 +43,6 @@
 #include <linux/kernel.h>
 #include <linux/genhd.h>
 #include <linux/ps2esdi.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/blk.h>
 #include <linux/blkpg.h>
 #include <linux/mca.h>
@@ -168,7 +167,7 @@ int __init ps2esdi_init(void)
 
        /* register the device - pass the name, major number and operations
           vector .                                                 */
-       if (devfs_register_blkdev(MAJOR_NR, "ed", &ps2esdi_fops)) {
+       if (register_blkdev(MAJOR_NR, "ed", &ps2esdi_fops)) {
                printk("%s: Unable to get major number %d\n", DEVICE_NAME, MAJOR_NR);
                return -1;
        }
@@ -182,7 +181,7 @@ int __init ps2esdi_init(void)
        if (error) {
                printk(KERN_WARNING "PS2ESDI: error initialising"
                        " device, releasing resources\n");
-               devfs_unregister_blkdev(MAJOR_NR, "ed");
+               unregister_blkdev(MAJOR_NR, "ed");
                blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
                del_gendisk(&ps2esdi_gendisk);
                blk_clear(MAJOR_NR);
@@ -233,7 +232,7 @@ cleanup_module(void) {
        release_region(io_base, 4);
        free_dma(dma_arb_level);
        free_irq(PS2ESDI_IRQ, &ps2esdi_gendisk);
-       devfs_unregister_blkdev(MAJOR_NR, "ed");
+       unregister_blkdev(MAJOR_NR, "ed");
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
        del_gendisk(&ps2esdi_gendisk);
        blk_clear(MAJOR_NR);

diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 92180c3c51085887b8ebaaebfbaca5fd66262be4..dff2ddec1fa305bcfb0544a8920fe663f699ebcf 100644 (file)
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -1034,7 +1034,7 @@ int swim3_init(void)
 
        if (floppy_count > 0)
        {
-               if (devfs_register_blkdev(MAJOR_NR, "fd", &floppy_fops)) {
+               if (register_blkdev(MAJOR_NR, "fd", &floppy_fops)) {
                        printk(KERN_ERR "Unable to get major %d for floppy\n",
                               MAJOR_NR);
                        return -EBUSY;

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index a1166a4e13940edb1d0561d294764be153ea0bcc..cbb195f05c96f9ae5fe9b8d25c8dedde08f8b6e3 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -164,7 +164,7 @@ int __init xd_init (void)
        init_timer (&xd_timer); xd_timer.function = xd_wakeup;
        init_timer (&xd_watchdog_int); xd_watchdog_int.function = xd_watchdog;
 
-       if (devfs_register_blkdev(MAJOR_NR,"xd",&xd_fops)) {
+       if (register_blkdev(MAJOR_NR,"xd",&xd_fops)) {
                printk("xd: Unable to get major number %d\n",MAJOR_NR);
                return -1;
        }
@@ -1085,7 +1085,7 @@ int init_module(void)
        printk(KERN_INFO "XD: Loaded as a module.\n");
        if (!xd_drives) {
                /* no drives detected - unload module */
-               devfs_unregister_blkdev(MAJOR_NR, "xd");
+               unregister_blkdev(MAJOR_NR, "xd");
                xd_done();
                return (-1);
        }
@@ -1095,7 +1095,7 @@ int init_module(void)
 
 void cleanup_module(void)
 {
-       devfs_unregister_blkdev(MAJOR_NR, "xd");
+       unregister_blkdev(MAJOR_NR, "xd");
        xd_done();
        devfs_unregister (devfs_handle);
        if (xd_drives) {

diff --git a/drivers/cdrom/aztcd.c b/drivers/cdrom/aztcd.c
index 5f8449ce1c6b22494aacf57853ea5b9d7b68c5e9..8ad58c7b1441615834e0f19821826b4fa041a3f6 100644 (file)
--- a/drivers/cdrom/aztcd.c
+++ b/drivers/cdrom/aztcd.c
@@ -1931,7 +1931,7 @@ int __init aztcd_init(void)
        }
        devfs_register(NULL, "aztcd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
                       S_IFBLK | S_IRUGO | S_IWUGO, &azt_fops, NULL);
-       if (devfs_register_blkdev(MAJOR_NR, "aztcd", &azt_fops) != 0) {
+       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);
                ret = -EIO;
@@ -1958,7 +1958,7 @@ int __init aztcd_init(void)
 void __exit aztcd_exit(void)
 {
        devfs_find_and_unregister(NULL, "aztcd", 0, 0, DEVFS_SPECIAL_BLK, 0);
-       if ((devfs_unregister_blkdev(MAJOR_NR, "aztcd") == -EINVAL)) {
+       if ((unregister_blkdev(MAJOR_NR, "aztcd") == -EINVAL)) {
                printk("What's that: can't unregister aztcd\n");
                return;
        }

diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index b57c880afe27f5697f59e86f8b907b682f988a24..ab5136e928963de29916cc8d90e8346eaf63c4b7 100644 (file)
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -3367,7 +3367,7 @@ int __init cdu31a_init(void)
                if (!request_region(cdu31a_port, 4, "cdu31a"))
                        goto errout3;
 
-               if (devfs_register_blkdev(MAJOR_NR, "cdu31a", &scd_bdops)) {
+               if (register_blkdev(MAJOR_NR, "cdu31a", &scd_bdops)) {
                        printk("Unable to get major %d for CDU-31a\n",
                               MAJOR_NR);
                        goto errout2;
@@ -3460,7 +3460,7 @@ int __init cdu31a_init(void)
       errout0:
        printk("Unable to register CDU-31a with Uniform cdrom driver\n");
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
-       if (devfs_unregister_blkdev(MAJOR_NR, "cdu31a")) {
+       if (unregister_blkdev(MAJOR_NR, "cdu31a")) {
                printk("Can't unregister block device for cdu31a\n");
        }
       errout2:
@@ -3477,7 +3477,7 @@ void __exit cdu31a_exit(void)
                    ("Can't unregister cdu31a from Uniform cdrom driver\n");
                return;
        }
-       if ((devfs_unregister_blkdev(MAJOR_NR, "cdu31a") == -EINVAL)) {
+       if ((unregister_blkdev(MAJOR_NR, "cdu31a") == -EINVAL)) {
                printk("Can't unregister cdu31a\n");
                return;
        }

diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index 0b5facfd1c2826f63bf86c595f299d418b83253a..9d6b0767e1bd8117e848d45e98691d652eaba5e9 100644 (file)
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -1367,7 +1367,7 @@ static void cleanup(int level)
                        printk("Can't unregister cdrom cm206\n");
                        return;
                }
-               if (devfs_unregister_blkdev(MAJOR_NR, "cm206")) {
+               if (unregister_blkdev(MAJOR_NR, "cm206")) {
                        printk("Can't unregister major cm206\n");
                        return;
                }
@@ -1490,7 +1490,7 @@ int __init cm206_init(void)
                return -EIO;
        }
        printk(".\n");
-       if (devfs_register_blkdev(MAJOR_NR, "cm206", &cm206_bdops) != 0) {
+       if (register_blkdev(MAJOR_NR, "cm206", &cm206_bdops) != 0) {
                printk(KERN_INFO "Cannot register for major %d!\n",
                       MAJOR_NR);
                cleanup(3);

diff --git a/drivers/cdrom/gscd.c b/drivers/cdrom/gscd.c
index 90f510585cb4cce2f3ac876f37b700d7b4bf5518..b37b983eeaadaf9583df46b7a1323afcfb66efa4 100644 (file)
--- a/drivers/cdrom/gscd.c
+++ b/drivers/cdrom/gscd.c
@@ -934,7 +934,7 @@ void __exit exit_gscd(void)
        CLEAR_TIMER;
 
        devfs_find_and_unregister(NULL, "gscd", 0, 0, DEVFS_SPECIAL_BLK, 0);
-       if ((devfs_unregister_blkdev(MAJOR_NR, "gscd") == -EINVAL)) {
+       if ((unregister_blkdev(MAJOR_NR, "gscd") == -EINVAL)) {
                printk("What's that: can't unregister GoldStar-module\n");
                return;
        }
@@ -1012,7 +1012,7 @@ int __init my_gscd_init(void)
                i++;
        }
 
-       if (devfs_register_blkdev(MAJOR_NR, "gscd", &gscd_fops) != 0) {
+       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);
                ret = -EIO;

diff --git a/drivers/cdrom/mcd.c b/drivers/cdrom/mcd.c
index a948dbcac9eabe762ebc813debfd2a10377f9c6b..c4db9209059d3ba98a96911cb1e5c0f29ff3e1d9 100644 (file)
--- a/drivers/cdrom/mcd.c
+++ b/drivers/cdrom/mcd.c
@@ -1039,7 +1039,7 @@ static void cleanup(int level)
        case 2:
                release_region(mcd_port, 4);
        case 1:
-               if (devfs_unregister_blkdev(MAJOR_NR, "mcd")) {
+               if (unregister_blkdev(MAJOR_NR, "mcd")) {
                        printk(KERN_WARNING "Can't unregister major mcd\n");
                        return;
                }
@@ -1065,7 +1065,7 @@ int __init mcd_init(void)
                return -EIO;
        }
 
-       if (devfs_register_blkdev(MAJOR_NR, "mcd", &mcd_bdops) != 0) {
+       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);
                return -EIO;
        }

diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index 922bcd644048a631604624551e61beff562c2743..7567fb2a6dc14fa58b90a42767e26ac297149a4b 100644 (file)
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -1166,7 +1166,7 @@ int __init mcdx_init_drive(int drive)
        }
 
        xtrace(INIT, "init() register blkdev\n");
-       if (devfs_register_blkdev(MAJOR_NR, "mcdx", &mcdx_bdops) != 0) {
+       if (register_blkdev(MAJOR_NR, "mcdx", &mcdx_bdops) != 0) {
                release_region((unsigned long) stuffp->wreg_data,
                               MCDX_IO_SIZE);
                xwarn("%s=0x%3p,%d: Init failed. Can't get major %d.\n",
@@ -1222,7 +1222,7 @@ int __init mcdx_init_drive(int drive)
                               MCDX_IO_SIZE);
                free_irq(stuffp->irq, NULL);
                kfree(stuffp);
-               if (devfs_unregister_blkdev(MAJOR_NR, "mcdx") != 0)
+               if (unregister_blkdev(MAJOR_NR, "mcdx") != 0)
                        xwarn("cleanup() unregister_blkdev() failed\n");
                blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
                return 2;

diff --git a/drivers/cdrom/optcd.c b/drivers/cdrom/optcd.c
index b8a6aa0e991a2d11359accde8540216dbefc6b62..cb5a01220b25c2cb58d2d90feb99b770578dc17a 100644 (file)
--- a/drivers/cdrom/optcd.c
+++ b/drivers/cdrom/optcd.c
@@ -2031,8 +2031,7 @@ int __init optcd_init(void)
                DEBUG((DEBUG_VFS, "exec_cmd COMINITDOUBLE: %02x", -status));
                return -EIO;
        }
-       if (devfs_register_blkdev(MAJOR_NR, "optcd", &opt_fops) != 0)
-       {
+       if (register_blkdev(MAJOR_NR, "optcd", &opt_fops) != 0) {
                printk(KERN_ERR "optcd: unable to get major %d\n", MAJOR_NR);
                release_region(optcd_port, 4);
                return -EIO;
@@ -2052,7 +2051,7 @@ int __init optcd_init(void)
 void __exit optcd_exit(void)
 {
        devfs_find_and_unregister(NULL, "optcd", 0, 0, DEVFS_SPECIAL_BLK, 0);
-       if (devfs_unregister_blkdev(MAJOR_NR, "optcd") == -EINVAL) {
+       if (unregister_blkdev(MAJOR_NR, "optcd") == -EINVAL) {
                printk(KERN_ERR "optcd: what's that: can't unregister\n");
                return;
        }

diff --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index 937c5f444828e994239bfde9a3a049001800ebcc..c822f2d3546e3047715cf34da88722153ad5d3ad 100644 (file)
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -5771,7 +5771,7 @@ int __init sbpcd_init(void)
        OUT(MIXER_data,0xCC); /* one nibble per channel, max. value: 0xFF */
 #endif /* SOUND_BASE */
 
-       if (devfs_register_blkdev(MAJOR_NR, major_name, &sbpcd_bdops) != 0)
+       if (register_blkdev(MAJOR_NR, major_name, &sbpcd_bdops) != 0)
        {
                msg(DBG_INF, "Can't get MAJOR %d for Matsushita CDROM\n", MAJOR_NR);
 #ifdef MODULE
@@ -5806,7 +5806,7 @@ int __init sbpcd_init(void)
                if (D_S[j].sbp_buf==NULL)
                {
                        msg(DBG_INF,"data buffer (%d frames) not available.\n",D_S[j].sbp_bufsiz);
-                       if ((devfs_unregister_blkdev(MAJOR_NR, major_name) == -EINVAL))
+                       if ((unregister_blkdev(MAJOR_NR, major_name) == -EINVAL))
                        {
                                printk("Can't unregister %s\n", major_name);
                        }
@@ -5858,7 +5858,7 @@ void sbpcd_exit(void)
 {
        int j;
        
-       if ((devfs_unregister_blkdev(MAJOR_NR, major_name) == -EINVAL))
+       if ((unregister_blkdev(MAJOR_NR, major_name) == -EINVAL))
        {
                msg(DBG_INF, "What's that: can't unregister %s.\n", major_name);
                return;

diff --git a/drivers/cdrom/sjcd.c b/drivers/cdrom/sjcd.c
index 0619f9f58ceb31cb9ac23b027968550d72a1798c..e152f72a2a1570a71f1656be929902c21ced91a6 100644 (file)
--- a/drivers/cdrom/sjcd.c
+++ b/drivers/cdrom/sjcd.c
@@ -1680,7 +1680,7 @@ int __init sjcd_init(void)
        printk("SJCD: sjcd=0x%x: ", sjcd_base);
 #endif
 
-       if (devfs_register_blkdev(MAJOR_NR, "sjcd", &sjcd_fops) != 0) {
+       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);
@@ -1789,7 +1789,7 @@ int __init sjcd_init(void)
 
 static int sjcd_cleanup(void)
 {
-       if ((devfs_unregister_blkdev(MAJOR_NR, "sjcd") == -EINVAL))
+       if ((unregister_blkdev(MAJOR_NR, "sjcd") == -EINVAL))
                printk("SJCD: cannot unregister device.\n");
        else {
                release_region(sjcd_base, 4);

diff --git a/drivers/cdrom/sonycd535.c b/drivers/cdrom/sonycd535.c
index 46865fc9a162b4c9a970fb1fbf9fce0e9c074f82..b244be024ec7dcb70448257631d454a44026e5dd 100644 (file)
--- a/drivers/cdrom/sonycd535.c
+++ b/drivers/cdrom/sonycd535.c
@@ -1572,7 +1572,7 @@ sony535_init(void)
                                                                MAJOR_NR, 0,
                                                                S_IFBLK | S_IRUGO | S_IWUGO,
                                                                &cdu_fops, NULL);
-                               if (devfs_register_blkdev(MAJOR_NR, CDU535_HANDLE, &cdu_fops)) {
+                               if (register_blkdev(MAJOR_NR, CDU535_HANDLE, &cdu_fops)) {
                                        printk("Unable to get major %d for %s\n",
                                                        MAJOR_NR, CDU535_MESSAGE_NAME);
                                        return -EIO;
@@ -1585,7 +1585,7 @@ sony535_init(void)
                                        kmalloc(sizeof *sony_toc, GFP_KERNEL);
                                if (sony_toc == NULL) {
                                        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
-                                       devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
+                                       unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
                                        devfs_unregister(sony_devfs_handle);
                                        return -ENOMEM;
                                }
@@ -1594,7 +1594,7 @@ sony535_init(void)
                                if (last_sony_subcode == NULL) {
                                        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
                                        kfree(sony_toc);
-                                       devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
+                                       unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
                                        devfs_unregister(sony_devfs_handle);
                                        return -ENOMEM;
                                }
@@ -1604,7 +1604,7 @@ sony535_init(void)
                                        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
                                        kfree(sony_toc);
                                        kfree(last_sony_subcode);
-                                       devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
+                                       unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
                                        devfs_unregister(sony_devfs_handle);
                                        return -ENOMEM;
                                }
@@ -1618,7 +1618,7 @@ sony535_init(void)
                                                kfree(sony_buffer);
                                                kfree(sony_toc);
                                                kfree(last_sony_subcode);
-                                               devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
+                                               unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
                                                devfs_unregister(sony_devfs_handle);
                                                return -ENOMEM;
                                        }
@@ -1643,7 +1643,7 @@ sony535_init(void)
                kfree(sony_buffer);
                kfree(sony_toc);
                kfree(last_sony_subcode);
-               devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
+               unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
                devfs_unregister(sony_devfs_handle);
                if (sony535_irq_used)
                        free_irq(sony535_irq_used, NULL);
@@ -1702,7 +1702,7 @@ sony535_exit(void)
        kfree(sony_toc);
        devfs_find_and_unregister(NULL, CDU535_HANDLE, 0, 0,
                                  DEVFS_SPECIAL_BLK, 0);
-       if (devfs_unregister_blkdev(MAJOR_NR, CDU535_HANDLE) == -EINVAL)
+       if (unregister_blkdev(MAJOR_NR, CDU535_HANDLE) == -EINVAL)
                printk("Uh oh, couldn't unregister " CDU535_HANDLE "\n");
        else
                printk(KERN_INFO CDU535_HANDLE " module released\n");

diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index f5fb26632eb29c5195f2626bdfaf170a7d50f1e9..40d9ef4b0ebf7bb0a37fe730da202328d53814d3 100644 (file)
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -35,7 +35,6 @@
 #include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/fs.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/kernel.h>
 #include <linux/hdreg.h>
 #include <linux/genhd.h>
@@ -818,7 +817,7 @@ static void __init hd_geninit(void)
 
 int __init hd_init(void)
 {
-       if (devfs_register_blkdev(MAJOR_NR,"hd",&hd_fops)) {
+       if (register_blkdev(MAJOR_NR,"hd",&hd_fops)) {
                printk("hd: unable to get major %d for hard disk\n",MAJOR_NR);
                return -1;
        }

diff --git a/drivers/ide/probe.c b/drivers/ide/probe.c
index 3766b7531c781ffad5f7f3a03756049fd04f00cd..8f296358a1e26b1096bff62cfc52a752c1d33795 100644 (file)
--- a/drivers/ide/probe.c
+++ b/drivers/ide/probe.c
@@ -1089,7 +1089,7 @@ static void channel_init(struct ata_channel *ch)
        }
 #endif
 
-       if (devfs_register_blkdev(ch->major, ch->name, ide_fops)) {
+       if (register_blkdev(ch->major, ch->name, ide_fops)) {
                printk("%s: UNABLE TO GET MAJOR NUMBER %d\n", ch->name, ch->major);
 
                return;

diff --git a/drivers/md/lvm.c b/drivers/md/lvm.c
index f3e98983fe155b03861779bf37a9aac28a0eb5cd..207014c30a17b5b8efcb301aaae58c74c40c7612 100644 (file)
--- a/drivers/md/lvm.c
+++ b/drivers/md/lvm.c
@@ -213,7 +213,6 @@
 #include <linux/proc_fs.h>
 #include <linux/blkdev.h>
 #include <linux/genhd.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/smp_lock.h>
 #include <asm/ioctl.h>
 #include <asm/uaccess.h>
@@ -395,9 +394,8 @@ int lvm_init(void)
                return -EIO;
        }
 
-       if (devfs_register_blkdev(MAJOR_NR, lvm_name, &lvm_blk_dops) < 0)
-       {
-               printk("%s -- devfs_register_blkdev failed\n", lvm_name);
+       if (register_blkdev(MAJOR_NR, lvm_name, &lvm_blk_dops) < 0) {
+               printk("%s -- register_blkdev failed\n", lvm_name);
                if (unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)
                        printk(KERN_ERR
                               "%s -- unregister_chrdev failed\n",
@@ -445,8 +443,8 @@ static void lvm_cleanup(void)
        if (unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)
                printk(KERN_ERR "%s -- unregister_chrdev failed\n",
                       lvm_name);
-       if (devfs_unregister_blkdev(MAJOR_NR, lvm_name) < 0)
-               printk(KERN_ERR "%s -- devfs_unregister_blkdev failed\n",
+       if (unregister_blkdev(MAJOR_NR, lvm_name) < 0)
+               printk(KERN_ERR "%s -- unregister_blkdev failed\n",
                       lvm_name);
 
        del_gendisk(&lvm_gendisk);

diff --git a/drivers/md/md.c b/drivers/md/md.c
index b84ff3330b32bdc79d9f304ca87a40da2a02afed..a4f962c3a469ea27eb81f04f1a1b62e8ab9eeb1b 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -3207,8 +3207,7 @@ int __init md_init(void)
                        MD_MAJOR_VERSION, MD_MINOR_VERSION,
                        MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
 
-       if (devfs_register_blkdev (MAJOR_NR, "md", &md_fops))
-       {
+       if (register_blkdev (MAJOR_NR, "md", &md_fops)) {
                printk(KERN_ALERT "md: Unable to get major %d for md\n", MAJOR_NR);
                return (-1);
        }
@@ -3568,7 +3567,7 @@ void cleanup_module(void)
        md_unregister_thread(md_recovery_thread);
        devfs_unregister(devfs_handle);
 
-       devfs_unregister_blkdev(MAJOR_NR,"md");
+       unregister_blkdev(MAJOR_NR,"md");
        unregister_reboot_notifier(&md_notifier);
        unregister_sysctl_table(raid_table_header);
 #ifdef CONFIG_PROC_FS

diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 928ebe40525153f3f00cb9eb3f23d0657863d9ea..df1ec9bdc9d0cc970e8d7d2804a2bb3dba10da3b 100644 (file)
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -593,22 +593,14 @@ int __init init_mtdblock(void)
        int i;
 
        spin_lock_init(&mtdblks_lock);
-#ifdef CONFIG_DEVFS_FS
-       if (devfs_register_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME, &mtd_fops))
-       {
-               printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
-                       MTD_BLOCK_MAJOR);
-               return -EAGAIN;
-       }
-
-       devfs_dir_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);
-       register_mtd_user(&notifier);
-#else
        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);
                return -EAGAIN;
        }
+#ifdef CONFIG_DEVFS_FS
+       devfs_dir_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);
+       register_mtd_user(&notifier);
 #endif
        
        /* We fill it in at open() time. */
@@ -630,10 +622,8 @@ static void __exit cleanup_mtdblock(void)
 #ifdef CONFIG_DEVFS_FS
        unregister_mtd_user(&notifier);
        devfs_unregister(devfs_dir_handle);
-       devfs_unregister_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME);
-#else
-       unregister_blkdev(MAJOR_NR,DEVICE_NAME);
 #endif
+       unregister_blkdev(MAJOR_NR,DEVICE_NAME);
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
        blk_size[MAJOR_NR] = NULL;
 }

diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index e5229cc967f97440cdad0b31fbb2c0ef7f371452..643a069a38f5616b9ed74c4628ff80f6b28660ce 100644 (file)
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -92,8 +92,7 @@ dasd_register_major(int major)
        }
 
        /* Register block device. */
-       new_major = devfs_register_blkdev(major, "dasd",
-                                         &dasd_device_operations);
+       new_major = register_blkdev(major, "dasd", &dasd_device_operations);
        if (new_major < 0) {
                MESSAGE(KERN_WARNING,
                        "Cannot register to major no %d, rc = %d", major, rc);
@@ -168,7 +167,7 @@ dasd_unregister_major(struct major_info * mi)
        bs = blk_size[major];
        blk_clear(major);
 
-       rc = devfs_unregister_blkdev(major, "dasd");
+       rc = unregister_blkdev(major, "dasd");
        if (rc < 0)
                MESSAGE(KERN_WARNING,
                        "Cannot unregister from major no %d, rc = %d",

diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 3985f4274eacca0a17b3782125ea4fb27950aea4..94c04fccfee75bc209b185adb8b864e809971937 100644 (file)
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -449,7 +449,7 @@ static int __init xpram_setup_blkdev(void)
        /*
         * Register xpram major.
         */
-       rc = devfs_register_blkdev(XPRAM_MAJOR, XPRAM_NAME, &xpram_devops);
+       rc = register_blkdev(XPRAM_MAJOR, XPRAM_NAME, &xpram_devops);
        if (rc < 0) {
                PRINT_ERR("Can't get xpram major %d\n", XPRAM_MAJOR);
                return rc;
@@ -489,7 +489,7 @@ static int __init xpram_setup_blkdev(void)
 static void __exit xpram_exit(void)
 {
        blk_clear(XPRAM_MAJOR);
-       devfs_unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
+       unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
        devfs_unregister(xpram_devfs_handle);
        unregister_sys_device(&xpram_sys_device);
 }

diff --git a/drivers/s390/char/tapeblock.c b/drivers/s390/char/tapeblock.c
index 1a2ab633f4228e452cad79b5b9cec4518ad98887..2a493f0e36563490f836114b22c5ab1839826798 100644 (file)
--- a/drivers/s390/char/tapeblock.c
+++ b/drivers/s390/char/tapeblock.c
@@ -97,11 +97,7 @@ tapeblock_init(void) {
        tape_dev_t* td;
        tape_init();
        /* Register the tape major number to the kernel */
-#ifdef CONFIG_DEVFS_FS
-       result = devfs_register_blkdev(tapeblock_major, "tBLK", &tapeblock_fops);
-#else
        result = register_blkdev(tapeblock_major, "tBLK", &tapeblock_fops);
-#endif
        if (result < 0) {
                PRINT_WARN(KERN_ERR "tape: can't get major %d for block device\n", tapeblock_major);
                result=-ENODEV;
@@ -149,11 +145,7 @@ out_undo_hardsect_size:
 out_undo_blk_size:
        kfree(blk_size[tapeblock_major]);
 out_undo_bdev:
-#ifdef CONFIG_DEVFS_FS
-       devfs_unregister_blkdev(tapeblock_major, "tBLK");
-#else
        unregister_blkdev(tapeblock_major, "tBLK");
-#endif
        result=-ENOMEM;
        blk_size[tapeblock_major]=
        hardsect_size[tapeblock_major]=
@@ -181,11 +173,7 @@ tapeblock_uninit(void) {
                max_sectors[tapeblock_major]=NULL;
        }
 
-#ifdef CONFIG_DEVFS_FS
-       devfs_unregister_blkdev(tapeblock_major, "tBLK");
-#else
        unregister_blkdev(tapeblock_major, "tBLK");
-#endif
 
 out:
        return;

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 6f7be79667d308f26a5d3e4a2e85699489ce2bee..556b92b3b3bfb7ed7b2a35392a3860557bfaac3c 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1198,8 +1198,7 @@ static int sd_init()
 
        if (!sd_registered) {
                for (k = 0; k < N_USED_SD_MAJORS; k++) {
-                       if (devfs_register_blkdev(SD_MAJOR(k), "sd",
-                                                 &sd_fops)) {
+                       if (register_blkdev(SD_MAJOR(k), "sd", &sd_fops)) {
                                printk(KERN_NOTICE "Unable to get major %d "
                                       "for SCSI disk\n", SD_MAJOR(k));
                                return 1;
@@ -1296,7 +1295,7 @@ cleanup_mem:
                sd_dsk_arr = NULL;
        }
        for (k = 0; k < N_USED_SD_MAJORS; k++) {
-               devfs_unregister_blkdev(SD_MAJOR(k), "sd");
+               unregister_blkdev(SD_MAJOR(k), "sd");
        }
        sd_registered--;
        return 1;
@@ -1560,7 +1559,7 @@ static void __exit exit_sd(void)
        SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
        scsi_unregister_device(&sd_template);
        for (k = 0; k < N_USED_SD_MAJORS; k++)
-               devfs_unregister_blkdev(SD_MAJOR(k), "sd");
+               unregister_blkdev(SD_MAJOR(k), "sd");
 
        sd_registered--;
        if (sd_dsk_arr != NULL) {

diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index a9ae22858798ecc5f2776583d4de3ee906e5f14a..4a8480893d9c0039c16ae97c850726f4e4b82991 100644 (file)
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -702,7 +702,7 @@ static int sr_init()
                return 0;
 
        if (!sr_registered) {
-               if (devfs_register_blkdev(MAJOR_NR, "sr", &sr_bdops)) {
+               if (register_blkdev(MAJOR_NR, "sr", &sr_bdops)) {
                        printk("Unable to get major %d for SCSI-CD\n", MAJOR_NR);
                        return 1;
                }
@@ -714,7 +714,7 @@ static int sr_init()
        sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS;
        scsi_CDs = kmalloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC);
        if (!scsi_CDs)
-               goto cleanup_devfs;
+               goto cleanup_dev;
        memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD));
 
        sr_sizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
@@ -725,8 +725,8 @@ static int sr_init()
 
 cleanup_cds:
        kfree(scsi_CDs);
-cleanup_devfs:
-       devfs_unregister_blkdev(MAJOR_NR, "sr");
+cleanup_dev:
+       unregister_blkdev(MAJOR_NR, "sr");
        sr_registered--;
        return 1;
 }
@@ -869,7 +869,7 @@ static int __init init_sr(void)
 static void __exit exit_sr(void)
 {
        scsi_unregister_device(&sr_template);
-       devfs_unregister_blkdev(MAJOR_NR, "sr");
+       unregister_blkdev(MAJOR_NR, "sr");
        sr_registered--;
        if (scsi_CDs != NULL) {
                kfree(scsi_CDs);

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 093eafdfe7b3c776842e0e23571d176ee806c125..4b65320f33c056d1c8bcae5c141be9a0886388f5 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -453,6 +453,8 @@ struct block_device_operations * get_blkfops(unsigned int major)
 
 int register_blkdev(unsigned int major, const char * name, struct block_device_operations *bdops)
 {
+       if (devfs_should_register_blkdev())
+               return 0;
        if (major == 0) {
                for (major = MAX_BLKDEV-1; major > 0; major--) {
                        if (blkdevs[major].bdops == NULL) {
@@ -474,6 +476,8 @@ int register_blkdev(unsigned int major, const char * name, struct block_device_o
 
 int unregister_blkdev(unsigned int major, const char * name)
 {
+       if (devfs_should_unregister_blkdev())
+               return 0;
        if (major >= MAX_BLKDEV)
                return -EINVAL;
        if (!blkdevs[major].bdops)

diff --git a/fs/devfs/base.c b/fs/devfs/base.c
index fc498d624f411768d8ca2adcee81c4615b6ee70b..90d8bf08d72eb96858d65957d8e929c940e7634b 100644 (file)
--- a/fs/devfs/base.c
+++ b/fs/devfs/base.c
@@ -2241,22 +2241,18 @@ int devfs_should_register_chrdev (void)
 
 
 /**
- *     devfs_register_blkdev - Optionally register a conventional block driver.
- *     @major: The major number for the driver.
- *     @name: The name of the driver (as seen in /proc/devices).
- *     @bdops: The &block_device_operations structure pointer.
+ *     devfs_should_register_blkdev - should we register a conventional block driver.
  *
- *     This function will register a block driver provided the "devfs=only"
- *     option was not provided at boot time.
- *     Returns 0 on success, else a negative error code on failure.
+ *     If the "devfs=only" option was provided at boot time, this function will
+ *     return -1, otherwise 0 is returned.
  */
 
-int devfs_register_blkdev (unsigned int major, const char *name,
-                          struct block_device_operations *bdops)
+int devfs_should_register_blkdev (void)
 {
-    if (boot_options & OPTION_ONLY) return 0;
-    return register_blkdev (major, name, bdops);
-}   /*  End Function devfs_register_blkdev  */
+    if (boot_options & OPTION_ONLY)
+           return -1;
+    return 0;
+}
 
 
 /**
@@ -2273,20 +2269,18 @@ int devfs_should_unregister_chrdev (void)
 
 
 /**
- *     devfs_unregister_blkdev - Optionally unregister a conventional block driver.
- *     @major: The major number for the driver.
- *     @name: The name of the driver (as seen in /proc/devices).
+ *     devfs_should_unregister_blkdev - should we unregister a conventional block driver.
  *
- *     This function will unregister a block driver provided the "devfs=only"
- *     option was not provided at boot time.
- *     Returns 0 on success, else a negative error code on failure.
+ *     If the "devfs=only" option was provided at boot time, this function will
+ *     return -1, otherwise 0 is returned.
  */
 
-int devfs_unregister_blkdev (unsigned int major, const char *name)
+int devfs_should_unregister_blkdev (void)
 {
-    if (boot_options & OPTION_ONLY) return 0;
-    return unregister_blkdev (major, name);
-}   /*  End Function devfs_unregister_blkdev  */
+    if (boot_options & OPTION_ONLY)
+           return -1;
+    return 0;
+}
 
 /**
  *     devfs_setup - Process kernel boot options.
@@ -2375,8 +2369,6 @@ EXPORT_SYMBOL(devfs_get_next_sibling);
 EXPORT_SYMBOL(devfs_auto_unregister);
 EXPORT_SYMBOL(devfs_get_unregister_slave);
 EXPORT_SYMBOL(devfs_get_name);
-EXPORT_SYMBOL(devfs_register_blkdev);
-EXPORT_SYMBOL(devfs_unregister_blkdev);
 
 
 /**

diff --git a/include/linux/devfs_fs_kernel.h b/include/linux/devfs_fs_kernel.h
index e6bd28ef673e85fc38a006d00d0e3735988331de..a75beebfb65262ff5ffc93ff79c6f2991768e8c0 100644 (file)
--- a/include/linux/devfs_fs_kernel.h
+++ b/include/linux/devfs_fs_kernel.h
@@ -95,10 +95,9 @@ extern void devfs_auto_unregister (devfs_handle_t master,devfs_handle_t slave);
 extern devfs_handle_t devfs_get_unregister_slave (devfs_handle_t master);
 extern const char *devfs_get_name (devfs_handle_t de, unsigned int *namelen);
 extern int devfs_should_register_chrdev (void);
-extern int devfs_register_blkdev (unsigned int major, const char *name,
-                                 struct block_device_operations *bdops);
+extern int devfs_should_register_blkdev (void);
 extern int devfs_should_unregister_chrdev (void);
-extern int devfs_unregister_blkdev (unsigned int major, const char *name);
+extern int devfs_should_unregister_blkdev (void);
 
 extern void devfs_register_tape (devfs_handle_t de);
 extern void devfs_register_series (devfs_handle_t dir, const char *format,
@@ -242,18 +241,17 @@ static inline int devfs_should_register_chrdev (void)
 {
     return 0;
 }
-static inline int devfs_register_blkdev (unsigned int major, const char *name,
-                                        struct block_device_operations *bdops)
+static inline int devfs_should_register_blkdev (void)
 {
-    return register_blkdev (major, name, bdops);
+    return 0;
 }
-static inline int devfs_unregister_chrdev (void)
+static inline int devfs_should_unregister_chrdev (void)
 {
     return 0;
 }
-static inline int devfs_unregister_blkdev (unsigned int major,const char *name)
+static inline int devfs_should_unregister_blkdev (void)
 {
-    return unregister_blkdev (major, name);
+    return 0;
 }
 
 static inline void devfs_register_tape (devfs_handle_t de)