[PATCH] (4/6) blksize_size[] removal

 - put block size in bdev->bd_block_size, make do_open() and
   check_partition() to set it (see above), switch set_blocksize() and
   block_size() to use of ->bd_block_size.  Remove manipulations with
   blksize_size[] from drivers, remove blksize_size[] itself.

diff --git a/arch/m68k/atari/stram.c b/arch/m68k/atari/stram.c
index b7b7b955327bf25d546096dc12bcbce7325d563c..1fbd57f3521da7f91cf55afd53ef34806fe7815f 100644 (file)
--- a/arch/m68k/atari/stram.c
+++ b/arch/m68k/atari/stram.c
@@ -974,8 +974,6 @@ void __init stram_swap_setup(char *str, int *ints)
 /*                                                             ST-RAM device                                                           */
 /* ------------------------------------------------------------------------ */
 
-static int stram_blocksizes[14] = {
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096 };
 static int stram_sizes[14] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 static int refcnt = 0;
@@ -1064,7 +1062,6 @@ int __init stram_device_init(void)
     }
 
     blk_init_queue(BLK_DEFAULT_QUEUE(STRAM_MAJOR), do_stram_request);
-    blksize_size[STRAM_MAJOR] = stram_blocksizes;
        stram_sizes[STRAM_MINOR] = (swap_end - swap_start)/1024;
     blk_size[STRAM_MAJOR] = stram_sizes;
        register_disk(NULL, MKDEV(STRAM_MAJOR, STRAM_MINOR), 1, &stram_fops,

diff --git a/drivers/acorn/block/fd1772.c b/drivers/acorn/block/fd1772.c
index 180211441424cde2aac0f162b198b816dff56063..7eaaf335f146c5c878bc2addb72f2bed3934297f 100644 (file)
--- a/drivers/acorn/block/fd1772.c
+++ b/drivers/acorn/block/fd1772.c
@@ -202,7 +202,6 @@ static struct archy_disk_type {
 #define MAX_DISK_SIZE 720
 
 static int floppy_sizes[256];
-static int floppy_blocksizes[256];
 
 /* current info on each unit */
 static struct archy_floppy_struct {
@@ -1614,7 +1613,6 @@ int fd1772_init(void)
                        floppy_sizes[i] = MAX_DISK_SIZE;
 
        blk_size[MAJOR_NR] = floppy_sizes;
-       blksize_size[MAJOR_NR] = floppy_blocksizes;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request);
 
        config_types();

diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index b5346338879ff50823b087e1cc9e6b88c9912190..f694d696e741205860a162e5bcf6e20dfb5d415c 100644 (file)
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -195,7 +195,6 @@ struct mfm_info {
 
 static struct hd_struct mfm[MFM_MAXDRIVES << 6];
 static int mfm_sizes[MFM_MAXDRIVES << 6];
-static int mfm_blocksizes[MFM_MAXDRIVES << 6];
 static DECLARE_WAIT_QUEUE_HEAD(mfm_wait_open);
 
 /* Stuff from the assembly routines */
@@ -1315,12 +1314,6 @@ static void mfm_geninit (void)
 {
        int i;
 
-       for (i = 0; i < (MFM_MAXDRIVES << 6); i++) {
-               /* Can't increase this - if you do all hell breaks loose */
-               mfm_blocksizes[i] = 1024;
-       }
-       blksize_size[MAJOR_NR] = mfm_blocksizes;
-
        mfm_drives = mfm_initdrives();
 
        printk("mfm: detected %d hard drive%s\n", mfm_drives,

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index d541ade1220c642523886b4865904952ac2ec6fa..12481db1849ef87588b079a523cd8bb352ce34aa 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -1962,7 +1962,6 @@ static boolean DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
       Controller->MaxBlocksPerCommand;
   Controller->GenericDiskInfo.part = Controller->DiskPartitions;
   Controller->GenericDiskInfo.sizes = Controller->PartitionSizes;
-  blksize_size[MajorNumber] = Controller->BlockSizes;
   /*
     Complete initialization of the Generic Disk Information structure.
   */
@@ -2044,10 +2043,6 @@ static void DAC960_ComputeGenericDiskInfo(DAC960_Controller_T *Controller)
              LogicalDeviceInfo->ConfigurableDeviceSize;
          else GenericDiskInfo->part[MinorNumber].nr_sects = 0;
        }
-      for (i = 0; i < DAC960_MaxPartitions; i++)
-       if (GenericDiskInfo->part[MinorNumber].nr_sects > 0)
-         Controller->BlockSizes[MinorNumber + i] = BLOCK_SIZE;
-       else Controller->BlockSizes[MinorNumber + i] = 0;
     }
 }
 

diff --git a/drivers/block/DAC960.h b/drivers/block/DAC960.h
index b5b44ff940eef25b06da040a284f318974d75b1a..55e9ffed539117e1d2d13ab3f8c0b9917b2cd4aa 100644 (file)
--- a/drivers/block/DAC960.h
+++ b/drivers/block/DAC960.h
@@ -2474,7 +2474,6 @@ typedef struct DAC960_Controller
   } FW;
   DiskPartition_T DiskPartitions[DAC960_MinorCount];
   int PartitionSizes[DAC960_MinorCount];
-  int BlockSizes[DAC960_MinorCount];
   unsigned char ProgressBuffer[DAC960_ProgressBufferSize];
   unsigned char UserStatusBuffer[DAC960_UserMessageSize];
 }

diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index a90054a7389d42c5beb0e79beff9318fa45ec645..9c522c8a87bc1f32c2671cf1334423da84376bbe 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -243,7 +243,6 @@ unsigned long       phys_acsi_buffer;
 
 static int                             NDevices = 0;
 static int                             acsi_sizes[MAX_DEV<<4] = { 0, };
-static int                             acsi_blocksizes[MAX_DEV<<4] = { 0, };
 static struct hd_struct        acsi_part[MAX_DEV<<4] = { {0,0}, };
 static int                             access_count[MAX_DEV] = { 0, };
 static char                    busy[MAX_DEV] = { 0, };
@@ -1738,9 +1737,6 @@ static void acsi_geninit(void)
                        NDevices, n_slm );
 #endif
                                         
-       for( i = 0; i < (MAX_DEV << 4); i++ )
-               acsi_blocksizes[i] = 1024;
-       blksize_size[MAJOR_NR] = acsi_blocksizes;
        for( i = 0; i < NDevices; ++i )
                register_disk(&acsi_gendisk, mk_kdev(MAJOR_NR,i<<4),
                                (acsi_info[i].type==HARDDISK)?1<<4:1,

diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 3aad1ba8052c89ab4d55e09556d9d712a2a3576f..87d0ae945c84a46abfb3c2d008e637649fc044ec 100644 (file)
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -141,7 +141,6 @@ static int num_dr_types = sizeof(drive_types) / sizeof(drive_types[0]);
 
 /* defaults for 3 1/2" HD-Disks */
 static int floppy_sizes[256]={880,880,880,880,720,720,720,720,};
-static int floppy_blocksizes[256];
 /* hardsector size assumed to be 512 */
 
 static int amiga_read(int), dos_read(int);
@@ -1858,7 +1857,6 @@ int __init amiga_floppy_init(void)
        post_write_timer.function = post_write;
   
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request, &amiflop_lock);
-       blksize_size[MAJOR_NR] = floppy_blocksizes;
        blk_size[MAJOR_NR] = floppy_sizes;
 
        for (i = 0; i < 128; i++)

diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index f73bcb9b30f627dd9ec6e2f43571afc459cc0846..13cc803b0e5a20d90048206c03ec7e3121566de6 100644 (file)
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -220,7 +220,6 @@ static struct atari_disk_type user_params[FD_MAX_UNITS];
 static struct atari_disk_type default_params[FD_MAX_UNITS];
 
 static int floppy_sizes[256];
-static int floppy_blocksizes[256];
 
 /* current info on each unit */
 static struct atari_floppy_struct {
@@ -2012,7 +2011,6 @@ int __init atari_floppy_init (void)
                        floppy_sizes[i] = MAX_DISK_SIZE;
 
        blk_size[MAJOR_NR] = floppy_sizes;
-       blksize_size[MAJOR_NR] = floppy_blocksizes;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request, &ataflop_lock);
 
        printk(KERN_INFO "Atari floppy driver: max. %cD, %strack buffering\n",

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index ec79f89e251d0e664f0490c91d44a05bdb9c2eb2..5f71a5d0d164cd0618260d41333d52c963970012 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -349,11 +349,6 @@ static void cciss_geninit( int ctlr)
                        continue;
                hba[ctlr]->hd[i << NWD_SHIFT].nr_sects = 
                hba[ctlr]->sizes[i << NWD_SHIFT] = drv->nr_blocks;
-
-               /* for each partition */ 
-               for(j=0; j<MAX_PART; j++)
-                       hba[ctlr]->blocksizes[(i<<NWD_SHIFT) + j] = 1024; 
-
                //hba[ctlr]->gendisk.nr_real++;
                (BLK_DEFAULT_QUEUE(MAJOR_NR + ctlr))->hardsect_size = drv->block_size;
        }
