diff -urN linux/drivers/block/ll_rw_blk.c new/drivers/block/ll_rw_blk.c --- linux/drivers/block/ll_rw_blk.c Thu Apr 12 21:15:52 2001 +++ new/drivers/block/ll_rw_blk.c Mon Apr 30 23:16:03 2001 @@ -85,25 +85,21 @@ int * blk_size[MAX_BLKDEV]; /* - * blksize_size contains the size of all block-devices: + * blksize_size contains the block size of all block-devices: * * blksize_size[MAJOR][MINOR] * - * if (!blksize_size[MAJOR]) then 1024 bytes is assumed. + * Access to this array should happen through the get_blksize_size() function. + * If (!blksize_size[MAJOR]) then 1024 bytes is assumed. */ int * blksize_size[MAX_BLKDEV]; /* * hardsect_size contains the size of the hardware sector of a device. * - * hardsect_size[MAJOR][MINOR] - * - * if (!hardsect_size[MAJOR]) - * then 512 bytes is assumed. - * else - * sector_size is hardsect_size[MAJOR][MINOR] - * This is currently set by some scsi devices and read by the msdos fs driver. - * Other uses may appear later. + * Access to this array should happen through the get_hardsect_size() function. + * The default value is assumed to be 512 unless specified differently by the + * corresponding low-level driver. */ int * hardsect_size[MAX_BLKDEV]; @@ -992,22 +988,14 @@ void ll_rw_block(int rw, int nr, struct buffer_head * bhs[]) { - unsigned int major; - int correct_size; + ssize_t correct_size; int i; if (!nr) return; - major = MAJOR(bhs[0]->b_dev); - /* Determine correct block size for this device. */ - correct_size = BLOCK_SIZE; - if (blksize_size[major]) { - i = blksize_size[major][MINOR(bhs[0]->b_dev)]; - if (i) - correct_size = i; - } + correct_size = get_blksize_size(bhs[0]->b_dev); /* Verify requested block sizes. */ for (i = 0; i < nr; i++) { diff -urN linux/drivers/block/loop.c new/drivers/block/loop.c --- linux/drivers/block/loop.c Thu Apr 12 04:05:14 2001 +++ new/drivers/block/loop.c Mon Apr 30 23:30:17 2001 @@ -272,22 +272,10 @@ return desc.error; } -static inline int loop_get_bs(struct loop_device *lo) -{ - int bs = 0; - - if (blksize_size[MAJOR(lo->lo_device)]) - bs = blksize_size[MAJOR(lo->lo_device)][MINOR(lo->lo_device)]; - if (!bs) - bs = BLOCK_SIZE; - - return bs; -} - static inline unsigned long loop_get_iv(struct loop_device *lo, unsigned long sector) { - int bs = loop_get_bs(lo); + int bs = get_blksize_size(lo->lo_device); unsigned long offset, IV; IV = sector / (bs >> 9) + lo->lo_offset / bs; @@ -306,9 +294,9 @@ pos = ((loff_t) bh->b_rsector << 9) + lo->lo_offset; if (rw == WRITE) - ret = lo_send(lo, bh, loop_get_bs(lo), pos); + ret = lo_send(lo, bh, get_blksize_size(lo->lo_device), pos); else - ret = lo_receive(lo, bh, loop_get_bs(lo), pos); + ret = lo_receive(lo, bh, get_blksize_size(lo->lo_device), pos); return ret; } @@ -650,12 +638,7 @@ lo->old_gfp_mask = inode->i_mapping->gfp_mask; inode->i_mapping->gfp_mask = GFP_BUFFER; - bs = 0; - if (blksize_size[MAJOR(inode->i_rdev)]) - bs = blksize_size[MAJOR(inode->i_rdev)][MINOR(inode->i_rdev)]; - if (!bs) - bs = BLOCK_SIZE; - + bs = get_blksize_size(inode->i_rdev); set_blocksize(dev, bs); lo->lo_bh = lo->lo_bhtail = NULL; diff -urN linux/drivers/char/raw.c new/drivers/char/raw.c --- linux/drivers/char/raw.c Fri Apr 27 23:23:25 2001 +++ new/drivers/char/raw.c Mon Apr 30 22:57:20 2001 @@ -124,22 +124,25 @@ return err; } - - /* - * Don't interfere with mounted devices: we cannot safely set - * the blocksize on a device which is already mounted. + /* + * 29.04.2001 Martin Dalecki: + * + * The original comment here was saying: + * + * "Don't interfere with mounted devices: we cannot safely set the + * blocksize on a device which is already mounted." + * + * However the code below was setting happily the blocksize + * disregarding the previous check. I have fixed this, however I'm + * quite sure, that the statement above isn't right and we should be + * able to remove the first arm of the branch below entierly. */ - - sector_size = 512; if (get_super(rdev) != NULL) { - if (blksize_size[MAJOR(rdev)]) - sector_size = blksize_size[MAJOR(rdev)][MINOR(rdev)]; + sector_size = get_blksize_size(rdev); } else { - if (hardsect_size[MAJOR(rdev)]) - sector_size = hardsect_size[MAJOR(rdev)][MINOR(rdev)]; + sector_size = get_hardsect_size(rdev); + set_blocksize(rdev, sector_size); } - - set_blocksize(rdev, sector_size); raw_devices[minor].sector_size = sector_size; for (sector_bits = 0; !(sector_size & 1); ) @@ -148,7 +151,7 @@ out: up(&raw_devices[minor].mutex); - + return err; } diff -urN linux/drivers/md/lvm-snap.c new/drivers/md/lvm-snap.c --- linux/drivers/md/lvm-snap.c Fri Apr 27 23:23:25 2001 +++ new/drivers/md/lvm-snap.c Mon Apr 30 23:27:40 2001 @@ -172,20 +172,6 @@ blocks[i] = start++; } -inline int lvm_get_blksize(kdev_t dev) -{ - int correct_size = BLOCK_SIZE, i, major; - - major = MAJOR(dev); - if (blksize_size[major]) - { - i = blksize_size[major][MINOR(dev)]; - if (i) - correct_size = i; - } - return correct_size; -} - #ifdef DEBUG_SNAPSHOT static inline void invalidate_snap_cache(unsigned long start, unsigned long nr, kdev_t dev) @@ -218,7 +204,7 @@ if (is == 0) return; is--; - blksize_snap = lvm_get_blksize(lv_snap->lv_block_exception[is].rdev_new); + blksize_snap = get_blksize_size(lv_snap->lv_block_exception[is].rdev_new); is -= is % (blksize_snap / sizeof(lv_COW_table_disk_t)); memset(lv_COW_table, 0, blksize_snap); @@ -262,7 +248,7 @@ snap_phys_dev = lv_snap->lv_block_exception[idx].rdev_new; snap_pe_start = lv_snap->lv_block_exception[idx - (idx % COW_entries_per_pe)].rsector_new - lv_snap->lv_chunk_size; - blksize_snap = lvm_get_blksize(snap_phys_dev); + blksize_snap = get_blksize_size(snap_phys_dev); COW_entries_per_block = blksize_snap / sizeof(lv_COW_table_disk_t); idx_COW_table = idx % COW_entries_per_pe % COW_entries_per_block; @@ -307,7 +293,7 @@ idx++; snap_phys_dev = lv_snap->lv_block_exception[idx].rdev_new; snap_pe_start = lv_snap->lv_block_exception[idx - (idx % COW_entries_per_pe)].rsector_new - lv_snap->lv_chunk_size; - blksize_snap = lvm_get_blksize(snap_phys_dev); + blksize_snap = get_blksize_size(snap_phys_dev); iobuf->blocks[0] = snap_pe_start >> (blksize_snap >> 10); } else iobuf->blocks[0]++; @@ -384,8 +370,8 @@ iobuf = lv_snap->lv_iobuf; - blksize_org = lvm_get_blksize(org_phys_dev); - blksize_snap = lvm_get_blksize(snap_phys_dev); + blksize_org = get_blksize_size(org_phys_dev); + blksize_snap = get_blksize_size(snap_phys_dev); max_blksize = max(blksize_org, blksize_snap); min_blksize = min(blksize_org, blksize_snap); max_sectors = KIO_MAX_SECTORS * (min_blksize>>9); diff -urN linux/drivers/md/lvm-snap.h new/drivers/md/lvm-snap.h --- linux/drivers/md/lvm-snap.h Mon Jan 29 01:11:20 2001 +++ new/drivers/md/lvm-snap.h Mon Apr 30 23:26:28 2001 @@ -32,7 +32,6 @@ #define LVM_SNAP_H /* external snapshot calls */ -extern inline int lvm_get_blksize(kdev_t); extern int lvm_snapshot_alloc(lv_t *); extern void lvm_snapshot_fill_COW_page(vg_t *, lv_t *); extern int lvm_snapshot_COW(kdev_t, ulong, ulong, ulong, lv_t *); diff -urN linux/drivers/md/lvm.c new/drivers/md/lvm.c --- linux/drivers/md/lvm.c Sat Apr 21 19:37:16 2001 +++ new/drivers/md/lvm.c Mon Apr 30 23:31:56 2001 @@ -1077,7 +1077,7 @@ memset(&bh,0,sizeof bh); bh.b_rsector = block; bh.b_dev = bh.b_rdev = inode->i_dev; - bh.b_size = lvm_get_blksize(bh.b_dev); + bh.b_size = get_blksize_size(bh.b_dev); if ((err=lvm_map(&bh, READ)) < 0) { printk("lvm map failed: %d\n", err); return -EINVAL; diff -urN linux/drivers/md/raid5.c new/drivers/md/raid5.c --- linux/drivers/md/raid5.c Fri Feb 9 20:30:23 2001 +++ new/drivers/md/raid5.c Mon Apr 30 23:22:58 2001 @@ -1136,23 +1136,6 @@ return 0; } -/* - * Determine correct block size for this device. - */ -unsigned int device_bsize (kdev_t dev) -{ - unsigned int i, correct_size; - - correct_size = BLOCK_SIZE; - if (blksize_size[MAJOR(dev)]) { - i = blksize_size[MAJOR(dev)][MINOR(dev)]; - if (i) - correct_size = i; - } - - return correct_size; -} - static int raid5_sync_request (mddev_t *mddev, unsigned long block_nr) { raid5_conf_t *conf = (raid5_conf_t *) mddev->private; diff -urN linux/drivers/s390/char/tape34xx.c new/drivers/s390/char/tape34xx.c --- linux/drivers/s390/char/tape34xx.c Thu Apr 12 04:02:28 2001 +++ new/drivers/s390/char/tape34xx.c Mon Apr 30 22:36:57 2001 @@ -1369,7 +1369,8 @@ ccw_req_t *cqr; ccw1_t *ccw; __u8 *data; - int s2b = blksize_size[tapeblock_major][tape->blk_minor]/hardsect_size[tapeblock_major][tape->blk_minor]; + int s2b = blksize_size[tapeblock_major][tape->blk_minor] + / get_hardsect_size(MKDEV(tapeblock_major,tape->blk_minor)); int realcount; int size,bhct = 0; struct buffer_head* bh; @@ -1388,7 +1389,7 @@ } data[0] = 0x01; data[1] = data[2] = data[3] = 0x00; - realcount=req->sector/s2b; + realcount=req->sector / s2b; if (((tape34xx_disc_data_t *) tape->discdata)->modeset_byte & 0x08) // IDRC on data[1] = data[1] | 0x80; diff -urN linux/fs/block_dev.c new/fs/block_dev.c --- linux/fs/block_dev.c Fri Feb 9 20:29:44 2001 +++ new/fs/block_dev.c Mon Apr 30 23:03:27 2001 @@ -14,12 +14,10 @@ #include #include #include +#include #include -extern int *blk_size[]; -extern int *blksize_size[]; - #define MAX_BUF_PER_PAGE (PAGE_SIZE / 512) #define NBUF 64 @@ -42,10 +40,8 @@ return -EPERM; written = write_error = buffercount = 0; - blocksize = BLOCK_SIZE; - if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)]) - blocksize = blksize_size[MAJOR(dev)][MINOR(dev)]; + blocksize = get_blksize_size(dev); i = blocksize; blocksize_bits = 0; while(i != 1) { @@ -182,9 +178,7 @@ ssize_t read; dev = inode->i_rdev; - blocksize = BLOCK_SIZE; - if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)]) - blocksize = blksize_size[MAJOR(dev)][MINOR(dev)]; + blocksize = get_blksize_size(dev); i = blocksize; blocksize_bits = 0; while (i != 1) { diff -urN linux/fs/buffer.c new/fs/buffer.c --- linux/fs/buffer.c Fri Apr 27 23:23:25 2001 +++ new/fs/buffer.c Mon Apr 30 23:47:21 2001 @@ -687,6 +687,13 @@ if (!blksize_size[MAJOR(dev)]) return; + /* 29/04/2001 Marcin Dalecki : + * + * The assumption that the size may not by lower then 512 is + * conflicting with the assumption in partitions/check.c that the block + * size may assume 256 bytes. + */ + /* Size must be a power of two, and between 512 and PAGE_SIZE */ if (size > PAGE_SIZE || size < 512 || (size & (size-1))) panic("Invalid blocksize passed to set_blocksize"); diff -urN linux/fs/partitions/check.c new/fs/partitions/check.c --- linux/fs/partitions/check.c Sat Feb 17 01:02:37 2001 +++ new/fs/partitions/check.c Mon Apr 30 23:37:50 2001 @@ -34,7 +34,6 @@ #include "ultrix.h" extern void device_init(void); -extern int *blk_size[]; extern void rd_load(void); extern void initrd_load(void); @@ -200,20 +199,13 @@ int ret = 1024; /* - * See whether the low-level driver has given us a minumum blocksize. - * If so, check to see whether it is larger than the default of 1024. - */ - if (!blksize_size[MAJOR(dev)]) - return ret; - - /* * Check for certain special power of two sizes that we allow. * With anything larger than 1024, we must force the blocksize up to * the natural blocksize for the device so that we don't have to try * and read partial sectors. Anything smaller should be just fine. */ - switch (blksize_size[MAJOR(dev)][MINOR(dev)]) { + switch (get_blksize_size(dev)) { case 2048: ret = 2048; break; diff -urN linux/fs/partitions/ibm.c new/fs/partitions/ibm.c --- linux/fs/partitions/ibm.c Sat Apr 14 05:26:07 2001 +++ new/fs/partitions/ibm.c Mon Apr 30 23:45:16 2001 @@ -125,12 +125,10 @@ return 0; } genhd_dasd_fillgeo(dev,&geo); - blocksize = hardsect_size[MAJOR(dev)][MINOR(dev)]; - if ( blocksize <= 0 ) { - return 0; - } - set_blocksize(dev, blocksize); /* OUCH !! */ + blocksize = get_hardsect_size(dev); + set_blocksize(dev, blocksize); + if ( ( bh = bread( dev, geo.start, blocksize) ) != NULL ) { strncpy ( type,bh -> b_data + 0, 4); strncpy ( name,bh -> b_data + 4, 6); diff -urN linux/fs/reiserfs/super.c new/fs/reiserfs/super.c --- linux/fs/reiserfs/super.c Fri Apr 27 23:18:08 2001 +++ new/fs/reiserfs/super.c Mon Apr 30 23:53:17 2001 @@ -1,7 +1,8 @@ /* * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README * - * Trivial changes by Alan Cox to add the LFS fixes + * Trivial changes by Alan Cox to add the LFS fixes. + * Trivial change by Marcin Dalecki. * * Trivial Changes: * Rights granted to Hans Reiser to redistribute under other terms providing @@ -21,6 +22,7 @@ #include #include #include +#include #else @@ -681,7 +683,6 @@ struct inode *root_inode; kdev_t dev = s->s_dev; int j; - extern int *blksize_size[]; struct reiserfs_transaction_handle th ; int old_format = 0; unsigned long blocks; @@ -696,17 +697,22 @@ } if (blocks) { - printk("reserfs: resize option for remount only\n"); + printk("reserfs: resize option for remount only\n"); return NULL; - } + } - if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)] != 0) { - /* as blocksize is set for partition we use it */ - size = blksize_size[MAJOR(dev)][MINOR(dev)]; - } else { + /* + * 29/04/2001 Marcin Dalecki : + * + * See what the current blocksize for the device is, and use that as the + * blocksize. Otherwise (or if the blocksize is smaller than the default) + * use the default. This is important for devices that have a hardware + * sectorsize that is larger than the default. + */ + size = get_hardsect_size(dev); + if (size < BLOCK_SIZE) size = BLOCK_SIZE; - set_blocksize (s->s_dev, BLOCK_SIZE); - } + set_blocksize (s->s_dev, BLOCK_SIZE); /* read block (64-th 1k block), which can contain reiserfs super block */ if (read_super_block (s, size)) { diff -urN linux/include/linux/blkdev.h new/include/linux/blkdev.h --- linux/include/linux/blkdev.h Sat Apr 28 00:48:49 2001 +++ new/include/linux/blkdev.h Mon Apr 30 22:43:51 2001 @@ -198,11 +198,18 @@ static inline int get_hardsect_size(kdev_t dev) { - extern int *hardsect_size[]; if (hardsect_size[MAJOR(dev)] != NULL) return hardsect_size[MAJOR(dev)][MINOR(dev)]; else return 512; +} + +static inline int get_blksize_size(kdev_t dev) +{ + if (blksize_size[MAJOR(dev)] != NULL) + return blksize_size[MAJOR(dev)][MINOR(dev)]; + else + return 1024; } #define blk_finished_io(nsects) \ diff -urN linux/include/linux/lvm.h new/include/linux/lvm.h --- linux/include/linux/lvm.h Sat Feb 17 01:06:17 2001 +++ new/include/linux/lvm.h Mon Apr 30 23:47:08 2001 @@ -113,6 +113,20 @@ #error Bad include/linux/major.h - LVM MAJOR undefined #endif +/* 29/04/2001 Marcin Dalecki : + * + * The following games on the definition of the BLOCK_SIZE are asking for + * trouble for two reasons: + * + * 1. This is conflicting with the unconditional definition in fs.h + * + * 2. There are many places in the kernel, where this values is implicitly + * assumed to be equal to 1024 bytes. + * + * Anybody responsible for AS/390 this should resolve this as soon as possible. + * Remove this CRAP! Contact me plase if you need some support. + */ + #ifdef BLOCK_SIZE #undef BLOCK_SIZE #endif