@@ -834,7 +829,6 @@ static int revalidate_allvol(kdev_t dev)
          */
        memset(hba[ctlr]->hd,         0, sizeof(struct hd_struct) * 256);
         memset(hba[ctlr]->sizes,      0, sizeof(int) * 256);
-        memset(hba[ctlr]->blocksizes, 0, sizeof(int) * 256);
         memset(hba[ctlr]->drv,        0, sizeof(drive_info_struct)
                                                * CISS_MAX_LUN);
         hba[ctlr]->gendisk.nr_real = 0;
@@ -1343,9 +1337,6 @@ static int register_new_disk(kdev_t dev, int ctlr)
                 invalidate_device(kdev, 1);
                 gdev->part[minor].start_sect = 0;
                 gdev->part[minor].nr_sects = 0;
-
-                /* reset the blocksize so we can read the partition table */
-                blksize_size[MAJOR_NR+ctlr][minor] = 1024;
         }
 
        ++hba[ctlr]->num_luns;
@@ -2540,9 +2531,6 @@ static int __init cciss_init_one(struct pci_dev *pdev,
 
        blk_queue_max_sectors(q, 512);
 
-       /* fill in the other Kernel structs */
-       blksize_size[MAJOR_NR+i] = hba[i]->blocksizes;
-
        /* Fill in the gendisk data */  
        hba[i]->gendisk.major = MAJOR_NR + i;
        hba[i]->gendisk.major_name = "cciss";

diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 9c8c86aef529781373ac90152be564964e09e7ee..23477bc0a4e3fa4f764603d63d578905350dc4e9 100644 (file)
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -85,7 +85,6 @@ struct ctlr_info
           // indexed by minor numbers
        struct hd_struct hd[256];
        int              sizes[256];
-       int              blocksizes[256];
 #ifdef CONFIG_CISS_SCSI_TAPE
        void *scsi_ctlr; /* ptr to structure containing scsi related stuff */
 #endif

diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index f5c2d25c66b25c757234aa583f6a834305786705..c871070894ed8ef3315636339692082483df83bf 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -102,7 +102,6 @@ static struct board_type products[] = {
 
 static struct hd_struct * ida;
 static int * ida_sizes;
-static int * ida_blocksizes;
 static struct gendisk ida_gendisk[MAX_CTLR];
 
 static struct proc_dir_entry *proc_array;
@@ -178,10 +177,6 @@ static void ida_geninit(int ctlr)
                ida_sizes[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)] =
                                drv->nr_blks;
 
-               for(j=0; j<16; j++)
-                       ida_blocksizes[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)+j] =
-                               1024;
-
                (BLK_DEFAULT_QUEUE(MAJOR_NR + ctlr))->hardsect_size = drv->blk_size;
                ida_gendisk[ctlr].nr_real++;
        }
@@ -343,7 +338,6 @@ void cleanup_module(void)
        remove_proc_entry("cpqarray", proc_root_driver);
        kfree(ida);
        kfree(ida_sizes);
-       kfree(ida_blocksizes);
 }
 #endif /* MODULE */
 
@@ -384,18 +378,8 @@ int __init cpqarray_init(void)
                return(num_cntlrs_reg);
        }
 
-       ida_blocksizes = kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);
-       if(ida_blocksizes==NULL)
-       {
-               kfree(ida);
-               kfree(ida_sizes); 
-               printk( KERN_ERR "cpqarray: out of memory");
-               return(num_cntlrs_reg);
-       }
-
        memset(ida, 0, sizeof(struct hd_struct)*nr_ctlr*NWD*16);
        memset(ida_sizes, 0, sizeof(int)*nr_ctlr*NWD*16);
-       memset(ida_blocksizes, 0, sizeof(int)*nr_ctlr*NWD*16);
        memset(ida_gendisk, 0, sizeof(struct gendisk)*MAX_CTLR);
 
                /* 
@@ -453,7 +437,6 @@ int __init cpqarray_init(void)
                        {
                                kfree(ida);
                                kfree(ida_sizes);
-                               kfree(ida_blocksizes);
                        }
                        return(num_cntlrs_reg);
        
@@ -481,8 +464,6 @@ int __init cpqarray_init(void)
                /* This is a driver limit and could be eliminated. */
                blk_queue_max_phys_segments(q, SG_MAX);
 
-               blksize_size[MAJOR_NR+i] = ida_blocksizes + (i*256);
-
                ida_gendisk[i].major = MAJOR_NR + i;
                ida_gendisk[i].major_name = "ida";
                ida_gendisk[i].minor_shift = NWD_SHIFT;
@@ -1512,7 +1493,6 @@ static int revalidate_allvol(kdev_t dev)
         */
        memset(ida+(ctlr*256),            0, sizeof(struct hd_struct)*NWD*16);
        memset(ida_sizes+(ctlr*256),      0, sizeof(int)*NWD*16);
-       memset(ida_blocksizes+(ctlr*256), 0, sizeof(int)*NWD*16);
        memset(hba[ctlr]->drv,            0, sizeof(drv_info_t)*NWD);
        ida_gendisk[ctlr].nr_real = 0;
 

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 8fda784f0e7fe0c0fa57bfb4c457a195ae9ad3b1..1f3d886e437d652431850745578ec2de3484b337 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -478,7 +478,6 @@ static struct floppy_struct *current_type[N_DRIVE];
 static struct floppy_struct user_params[N_DRIVE];
 
 static int floppy_sizes[256];
-static int floppy_blocksizes[256];
 
 /*
  * The driver is trying to determine the correct media format
@@ -3881,6 +3880,12 @@ static int floppy_revalidate(kdev_t dev)
                if (cf)
                        UDRS->generation++;
                if (NO_GEOM){
+#if 0
+       /*
+        * What the devil is going on here?  We are not guaranteed to do
+        * any IO and ENXIO case is nothing but ENOMEM in disguise - it
+        * happens if and only if buffer cache is out of memory.  WTF?
+        */
                        /* auto-sensing */
                        int size = floppy_blocksizes[minor(dev)];
                        if (!size)
@@ -3895,6 +3900,9 @@ static int floppy_revalidate(kdev_t dev)
                        wait_on_buffer(bh);
                        brelse(bh);
                        return 0;
+#endif
+                       process_fd_request();
+                       return 0;
                }
                if (cf)
                        poll_drive(0, FD_RAW_NEED_DISK);
@@ -4183,7 +4191,6 @@ int __init floppy_init(void)
                        floppy_sizes[i] = MAX_DISK_SIZE;
 
        blk_size[MAJOR_NR] = floppy_sizes;
-       blksize_size[MAJOR_NR] = floppy_blocksizes;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request, &floppy_lock);
        reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
        config_types();

diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index a998a4463691ce3fff3e5396cbd81a5b4de7e514..8359ae8346fbf93fbc8d8f031367fd90f4ce9463 100644 (file)
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -70,15 +70,6 @@ struct blk_dev_struct blk_dev[MAX_BLKDEV]; /* initialized by blk_dev_init() */
  */
 int * blk_size[MAX_BLKDEV];
 
-/*
- * blksize_size contains the size of all block-devices:
- *
- * blksize_size[MAJOR][MINOR]
- *
- * if (!blksize_size[MAJOR]) then 1024 bytes is assumed.
- */
-int * blksize_size[MAX_BLKDEV];
-
 /*
  * How many reqeusts do we allocate per queue,
  * and how many do we "batch" on freeing them?

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 2861dd2e6a116fe75759101c4ad2b5c2ec2c6d1a..5bce942e8baaabfed2c72b895b351b63780b0d1c 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -81,7 +81,6 @@
 static int max_loop = 8;
 static struct loop_device *loop_dev;
 static int *loop_sizes;
-static int *loop_blksizes;
 static devfs_handle_t devfs_handle;      /*  For the directory */
 
 /*
@@ -989,10 +988,6 @@ int __init loop_init(void)
        if (!loop_sizes)
                goto out_mem;
 
-       loop_blksizes = kmalloc(max_loop * sizeof(int), GFP_KERNEL);
-       if (!loop_blksizes)
-               goto out_mem;
-
        blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), loop_make_request);
        blk_queue_bounce_limit(BLK_DEFAULT_QUEUE(MAJOR_NR), BLK_BOUNCE_HIGH);
 
@@ -1007,9 +1002,7 @@ int __init loop_init(void)
        }
 
        memset(loop_sizes, 0, max_loop * sizeof(int));
-       memset(loop_blksizes, 0, max_loop * sizeof(int));
        blk_size[MAJOR_NR] = loop_sizes;
-       blksize_size[MAJOR_NR] = loop_blksizes;
        for (i = 0; i < max_loop; i++)
                register_disk(NULL, mk_kdev(MAJOR_NR, i), 1, &lo_fops, 0);
 
@@ -1031,7 +1024,6 @@ void loop_exit(void)
 
        kfree(loop_dev);
        kfree(loop_sizes);
-       kfree(loop_blksizes);
 }
 
 module_init(loop_init);

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index b9f2c58c564a82bc1676567f338728350787de0e..d2d42e341f044e1068c4e70fffe084e7eb6816da 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -518,7 +518,6 @@ static int __init nbd_init(void)
 #ifdef MODULE
        printk("nbd: registered device at major %d\n", MAJOR_NR);
 #endif
-       blksize_size[MAJOR_NR] = nbd_blksizes;
        blk_size[MAJOR_NR] = nbd_sizes;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_nbd_request, &nbd_lock);
        for (i = 0; i < MAX_NBD; i++) {

diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 126443216dd1a9d4ca620f1fe1ea840c8d03b7ad..52632b029bc327aa0609355bfef1c19b79c36ae8 100644 (file)
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -223,8 +223,6 @@ static void     do_pcd_read_drq(void);
 static void    do_pcd_request(request_queue_t * q);
 static void    do_pcd_read(void);
 
-static int pcd_blocksizes[PCD_UNITS];
-
 struct pcd_unit {
        struct pi_adapter pia;          /* interface to paride layer */
        struct pi_adapter *pi;
@@ -357,9 +355,6 @@ int pcd_init (void) /* preliminary initialisation */
 
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_pcd_request, &pcd_lock);
 
-       for (i=0;i<PCD_UNITS;i++) pcd_blocksizes[i] = 1024;
-        blksize_size[MAJOR_NR] = pcd_blocksizes;
-
        return 0;
 }
 

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index a54e4fbca49c166fea11971b016e14fba651d2e8..5ba9e148e6fc2b0bbb98de250b3a2a4bd94e883f 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -286,7 +286,6 @@ static void pd_eject( int unit);
 
 static struct hd_struct pd_hd[PD_DEVS];
 static int pd_sizes[PD_DEVS];
-static int pd_blocksizes[PD_DEVS];
 
 #define PD_NAMELEN     8
 
@@ -400,9 +399,6 @@ int pd_init (void)
        pd_gendisk.major_name = name;
        add_gendisk(&pd_gendisk);
 
-       for(i=0;i<PD_DEVS;i++) pd_blocksizes[i] = 1024;
-       blksize_size[MAJOR_NR] = pd_blocksizes;
-
        printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
                name,name,PD_VERSION,major,cluster,nice);
        pd_init_units();

diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index ae5ac1934e630e1e96f58e22c8272ce1aa4a2bc1..35767a675fe3ba98dd3d1c01341106183d198bb8 100644 (file)
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -265,8 +265,6 @@ static void pf_lock(int unit, int func);
 static void pf_eject(int unit);
 static int pf_check_media(kdev_t dev);
 
-static int pf_blocksizes[PF_UNITS];
-
 #define PF_NM           0
 #define PF_RO           1
 #define PF_RW           2
@@ -362,8 +360,6 @@ int pf_init (void)      /* preliminary initialisation */
        blk_queue_max_phys_segments(q, cluster);
        blk_queue_max_hw_segments(q, cluster);
 
-       for (i=0;i<PF_UNITS;i++) pf_blocksizes[i] = 1024;
-       blksize_size[MAJOR_NR] = pf_blocksizes;
        for (i=0;i<PF_UNITS;i++)
                register_disk(NULL, mk_kdev(MAJOR_NR, i), 1, &pf_fops, 0);
 

diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index d75890d4bc913b7d1524921aea7c31e32720f6dc..8c38944d603bf6673fed0c0b7b15d50b1fe2f7ca 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -115,7 +115,6 @@ static int no_int_yet;
 static int access_count[MAX_HD];
 static char ps2esdi_valid[MAX_HD];
 static int ps2esdi_sizes[MAX_HD << 6];
-static int ps2esdi_blocksizes[MAX_HD << 6];
 static int ps2esdi_drives;
 static struct hd_struct ps2esdi[MAX_HD << 6];
 static u_short io_base;
@@ -413,12 +412,8 @@ static void __init ps2esdi_geninit(void)
 
        ps2esdi_gendisk.nr_real = ps2esdi_drives;
 
-       for (i = 0; i < (MAX_HD << 6); i++)
-               ps2esdi_blocksizes[i] = 1024;
-
        request_dma(dma_arb_level, "ed");
        request_region(io_base, 4, "ed");
-       blksize_size[MAJOR_NR] = ps2esdi_blocksizes;
        blk_queue_max_sectors(BLK_DEFAULT_QUEUE(MAJOR_NR), 128);
 
        for (i = 0; i < ps2esdi_drives; i++) {

diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index f3255deae0be449719e86809266b5f51a3d0a72c..d5af5c1d319672b3f4ae1715cda1f29df3ece04a 100644 (file)
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -73,8 +73,6 @@ int initrd_below_start_ok;
  */
 
 static unsigned long rd_length[NUM_RAMDISKS];  /* Size of RAM disks in bytes   */
-static int rd_hardsec[NUM_RAMDISKS];           /* Size of real blocks in bytes */
-static int rd_blocksizes[NUM_RAMDISKS];                /* Size of 1024 byte blocks :)  */
 static int rd_kbsize[NUM_RAMDISKS];    /* Size in blocks of 1024 bytes */
 static devfs_handle_t devfs_handle;
 static struct block_device *rd_bdev[NUM_RAMDISKS];/* Protected device data */
@@ -430,8 +428,6 @@ static int __init rd_init (void)
        for (i = 0; i < NUM_RAMDISKS; i++) {
                /* rd_size is given in kB */
                rd_length[i] = rd_size << 10;
-               rd_hardsec[i] = rd_blocksize;
-               rd_blocksizes[i] = rd_blocksize;
                rd_kbsize[i] = rd_size;
        }
        devfs_handle = devfs_mk_dir (NULL, "rd", NULL);
@@ -451,7 +447,6 @@ static int __init rd_init (void)
                        INITRD_MINOR, S_IFBLK | S_IRUSR, &rd_bd_op, NULL);
 #endif
 
-       blksize_size[MAJOR_NR] = rd_blocksizes; /* Avoid set_blocksize() check */
        blk_size[MAJOR_NR] = rd_kbsize;         /* Size of the RAM disk in kB  */
 
        /* rd_size is given in kB */

diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 9a309d1c37af313234027598fe668d1264e43cb2..86aa180e696ed1931133c2c4b31b063ad2a30a60 100644 (file)
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -35,7 +35,6 @@
 #include <linux/blk.h>
 #include <linux/devfs_fs_kernel.h>
 
-static int floppy_blocksizes[2] = {512,512};
 static int floppy_sizes[2] = {2880,2880};
 
 #define MAX_FLOPPIES   2
@@ -1034,7 +1033,6 @@ int swim3_init(void)
                }
                blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request,
                                &swim3_lock);
-               blksize_size[MAJOR_NR] = floppy_blocksizes;
                blk_size[MAJOR_NR] = floppy_sizes;
        }
 

diff --git a/drivers/block/swim_iop.c b/drivers/block/swim_iop.c
index 6033898f7dc35ed1084f7060736d01eb41c6d3d2..68a6c978328c8ed59967bba13a376154ca519516 100644 (file)
--- a/drivers/block/swim_iop.c
+++ b/drivers/block/swim_iop.c
@@ -81,7 +81,6 @@ static int floppy_count;
 
 static struct floppy_state floppy_states[MAX_FLOPPIES];
 
-static int floppy_blocksizes[2] = {512,512};
 static int floppy_sizes[2] = {2880,2880};
 
 static spinlock_t swim_iop_lock = SPIN_LOCK_UNLOCKED;
@@ -151,7 +150,6 @@ int swimiop_init(void)
        }
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_fd_request,
                        &swim_iop_lock);
-       blksize_size[MAJOR_NR] = floppy_blocksizes;
        blk_size[MAJOR_NR] = floppy_sizes;
 
        printk("SWIM-IOP: %s by Joshua M. Thompson (funaho@jurai.org)\n",

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 46fe35af7d746e393399df9399e50ba048398932..0001fde07bbde58e487738104bb1ad113e7973f0 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -120,7 +120,6 @@ static unsigned int xd_bases[] __initdata =
 
 static struct hd_struct xd_struct[XD_MAXDRIVES << 6];
 static int xd_sizes[XD_MAXDRIVES << 6], xd_access[XD_MAXDRIVES];
-static int xd_blocksizes[XD_MAXDRIVES << 6];
 
 static spinlock_t xd_lock = SPIN_LOCK_UNLOCKED;
 
@@ -207,9 +206,6 @@ static void __init xd_geninit (void)
        u_char i,controller;
        unsigned int address;
 
-       for(i=0;i<(XD_MAXDRIVES << 6);i++) xd_blocksizes[i] = 1024;
-       blksize_size[MAJOR_NR] = xd_blocksizes;
-
        if (xd_detect(&controller,&address)) {
 
                printk("Detected a%s controller (type %d) at address %06x\n",

diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index f7d35d7305d8fbb7cdf45862ce90e848968c17c4..e9d25a022dc55111d274fb7ec4dd6ebee59e4b74 100644 (file)
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -61,7 +61,6 @@ extern struct mem_info m68k_memory[NUM_MEMINFO];
 
 static u_long *z2ram_map    = NULL;
 static u_long z2ram_size    = 0;
-static int z2_blocksizes[Z2MINOR_COUNT];
 static int z2_sizes[Z2MINOR_COUNT];
 static int z2_count         = 0;
 static int chip_count       = 0;
@@ -361,13 +360,11 @@ z2_init( void )
            int i;
 
            for (i = 0; i < Z2MINOR_COUNT; i++) {
-                   z2_blocksizes[ i ] = 1024;
                    z2_sizes[ i ] = 0;
            }
     }    
    
     blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUES, &z2ram_lock);
-    blksize_size[ MAJOR_NR ] = z2_blocksizes;
     blk_size[ MAJOR_NR ] = z2_sizes;
 
     return 0;

diff --git a/drivers/cdrom/aztcd.c b/drivers/cdrom/aztcd.c
index 410279f4b1b72975b58c87fbc66958c49ffc7add..717fbf2f0d9a28217c8b43bdbd1ccb787bdbcc99 100644 (file)
--- a/drivers/cdrom/aztcd.c
+++ b/drivers/cdrom/aztcd.c
@@ -191,8 +191,6 @@
 #include <asm/io.h>
 
 #include <asm/uaccess.h>
-static int aztcd_blocksizes[1] = { 2048 };
-
 
 /*###########################################################################
   Defines
@@ -1926,7 +1924,7 @@ int __init aztcd_init(void)
                return -EIO;
        }
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_aztcd_request, &aztSpin);
-       blksize_size[MAJOR_NR] = aztcd_blocksizes;
+       blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), 2048);
        register_disk(NULL, mk_kdev(MAJOR_NR, 0), 1, &azt_fops, 0);
 
        if ((azt_port == 0x1f0) || (azt_port == 0x170))

diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index 5d4846f7bd370507c5630806d4652af3ec86a389..26517dda18838f4d8802cf67f3c7287ba51d0115 100644 (file)
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -3301,8 +3301,6 @@ __setup("cdu31a=", cdu31a_setup);
 
 #endif
 
-static int cdu31a_block_size;
-
 /*
  * Initialize the driver.
  */
@@ -3442,9 +3440,6 @@ int __init cdu31a_init(void)
                blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR),
                               do_cdu31a_request,
                               &cdu31a_lock);
-               cdu31a_block_size = 1024;       /* 1kB default block size */
-               /* use 'mount -o block=2048' */
-               blksize_size[MAJOR_NR] = &cdu31a_block_size;
 
                init_timer(&cdu31a_abort_timer);
                cdu31a_abort_timer.function = handle_abort_timeout;

diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index 112357b85f1540e222cdd0daacd56000e0a1cca5..031b79f7507f429bc85f68ac87534a7b37d87690 100644 (file)
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -261,8 +261,6 @@ struct toc_struct {         /* private copy of Table of Contents */
        uch track, fsm[3], q0;
 };
 
-static int cm206_blocksizes[1] = { 2048 };
-
 struct cm206_struct {
        volatile ush intr_ds;   /* data status read on last interrupt */
        volatile ush intr_ls;   /* uart line status read on last interrupt */
@@ -1502,7 +1500,7 @@ int __init cm206_init(void)
        devfs_plain_cdrom(&cm206_info, &cm206_bdops);
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_cm206_request,
                       &cm206_lock);
-       blksize_size[MAJOR_NR] = cm206_blocksizes;
+       blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), 2048);
        init_bh(CM206_BH, cm206_bh);
 
        memset(cd, 0, sizeof(*cd));     /* give'm some reasonable value */

diff --git a/drivers/cdrom/gscd.c b/drivers/cdrom/gscd.c
index 0809a79fd97caf47917374974bb93b171c5be1be..8e767f3105a294473d19740b70335f3ade4f35de 100644 (file)
--- a/drivers/cdrom/gscd.c
+++ b/drivers/cdrom/gscd.c
@@ -74,8 +74,6 @@
 #define gscd_port gscd         /* for compatible parameter passing with "insmod" */
 #include "gscd.h"
 
-static int gscd_blocksizes[1] = { 512 };
-
 static int gscdPresent = 0;
 
 static unsigned char gscd_buf[2048];   /* buffer for block size conversion */
@@ -1021,7 +1019,6 @@ int __init my_gscd_init(void)
                       S_IFBLK | S_IRUGO | S_IWUGO, &gscd_fops, NULL);
 
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_gscd_request, &gscd_lock);
-       blksize_size[MAJOR_NR] = gscd_blocksizes;
 
        disk_state = 0;
        gscdPresent = 1;

diff --git a/drivers/cdrom/mcd.c b/drivers/cdrom/mcd.c
index 4d5cf1bd95a43cc86d1bb45719bf0618e2499a68..421d1b77f7a6ffc08a0b64e502000377b27ca4e3 100644 (file)
--- a/drivers/cdrom/mcd.c
+++ b/drivers/cdrom/mcd.c
@@ -107,9 +107,6 @@
 #define mcd_port mcd           /* for compatible parameter passing with "insmod" */
 #include "mcd.h"
 
-static int mcd_blocksizes[1];
-
-
 /* I added A flag to drop to 1x speed if too many errors 0 = 1X ; 1 = 2X */
 static int mcdDouble;
 
@@ -1072,7 +1069,6 @@ int __init mcd_init(void)
                return -EIO;
        }
 
-       blksize_size[MAJOR_NR] = mcd_blocksizes;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_mcd_request,
                       &mcd_spinlock);
 

diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index 332a05132284785df84bd8826e6140b2c8d6c865..c51740cbdba9828c97ef16c4f13fc5c4c701acb4 100644 (file)
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -285,7 +285,6 @@ static int mcdx_setattentuator(struct s_drive_stuff *,
 
 /* static variables ************************************************/
 
-static int mcdx_blocksizes[MCDX_NDRIVES];
 static int mcdx_drive_map[][2] = MCDX_DRIVEMAP;
 static struct s_drive_stuff *mcdx_stuffp[MCDX_NDRIVES];
 static struct s_drive_stuff *mcdx_irq_map[16] = { 0, 0, 0, 0, 0, 0, 0, 0,
@@ -1086,8 +1085,6 @@ int __init mcdx_init_drive(int drive)
        int size = sizeof(*stuffp);
        char msg[80];
 
-       mcdx_blocksizes[drive] = 0;
-
        xtrace(INIT, "init() try drive %d\n", drive);
 
        xtrace(INIT, "kmalloc space for stuffpt's\n");
@@ -1184,7 +1181,6 @@ int __init mcdx_init_drive(int drive)
 
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_mcdx_request,
                       &mcdx_lock);
-       blksize_size[MAJOR_NR] = mcdx_blocksizes;
 
        xtrace(INIT, "init() subscribe irq and i/o\n");
        mcdx_irq_map[stuffp->irq] = stuffp;

diff --git a/drivers/cdrom/optcd.c b/drivers/cdrom/optcd.c
index afbf0611cb515882f9b687c70b7586c42bd4e24d..fa39f72ff1f641519154c7bc32406fdfffd718c9 100644 (file)
--- a/drivers/cdrom/optcd.c
+++ b/drivers/cdrom/optcd.c
@@ -108,8 +108,6 @@ static void debug(int debug_this, const char* fmt, ...)
 #define DEBUG(x)
 #endif
 
-static int blksize = 2048;
-
 \f
 /* Drive hardware/firmware characteristics
    Identifiers in accordance with Optics Storage documentation */
@@ -2059,9 +2057,9 @@ int __init optcd_init(void)
        }
        devfs_register (NULL, "optcd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
                        S_IFBLK | S_IRUGO | S_IWUGO, &opt_fops, NULL);
-       blksize_size[MAJOR_NR] = &blksize;
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_optcd_request,
                       &optcd_lock);
+       blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), 2048);
        request_region(optcd_port, 4, "optcd");
        register_disk(NULL, mk_kdev(MAJOR_NR,0), 1, &opt_fops, 0);
 

diff --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index f213a70f417e8f46e1f90de002a3b3b0d40a3f3c..fa9b57634276c49d3074aefa0db9447006e7ae3b 100644 (file)
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -674,7 +674,6 @@ static int n_retries=6;
 
 static int ndrives;
 static u_char drv_pattern[NR_SBPCD]={speed_auto,speed_auto,speed_auto,speed_auto};
-static int sbpcd_blocksizes[NR_SBPCD];
 
 /*==========================================================================*/
 /*
@@ -5928,12 +5927,8 @@ int __init SBPCD_INIT(void)
                {
                        printk(" sbpcd: Unable to register with Uniform CD-ROm driver\n");
                }
-               /*
-                * set the block size
-                */
-               sbpcd_blocksizes[j]=CD_FRAMESIZE;
        }
-       blksize_size[MAJOR_NR]=sbpcd_blocksizes;
+       blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), CD_FRAMESIZE);
 
 #ifndef MODULE
  init_done:

diff --git a/drivers/cdrom/sjcd.c b/drivers/cdrom/sjcd.c
index ad1d65b681ea857bb8519d0867708e87f0882a88..1f78efb6f7a00d96b54f6916046194a4b97f1d58 100644 (file)
--- a/drivers/cdrom/sjcd.c
+++ b/drivers/cdrom/sjcd.c
@@ -1658,8 +1658,6 @@ static struct block_device_operations sjcd_fops = {
        check_media_change:sjcd_disk_change,
 };
 
-static int blksize = 2048;
-
 /*
  * Following stuff is intended for initialization of the cdrom. It
  * first looks for presence of device. If the device is present, it
@@ -1686,8 +1684,6 @@ int __init sjcd_init(void)
        printk("SJCD: sjcd=0x%x: ", sjcd_base);
 #endif
 
-       blksize_size[MAJOR_NR] = &blksize;
-
        if (devfs_register_blkdev(MAJOR_NR, "sjcd", &sjcd_fops) != 0) {
                printk("SJCD: Unable to get major %d for Sanyo CD-ROM\n",
                       MAJOR_NR);
@@ -1695,6 +1691,7 @@ int __init sjcd_init(void)
        }
 
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_sjcd_request, &sjcd_lock);
+       blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), 2048);
        register_disk(NULL, mk_kdev(MAJOR_NR, 0), 1, &sjcd_fops, 0);
 
        if (check_region(sjcd_base, 4)) {

diff --git a/drivers/cdrom/sonycd535.c b/drivers/cdrom/sonycd535.c
index 7f88b99efcf69419524138a202bcec2ba9f4b1f9..356ad23f6a378d55a3d8ef5a2ba6b38f46d42373 100644 (file)
--- a/drivers/cdrom/sonycd535.c
+++ b/drivers/cdrom/sonycd535.c
@@ -1471,8 +1471,6 @@ static struct block_device_operations cdu_fops =
        check_media_change:     cdu535_check_media_change,
 };
 
-static int sonycd535_block_size = CDU535_BLOCK_SIZE;
-
 /*
  * Initialize the driver.
  */
@@ -1599,8 +1597,7 @@ sony535_init(void)
                                blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR),
                                                do_cdu535_request,
                                                &sonycd535_lock);
-                               blksize_size[MAJOR_NR] = &sonycd535_block_size;
-
+                               blk_queue_hardsect_size(BLK_DEFAULT_QUEUE(MAJOR_NR), CDU535_BLOCK_SIZE);
                                sony_toc = (struct s535_sony_toc *)
                                        kmalloc(sizeof *sony_toc, GFP_KERNEL);
                                if (sony_toc == NULL) {

diff --git a/drivers/ide/ataraid.c b/drivers/ide/ataraid.c
index 680236c8739190fd1594afe53786173ed00328e3..a4c5704ff27a56799cfbf9f03308121fcd76d864 100644 (file)
--- a/drivers/ide/ataraid.c
+++ b/drivers/ide/ataraid.c
@@ -34,8 +34,6 @@
 
 #include "ataraid.h"
 
-static int ataraid_blksize_size[256];
-
 static struct raid_device_operations* ataraid_ops[16];
 
 static int ataraid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
@@ -236,14 +234,8 @@ static __init int ataraid_init(void)
 {
        int i;
         for(i=0;i<256;i++)
-       {
-               ataraid_blksize_size[i] = 1024;  
                ataraid_readahead[i] = 1023;
-       }
        
-       if (blksize_size[ATAMAJOR]==NULL)
-               blksize_size[ATAMAJOR] = ataraid_blksize_size;
-
        /* setup the gendisk structure */       
        ataraid_gendisk.part = kmalloc(256 * sizeof(struct hd_struct),GFP_KERNEL);
        if (ataraid_gendisk.part==NULL) {
@@ -281,7 +273,6 @@ static void __exit ataraid_exit(void)
 {
        unregister_blkdev(ATAMAJOR, "ataraid");
        blk_size[ATAMAJOR] = NULL;
-       blksize_size[ATAMAJOR] = NULL;                       
 
        del_gendisk(&ataraid_gendisk);
         

diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index 6c708f38ba205b1a8ec06bf015185d1038d39b9b..03821aa1cd6d80348affb6f621c4faa4fe712e91 100644 (file)
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -107,8 +107,6 @@ static int NR_HD;
 
 static struct hd_struct hd[MAX_HD<<6];
 static int hd_sizes[MAX_HD<<6];
-static int hd_blocksizes[MAX_HD<<6];
-
 
 static struct timer_list device_timer;
 
@@ -727,10 +725,6 @@ static void __init hd_geninit(void)
 {
        int drive;
 
-       for(drive=0; drive < (MAX_HD << 6); drive++)
-               hd_blocksizes[drive] = 1024;
-
-       blksize_size[MAJOR_NR] = hd_blocksizes;
        blk_queue_hardsect_size(QUEUE, 512);
 
 #ifdef __i386__

diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index fc144ae3ec3b0d0afe98e879228a1895a5271dea..4282bd421fe41eba772d686bdb48bd571e10b43e 100644 (file)
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -781,12 +781,6 @@ static void init_gendisk(struct ata_channel *hwif)
                goto err_kmalloc_gd_part;
        memset(gd->part, 0, minors * sizeof(struct hd_struct));
 
-       blksize_size[hwif->major] = kmalloc (minors*sizeof(int), GFP_KERNEL);
-       if (!blksize_size[hwif->major])
-               goto err_kmalloc_bs;
-       for (i = 0; i < minors; ++i)
-           blksize_size[hwif->major][i] = BLOCK_SIZE;
-
        for (unit = 0; unit < MAX_DRIVES; ++unit)
                hwif->drives[unit].part = &gd->part[unit << PARTN_BITS];
 

diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 4b8a6dbebd939ffb1d1468424f150d7b47f07cc5..e5272d4221bb29362b32d0e0abdd3ab889376bb3 100644 (file)
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -2200,7 +2200,6 @@ void ide_unregister(struct ata_channel *ch)
         * Remove us from the kernel's knowledge.
         */
        unregister_blkdev(ch->major, ch->name);
-       kfree(blksize_size[ch->major]);
        blk_dev[ch->major].data = NULL;
        blk_dev[ch->major].queue = NULL;
        blk_clear(ch->major);

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 410731ee7c9d80d205356d96047887bbddb176a9..c4a86516f2fa04ab9fc1270977cb08a39d42dd21 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -105,7 +105,6 @@ static ctl_table raid_root_table[] = {
  * subsystems want to have a pre-defined structure
  */
 struct hd_struct md_hd_struct[MAX_MD_DEVS];
-static int md_blocksizes[MAX_MD_DEVS];
 static int md_maxreadahead[MAX_MD_DEVS];
 static mdk_thread_t *md_recovery_thread;
 
@@ -1714,9 +1713,18 @@ static int do_md_run(mddev_t * mddev)
                if (rdev->faulty)
                        continue;
                invalidate_device(rdev->dev, 1);
+#if 0
+       /*
+        * Aside of obvious breakage (code below results in block size set
+        * according to the sector size of last component instead of the
+        * maximal sector size), we have more interesting problem here.
+        * Namely, we actually ought to set _sector_ size for the array
+        * and that requires per-array request queues.  Disabled for now.
+        */
                md_blocksizes[mdidx(mddev)] = 1024;
                if (bdev_hardsect_size(rdev->bdev) > md_blocksizes[mdidx(mddev)])
                        md_blocksizes[mdidx(mddev)] = bdev_hardsect_size(rdev->bdev);
+#endif
        }
        mddev->pers = pers[pnum];
 
@@ -3613,11 +3621,9 @@ static void md_geninit(void)
        int i;
 
        for(i = 0; i < MAX_MD_DEVS; i++) {
-               md_blocksizes[i] = 1024;
                md_size[i] = 0;
                md_maxreadahead[i] = 32;
        }
-       blksize_size[MAJOR_NR] = md_blocksizes;
        blk_size[MAJOR_NR] = md_size;
 
        dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index c229b896d48a41c816d218044ea217179262e224..74059a6da25c686c5dbd3fe3ad767e39392601cd 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -123,7 +123,6 @@
  *     Some of these can be made smaller later
  */
 
-static int i2ob_blksizes[MAX_I2OB<<4];
 static int i2ob_sizes[MAX_I2OB<<4];
 static int i2ob_media_change_flag[MAX_I2OB];
 
@@ -1815,7 +1814,6 @@ int i2o_block_init(void)
         *      Now fill in the boiler plate
         */
         
-       blksize_size[MAJOR_NR] = i2ob_blksizes;
        blk_size[MAJOR_NR] = i2ob_sizes;
        blk_dev[MAJOR_NR].queue = i2ob_get_queue;
        
@@ -1830,7 +1828,6 @@ int i2o_block_init(void)
                i2ob_dev[i].head = NULL;
                i2ob_dev[i].tail = NULL;
                i2ob_dev[i].depth = MAX_I2OB_DEPTH;
-               i2ob_blksizes[i] = 1024;
        }
        
        /*

diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index bda917c7f4ee90b5d104f8f8fe66dee872acce46..889164aac0df714faf7e9dd0b8635fb3041f5e61 100644 (file)
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -177,7 +177,6 @@ static struct mtd_notifier ftl_notifier = {
 
 static struct hd_struct ftl_hd[MINOR_NR(MAX_DEV, 0, 0)];
 static int ftl_sizes[MINOR_NR(MAX_DEV, 0, 0)];
-static int ftl_blocksizes[MINOR_NR(MAX_DEV, 0, 0)];
 
 static struct gendisk ftl_gendisk = {
     major:             FTL_MAJOR,
@@ -1345,13 +1344,10 @@ int init_ftl(void)
        return -EAGAIN;
     }
     
-    for (i = 0; i < MINOR_NR(MAX_DEV, 0, 0); i++)
-       ftl_blocksizes[i] = 1024;
     for (i = 0; i < MAX_DEV*MAX_PART; i++) {
        ftl_hd[i].nr_sects = 0;
        ftl_hd[i].start_sect = 0;
     }
-    blksize_size[FTL_MAJOR] = ftl_blocksizes;
     ftl_gendisk.major = FTL_MAJOR;
     blk_init_queue(BLK_DEFAULT_QUEUE(FTL_MAJOR), &do_ftl_request);
     add_gendisk(&ftl_gendisk);

diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index c5d2455bb3764e1a418016713733fb2be7fdf0dc..3262d574ee6fcf3c5438a7f0c46f8848177c7074 100644 (file)
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -55,8 +55,6 @@ static struct mtdblk_dev {
 static spinlock_t mtdblks_lock;
 
 static int mtd_sizes[MAX_MTD_DEVICES];
-static int mtd_blksizes[MAX_MTD_DEVICES];
-
 
 /*
  * Cache stuff...
@@ -346,10 +344,6 @@ static int mtdblock_open(struct inode *inode, struct file *file)
 
        mtdblks[dev] = mtdblk;
        mtd_sizes[dev] = mtdblk->mtd->size/1024;
-       if (mtdblk->mtd->erasesize)
-               mtd_blksizes[dev] = mtdblk->mtd->erasesize;
-       if (mtd_blksizes[dev] > PAGE_SIZE)
-               mtd_blksizes[dev] = PAGE_SIZE;
        set_device_ro (inode->i_rdev, !(mtdblk->mtd->flags & MTD_WRITEABLE));
        
        spin_unlock(&mtdblks_lock);
@@ -626,13 +620,9 @@ int __init init_mtdblock(void)
 #endif
        
        /* We fill it in at open() time. */
-       for (i=0; i< MAX_MTD_DEVICES; i++) {
+       for (i=0; i< MAX_MTD_DEVICES; i++)
                mtd_sizes[i] = 0;
-               mtd_blksizes[i] = BLOCK_SIZE;
-       }
        init_waitqueue_head(&thr_wq);
-       /* Allow the block size to default to BLOCK_SIZE. */
-       blksize_size[MAJOR_NR] = mtd_blksizes;
        blk_size[MAJOR_NR] = mtd_sizes;
        
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request, &mtddev_lock);
@@ -653,7 +643,6 @@ static void __exit cleanup_mtdblock(void)
        unregister_blkdev(MAJOR_NR,DEVICE_NAME);
 #endif
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
-       blksize_size[MAJOR_NR] = NULL;
        blk_size[MAJOR_NR] = NULL;
 }
 

diff --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index a3f4c6c8e83d42c9bbd11619c9a3f91d96060acb..fbd345373dbd03925c7ff7dac45b9caf3f4a0b7e 100644 (file)
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -267,7 +267,6 @@ int __init init_mtdblock(void)
        }
        
        /* Allow the block size to default to BLOCK_SIZE. */
-       blksize_size[MAJOR_NR] = NULL;
        blk_size[MAJOR_NR] = mtd_sizes;
        
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request);
@@ -277,7 +276,6 @@ int __init init_mtdblock(void)
 static void __exit cleanup_mtdblock(void)
 {
        unregister_blkdev(MAJOR_NR,DEVICE_NAME);
-       blksize_size[MAJOR_NR] = NULL;
        blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
 }
 

diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index ae0b5bec47e11affd02a16fccda6b898ffd2ffd1..60b3f30962d6cd9fe347ddbec5d1b620c4eb465b 100644 (file)
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -53,7 +53,6 @@
  */
 
 static int nftl_sizes[256];
-static int nftl_blocksizes[256];
 
 /* .. for the Linux partition table handling. */
 struct hd_struct part_table[256];
@@ -146,7 +145,6 @@ static void NFTL_setup(struct mtd_info *mtd)
        NFTLs[firstfree] = nftl;
        /* Finally, set up the block device sizes */
        nftl_sizes[firstfree * 16] = nftl->nr_sects;
-       //nftl_blocksizes[firstfree*16] = 512;
        part_table[firstfree * 16].nr_sects = nftl->nr_sects;
 
        nftl_gendisk.nr_real++;
@@ -1027,13 +1025,6 @@ int __init init_nftl(void)
                return -EBUSY;
        } else {
                blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &nftl_request);
-
-               /* set block size to 1kB each */
-               for (i = 0; i < 256; i++) {
-                       nftl_blocksizes[i] = 1024;
-               }
-               blksize_size[MAJOR_NR] = nftl_blocksizes;
-
                add_gendisk(&nftl_gendisk);
        }
        

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 315689f872a1491d6278b5b1572f7c39ceeed8f9..df6ac1986aceba9327c087245f88947aa1ca57b2 100644 (file)
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -716,13 +716,6 @@ dasd_register_major (major_info_t * major_info)
                goto out_blk_size;
        memset (blk_size[major], 0, (1 << MINORBITS) * sizeof (int));
 
-        /* init blksize_size */
-       blksize_size[major] =
-           (int *) kmalloc ((1 << MINORBITS) * sizeof (int), GFP_ATOMIC);
-       if (!blksize_size[major])
-               goto out_blksize_size;
-       memset (blksize_size[major], 0, (1 << MINORBITS) * sizeof (int));
-
        /* finally do the gendisk stuff */
        major_info->gendisk.part = kmalloc ((1 << MINORBITS) *
                                            sizeof (struct hd_struct),
@@ -741,10 +734,6 @@ dasd_register_major (major_info_t * major_info)
 
         /* error handling - free the prior allocated memory */  
       out_gendisk:
-       kfree (blksize_size[major]);
-       blksize_size[major] = NULL;
-
-      out_blksize_size:
        kfree (blk_size[major]);
        blk_size[major] = NULL;
 
@@ -801,7 +790,6 @@ dasd_unregister_major (major_info_t * major_info)
        kfree (major_info->gendisk.part);
 
        kfree (blk_size[major]);
-       kfree (blksize_size[major]);
 
        blk_clear(major);
 
@@ -3339,7 +3327,6 @@ dasd_setup_blkdev (dasd_device_t *device )
                                  sizes.s2b_shift) >> 1;
                 else
                         device->major_info->gendisk.sizes[minor + i] = 0;
-                blksize_size[major][minor + i] = device->sizes.bp_block;
                blk_queue_max_sectors(device->request_queue,
                 device->discipline->max_blocks << device->sizes.s2b_shift);
                device->major_info->gendisk.part[minor+i].start_sect = 0;
@@ -3369,7 +3356,6 @@ dasd_disable_blkdev (dasd_device_t *device )
         for (i = 0; i < (1 << DASD_PARTN_BITS); i++) {
                 destroy_buffers(MKDEV(major,minor+i));
                 device->major_info->gendisk.sizes[minor + i] = 0;
-                blksize_size[major][minor + i] = 0;
         }
         if (device->request_queue) {
             blk_cleanup_queue (device->request_queue);

diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 5deda7e8b69232236b6e9a03dc6dad8a3a764003..42df4dc4ba1703f7438ae14923f6e2a3e13961da 100644 (file)
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -189,7 +189,6 @@ MODULE_PARM_DESC(sizes, "list of device (partition) sizes " \
 /* The following items are obtained through kmalloc() in init_module() */
 
 Xpram_Dev *xpram_devices = NULL;
-int *xpram_blksizes = NULL;
 int *xpram_offsets = NULL;   /* partition offsets */
 
 #define MIN(x,y) ((x) < (y) ? (x) : (y))
@@ -1062,16 +1061,6 @@ int xpram_init(void)
                PRINT_DEBUG(" device(%d) offset = %d kB, size = %d kB\n",i, xpram_offsets[i], xpram_sizes[i]);
 #endif
 
-       xpram_blksizes = kmalloc(xpram_devs * sizeof(int), GFP_KERNEL);
-       if (!xpram_blksizes) {
-               PRINT_ERR("Not enough memory for xpram_blksizes\n");
-                PRINT_ERR("Giving up xpram\n");
-               goto fail_malloc_blksizes;
-       }
-       for (i=0; i < xpram_devs; i++) /* all the same blocksize */
-               xpram_blksizes[i] = xpram_blksize;
-       blksize_size[major]=xpram_blksizes;
-
        /* 
         * allocate the devices -- we can't have them static, as the number
         * can be specified at load time
@@ -1142,10 +1131,7 @@ int xpram_init(void)
        }
        kfree(xpram_devices);
 #endif /* V24 */
- fail_malloc_blksizes:
        kfree (xpram_offsets);
-       kfree (xpram_blksizes);
-       blksize_size[major] = NULL;
  fail_malloc_devices:
  fail_malloc:
 #if (XPRAM_VERSION == 22)
@@ -1183,7 +1169,6 @@ void cleanup_module(void)
 #if (XPRAM_VERSION == 22)
        blk_dev[major].request_fn = NULL;
 #endif /* V22 */
-       kfree(blksize_size[major]);
        kfree(xpram_offsets);
        blk_clear(major);
 

diff --git a/drivers/s390/char/tapeblock.c b/drivers/s390/char/tapeblock.c
index f58db89df3b0b7e291665f2d58f3b101954d2b27..36863303765a65a30e9d96465af0055371b71ef5 100644 (file)
--- a/drivers/s390/char/tapeblock.c
+++ b/drivers/s390/char/tapeblock.c
@@ -74,8 +74,8 @@ tapeblock_rmdevfstree (tape_info_t* ti) {
 void 
 tapeblock_setup(tape_info_t* ti) {
     blk_size[tapeblock_major][ti->blk_minor]=0; // this will be detected
-    blksize_size[tapeblock_major][ti->blk_minor]=2048; // blocks are 2k by default.
     blk_init_queue (&ti->request_queue, tape_request_fn); 
+    blk_queue_hardsect_size(&ti->request_queue, 2048);
 #ifdef CONFIG_DEVFS_FS
     tapeblock_mkdevfstree(ti);
 #endif
@@ -103,8 +103,6 @@ tapeblock_init(void) {
     PRINT_WARN(KERN_ERR " tape gets major %d for block device\n", result);
     blk_size[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
     memset(blk_size[tapeblock_major],0,256*sizeof(int));
-    blksize_size[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
-    memset(blksize_size[tapeblock_major],0,256*sizeof(int));
     max_sectors[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
     memset(max_sectors[tapeblock_major],0,256*sizeof(int));
     blkfront = kmalloc(sizeof(tape_frontend_t),GFP_KERNEL);
@@ -585,6 +583,6 @@ int tapeblock_mediumdetect(tape_info_t* ti) {
        s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
        losize=(hisize+losize)/2+1;
     }
-    blk_size[tapeblock_major][ti->blk_minor]=(losize)*(blksize_size[tapeblock_major][ti->blk_minor]/1024);
+    blk_size[tapeblock_major][ti->blk_minor]=losize*2;
     return 0;
 }

diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index a31a89a85236022baf2d4ae842a6972298e93d5b..5806be8d8f7d841136ccfcb0c796114053c4f9ca 100644 (file)
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -135,7 +135,6 @@ struct jsflash {
 
 /*
  */
-static int jsfd_blksizes[JSF_MAX];
 static int jsfd_sizes[JSF_MAX];
 static u64 jsfd_bytesizes[JSF_MAX];
 
@@ -665,7 +664,6 @@ int jsfd_init(void) {
                return -EIO;
        }
 
-       blksize_size[JSFD_MAJOR] = jsfd_blksizes;
        blk_size[JSFD_MAJOR] = jsfd_sizes;
 
        blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
@@ -676,7 +674,6 @@ int jsfd_init(void) {
 
                jdp->refcnt = 0;
 
-               jsfd_blksizes[i] = 1024;
                jsfd_bytesizes[i] = jdp->dsize;
                jsfd_sizes[i] = jsfd_bytesizes[i] >> 10;
                register_disk(NULL, MKDEV(JSFD_MAJOR, i), 1, &jsfd_fops,

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index f181515cb037502456ee7605526bcd62cd201a83..00d7534c0dad99e2d975b1b8ebc6722015a40bbb 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -83,7 +83,6 @@ struct hd_struct *sd;
 
 static Scsi_Disk *rscsi_disks;
 static int *sd_sizes;
-static int *sd_blocksizes;
 static int *sd_max_sectors;
 
 static int check_scsidisk_media_change(kdev_t);
@@ -946,19 +945,7 @@ static int sd_init_onedisk(int i)
                         */
                        rscsi_disks[i].capacity = 0;
                }
-               if (sector_size > 1024) {
-                       int m;
-
-                       /*
-                        * We must fix the sd_blocksizes and sd_hardsizes
-                        * to allow us to read the partition tables.
-                        * The disk reading code does not allow for reading
-                        * of partial sectors.
-                        */
-                       for (m = i << 4; m < ((i + 1) << 4); m++) {
-                               sd_blocksizes[m] = sector_size;
-                       }
-               } {
+               {
                        /*
                         * The msdos fs needs to know the hardware sector size
                         * So I have created this table. See ll_rw_blk.c
@@ -1090,12 +1077,11 @@ static int sd_init()
 
        init_mem_lth(rscsi_disks, sd_template.dev_max);
        init_mem_lth(sd_sizes, maxparts);
-       init_mem_lth(sd_blocksizes, maxparts);
        init_mem_lth(sd, maxparts);
        init_mem_lth(sd_gendisks, N_USED_SD_MAJORS);
        init_mem_lth(sd_max_sectors, sd_template.dev_max << 4);
 
-       if (!rscsi_disks || !sd_sizes || !sd_blocksizes || !sd || !sd_gendisks)
+       if (!rscsi_disks || !sd_sizes || !sd || !sd_gendisks)
                goto cleanup_mem;
 
        zero_mem_lth(rscsi_disks, sd_template.dev_max);
@@ -1103,7 +1089,6 @@ static int sd_init()
        zero_mem_lth(sd, maxparts);
 
        for (i = 0; i < maxparts; i++) {
-               sd_blocksizes[i] = 1024;
                /*
                 * Allow lowlevel device drivers to generate 512k large scsi
                 * commands if they know what they're doing and they ask for it
@@ -1114,10 +1099,6 @@ static int sd_init()
 
        for (i = 0; i < N_USED_SD_MAJORS; i++) {
                request_queue_t *q = blk_get_queue(mk_kdev(SD_MAJOR(i), 0));
-               int parts_per_major = (SCSI_DISKS_PER_MAJOR << 4);
-
-               blksize_size[SD_MAJOR(i)] =
-                       sd_blocksizes + i * parts_per_major;
                blk_queue_hardsect_size(q, 512);
        }
 
@@ -1157,7 +1138,6 @@ cleanup_gendisks:
 cleanup_mem:
        kfree(sd_gendisks);
        kfree(sd);
-       kfree(sd_blocksizes);
        kfree(sd_sizes);
        kfree(rscsi_disks);
        for (i = 0; i < N_USED_SD_MAJORS; i++) {
@@ -1331,7 +1311,6 @@ static void __exit exit_sd(void)
        if (rscsi_disks != NULL) {
                kfree(rscsi_disks);
                kfree(sd_sizes);
-               kfree(sd_blocksizes);
                kfree((char *) sd);
        }
        for (i = 0; i < N_USED_SD_MAJORS; i++) {

diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 6a07030fd27abb0ea8832759d3d01ecccc48e96a..af5484c725761f74e4fe7935c1830703127b0863 100644 (file)
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -89,8 +89,6 @@ static struct Scsi_Device_Template sr_template =
 Scsi_CD *scsi_CDs;
 static int *sr_sizes;
 
-static int *sr_blocksizes;
-
 static int sr_open(struct cdrom_device_info *, int);
 void get_sectorsize(int);
 void get_capabilities(int);
@@ -724,18 +722,6 @@ static int sr_init()
        if (!sr_sizes)
                goto cleanup_cds;
        memset(sr_sizes, 0, sr_template.dev_max * sizeof(int));
-
-       sr_blocksizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
-       if (!sr_blocksizes)
-               goto cleanup_sizes;
-
-       /*
-        * These are good guesses for the time being.
-        */
-       for (i = 0; i < sr_template.dev_max; i++)
-               sr_blocksizes[i] = 2048;
-
-       blksize_size[MAJOR_NR] = sr_blocksizes;
        return 0;
 cleanup_sizes:
        kfree(sr_sizes);
@@ -845,9 +831,6 @@ static void __exit exit_sr(void)
 
                kfree(sr_sizes);
                sr_sizes = NULL;
-
-               kfree(sr_blocksizes);
-               sr_blocksizes = NULL;
        }
        blk_clear(MAJOR_NR);
 

diff --git a/fs/block_dev.c b/fs/block_dev.c
index f4a3b0f51cd91b93975b7e9786a1b8e9329a02c8..37b636b4e4ba40072b4f359b87c8705fdc85c5b5 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -66,25 +66,13 @@ int set_blocksize(struct block_device *bdev, int size)
        if (size < get_hardsect_size(dev))
                return -EINVAL;
 
-       /* No blocksize array? Implies hardcoded BLOCK_SIZE */
-       if (!blksize_size[major(dev)]) {
-               if (size == BLOCK_SIZE)
-                       return 0;
-               return -EINVAL;
-       }
-
-       oldsize = blksize_size[major(dev)][minor(dev)];
+       oldsize = bdev->bd_block_size;
        if (oldsize == size)
                return 0;
 
-       if (!oldsize && size == BLOCK_SIZE) {
-               blksize_size[major(dev)][minor(dev)] = size;
-               return 0;
-       }
-
        /* Ok, we're actually changing the blocksize.. */
        sync_blockdev(bdev);
-       blksize_size[major(dev)][minor(dev)] = size;
+       bdev->bd_block_size = size;
        bdev->bd_inode->i_blkbits = blksize_bits(size);
        kill_bdev(bdev);
        return 0;
@@ -615,9 +603,18 @@ static int do_open(struct block_device *bdev, struct inode *inode, struct file *
                if (ret)
                        goto out2;
        }
-       bdev->bd_openers++;
        bdev->bd_inode->i_size = blkdev_size(dev);
-       bdev->bd_inode->i_blkbits = blksize_bits(block_size(bdev));
+       if (!bdev->bd_openers) {
+               unsigned bsize = bdev_hardsect_size(bdev);
+               while (bsize < PAGE_CACHE_SIZE) {
+                       if (bdev->bd_inode->i_size & bsize)
+                               break;
+                       bsize <<= 1;
+               }
+               bdev->bd_block_size = bsize;
+               bdev->bd_inode->i_blkbits = blksize_bits(bsize);
+       }
+       bdev->bd_openers++;
        unlock_kernel();
        up(&bdev->bd_sem);
        return 0;

diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index cfd07dc90fdc161ef4f05a3d923126bc47335134..f87081f3f04fcaed12f6ecc8e4b6f51391aaf40c 100644 (file)
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -253,7 +253,16 @@ static void check_partition(struct gendisk *hd, kdev_t dev, int first_part_minor
        bdev = bdget(kdev_t_to_nr(dev));
        bdev->bd_contains = bdev;
        bdev->bd_inode->i_size = (loff_t)hd->part[minor(dev)].nr_sects << 9;
-       bdev->bd_inode->i_blkbits = blksize_bits(block_size(bdev));
+       if (!bdev->bd_openers) {
+               unsigned bsize = bdev_hardsect_size(bdev);
+               while (bsize < PAGE_CACHE_SIZE) {
+                       if (bdev->bd_inode->i_size & bsize)
+                               break;
+                       bsize <<= 1;
+               }
+               bdev->bd_block_size = bsize;
+               bdev->bd_inode->i_blkbits = blksize_bits(bsize);
+       }
        for (i = 0; check_part[i]; i++) {
                int res;
                res = check_part[i](hd, bdev, first_sector, first_part_minor);
@@ -477,12 +486,6 @@ int wipe_partitions(kdev_t dev)
                g->part[minor].start_sect = 0;
                g->part[minor].nr_sects = 0;
        }
-
-       /* some places do blksize_size[major][minor] = 1024,
-          as preparation for reading partition table - superfluous */
-       /* sd.c used to set blksize_size to 2048 in case
-          rscsi_disks[target].device->sector_size == 2048 */
-
        return 0;
 }
 

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 2bb86494e555f6acc6d0437cf538a58a266dfca0..f747fb405f01f49af69120654f9b4930db73451b 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -317,7 +317,6 @@ extern void blk_dump_rq_flags(struct request *, char *);
 extern void generic_unplug_device(void *);
 
 extern int * blk_size[MAX_BLKDEV];     /* in units of 1024 bytes */
-extern int * blksize_size[MAX_BLKDEV];
 
 #define MAX_PHYS_SEGMENTS 128
 #define MAX_HW_SEGMENTS 128
@@ -335,7 +334,6 @@ extern inline void blk_clear(int major)
 #if 0
        blk_size_in_bytes[major] = NULL;
 #endif
-       blksize_size[major] = NULL;
 }
 
 extern inline int queue_hardsect_size(request_queue_t *q)
@@ -374,16 +372,7 @@ extern inline unsigned int blksize_bits(unsigned int size)
 
 extern inline unsigned int block_size(struct block_device *bdev)
 {
-       int retval = BLOCK_SIZE;
-       kdev_t dev = to_kdev_t(bdev->bd_dev);
-       int major = major(dev);
-
-       if (blksize_size[major]) {
-               int minor = minor(dev);
-               if (blksize_size[major][minor])
-                       retval = blksize_size[major][minor];
-       }
-       return retval;
+       return bdev->bd_block_size;
 }
 
 static inline loff_t blkdev_size_in_bytes(kdev_t dev)

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 898b2094679e2c05aff5b513f4b1acd5cafa2799..cf2020f1042880ff38250539274a69763d74ed2f 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -343,6 +343,7 @@ struct block_device {
        void *                  bd_holder;
        int                     bd_holders;
        struct block_device *   bd_contains;
+       unsigned                bd_block_size;
 };
 
 struct inode {

diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index 2dcb08756890ef60bc1089e205bed9f29ddad655..5d66159f21b7572f1d96d70864dd7c9d0789146e 100644 (file)
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -317,7 +317,6 @@ EXPORT_SYMBOL(tty_unregister_driver);
 EXPORT_SYMBOL(tty_std_termios);
 
 /* block device driver support */
-EXPORT_SYMBOL(blksize_size);
 EXPORT_SYMBOL(blk_size);
 EXPORT_SYMBOL(blk_dev);
 EXPORT_SYMBOL(is_read_only);