diff options
54 files changed, 915 insertions, 1374 deletions
diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting index b88f356a5919..2dcccf3d8a3a 100644 --- a/Documentation/filesystems/porting +++ b/Documentation/filesystems/porting @@ -230,3 +230,21 @@ anything from oops to silent memory corruption. Use bdev_read_only(bdev) instead of is_read_only(kdev). The latter is still alive, but only because of the mess in drivers/s390/block/dasd.c. As soon as it gets fixed is_read_only() will die. + +--- +[mandatory] + + is_read_only() is gone; use bdev_read_only() instead. + +--- +[mandatory] + + destroy_buffers() is gone; use invalidate_bdev(). + +--- +[mandatory] + + fsync_dev() is gone; use fsync_bdev(). NOTE: lvm breakage is +deliberate; as soon as struct block_device * is propagated in a reasonable +way by that code fixing will become trivial; until then nothing can be +done. diff --git a/arch/sparc/kernel/signal.c b/arch/sparc/kernel/signal.c index 743a2eed2cd5..7dfb666b685a 100644 --- a/arch/sparc/kernel/signal.c +++ b/arch/sparc/kernel/signal.c @@ -1090,7 +1090,7 @@ static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, #ifdef DEBUG_SIGNALS_MAPS -#define MAPS_LINE_FORMAT "%08lx-%08lx %s %08lx %s %lu " +#define MAPS_LINE_FORMAT "%08lx-%08lx %s %08lx %02x:%02x %lu " static inline void read_maps (void) { @@ -1107,7 +1107,7 @@ static inline void read_maps (void) char *line; char str[5], *cp = str; int flags; - kdev_t dev; + dev_t dev; unsigned long ino; /* @@ -1132,7 +1132,7 @@ static inline void read_maps (void) buffer, PAGE_SIZE); } printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT, - kdevname(dev), ino); + MAJOR(dev), MINOR(dev), ino); if (map->vm_file != NULL) printk("%s\n", line); else diff --git a/arch/sparc64/kernel/signal.c b/arch/sparc64/kernel/signal.c index 3edaef15cc9e..9cc20dc19033 100644 --- a/arch/sparc64/kernel/signal.c +++ b/arch/sparc64/kernel/signal.c @@ -633,7 +633,7 @@ static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, #ifdef DEBUG_SIGNALS_MAPS -#define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu " +#define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %02x:%02x %lu " static inline void read_maps (void) { @@ -650,7 +650,7 @@ static inline void read_maps (void) char *line; char str[5], *cp = str; int flags; - kdev_t dev; + dev_t dev; unsigned long ino; /* @@ -675,7 +675,7 @@ static inline void read_maps (void) buffer, PAGE_SIZE); } printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT, - kdevname(dev), ino); + MAJOR(dev), MINOR(dev), ino); if (map->vm_file != NULL) printk("%s\n", line); else diff --git a/arch/sparc64/kernel/signal32.c b/arch/sparc64/kernel/signal32.c index 4a49af3a33ba..47246310aa15 100644 --- a/arch/sparc64/kernel/signal32.c +++ b/arch/sparc64/kernel/signal32.c @@ -1319,7 +1319,7 @@ static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs #ifdef DEBUG_SIGNALS_MAPS -#define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu " +#define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %02x:%02x %lu " static inline void read_maps (void) { @@ -1336,7 +1336,7 @@ static inline void read_maps (void) char *line; char str[5], *cp = str; int flags; - kdev_t dev; + dev_t dev; unsigned long ino; /* @@ -1361,7 +1361,7 @@ static inline void read_maps (void) buffer, PAGE_SIZE); } printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT, - kdevname(dev), ino); + MAJOR(dev), MINOR(dev), ino); if (map->vm_file != NULL) printk("%s\n", line); else diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c index bb57f0ab64a8..3dda5dc8eefb 100644 --- a/drivers/block/ll_rw_blk.c +++ b/drivers/block/ll_rw_blk.c @@ -1211,21 +1211,19 @@ void blk_put_request(struct request *rq) static long ro_bits[MAX_BLKDEV][8]; -int is_read_only(kdev_t dev) +int bdev_read_only(struct block_device *bdev) { int minor,major; - major = major(dev); - minor = minor(dev); - if (major < 0 || major >= MAX_BLKDEV) return 0; + if (!bdev) + return 0; + major = MAJOR(bdev->bd_dev); + minor = MINOR(bdev->bd_dev); + if (major < 0 || major >= MAX_BLKDEV) + return 0; return ro_bits[major][minor >> 5] & (1 << (minor & 31)); } -int bdev_read_only(struct block_device *bdev) -{ - return bdev && is_read_only(to_kdev_t(bdev->bd_dev)); -} - void set_device_ro(kdev_t dev,int flag) { int minor,major; diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c index 5092049cdb57..494aa03dc273 100644 --- a/drivers/cdrom/cdrom.c +++ b/drivers/cdrom/cdrom.c @@ -318,8 +318,9 @@ static void sanitize_format(union cdrom_addr *addr, static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, unsigned long arg); -int cdrom_get_last_written(kdev_t dev, long *last_written); -int cdrom_get_next_writable(kdev_t dev, long *next_writable); +int cdrom_get_last_written(struct cdrom_device_info *, long *); +static int cdrom_get_next_writable(struct cdrom_device_info *, long *); +static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*); #ifdef CONFIG_SYSCTL static void cdrom_sysctl_register(void); @@ -441,7 +442,7 @@ int unregister_cdrom(struct cdrom_device_info *unreg) return 0; } -struct cdrom_device_info *cdrom_find_device(kdev_t dev) +static struct cdrom_device_info *cdrom_find_device(kdev_t dev) { struct cdrom_device_info *cdi; @@ -780,7 +781,7 @@ static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot) return cdi->ops->generic_packet(cdi, &cgc); } -int cdrom_select_disc(struct cdrom_device_info *cdi, int slot) +static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot) { struct cdrom_changer_info info; int curslot; @@ -864,7 +865,7 @@ int cdrom_media_changed(kdev_t dev) } /* badly broken, I know. Is due for a fixup anytime. */ -void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks) +static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks) { struct cdrom_tochdr header; struct cdrom_tocentry entry; @@ -1926,7 +1927,6 @@ static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, { struct cdrom_device_ops *cdo = cdi->ops; struct cdrom_generic_command cgc; - kdev_t dev = cdi->dev; char buffer[32]; int ret = 0; @@ -2198,7 +2198,7 @@ static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, case CDROM_NEXT_WRITABLE: { long next = 0; cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); - if ((ret = cdrom_get_next_writable(dev, &next))) + if ((ret = cdrom_get_next_writable(cdi, &next))) return ret; IOCTL_OUT(arg, long, next); return 0; @@ -2206,7 +2206,7 @@ static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, case CDROM_LAST_WRITTEN: { long last = 0; cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); - if ((ret = cdrom_get_last_written(dev, &last))) + if ((ret = cdrom_get_last_written(cdi, &last))) return ret; IOCTL_OUT(arg, long, last); return 0; @@ -2216,10 +2216,9 @@ static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, return -ENOTTY; } -int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type, +static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type, track_information *ti) { - struct cdrom_device_info *cdi = cdrom_find_device(dev); struct cdrom_device_ops *cdo = cdi->ops; struct cdrom_generic_command cgc; int ret; @@ -2246,9 +2245,8 @@ int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type, } /* requires CD R/RW */ -int cdrom_get_disc_info(kdev_t dev, disc_information *di) +static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di) { - struct cdrom_device_info *cdi = cdrom_find_device(dev); struct cdrom_device_ops *cdo = cdi->ops; struct cdrom_generic_command cgc; int ret; @@ -2278,9 +2276,8 @@ int cdrom_get_disc_info(kdev_t dev, disc_information *di) /* return the last written block on the CD-R media. this is for the udf file system. */ -int cdrom_get_last_written(kdev_t dev, long *last_written) -{ - struct cdrom_device_info *cdi = cdrom_find_device(dev); +int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written) +{ struct cdrom_tocentry toc; disc_information di; track_information ti; @@ -2290,17 +2287,17 @@ int cdrom_get_last_written(kdev_t dev, long *last_written) if (!CDROM_CAN(CDC_GENERIC_PACKET)) goto use_toc; - if ((ret = cdrom_get_disc_info(dev, &di))) + if ((ret = cdrom_get_disc_info(cdi, &di))) goto use_toc; last_track = (di.last_track_msb << 8) | di.last_track_lsb; - if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti))) + if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti))) goto use_toc; /* if this track is blank, try the previous. */ if (ti.blank) { last_track--; - if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti))) + if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti))) goto use_toc; } @@ -2330,9 +2327,8 @@ use_toc: } /* return the next writable block. also for udf file system. */ -int cdrom_get_next_writable(kdev_t dev, long *next_writable) +static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable) { - struct cdrom_device_info *cdi = cdrom_find_device(dev); disc_information di; track_information ti; __u16 last_track; @@ -2341,17 +2337,17 @@ int cdrom_get_next_writable(kdev_t dev, long *next_writable) if (!CDROM_CAN(CDC_GENERIC_PACKET)) goto use_last_written; - if ((ret = cdrom_get_disc_info(dev, &di))) + if ((ret = cdrom_get_disc_info(cdi, &di))) goto use_last_written; last_track = (di.last_track_msb << 8) | di.last_track_lsb; - if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti))) + if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti))) goto use_last_written; /* if this track is blank, try the previous. */ if (ti.blank) { last_track--; - if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti))) + if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti))) goto use_last_written; } @@ -2364,7 +2360,7 @@ int cdrom_get_next_writable(kdev_t dev, long *next_writable) return 0; use_last_written: - if ((ret = cdrom_get_last_written(dev, next_writable))) { + if ((ret = cdrom_get_last_written(cdi, next_writable))) { *next_writable = 0; return ret; } else { @@ -2373,11 +2369,7 @@ use_last_written: } } -EXPORT_SYMBOL(cdrom_get_disc_info); -EXPORT_SYMBOL(cdrom_get_track_info); -EXPORT_SYMBOL(cdrom_get_next_writable); EXPORT_SYMBOL(cdrom_get_last_written); -EXPORT_SYMBOL(cdrom_count_tracks); EXPORT_SYMBOL(register_cdrom); EXPORT_SYMBOL(unregister_cdrom); EXPORT_SYMBOL(cdrom_open); @@ -2385,11 +2377,9 @@ EXPORT_SYMBOL(cdrom_release); EXPORT_SYMBOL(cdrom_ioctl); EXPORT_SYMBOL(cdrom_media_changed); EXPORT_SYMBOL(cdrom_number_of_slots); -EXPORT_SYMBOL(cdrom_select_disc); EXPORT_SYMBOL(cdrom_mode_select); EXPORT_SYMBOL(cdrom_mode_sense); EXPORT_SYMBOL(init_cdrom_command); -EXPORT_SYMBOL(cdrom_find_device); #ifdef CONFIG_SYSCTL diff --git a/drivers/char/pty.c b/drivers/char/pty.c index fc6d0fe36b66..e9acfc1a5ae1 100644 --- a/drivers/char/pty.c +++ b/drivers/char/pty.c @@ -25,8 +25,6 @@ #include <asm/uaccess.h> #include <asm/system.h> #include <asm/bitops.h> - -#define BUILDING_PTY_C 1 #include <linux/devpts_fs.h> struct pty_struct { diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c index 4a2bd436f8e4..1c7b4b01d3a4 100644 --- a/drivers/char/tty_io.c +++ b/drivers/char/tty_io.c @@ -1336,7 +1336,7 @@ retry_open: ptmx_found: set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */ minor -= driver->minor_start; - devpts_pty_new(driver->other->name_base + minor, mk_kdev(driver->other->major, minor + driver->other->minor_start)); + devpts_pty_new(driver->other->name_base + minor, MKDEV(driver->other->major, minor + driver->other->minor_start)); tty_register_devfs(&pts_driver[major], DEVFS_FL_DEFAULT, pts_driver[major].minor_start + minor); noctty = 1; diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c index 104c928813a4..0e0388efd705 100644 --- a/drivers/ide/ide-cd.c +++ b/drivers/ide/ide-cd.c @@ -1937,9 +1937,9 @@ static int cdrom_read_tocentry(struct ata_device *drive, int trackno, int msf_fl /* Try to read the entire TOC for the disk into our internal buffer. */ static int cdrom_read_toc(struct ata_device *drive, struct request_sense *sense) { - int minor, stat, ntracks, i; - kdev_t dev; + int stat, ntracks, i; struct cdrom_info *info = drive->driver_data; + struct cdrom_device_info *cdi = &info->devinfo; struct atapi_toc *toc = info->toc; struct { struct atapi_toc_header hdr; @@ -2071,10 +2071,8 @@ static int cdrom_read_toc(struct ata_device *drive, struct request_sense *sense) toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track); /* Now try to get the total cdrom capacity. */ - minor = (drive->select.b.unit) << PARTN_BITS; - dev = mk_kdev(drive->channel->major, minor); /* FIXME: This is making worng assumptions about register layout. */ - stat = cdrom_get_last_written(dev, (unsigned long *) &toc->capacity); + stat = cdrom_get_last_written(cdi, (unsigned long *) &toc->capacity); if (stat) stat = cdrom_read_capacity(drive, &toc->capacity, sense); if (stat) diff --git a/drivers/md/linear.c b/drivers/md/linear.c index d8f29104dacf..daeeb075182c 100644 --- a/drivers/md/linear.c +++ b/drivers/md/linear.c @@ -60,7 +60,6 @@ static int linear_run (mddev_t *mddev) goto out; } - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->size = rdev->size; @@ -163,7 +162,7 @@ static int linear_make_request (request_queue_t *q, struct bio *bio) if (block >= (tmp_dev->size + tmp_dev->offset) || block < tmp_dev->offset) { - printk ("linear_make_request: Block %ld out of bounds on dev %s size %ld offset %ld\n", block, kdevname(tmp_dev->dev), tmp_dev->size, tmp_dev->offset); + printk ("linear_make_request: Block %ld out of bounds on dev %s size %ld offset %ld\n", block, bdevname(tmp_dev->bdev), tmp_dev->size, tmp_dev->offset); bio_io_error(bio); return 0; } @@ -186,11 +185,11 @@ static int linear_status (char *page, mddev_t *mddev) for (j = 0; j < conf->nr_zones; j++) { sz += sprintf(page+sz, "[%s", - partition_name(conf->hash_table[j].dev0->dev)); + bdev_partition_name(conf->hash_table[j].dev0->bdev)); if (conf->hash_table[j].dev1) sz += sprintf(page+sz, "/%s] ", - partition_name(conf->hash_table[j].dev1->dev)); + bdev_partition_name(conf->hash_table[j].dev1->bdev)); else sz += sprintf(page+sz, "] "); } diff --git a/drivers/md/md.c b/drivers/md/md.c index 05c8b963b8cd..7df31c2d5a57 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -297,20 +297,20 @@ char * partition_name(kdev_t dev) return dname->name; } -static unsigned int calc_dev_sboffset(kdev_t dev, mddev_t *mddev, +static unsigned int calc_dev_sboffset(mdk_rdev_t *rdev, mddev_t *mddev, int persistent) { - unsigned int size = (blkdev_size_in_bytes(dev) >> BLOCK_SIZE_BITS); + unsigned int size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS; if (persistent) size = MD_NEW_SIZE_BLOCKS(size); return size; } -static unsigned int calc_dev_size(kdev_t dev, mddev_t *mddev, int persistent) +static unsigned int calc_dev_size(mdk_rdev_t *rdev, mddev_t *mddev, int persistent) { unsigned int size; - size = calc_dev_sboffset(dev, mddev, persistent); + size = calc_dev_sboffset(rdev, mddev, persistent); if (!mddev->sb) { MD_BUG(); return size; @@ -467,7 +467,7 @@ static int read_disk_sb(mdk_rdev_t * rdev) * * It also happens to be a multiple of 4Kb. */ - sb_offset = calc_dev_sboffset(rdev->dev, rdev->mddev, 1); + sb_offset = calc_dev_sboffset(rdev, rdev->mddev, 1); rdev->sb_offset = sb_offset; if (!sync_page_io(rdev->bdev, sb_offset<<1, MD_SB_BYTES, rdev->sb_page, READ)) @@ -850,7 +850,7 @@ static int write_disk_sb(mdk_rdev_t * rdev) return 1; } - sb_offset = calc_dev_sboffset(dev, rdev->mddev, 1); + sb_offset = calc_dev_sboffset(rdev, rdev->mddev, 1); if (rdev->sb_offset != sb_offset) { printk(KERN_INFO "%s's sb offset has changed from %ld to %ld, skipping\n", partition_name(dev), rdev->sb_offset, sb_offset); @@ -861,7 +861,7 @@ static int write_disk_sb(mdk_rdev_t * rdev) * its size has changed to zero silently, and the MD code does * not yet know that it's faulty. */ - size = calc_dev_size(dev, rdev->mddev, 1); + size = calc_dev_size(rdev, rdev->mddev, 1); if (size != rdev->size) { printk(KERN_INFO "%s's size has changed from %ld to %ld since import, skipping\n", partition_name(dev), rdev->size, size); @@ -1001,19 +1001,19 @@ void md_update_sb(mddev_t *mddev) * * a faulty rdev _never_ has rdev->sb set. */ -static int md_import_device(kdev_t newdev, int on_disk) +static mdk_rdev_t *md_import_device(kdev_t newdev, int on_disk) { int err; mdk_rdev_t *rdev; unsigned int size; if (find_rdev_all(newdev)) - return -EEXIST; + return ERR_PTR(-EEXIST); rdev = (mdk_rdev_t *) kmalloc(sizeof(*rdev), GFP_KERNEL); if (!rdev) { printk(KERN_ERR "md: could not alloc mem for %s!\n", partition_name(newdev)); - return -ENOMEM; + return ERR_PTR(-ENOMEM); } memset(rdev, 0, sizeof(*rdev)); @@ -1030,7 +1030,7 @@ static int md_import_device(kdev_t newdev, int on_disk) rdev->desc_nr = -1; rdev->faulty = 0; - size = (blkdev_size_in_bytes(newdev) >> BLOCK_SIZE_BITS); + size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS; if (!size) { printk(KERN_WARNING "md: %s has zero or unknown size, marking faulty!\n", @@ -1066,7 +1066,7 @@ static int md_import_device(kdev_t newdev, int on_disk) if (rdev->faulty && rdev->sb) free_disk_sb(rdev); - return 0; + return rdev; abort_free: if (rdev->sb) { @@ -1075,7 +1075,7 @@ abort_free: free_disk_sb(rdev); } kfree(rdev); - return err; + return ERR_PTR(err); } /* @@ -1463,7 +1463,7 @@ static int device_size_calculation(mddev_t * mddev) MD_BUG(); continue; } - rdev->size = calc_dev_size(rdev->dev, mddev, persistent); + rdev->size = calc_dev_size(rdev, mddev, persistent); if (rdev->size < sb->chunk_size / 1024) { printk(KERN_WARNING "md: Dev %s smaller than chunk_size: %ldk < %dk\n", @@ -1741,8 +1741,7 @@ static int do_md_stop(mddev_t * mddev, int ro) md_unregister_thread(mddev->sync_thread); mddev->sync_thread = NULL; if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; } } @@ -1951,16 +1950,12 @@ static int autostart_array(kdev_t startdev) mdp_super_t *sb = NULL; mdk_rdev_t *start_rdev = NULL, *rdev; - if (md_import_device(startdev, 1)) { + start_rdev = md_import_device(startdev, 1); + if (IS_ERR(start_rdev)) { printk(KERN_WARNING "md: could not import %s!\n", partition_name(startdev)); goto abort; } - start_rdev = find_rdev_all(startdev); - if (!start_rdev) { - MD_BUG(); - goto abort; - } if (start_rdev->faulty) { printk(KERN_WARNING "md: can not autostart based on faulty %s!\n", partition_name(startdev)); @@ -1989,16 +1984,12 @@ static int autostart_array(kdev_t startdev) continue; if (kdev_same(dev, startdev)) continue; - if (md_import_device(dev, 1)) { + rdev = md_import_device(dev, 1); + if (IS_ERR(rdev)) { printk(KERN_WARNING "md: could not import %s, trying to run array nevertheless.\n", partition_name(dev)); continue; } - rdev = find_rdev_all(dev); - if (!rdev) { - MD_BUG(); - goto abort; - } list_add(&rdev->pending, &pending_raid_disks); } @@ -2108,7 +2099,7 @@ static int get_disk_info(mddev_t * mddev, void * arg) static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) { - int err, size, persistent; + int size, persistent; mdk_rdev_t *rdev; unsigned int nr; kdev_t dev; @@ -2121,14 +2112,9 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) } if (!mddev->sb) { /* expecting a device which has a superblock */ - err = md_import_device(dev, 1); - if (err) { - printk(KERN_WARNING "md: md_import_device returned %d\n", err); - return -EINVAL; - } - rdev = find_rdev_all(dev); - if (!rdev) { - MD_BUG(); + rdev = md_import_device(dev, 1); + if (IS_ERR(rdev)) { + printk(KERN_WARNING "md: md_import_device returned %ld\n", PTR_ERR(rdev)); return -EINVAL; } if (!list_empty(&mddev->disks)) { @@ -2165,17 +2151,11 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) SET_SB(state); if (!(info->state & (1<<MD_DISK_FAULTY))) { - err = md_import_device (dev, 0); - if (err) { - printk(KERN_WARNING "md: error, md_import_device() returned %d\n", err); + rdev = md_import_device (dev, 0); + if (IS_ERR(rdev)) { + printk(KERN_WARNING "md: error, md_import_device() returned %ld\n", PTR_ERR(rdev)); return -EINVAL; } - rdev = find_rdev_all(dev); - if (!rdev) { - MD_BUG(); - return -EINVAL; - } - rdev->old_dev = dev; rdev->desc_nr = info->number; @@ -2185,8 +2165,8 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) if (!persistent) printk(KERN_INFO "md: nonpersistent superblock ...\n"); - size = calc_dev_size(dev, mddev, persistent); - rdev->sb_offset = calc_dev_sboffset(dev, mddev, persistent); + size = calc_dev_size(rdev, mddev, persistent); + rdev->sb_offset = calc_dev_sboffset(rdev, mddev, persistent); if (!mddev->sb->size || (mddev->sb->size > size)) mddev->sb->size = size; @@ -2250,7 +2230,7 @@ static int hot_remove_disk(mddev_t * mddev, kdev_t dev) printk(KERN_INFO "md: trying to remove %s from md%d ... \n", partition_name(dev), mdidx(mddev)); - if (!mddev->pers->diskop) { + if (!mddev->pers->hot_remove_disk) { printk(KERN_WARNING "md%d: personality does not support diskops!\n", mdidx(mddev)); return -EINVAL; @@ -2274,7 +2254,7 @@ static int hot_remove_disk(mddev_t * mddev, kdev_t dev) return -EINVAL; } - err = mddev->pers->diskop(mddev, &disk, DISKOP_HOT_REMOVE_DISK); + err = mddev->pers->hot_remove_disk(mddev, disk->number); if (err == -EBUSY) { MD_BUG(); goto busy; @@ -2308,35 +2288,31 @@ static int hot_add_disk(mddev_t * mddev, kdev_t dev) printk(KERN_INFO "md: trying to hot-add %s to md%d ... \n", partition_name(dev), mdidx(mddev)); - if (!mddev->pers->diskop) { + if (!mddev->pers->hot_add_disk) { printk(KERN_WARNING "md%d: personality does not support diskops!\n", mdidx(mddev)); return -EINVAL; } - persistent = !mddev->sb->not_persistent; - size = calc_dev_size(dev, mddev, persistent); - - if (size < mddev->sb->size) { - printk(KERN_WARNING "md%d: disk size %d blocks < array size %d\n", - mdidx(mddev), size, mddev->sb->size); - return -ENOSPC; - } - rdev = find_rdev(mddev, dev); if (rdev) return -EBUSY; - err = md_import_device (dev, 0); - if (err) { - printk(KERN_WARNING "md: error, md_import_device() returned %d\n", err); + rdev = md_import_device (dev, 0); + if (IS_ERR(rdev)) { + printk(KERN_WARNING "md: error, md_import_device() returned %ld\n", PTR_ERR(rdev)); return -EINVAL; } - rdev = find_rdev_all(dev); - if (!rdev) { - MD_BUG(); - return -EINVAL; + persistent = !mddev->sb->not_persistent; + size = calc_dev_size(rdev, mddev, persistent); + + if (size < mddev->sb->size) { + printk(KERN_WARNING "md%d: disk size %d blocks < array size %d\n", + mdidx(mddev), size, mddev->sb->size); + err = -ENOSPC; + goto abort_export; } + if (rdev->faulty) { printk(KERN_WARNING "md: can not hot-add faulty %s disk to md%d!\n", partition_name(dev), mdidx(mddev)); @@ -2351,7 +2327,7 @@ static int hot_add_disk(mddev_t * mddev, kdev_t dev) */ rdev->old_dev = dev; rdev->size = size; - rdev->sb_offset = calc_dev_sboffset(dev, mddev, persistent); + rdev->sb_offset = calc_dev_sboffset(rdev, mddev, persistent); disk = mddev->sb->disks + mddev->sb->raid_disks; for (i = mddev->sb->raid_disks; i < MD_SB_DISKS; i++) { @@ -2386,7 +2362,7 @@ static int hot_add_disk(mddev_t * mddev, kdev_t dev) disk->major = major(dev); disk->minor = minor(dev); - if (mddev->pers->diskop(mddev, &disk, DISKOP_HOT_ADD_DISK)) { + if (mddev->pers->hot_add_disk(mddev, disk, rdev)) { MD_BUG(); err = -EINVAL; goto abort_unbind_export; @@ -2922,7 +2898,7 @@ int md_error(mddev_t *mddev, struct block_device *bdev) if (!rrdev || rrdev->faulty) return 0; if (!mddev->pers->error_handler - || mddev->pers->error_handler(mddev,rdev) <= 0) { + || mddev->pers->error_handler(mddev,bdev) <= 0) { rrdev->faulty = 1; } else return 1; @@ -3134,8 +3110,9 @@ mdp_disk_t *get_spare(mddev_t *mddev) } static unsigned int sync_io[DK_MAX_MAJOR][DK_MAX_DISK]; -void md_sync_acct(kdev_t dev, unsigned long nr_sectors) +void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors) { + kdev_t dev = to_kdev_t(bdev->bd_dev); unsigned int major = major(dev); unsigned int index; @@ -3367,7 +3344,7 @@ void md_do_recovery(void *data) ITERATE_MDDEV(mddev,tmp) if (mddev_lock(mddev)==0) { sb = mddev->sb; - if (!sb || !mddev->pers || !mddev->pers->diskop || mddev->ro) + if (!sb || !mddev->pers || mddev->ro) goto unlock; if (mddev->recovery_running > 0) /* resync/recovery still happening */ @@ -3381,16 +3358,19 @@ void md_do_recovery(void *data) * If we were doing a reconstruction, * we need to retrieve the spare */ + if (!mddev->pers->spare_inactive) + goto unlock; if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; } } else { + if (!mddev->pers->spare_active) + goto unlock; /* success...*/ if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_ACTIVE); + mddev->pers->spare_active(mddev, + &mddev->spare); mark_disk_sync(mddev->spare); mark_disk_active(mddev->spare); sb->active_disks++; @@ -3429,12 +3409,13 @@ void md_do_recovery(void *data) if (!mddev->sync_thread) { printk(KERN_ERR "md%d: could not start resync thread...\n", mdidx(mddev)); if (mddev->spare) - mddev->pers->diskop(mddev, &mddev->spare, DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; mddev->recovery_running = 0; } else { if (mddev->spare) - mddev->pers->diskop(mddev, &mddev->spare, DISKOP_SPARE_WRITE); + mddev->pers->spare_write(mddev, + mddev->spare->number); mddev->recovery_running = 1; md_wakeup_thread(mddev->sync_thread); } @@ -3588,19 +3569,12 @@ static void autostart_arrays(void) for (i = 0; i < dev_cnt; i++) { kdev_t dev = detected_devices[i]; - if (md_import_device(dev,1)) { + rdev = md_import_device(dev,1); + if (IS_ERR(rdev)) { printk(KERN_ALERT "md: could not import %s!\n", partition_name(dev)); continue; } - /* - * Sanity checks: - */ - rdev = find_rdev_all(dev); - if (!rdev) { - MD_BUG(); - continue; - } if (rdev->faulty) { MD_BUG(); continue; diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c index 32dc200aee66..ac08a9a90611 100644 --- a/drivers/md/multipath.c +++ b/drivers/md/multipath.c @@ -55,9 +55,8 @@ static mdk_personality_t multipath_personality; static spinlock_t retry_list_lock = SPIN_LOCK_UNLOCKED; struct multipath_bh *multipath_retry_list = NULL, **multipath_retry_tail; -static int multipath_diskop(mddev_t *mddev, mdp_disk_t **d, int state); - - +static int multipath_spare_write(mddev_t *, int); +static int multipath_spare_active(mddev_t *mddev, mdp_disk_t **d); static struct multipath_bh *multipath_alloc_mpbh(multipath_conf_t *conf) { @@ -313,14 +312,14 @@ static void mark_disk_bad (mddev_t *mddev, int failed) mddev->sb_dirty = 1; md_wakeup_thread(conf->thread); conf->working_disks--; - printk (DISK_FAILED, partition_name (multipath->dev), + printk (DISK_FAILED, bdev_partition_name (multipath->bdev), conf->working_disks); } /* * Careful, this can execute in IRQ contexts as well! */ -static int multipath_error (mddev_t *mddev, kdev_t dev) +static int multipath_error (mddev_t *mddev, struct block_device *bdev) { multipath_conf_t *conf = mddev_to_conf(mddev); struct multipath_info * multipaths = conf->multipaths; @@ -345,7 +344,7 @@ static int multipath_error (mddev_t *mddev, kdev_t dev) * which has just failed. */ for (i = 0; i < disks; i++) { - if (kdev_same(multipaths[i].dev, dev) && !multipaths[i].operational) + if (multipaths[i].bdev == bdev && !multipaths[i].operational) return 0; } printk (LAST_DISK); @@ -354,7 +353,7 @@ static int multipath_error (mddev_t *mddev, kdev_t dev) * Mark disk as unusable */ for (i = 0; i < disks; i++) { - if (kdev_same(multipaths[i].dev,dev) && multipaths[i].operational) { + if (multipaths[i].bdev == bdev && multipaths[i].operational) { mark_disk_bad(mddev, i); break; } @@ -366,11 +365,11 @@ static int multipath_error (mddev_t *mddev, kdev_t dev) spare = get_spare(mddev); if (spare) { - err = multipath_diskop(mddev, &spare, DISKOP_SPARE_WRITE); + err = multipath_spare_write(mddev, spare->number); printk("got DISKOP_SPARE_WRITE err: %d. (spare_faulty(): %d)\n", err, disk_faulty(spare)); } if (!err && !disk_faulty(spare)) { - multipath_diskop(mddev, &spare, DISKOP_SPARE_ACTIVE); + multipath_spare_active(mddev, &spare); mark_disk_sync(spare); mark_disk_active(spare); sb->active_disks++; @@ -406,259 +405,240 @@ static void print_multipath_conf (multipath_conf_t *conf) printk(" disk%d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare,tmp->operational, tmp->number,tmp->raid_disk,tmp->used_slot, - partition_name(tmp->dev)); + bdev_partition_name(tmp->bdev)); } } -static int multipath_diskop(mddev_t *mddev, mdp_disk_t **d, int state) +/* + * Find the spare disk ... (can only be in the 'high' area of the array) + */ +static struct multipath_info *find_spare(mddev_t *mddev, int number) { - int err = 0; - int i, failed_disk=-1, spare_disk=-1, removed_disk=-1, added_disk=-1; multipath_conf_t *conf = mddev->private; - struct multipath_info *tmp, *sdisk, *fdisk, *rdisk, *adisk; - mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; - mdk_rdev_t *spare_rdev, *failed_rdev; - struct block_device *bdev; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (p->spare && p->number == number) + return p; + } + return NULL; +} + +static int multipath_spare_inactive(mddev_t *mddev) +{ + multipath_conf_t *conf = mddev->private; + struct multipath_info *p; + int err = 0; print_multipath_conf(conf); spin_lock_irq(&conf->device_lock); - /* - * find the disk ... - */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); - /* - * Find the failed disk within the MULTIPATH configuration ... - * (this can only be in the first conf->working_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->multipaths + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } - } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - /* fall through */ + print_multipath_conf(conf); + return err; +} - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: +static int multipath_spare_write(mddev_t *mddev, int number) +{ + multipath_conf_t *conf = mddev->private; + struct multipath_info *p; + int err = 0; - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - - case DISKOP_HOT_REMOVE_DISK: - - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - printk(KERN_ERR "hot-remove-disk, slot %d is identified to be the requested disk (number %d), but is still operational!\n", i, (*d)->number); - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p) { + p->operational = 1; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); - case DISKOP_HOT_ADD_DISK: + print_multipath_conf(conf); + return err; +} - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - } +static int multipath_spare_active(mddev_t *mddev, mdp_disk_t **d) +{ + int err = 0; + int i, failed_disk=-1, spare_disk=-1; + multipath_conf_t *conf = mddev->private; + struct multipath_info *tmp, *sdisk, *fdisk; + mdp_super_t *sb = mddev->sb; + mdp_disk_t *failed_desc, *spare_desc; + mdk_rdev_t *spare_rdev, *failed_rdev; - switch (state) { + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); /* - * Switch the spare disk to write-only mode: + * Find the failed disk within the MULTIPATH configuration ... + * (this can only be in the first conf->working_disks part) */ - case DISKOP_SPARE_WRITE: - sdisk = conf->multipaths + spare_disk; - sdisk->operational = 1; - break; + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->multipaths + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; + } + } /* - * Deactivate a spare disk: + * When we activate a spare disk we _must_ have a disk in + * the lower (active) part of the array to replace. */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->multipaths + spare_disk; - sdisk->operational = 0; - break; + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->nr_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * Find the spare disk ... (can only be in the 'high' + * area of the array) */ - case DISKOP_SPARE_ACTIVE: - sdisk = conf->multipaths + spare_disk; - fdisk = conf->multipaths + failed_disk; - - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; - - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->multipaths + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } + sdisk = conf->multipaths + spare_disk; + fdisk = conf->multipaths + failed_disk; - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; + } - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); - xchg_values(spare_rdev->desc_nr, failed_rdev->desc_nr); - spare_rdev->alias_device = 0; - failed_rdev->alias_device = 1; + /* + * do the switch finally + */ + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + xchg_values(spare_rdev->desc_nr, failed_rdev->desc_nr); + spare_rdev->alias_device = 0; + failed_rdev->alias_device = 1; - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + /* + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) + */ - *d = failed_desc; + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - if (!sdisk->bdev) - sdisk->used_slot = 0; - /* - * this really activates the spare. - */ - fdisk->spare = 0; + *d = failed_desc; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ + if (!sdisk->bdev) + sdisk->used_slot = 0; + /* + * this really activates the spare. + */ + fdisk->spare = 0; - conf->working_disks++; + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ - break; + conf->working_disks++; +abort: + spin_unlock_irq(&conf->device_lock); - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->multipaths + removed_disk; + print_multipath_conf(conf); + return err; +} - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - bdev = rdisk->bdev; - rdisk->dev = NODEV; - rdisk->bdev = NULL; - rdisk->used_slot = 0; - conf->nr_disks--; - bdput(bdev); - break; - - case DISKOP_HOT_ADD_DISK: - adisk = conf->multipaths + added_disk; - added_desc = *d; - - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; +static int multipath_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + multipath_conf_t *conf = mddev->private; + int err = 1; + int i; + + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + p->bdev = rdev->bdev; + p->operational = 0; + p->spare = 1; + p->used_slot = 1; + conf->nr_disks++; + err = 0; + break; } + } + if (err) + MD_BUG(); + spin_unlock_irq(&conf->device_lock); - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - adisk->dev = mk_kdev(added_desc->major,added_desc->minor); - /* it will be held open by rdev */ - adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); + print_multipath_conf(conf); + return err; +} - adisk->operational = 0; - adisk->spare = 1; - adisk->used_slot = 1; - conf->nr_disks++; +static int multipath_remove_disk(mddev_t *mddev, int number) +{ + multipath_conf_t *conf = mddev->private; + int err = 1; + int i; - break; + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); - default: - MD_BUG(); - err = 1; - goto abort; + for (i = 0; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (p->used_slot && (p->number == number)) { + if (p->operational) { + printk(KERN_ERR "hot-remove-disk, slot %d is identified to be the requested disk (number %d), but is still operational!\n", i, number); + err = -EBUSY; + goto abort; + } + if (p->spare && i < conf->raid_disks) + break; + p->bdev = NULL; + p->used_slot = 0; + conf->nr_disks--; + err = 0; + break; + } } + if (err) + MD_BUG(); abort: spin_unlock_irq(&conf->device_lock); @@ -666,7 +646,6 @@ abort: return err; } - #define IO_ERROR KERN_ALERT \ "multipath: %s: unrecoverable IO read error for block %lu\n" @@ -872,7 +851,7 @@ static int multipath_run (mddev_t *mddev) if (rdev->faulty) { /* this is a "should never happen" case and if it */ /* ever does happen, a continue; won't help */ - printk(ERRORS, partition_name(rdev->dev)); + printk(ERRORS, bdev_partition_name(rdev->bdev)); continue; } else { /* this is a "should never happen" case and if it */ @@ -892,7 +871,7 @@ static int multipath_run (mddev_t *mddev) disk = conf->multipaths + disk_idx; if (!disk_sync(desc)) - printk(NOT_IN_SYNC, partition_name(rdev->dev)); + printk(NOT_IN_SYNC, bdev_partition_name(rdev->bdev)); /* * Mark all disks as spare to start with, then pick our @@ -901,7 +880,6 @@ static int multipath_run (mddev_t *mddev) */ disk->number = desc->number; disk->raid_disk = desc->raid_disk; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -911,7 +889,7 @@ static int multipath_run (mddev_t *mddev) if (disk_active(desc)) { if(!conf->working_disks) { - printk(OPERATIONAL, partition_name(rdev->dev), + printk(OPERATIONAL, bdev_partition_name(rdev->bdev), desc->raid_disk); disk->operational = 1; disk->spare = 0; @@ -928,7 +906,7 @@ static int multipath_run (mddev_t *mddev) if(!conf->working_disks && num_rdevs) { desc = &sb->disks[def_rdev->desc_nr]; disk = conf->multipaths + desc->raid_disk; - printk(OPERATIONAL, partition_name(def_rdev->dev), + printk(OPERATIONAL, bdev_partition_name(def_rdev->bdev), disk->raid_disk); disk->operational = 1; disk->spare = 0; @@ -1074,7 +1052,11 @@ static mdk_personality_t multipath_personality= stop: multipath_stop, status: multipath_status, error_handler: multipath_error, - diskop: multipath_diskop, + hot_add_disk: multipath_add_disk, + hot_remove_disk:multipath_remove_disk, + spare_inactive: multipath_spare_inactive, + spare_active: multipath_spare_active, + spare_write: multipath_spare_write, }; static int __init multipath_init (void) diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index 4c855576f9fe..088993cf5165 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -589,10 +589,10 @@ static void mark_disk_bad(mddev_t *mddev, int failed) md_wakeup_thread(conf->thread); if (!mirror->write_only) conf->working_disks--; - printk(DISK_FAILED, partition_name(mirror->dev), conf->working_disks); + printk(DISK_FAILED, bdev_partition_name(mirror->bdev), conf->working_disks); } -static int error(mddev_t *mddev, kdev_t dev) +static int error(mddev_t *mddev, struct block_device *bdev) { conf_t *conf = mddev_to_conf(mddev); mirror_info_t * mirrors = conf->mirrors; @@ -607,7 +607,7 @@ static int error(mddev_t *mddev, kdev_t dev) * else mark the drive as failed */ for (i = 0; i < disks; i++) - if (kdev_same(mirrors[i].dev, dev) && mirrors[i].operational) + if (mirrors[i].bdev == bdev && mirrors[i].operational) break; if (i == disks) return 0; @@ -640,7 +640,7 @@ static void print_conf(conf_t *conf) printk(" disk %d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare, tmp->operational, tmp->number, tmp->raid_disk, tmp->used_slot, - partition_name(tmp->dev)); + bdev_partition_name(tmp->bdev)); } } @@ -658,263 +658,242 @@ static void close_sync(conf_t *conf) conf->r1buf_pool = NULL; } -static int diskop(mddev_t *mddev, mdp_disk_t **d, int state) +static mirror_info_t *find_spare(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (p->spare && p->number == number) + return p; + } + return NULL; +} + +static int raid1_spare_active(mddev_t *mddev, mdp_disk_t **d) { int err = 0; - int i, failed_disk = -1, spare_disk = -1, removed_disk = -1, added_disk = -1; + int i, failed_disk = -1, spare_disk = -1; conf_t *conf = mddev->private; - mirror_info_t *tmp, *sdisk, *fdisk, *rdisk, *adisk; + mirror_info_t *tmp, *sdisk, *fdisk; mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; + mdp_disk_t *failed_desc, *spare_desc; mdk_rdev_t *spare_rdev, *failed_rdev; - struct block_device *bdev; print_conf(conf); spin_lock_irq(&conf->device_lock); /* - * find the disk ... + * Find the failed disk within the RAID1 configuration ... + * (this can only be in the first conf->working_disks part) */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: - - /* - * Find the failed disk within the RAID1 configuration ... - * (this can only be in the first conf->working_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->mirrors + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->mirrors + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; + } + /* + * When we activate a spare disk we _must_ have a disk in + * the lower (active) part of the array to replace. + */ + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } + /* + * Find the spare disk ... (can only be in the 'high' + * area of the array) + */ + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->mirrors + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } - /* fall through */ - - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - - case DISKOP_HOT_REMOVE_DISK: - - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + sdisk = conf->mirrors + spare_disk; + fdisk = conf->mirrors + failed_disk; - case DISKOP_HOT_ADD_DISK: + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; } - switch (state) { - /* - * Switch the spare disk to write-only mode: - */ - case DISKOP_SPARE_WRITE: - sdisk = conf->mirrors + spare_disk; - sdisk->operational = 1; - sdisk->write_only = 1; - break; /* - * Deactivate a spare disk: + * do the switch finally */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->mirrors + spare_disk; - sdisk->operational = 0; - sdisk->write_only = 0; - break; + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->nr_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * There must be a spare_rdev, but there may not be a + * failed_rdev. That slot might be empty... */ - case DISKOP_SPARE_ACTIVE: - sdisk = conf->mirrors + spare_disk; - fdisk = conf->mirrors + failed_disk; - - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; - - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; - } + spare_rdev->desc_nr = failed_desc->number; + if (failed_rdev) + failed_rdev->desc_nr = spare_desc->number; - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } + /* + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) + */ + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); + *d = failed_desc; - /* - * There must be a spare_rdev, but there may not be a - * failed_rdev. That slot might be empty... - */ - spare_rdev->desc_nr = failed_desc->number; - if (failed_rdev) - failed_rdev->desc_nr = spare_desc->number; + if (!sdisk->bdev) + sdisk->used_slot = 0; + /* + * this really activates the spare. + */ + fdisk->spare = 0; + fdisk->write_only = 0; - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + conf->working_disks++; +abort: + spin_unlock_irq(&conf->device_lock); - *d = failed_desc; + print_conf(conf); + return err; +} - if (!sdisk->bdev) - sdisk->used_slot = 0; - /* - * this really activates the spare. - */ - fdisk->spare = 0; - fdisk->write_only = 0; +static int raid1_spare_inactive(mddev_t *mddev) +{ + conf_t *conf = mddev->private; + mirror_info_t *p; + int err = 0; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ + print_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + p->write_only = 0; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_conf(conf); + return err; +} - conf->working_disks++; +static int raid1_spare_write(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + mirror_info_t *p; + int err = 0; - break; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p) { + p->operational = 1; + p->write_only = 1; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_conf(conf); + return err; +} - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->mirrors + removed_disk; +static int raid1_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + conf_t *conf = mddev->private; + int err = 1; + int i; - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - bdev = rdisk->bdev; - rdisk->dev = NODEV; - rdisk->bdev = NULL; - rdisk->used_slot = 0; - conf->nr_disks--; - bdput(bdev); - break; - - case DISKOP_HOT_ADD_DISK: - adisk = conf->mirrors + added_disk; - added_desc = *d; - - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + /* + * find the disk ... + */ + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + /* it will be held open by rdev */ + p->bdev = rdev->bdev; + p->operational = 0; + p->write_only = 0; + p->spare = 1; + p->used_slot = 1; + p->head_position = 0; + conf->nr_disks++; + err = 0; + break; } + } + if (err) + MD_BUG(); + spin_unlock_irq(&conf->device_lock); - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - adisk->dev = mk_kdev(added_desc->major, added_desc->minor); - /* it will be held open by rdev */ - adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); - - adisk->operational = 0; - adisk->write_only = 0; - adisk->spare = 1; - adisk->used_slot = 1; - adisk->head_position = 0; - conf->nr_disks++; + print_conf(conf); + return err; +} - break; +static int raid1_remove_disk(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + int err = 1; + int i; - default: - MD_BUG(); - err = 1; - goto abort; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + for (i = 0; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (p->used_slot && (p->number == number)) { + if (p->operational) { + err = -EBUSY; + goto abort; + } + if (p->spare && (i < conf->raid_disks)) + break; + p->bdev = NULL; + p->used_slot = 0; + conf->nr_disks--; + err = 0; + break; + } } + if (err) + MD_BUG(); abort: spin_unlock_irq(&conf->device_lock); @@ -922,7 +901,6 @@ abort: return err; } - #define IO_ERROR KERN_ALERT \ "raid1: %s: unrecoverable I/O read error for block %lu\n" @@ -1045,7 +1023,7 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio) if (!mbio) continue; - md_sync_acct(to_kdev_t(mbio->bi_bdev->bd_dev), mbio->bi_size >> 9); + md_sync_acct(mbio->bi_bdev, mbio->bi_size >> 9); generic_make_request(mbio); atomic_inc(&conf->mirrors[i].nr_pending); } @@ -1217,7 +1195,7 @@ static int sync_request(mddev_t *mddev, sector_t sector_nr, int go_faster) BUG(); r1_bio->read_bio = read_bio; - md_sync_acct(to_kdev_t(read_bio->bi_bdev->bd_dev), nr_sectors); + md_sync_acct(read_bio->bi_bdev, nr_sectors); generic_make_request(read_bio); atomic_inc(&conf->mirrors[conf->last_used].nr_pending); @@ -1304,7 +1282,7 @@ static int run(mddev_t *mddev) ITERATE_RDEV(mddev, rdev, tmp) { if (rdev->faulty) { - printk(ERRORS, partition_name(rdev->dev)); + printk(ERRORS, bdev_partition_name(rdev->bdev)); } else { if (!rdev->sb) { MD_BUG(); @@ -1322,7 +1300,6 @@ static int run(mddev_t *mddev) if (disk_faulty(descriptor)) { disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -1335,27 +1312,26 @@ static int run(mddev_t *mddev) if (disk_active(descriptor)) { if (!disk_sync(descriptor)) { printk(NOT_IN_SYNC, - partition_name(rdev->dev)); + bdev_partition_name(rdev->bdev)); continue; } if ((descriptor->number > MD_SB_DISKS) || (disk_idx > sb->raid_disks)) { printk(INCONSISTENT, - partition_name(rdev->dev)); + bdev_partition_name(rdev->bdev)); continue; } if (disk->operational) { printk(ALREADY_RUNNING, - partition_name(rdev->dev), + bdev_partition_name(rdev->bdev), disk_idx); continue; } - printk(OPERATIONAL, partition_name(rdev->dev), + printk(OPERATIONAL, bdev_partition_name(rdev->bdev), disk_idx); disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 1; @@ -1368,10 +1344,9 @@ static int run(mddev_t *mddev) /* * Must be a spare disk .. */ - printk(SPARE, partition_name(rdev->dev)); + printk(SPARE, bdev_partition_name(rdev->bdev)); disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -1405,7 +1380,6 @@ static int run(mddev_t *mddev) !disk->used_slot) { disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = NODEV; disk->bdev = NULL; disk->operational = 0; disk->write_only = 0; @@ -1495,7 +1469,11 @@ static mdk_personality_t raid1_personality = stop: stop, status: status, error_handler: error, - diskop: diskop, + hot_add_disk: raid1_add_disk, + hot_remove_disk:raid1_remove_disk, + spare_write: raid1_spare_write, + spare_inactive: raid1_spare_inactive, + spare_active: raid1_spare_active, sync_request: sync_request }; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index f19d8d936f44..5d0af20344cc 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -439,7 +439,7 @@ static void raid5_build_block (struct stripe_head *sh, int i) dev->sector = compute_blocknr(sh, i); } -static int error (mddev_t *mddev, kdev_t dev) +static int error(mddev_t *mddev, struct block_device *bdev) { raid5_conf_t *conf = (raid5_conf_t *) mddev->private; mdp_super_t *sb = mddev->sb; @@ -449,36 +449,36 @@ static int error (mddev_t *mddev, kdev_t dev) PRINTK("raid5: error called\n"); for (i = 0, disk = conf->disks; i < conf->raid_disks; i++, disk++) { - if (kdev_same(disk->dev, dev)) { - if (disk->operational) { - disk->operational = 0; - mark_disk_faulty(sb->disks+disk->number); - mark_disk_nonsync(sb->disks+disk->number); - mark_disk_inactive(sb->disks+disk->number); - sb->active_disks--; - sb->working_disks--; - sb->failed_disks++; - mddev->sb_dirty = 1; - conf->working_disks--; - conf->failed_disks++; - md_wakeup_thread(conf->thread); - printk (KERN_ALERT - "raid5: Disk failure on %s, disabling device." - " Operation continuing on %d devices\n", - partition_name (dev), conf->working_disks); - } - return 0; + if (disk->bdev != bdev) + continue; + if (disk->operational) { + disk->operational = 0; + mark_disk_faulty(sb->disks+disk->number); + mark_disk_nonsync(sb->disks+disk->number); + mark_disk_inactive(sb->disks+disk->number); + sb->active_disks--; + sb->working_disks--; + sb->failed_disks++; + mddev->sb_dirty = 1; + conf->working_disks--; + conf->failed_disks++; + md_wakeup_thread(conf->thread); + printk (KERN_ALERT + "raid5: Disk failure on %s, disabling device." + " Operation continuing on %d devices\n", + bdev_partition_name(bdev), conf->working_disks); } + return 0; } /* * handle errors in spares (during reconstruction) */ if (conf->spare) { disk = conf->spare; - if (kdev_same(disk->dev, dev)) { + if (disk->bdev == bdev) { printk (KERN_ALERT "raid5: Disk failure on spare %s\n", - partition_name (dev)); + bdev_partition_name (bdev)); if (!conf->spare->operational) { /* probably a SET_DISK_FAULTY ioctl */ return -EIO; @@ -1017,7 +1017,7 @@ static void handle_stripe(struct stripe_head *sh) locked++; PRINTK("Reading block %d (sync=%d)\n", i, syncing); if (syncing) - md_sync_acct(conf->disks[i].dev, STRIPE_SECTORS); + md_sync_acct(conf->disks[i].bdev, STRIPE_SECTORS); } } } @@ -1156,9 +1156,9 @@ static void handle_stripe(struct stripe_head *sh) locked++; set_bit(STRIPE_INSYNC, &sh->state); if (conf->disks[failed_num].operational) - md_sync_acct(conf->disks[failed_num].dev, STRIPE_SECTORS); + md_sync_acct(conf->disks[failed_num].bdev, STRIPE_SECTORS); else if ((spare=conf->spare)) - md_sync_acct(spare->dev, STRIPE_SECTORS); + md_sync_acct(spare->bdev, STRIPE_SECTORS); } } @@ -1428,14 +1428,13 @@ static int run (mddev_t *mddev) disk = conf->disks + raid_disk; if (disk_faulty(desc)) { - printk(KERN_ERR "raid5: disabled device %s (errors detected)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (errors detected)\n", bdev_partition_name(rdev->bdev)); if (!rdev->faulty) { MD_BUG(); goto abort; } disk->number = desc->number; disk->raid_disk = raid_disk; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; disk->operational = 0; @@ -1446,23 +1445,22 @@ static int run (mddev_t *mddev) } if (disk_active(desc)) { if (!disk_sync(desc)) { - printk(KERN_ERR "raid5: disabled device %s (not in sync)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (not in sync)\n", bdev_partition_name(rdev->bdev)); MD_BUG(); goto abort; } if (raid_disk > sb->raid_disks) { - printk(KERN_ERR "raid5: disabled device %s (inconsistent descriptor)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (inconsistent descriptor)\n", bdev_partition_name(rdev->bdev)); continue; } if (disk->operational) { - printk(KERN_ERR "raid5: disabled device %s (device %d already operational)\n", partition_name(rdev->dev), raid_disk); + printk(KERN_ERR "raid5: disabled device %s (device %d already operational)\n", bdev_partition_name(rdev->bdev), raid_disk); continue; } - printk(KERN_INFO "raid5: device %s operational as raid disk %d\n", partition_name(rdev->dev), raid_disk); + printk(KERN_INFO "raid5: device %s operational as raid disk %d\n", bdev_partition_name(rdev->bdev), raid_disk); disk->number = desc->number; disk->raid_disk = raid_disk; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; disk->operational = 1; disk->used_slot = 1; @@ -1472,10 +1470,9 @@ static int run (mddev_t *mddev) /* * Must be a spare disk .. */ - printk(KERN_INFO "raid5: spare disk %s\n", partition_name(rdev->dev)); + printk(KERN_INFO "raid5: spare disk %s\n", bdev_partition_name(rdev->bdev)); disk->number = desc->number; disk->raid_disk = raid_disk; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; disk->operational = 0; @@ -1495,7 +1492,6 @@ static int run (mddev_t *mddev) disk->number = desc->number; disk->raid_disk = raid_disk; - disk->dev = NODEV; disk->bdev = NULL; disk->operational = 0; @@ -1691,282 +1687,246 @@ static void print_raid5_conf (raid5_conf_t *conf) printk(" disk %d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare,tmp->operational, tmp->number,tmp->raid_disk,tmp->used_slot, - partition_name(tmp->dev)); + bdev_partition_name(tmp->bdev)); + } +} + +static struct disk_info *find_spare(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (p->spare && p->number == number) + return p; } + return NULL; } -static int diskop(mddev_t *mddev, mdp_disk_t **d, int state) +static int raid5_spare_active(mddev_t *mddev, mdp_disk_t **d) { int err = 0; - int i, failed_disk=-1, spare_disk=-1, removed_disk=-1, added_disk=-1; + int i, failed_disk=-1, spare_disk=-1; raid5_conf_t *conf = mddev->private; - struct disk_info *tmp, *sdisk, *fdisk, *rdisk, *adisk; + struct disk_info *tmp, *sdisk, *fdisk; mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; + mdp_disk_t *failed_desc, *spare_desc; mdk_rdev_t *spare_rdev, *failed_rdev; print_raid5_conf(conf); spin_lock_irq(&conf->device_lock); + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->disks + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; + } + } + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } /* - * find the disk ... + * Find the spare disk ... (can only be in the 'high' + * area of the array) */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: - - /* - * Find the failed disk within the RAID5 configuration ... - * (this can only be in the first conf->raid_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->disks + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } - } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - /* fall through */ - - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: - - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->disks + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } - break; - - case DISKOP_HOT_REMOVE_DISK: + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (!conf->spare) { + MD_BUG(); + err = 1; + goto abort; + } + sdisk = conf->disks + spare_disk; + fdisk = conf->disks + failed_disk; - case DISKOP_HOT_ADD_DISK: + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; } - switch (state) { /* - * Switch the spare disk to write-only mode: + * do the switch finally */ - case DISKOP_SPARE_WRITE: - if (conf->spare) { - MD_BUG(); - err = 1; - goto abort; - } - sdisk = conf->disks + spare_disk; - sdisk->operational = 1; - sdisk->write_only = 1; - conf->spare = sdisk; - break; - /* - * Deactivate a spare disk: + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + + /* There must be a spare_rdev, but there may not be a + * failed_rdev. That slot might be empty... */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->disks + spare_disk; - sdisk->operational = 0; - sdisk->write_only = 0; - /* - * Was the spare being resynced? - */ - if (conf->spare == sdisk) - conf->spare = NULL; - break; + spare_rdev->desc_nr = failed_desc->number; + if (failed_rdev) + failed_rdev->desc_nr = spare_desc->number; + + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); + /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->raid_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) */ - case DISKOP_SPARE_ACTIVE: - if (!conf->spare) { - MD_BUG(); - err = 1; - goto abort; - } - sdisk = conf->disks + spare_disk; - fdisk = conf->disks + failed_disk; - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; - } + *d = failed_desc; - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } + if (!sdisk->bdev) + sdisk->used_slot = 0; - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); - - /* There must be a spare_rdev, but there may not be a - * failed_rdev. That slot might be empty... - */ - spare_rdev->desc_nr = failed_desc->number; - if (failed_rdev) - failed_rdev->desc_nr = spare_desc->number; - - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + /* + * this really activates the spare. + */ + fdisk->spare = 0; + fdisk->write_only = 0; - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ + conf->failed_disks--; + conf->working_disks++; + conf->spare = NULL; +abort: + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - *d = failed_desc; +static int raid5_spare_inactive(mddev_t *mddev) +{ + raid5_conf_t *conf = mddev->private; + struct disk_info *p; + int err = 0; - if (kdev_none(sdisk->dev)) - sdisk->used_slot = 0; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + p->write_only = 0; + if (conf->spare == p) + conf->spare = NULL; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - /* - * this really activates the spare. - */ - fdisk->spare = 0; - fdisk->write_only = 0; +static int raid5_spare_write(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + struct disk_info *p; + int err = 0; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ - conf->failed_disks--; - conf->working_disks++; - conf->spare = NULL; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p && !conf->spare) { + p->operational = 1; + p->write_only = 1; + conf->spare = p; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - break; +static int raid5_remove_disk(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + int err = 1; + int i; - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->disks + removed_disk; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; + for (i = 0; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (p->used_slot && p->number == number) { + if (p->operational) { + err = -EBUSY; + goto abort; + } + if (p->spare && i < conf->raid_disks) + break; + p->bdev = NULL; + p->used_slot = 0; + err = 0; + break; } - rdisk->dev = NODEV; - rdisk->bdev = NULL; - rdisk->used_slot = 0; + } + if (err) + MD_BUG(); +abort: + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - break; +static int raid5_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + raid5_conf_t *conf = mddev->private; + int err = 1; + int i; - case DISKOP_HOT_ADD_DISK: - adisk = conf->disks + added_disk; - added_desc = *d; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + /* + * find the disk ... + */ - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + /* it will be held open by rdev */ + p->bdev = rdev->bdev; + p->operational = 0; + p->write_only = 0; + p->spare = 1; + p->used_slot = 1; + err = 0; + break; } - - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - adisk->dev = mk_kdev(added_desc->major,added_desc->minor); - /* it will be held open by rdev */ - adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); - - adisk->operational = 0; - adisk->write_only = 0; - adisk->spare = 1; - adisk->used_slot = 1; - - - break; - - default: - MD_BUG(); - err = 1; - goto abort; } -abort: + if (err) + MD_BUG(); spin_unlock_irq(&conf->device_lock); print_raid5_conf(conf); return err; @@ -1980,7 +1940,11 @@ static mdk_personality_t raid5_personality= stop: stop, status: status, error_handler: error, - diskop: diskop, + hot_add_disk: raid5_add_disk, + hot_remove_disk:raid5_remove_disk, + spare_write: raid5_spare_write, + spare_inactive: raid5_spare_inactive, + spare_active: raid5_spare_active, sync_request: sync_request }; diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c index 7ed4d818f3e6..a9ae22858798 100644 --- a/drivers/scsi/sr.c +++ b/drivers/scsi/sr.c @@ -522,8 +522,8 @@ void get_sectorsize(int i) SCp->needs_sector_size = 1; } else { #if 0 - if (cdrom_get_last_written(mkdev(MAJOR_NR, i), - &scsi_CDs[i].capacity)) + if (cdrom_get_last_written(&SCp->cdi, + &SCp->capacity)) #endif SCp->capacity = 1 + ((buffer[0] << 24) | (buffer[1] << 16) | diff --git a/fs/Makefile b/fs/Makefile index 28fe3eb901db..2f516179753c 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -40,6 +40,7 @@ obj-$(CONFIG_QUOTACTL) += quota.o obj-$(CONFIG_PROC_FS) += proc/ obj-y += partitions/ obj-y += driverfs/ +obj-y += devpts/ # Do not add any filesystems before this line obj-$(CONFIG_EXT3_FS) += ext3/ # Before ext2 so root fs can be ext3 @@ -81,7 +82,6 @@ obj-$(CONFIG_AUTOFS_FS) += autofs/ obj-$(CONFIG_AUTOFS4_FS) += autofs4/ obj-$(CONFIG_ADFS_FS) += adfs/ obj-$(CONFIG_REISERFS_FS) += reiserfs/ -obj-$(CONFIG_DEVPTS_FS) += devpts/ obj-$(CONFIG_SUN_OPENPROMFS) += openpromfs/ obj-$(CONFIG_JFS_FS) += jfs/ diff --git a/fs/block_dev.c b/fs/block_dev.c index be2c8ef578de..ec7e816c7c0f 100644 --- a/fs/block_dev.c +++ b/fs/block_dev.c @@ -297,7 +297,6 @@ struct block_device *bdget(dev_t dev) new_bdev->bd_inode = inode; inode->i_mode = S_IFBLK; inode->i_rdev = kdev; - inode->i_dev = kdev; inode->i_bdev = new_bdev; inode->i_data.a_ops = &def_blk_aops; inode->i_data.gfp_mask = GFP_USER; diff --git a/fs/buffer.c b/fs/buffer.c index 8510f2bb9309..f96f5f48bd13 100644 --- a/fs/buffer.c +++ b/fs/buffer.c @@ -246,22 +246,6 @@ int fsync_bdev(struct block_device *bdev) } /* - * Write out and wait upon all dirty data associated with this - * kdev_t. Filesystem data as well as the underlying block - * device. Takes the superblock lock. - */ -int fsync_dev(kdev_t dev) -{ - struct block_device *bdev = bdget(kdev_t_to_nr(dev)); - if (bdev) { - int res = fsync_bdev(bdev); - bdput(bdev); - return res; - } - return 0; -} - -/* * sync everything. */ asmlinkage long sys_sync(void) diff --git a/fs/devpts/Makefile b/fs/devpts/Makefile index 59aba3c15f50..f80cfe5bd8cd 100644 --- a/fs/devpts/Makefile +++ b/fs/devpts/Makefile @@ -4,6 +4,6 @@ obj-$(CONFIG_DEVPTS_FS) += devpts.o -devpts-objs := root.o inode.o +devpts-objs := inode.o include $(TOPDIR)/Rules.make diff --git a/fs/devpts/devpts_i.h b/fs/devpts/devpts_i.h deleted file mode 100644 index da387ea1a932..000000000000 --- a/fs/devpts/devpts_i.h +++ /dev/null @@ -1,41 +0,0 @@ -/* -*- linux-c -*- --------------------------------------------------------- * - * - * linux/fs/devpts/devpts_i.h - * - * Copyright 1998 H. Peter Anvin -- All Rights Reserved - * - * This file is part of the Linux kernel and is made available under - * the terms of the GNU General Public License, version 2, or at your - * option, any later version, incorporated herein by reference. - * - * ------------------------------------------------------------------------- */ - -#include <linux/fs.h> -#include <linux/tty.h> -#include <linux/types.h> - -#define BUILDING_DEVPTS 1 -#include <linux/devpts_fs.h> - -struct devpts_sb_info { - u32 magic; - int setuid; - int setgid; - uid_t uid; - gid_t gid; - umode_t mode; - - unsigned int max_ptys; - struct inode **inodes; -}; - -#define DEVPTS_SUPER_MAGIC 0x1cd1 -#define DEVPTS_SBI_MAGIC 0x01da1d02 - -extern inline struct devpts_sb_info *SBI(struct super_block *sb) -{ - return (struct devpts_sb_info *)(sb->u.generic_sbp); -} - -extern struct inode_operations devpts_root_inode_operations; -extern struct file_operations devpts_root_operations; diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c index 0727e719279d..973c288fe28a 100644 --- a/fs/devpts/inode.c +++ b/fs/devpts/inode.c @@ -11,135 +11,70 @@ * ------------------------------------------------------------------------- */ #include <linux/module.h> - -#include <linux/string.h> -#include <linux/fs.h> #include <linux/init.h> -#include <linux/kdev_t.h> -#include <linux/kernel.h> -#include <linux/major.h> -#include <linux/slab.h> -#include <linux/stat.h> -#include <linux/tty.h> -#include <asm/bitops.h> -#include <asm/uaccess.h> +#include <linux/fs.h> +#include <linux/sched.h> +#include <linux/namei.h> -#include "devpts_i.h" +#define DEVPTS_SUPER_MAGIC 0x1cd1 static struct vfsmount *devpts_mnt; +static struct dentry *devpts_root; -static void devpts_put_super(struct super_block *sb) -{ - struct devpts_sb_info *sbi = SBI(sb); - struct inode *inode; - int i; +static struct { + int setuid; + int setgid; + uid_t uid; + gid_t gid; + umode_t mode; +} config = {mode: 0600}; - for ( i = 0 ; i < sbi->max_ptys ; i++ ) { - if ( (inode = sbi->inodes[i]) ) { - if ( atomic_read(&inode->i_count) != 1 ) - printk("devpts_put_super: badness: entry %d count %d\n", - i, atomic_read(&inode->i_count)); - inode->i_nlink--; - iput(inode); - } - } - kfree(sbi->inodes); - kfree(sbi); -} - -static int devpts_remount (struct super_block * sb, int * flags, char * data); - -static struct super_operations devpts_sops = { - put_super: devpts_put_super, - statfs: simple_statfs, - remount_fs: devpts_remount, -}; - -static int devpts_parse_options(char *options, struct devpts_sb_info *sbi) +static int devpts_remount(struct super_block *sb, int *flags, char *data) { int setuid = 0; int setgid = 0; uid_t uid = 0; gid_t gid = 0; umode_t mode = 0600; - char *this_char, *value; + char *this_char; this_char = NULL; - while ((this_char = strsep(&options, ",")) != NULL) { + while ((this_char = strsep(&data, ",")) != NULL) { + int n; + char dummy; if (!*this_char) continue; - if ((value = strchr(this_char,'=')) != NULL) - *value++ = 0; - if (!strcmp(this_char,"uid")) { - if (!value || !*value) - return 1; - uid = simple_strtoul(value,&value,0); - if (*value) - return 1; + if (sscanf(this_char, "uid=%i%c", &n, &dummy) == 1) { setuid = 1; - } - else if (!strcmp(this_char,"gid")) { - if (!value || !*value) - return 1; - gid = simple_strtoul(value,&value,0); - if (*value) - return 1; + uid = n; + } else if (sscanf(this_char, "gid=%i%c", &n, &dummy) == 1) { setgid = 1; + gid = n; + } else if (sscanf(this_char, "mode=%o%c", &n, &dummy) == 1) + mode = n & ~S_IFMT; + else { + printk("devpts: called with bogus options\n"); + return -EINVAL; } - else if (!strcmp(this_char,"mode")) { - if (!value || !*value) - return 1; - mode = simple_strtoul(value,&value,8); - if (*value) - return 1; - } - else - return 1; } - sbi->setuid = setuid; - sbi->setgid = setgid; - sbi->uid = uid; - sbi->gid = gid; - sbi->mode = mode & ~S_IFMT; + config.setuid = setuid; + config.setgid = setgid; + config.uid = uid; + config.gid = gid; + config.mode = mode; return 0; } -static int devpts_remount(struct super_block * sb, int * flags, char * data) -{ - struct devpts_sb_info *sbi = sb->u.generic_sbp; - int res = devpts_parse_options(data,sbi); - if (res) { - printk("devpts: called with bogus options\n"); - return -EINVAL; - } - return 0; -} +static struct super_operations devpts_sops = { + statfs: simple_statfs, + remount_fs: devpts_remount, +}; static int devpts_fill_super(struct super_block *s, void *data, int silent) { - int error = -ENOMEM; struct inode * inode; - struct devpts_sb_info *sbi; - - sbi = kmalloc(sizeof(*sbi), GFP_KERNEL); - if ( !sbi ) - goto fail; - memset(sbi, 0, sizeof(*sbi)); - - sbi->magic = DEVPTS_SBI_MAGIC; - sbi->max_ptys = unix98_max_ptys; - sbi->inodes = kmalloc(sizeof(struct inode *) * sbi->max_ptys, GFP_KERNEL); - if ( !sbi->inodes ) - goto fail_free; - memset(sbi->inodes, 0, sizeof(struct inode *) * sbi->max_ptys); - if ( devpts_parse_options(data,sbi) && !silent) { - error = -EINVAL; - printk("devpts: called with bogus options\n"); - goto fail_free; - } - s->u.generic_sbp = (void *) sbi; s->s_blocksize = 1024; s->s_blocksize_bits = 10; s->s_magic = DEVPTS_SUPER_MAGIC; @@ -147,27 +82,25 @@ static int devpts_fill_super(struct super_block *s, void *data, int silent) inode = new_inode(s); if (!inode) - goto fail_free; + goto fail; inode->i_ino = 1; inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; inode->i_blocks = 0; inode->i_blksize = 1024; inode->i_uid = inode->i_gid = 0; inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR; - inode->i_op = &devpts_root_inode_operations; - inode->i_fop = &devpts_root_operations; + inode->i_op = &simple_dir_inode_operations; + inode->i_fop = &simple_dir_operations; inode->i_nlink = 2; - s->s_root = d_alloc_root(inode); + devpts_root = s->s_root = d_alloc_root(inode); if (s->s_root) return 0; printk("devpts: get root dentry failed\n"); iput(inode); -fail_free: - kfree(sbi); fail: - return error; + return -ENOMEM; } static struct super_block *devpts_get_sb(struct file_system_type *fs_type, @@ -183,44 +116,52 @@ static struct file_system_type devpts_fs_type = { kill_sb: kill_anon_super, }; -void devpts_pty_new(int number, kdev_t device) +/* + * The normal naming convention is simply /dev/pts/<number>; this conforms + * to the System V naming convention + */ + +static struct dentry *get_node(int num) { - struct super_block *sb = devpts_mnt->mnt_sb; - struct devpts_sb_info *sbi = SBI(sb); - struct inode *inode; - - if ( sbi->inodes[number] ) - return; /* Already registered, this does happen */ - - inode = new_inode(sb); + char s[10]; + struct dentry *root = devpts_root; + down(&root->d_inode->i_sem); + return lookup_one_len(s, root, sprintf(s, "%d", num)); +} + +void devpts_pty_new(int number, dev_t device) +{ + struct dentry *dentry; + struct inode *inode = new_inode(devpts_mnt->mnt_sb); if (!inode) return; inode->i_ino = number+2; - inode->i_blocks = 0; inode->i_blksize = 1024; - inode->i_uid = sbi->setuid ? sbi->uid : current->fsuid; - inode->i_gid = sbi->setgid ? sbi->gid : current->fsgid; + inode->i_uid = config.setuid ? config.uid : current->fsuid; + inode->i_gid = config.setgid ? config.gid : current->fsgid; inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; - init_special_inode(inode, S_IFCHR|sbi->mode, kdev_t_to_nr(device)); + init_special_inode(inode, S_IFCHR|config.mode, device); - if ( sbi->inodes[number] ) { - iput(inode); - return; - } - sbi->inodes[number] = inode; + dentry = get_node(number); + if (!IS_ERR(dentry) && !dentry->d_inode) + d_instantiate(dentry, inode); + up(&devpts_root->d_inode->i_sem); } void devpts_pty_kill(int number) { - struct super_block *sb = devpts_mnt->mnt_sb; - struct devpts_sb_info *sbi = SBI(sb); - struct inode *inode = sbi->inodes[number]; + struct dentry *dentry = get_node(number); - if ( inode ) { - sbi->inodes[number] = NULL; - inode->i_nlink--; - iput(inode); + if (!IS_ERR(dentry)) { + struct inode *inode = dentry->d_inode; + if (inode) { + inode->i_nlink--; + d_delete(dentry); + dput(dentry); + } + dput(dentry); } + up(&devpts_root->d_inode->i_sem); } static int __init init_devpts_fs(void) @@ -231,22 +172,12 @@ static int __init init_devpts_fs(void) err = PTR_ERR(devpts_mnt); if (!IS_ERR(devpts_mnt)) err = 0; -#ifdef MODULE - if ( !err ) { - devpts_upcall_new = devpts_pty_new; - devpts_upcall_kill = devpts_pty_kill; - } -#endif } return err; } static void __exit exit_devpts_fs(void) { -#ifdef MODULE - devpts_upcall_new = NULL; - devpts_upcall_kill = NULL; -#endif unregister_filesystem(&devpts_fs_type); kern_umount(devpts_mnt); } @@ -254,4 +185,3 @@ static void __exit exit_devpts_fs(void) module_init(init_devpts_fs) module_exit(exit_devpts_fs) MODULE_LICENSE("GPL"); - diff --git a/fs/devpts/root.c b/fs/devpts/root.c deleted file mode 100644 index 44e7bd7e3baa..000000000000 --- a/fs/devpts/root.c +++ /dev/null @@ -1,142 +0,0 @@ -/* -*- linux-c -*- --------------------------------------------------------- * - * - * linux/fs/devpts/root.c - * - * Copyright 1998 H. Peter Anvin -- All Rights Reserved - * - * This file is part of the Linux kernel and is made available under - * the terms of the GNU General Public License, version 2, or at your - * option, any later version, incorporated herein by reference. - * - * ------------------------------------------------------------------------- */ - -#include <linux/errno.h> -#include <linux/stat.h> -#include <linux/param.h> -#include <linux/string.h> -#include <linux/smp_lock.h> -#include "devpts_i.h" - -static int devpts_root_readdir(struct file *,void *,filldir_t); -static struct dentry *devpts_root_lookup(struct inode *,struct dentry *); -static int devpts_revalidate(struct dentry *, int); - -struct file_operations devpts_root_operations = { - read: generic_read_dir, - readdir: devpts_root_readdir, -}; - -struct inode_operations devpts_root_inode_operations = { - lookup: devpts_root_lookup, -}; - -static struct dentry_operations devpts_dentry_operations = { - d_revalidate: devpts_revalidate, -}; - -/* - * The normal naming convention is simply /dev/pts/<number>; this conforms - * to the System V naming convention - */ - -#define genptsname(buf,num) sprintf(buf, "%d", num) - -static int devpts_root_readdir(struct file *filp, void *dirent, filldir_t filldir) -{ - struct inode * inode = filp->f_dentry->d_inode; - struct devpts_sb_info * sbi = SBI(filp->f_dentry->d_inode->i_sb); - off_t nr; - char numbuf[16]; - - lock_kernel(); - - nr = filp->f_pos; - - switch(nr) - { - case 0: - if (filldir(dirent, ".", 1, nr, inode->i_ino, DT_DIR) < 0) - goto out; - filp->f_pos = ++nr; - /* fall through */ - case 1: - if (filldir(dirent, "..", 2, nr, inode->i_ino, DT_DIR) < 0) - goto out; - filp->f_pos = ++nr; - /* fall through */ - default: - while ( nr - 2 < sbi->max_ptys ) { - int ptynr = nr - 2; - if ( sbi->inodes[ptynr] ) { - genptsname(numbuf, ptynr); - if ( filldir(dirent, numbuf, strlen(numbuf), nr, nr, DT_CHR) < 0 ) - goto out; - } - filp->f_pos = ++nr; - } - break; - } - -out: - unlock_kernel(); - return 0; -} - -/* - * Revalidate is called on every cache lookup. We use it to check that - * the pty really does still exist. Never revalidate negative dentries; - * for simplicity (fix later?) - */ -static int devpts_revalidate(struct dentry * dentry, int flags) -{ - struct devpts_sb_info *sbi; - - if ( !dentry->d_inode ) - return 0; - - sbi = SBI(dentry->d_inode->i_sb); - - return ( sbi->inodes[dentry->d_inode->i_ino - 2] == dentry->d_inode ); -} - -static struct dentry *devpts_root_lookup(struct inode * dir, struct dentry * dentry) -{ - struct devpts_sb_info *sbi = SBI(dir->i_sb); - unsigned int entry; - int i; - const char *p; - - dentry->d_op = &devpts_dentry_operations; - - if ( dentry->d_name.len == 1 && dentry->d_name.name[0] == '0' ) { - entry = 0; - } else if ( dentry->d_name.len < 1 ) { - return NULL; - } else { - p = dentry->d_name.name; - if ( *p < '1' || *p > '9' ) - return NULL; - entry = *p++ - '0'; - - for ( i = dentry->d_name.len-1 ; i ; i-- ) { - unsigned int nentry = *p++ - '0'; - if ( nentry > 9 ) - return NULL; - if ( entry >= ~0U/10 ) - return NULL; - entry = nentry + entry * 10; - } - } - - if ( entry >= sbi->max_ptys ) - return NULL; - - lock_kernel(); - if ( sbi->inodes[entry] ) - atomic_inc(&sbi->inodes[entry]->i_count); - - d_add(dentry, sbi->inodes[entry]); - unlock_kernel(); - - return NULL; -} diff --git a/fs/inode.c b/fs/inode.c index a3b2cd4e8a3c..d0e6bda9772a 100644 --- a/fs/inode.c +++ b/fs/inode.c @@ -101,7 +101,7 @@ static struct inode *alloc_inode(struct super_block *sb) struct address_space * const mapping = &inode->i_data; inode->i_sb = sb; - inode->i_dev = to_kdev_t(sb->s_dev); + inode->i_dev = sb->s_dev; inode->i_blkbits = sb->s_blocksize_bits; inode->i_flags = 0; atomic_set(&inode->i_count, 1); diff --git a/fs/jfs/jfs_incore.h b/fs/jfs/jfs_incore.h index c54907dddbe5..71256e2322cd 100644 --- a/fs/jfs/jfs_incore.h +++ b/fs/jfs/jfs_incore.h @@ -122,7 +122,7 @@ struct jfs_sb_info { short nbperpage; /* 2: blocks per page */ short l2nbperpage; /* 2: log2 blocks per page */ short l2niperblk; /* 2: log2 inodes per page */ - kdev_t logdev; /* 2: external log device */ + u32 logdev; /* 2: external log device */ uint aggregate; /* volume identifier in log record */ pxd_t logpxd; /* 8: pxd describing log */ pxd_t ait2; /* 8: pxd describing AIT copy */ diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c index 1bd50e77c4a5..68e08f8b6004 100644 --- a/fs/jfs/jfs_logmgr.c +++ b/fs/jfs/jfs_logmgr.c @@ -1102,7 +1102,7 @@ int lmLogOpen(struct super_block *sb, log_t ** logptr) */ externalLog: - if (!(bdev = bdget(kdev_t_to_nr(JFS_SBI(sb)->logdev)))) { + if (!(bdev = bdget(JFS_SBI(sb)->logdev))) { rc = ENODEV; goto free; } diff --git a/fs/jfs/jfs_mount.c b/fs/jfs/jfs_mount.c index afab3ab7ed5f..d8a7773fa9ff 100644 --- a/fs/jfs/jfs_mount.c +++ b/fs/jfs/jfs_mount.c @@ -406,7 +406,7 @@ static int chkSuper(struct super_block *sb) if (sbi->mntflag & JFS_INLINELOG) sbi->logpxd = j_sb->s_logpxd; else { - sbi->logdev = to_kdev_t(le32_to_cpu(j_sb->s_logdev)); + sbi->logdev = le32_to_cpu(j_sb->s_logdev); memcpy(sbi->uuid, j_sb->s_uuid, sizeof(sbi->uuid)); memcpy(sbi->loguuid, j_sb->s_loguuid, sizeof(sbi->uuid)); } diff --git a/fs/locks.c b/fs/locks.c index 1e58f91263c5..bb32d1516343 100644 --- a/fs/locks.c +++ b/fs/locks.c @@ -1751,9 +1751,12 @@ static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx) ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ " : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); } + /* + * NOTE: it should be inode->i_sb->s_id, not kdevname(...). + */ out += sprintf(out, "%d %s:%ld ", fl->fl_pid, - inode ? kdevname(inode->i_dev) : "<none>", + inode ? kdevname(to_kdev_t(inode->i_dev)) : "<none>", inode ? inode->i_ino : 0); out += sprintf(out, "%Ld ", fl->fl_start); if (fl->fl_end == OFFSET_MAX) diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c index e974fe17805f..6f72f241ea9b 100644 --- a/fs/nfsd/export.c +++ b/fs/nfsd/export.c @@ -68,17 +68,17 @@ static svc_client * clients; * Find the client's export entry matching xdev/xino. */ svc_export * -exp_get(svc_client *clp, kdev_t dev, ino_t ino) +exp_get(svc_client *clp, dev_t dev, ino_t ino) { struct list_head *head, *p; if (!clp) return NULL; - head = &clp->cl_export[EXPORT_HASH(kdev_t_to_nr(dev))]; + head = &clp->cl_export[EXPORT_HASH(dev)]; list_for_each(p, head) { svc_export *exp = list_entry(p, svc_export, ex_hash); - if (exp->ex_ino == ino && kdev_same(exp->ex_dev, dev)) + if (exp->ex_ino == ino && exp->ex_dev == dev) return exp; } return NULL; @@ -250,7 +250,7 @@ exp_export(struct nfsctl_export *nxp) struct nameidata nd; struct inode *inode = NULL; int err; - kdev_t dev; + dev_t dev; ino_t ino; /* Consistency check */ @@ -276,7 +276,7 @@ exp_export(struct nfsctl_export *nxp) if (err) goto out_unlock; inode = nd.dentry->d_inode; - dev = inode->i_dev; + dev = inode->i_sb->s_dev; ino = inode->i_ino; err = -EINVAL; @@ -364,7 +364,7 @@ exp_export(struct nfsctl_export *nxp) if (parent) exp_change_parents(clp, parent, exp); - list_add(&exp->ex_hash, clp->cl_export + EXPORT_HASH(kdev_t_to_nr(dev))); + list_add(&exp->ex_hash, clp->cl_export + EXPORT_HASH(dev)); list_add_tail(&exp->ex_list, &clp->cl_list); exp_fsid_hash(clp, exp); @@ -398,7 +398,7 @@ exp_do_unexport(svc_export *unexp) dentry = unexp->ex_dentry; mnt = unexp->ex_mnt; inode = dentry->d_inode; - if (!kdev_same(unexp->ex_dev, inode->i_dev) || unexp->ex_ino != inode->i_ino) + if (unexp->ex_dev != inode->i_sb->s_dev || unexp->ex_ino != inode->i_ino) printk(KERN_WARNING "nfsd: bad dentry in unexport!\n"); dput(dentry); mntput(mnt); @@ -440,8 +440,7 @@ exp_unexport(struct nfsctl_export *nxp) err = -EINVAL; clp = exp_getclientbyname(nxp->ex_client); if (clp) { - kdev_t ex_dev = to_kdev_t(nxp->ex_dev); - svc_export *exp = exp_get(clp, ex_dev, nxp->ex_ino); + svc_export *exp = exp_get(clp, nxp->ex_dev, nxp->ex_ino); if (exp) { exp_do_unexport(exp); err = 0; diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c index 89d1f99ef77c..71279e639ba3 100644 --- a/fs/nfsd/nfs3xdr.c +++ b/fs/nfsd/nfs3xdr.c @@ -219,7 +219,7 @@ encode_saved_post_attr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp) && (fhp->fh_export->ex_flags & NFSEXP_FSID)) p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); else - p = xdr_encode_hyper(p, (u64) kdev_t_to_nr(inode->i_dev)); + p = xdr_encode_hyper(p, (u64) inode->i_dev); p = xdr_encode_hyper(p, (u64) inode->i_ino); p = encode_time3(p, fhp->fh_post_atime); p = encode_time3(p, fhp->fh_post_mtime); diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c index 4b889c888fbb..f0f88f19164c 100644 --- a/fs/nfsd/nfsfh.c +++ b/fs/nfsd/nfsfh.c @@ -97,7 +97,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access) rqstp->rq_reffh = fh; if (!fhp->fh_dentry) { - kdev_t xdev = NODEV; + dev_t xdev = 0; ino_t xino = 0; __u32 *datap=NULL; __u32 tfh[3]; /* filehandle fragment for oldstyle filehandles */ @@ -122,7 +122,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access) case 0: if ((data_left-=2)<0) goto out; nfsdev = ntohl(*datap++); - xdev = mk_kdev(nfsdev>>16, nfsdev&0xFFFF); + xdev = MKDEV(nfsdev>>16, nfsdev&0xFFFF); xino = *datap++; break; case 1: @@ -136,7 +136,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access) if (fh->fh_size != NFS_FHSIZE) goto out; /* assume old filehandle format */ - xdev = u32_to_kdev_t(fh->ofh_xdev); + xdev = u32_to_dev_t(fh->ofh_xdev); xino = u32_to_ino_t(fh->ofh_xino); } @@ -308,7 +308,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry, st __u32 *datap; dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %s/%s, ino=%ld)\n", - major(exp->ex_dev), minor(exp->ex_dev), (long) exp->ex_ino, + MAJOR(exp->ex_dev), MINOR(exp->ex_dev), (long) exp->ex_ino, parent->d_name.name, dentry->d_name.name, (inode ? inode->i_ino : 0)); @@ -329,7 +329,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry, st memset(&fhp->fh_handle.fh_base, 0, NFS_FHSIZE); fhp->fh_handle.fh_size = NFS_FHSIZE; fhp->fh_handle.ofh_dcookie = 0xfeebbaca; - fhp->fh_handle.ofh_dev = htonl((major(exp->ex_dev)<<16)| minor(exp->ex_dev)); + fhp->fh_handle.ofh_dev = htonl((MAJOR(exp->ex_dev)<<16)| MINOR(exp->ex_dev)); fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev; fhp->fh_handle.ofh_xino = ino_t_to_u32(exp->ex_ino); fhp->fh_handle.ofh_dirino = ino_t_to_u32(parent_ino(dentry)); @@ -348,7 +348,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry, st } else { fhp->fh_handle.fh_fsid_type = 0; /* fsid_type 0 == 2byte major, 2byte minor, 4byte inode */ - *datap++ = htonl((major(exp->ex_dev)<<16)| minor(exp->ex_dev)); + *datap++ = htonl((MAJOR(exp->ex_dev)<<16)| MINOR(exp->ex_dev)); *datap++ = ino_t_to_u32(exp->ex_ino); fhp->fh_handle.fh_size = 3*4; } diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c index 02419edd0250..56cd76ef5c57 100644 --- a/fs/nfsd/vfs.c +++ b/fs/nfsd/vfs.c @@ -66,7 +66,7 @@ struct raparms { struct raparms *p_next; unsigned int p_count; ino_t p_ino; - kdev_t p_dev; + dev_t p_dev; struct file_ra_state p_ra; }; @@ -527,14 +527,14 @@ nfsd_sync_dir(struct dentry *dp) static spinlock_t ra_lock = SPIN_LOCK_UNLOCKED; static inline struct raparms * -nfsd_get_raparms(kdev_t dev, ino_t ino) +nfsd_get_raparms(dev_t dev, ino_t ino) { struct raparms *ra, **rap, **frap = NULL; int depth = 0; spin_lock(&ra_lock); for (rap = &raparm_cache; (ra = *rap); rap = &ra->p_next) { - if (ra->p_ino == ino && kdev_same(ra->p_dev, dev)) + if (ra->p_ino == ino && ra->p_dev == dev) goto found; depth++; if (ra->p_count == 0) @@ -691,8 +691,8 @@ nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset, } if (err >= 0 && stable) { - static unsigned long last_ino; - static kdev_t last_dev = NODEV; + static ino_t last_ino; + static dev_t last_dev = 0; /* * Gathered writes: If another process is currently @@ -708,7 +708,7 @@ nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset, */ if (EX_WGATHER(exp)) { if (atomic_read(&inode->i_writecount) > 1 - || (last_ino == inode->i_ino && kdev_same(last_dev, inode->i_dev))) { + || (last_ino == inode->i_ino && last_dev == inode->i_dev)) { dprintk("nfsd: write defer %d\n", current->pid); set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout((HZ+99)/100); diff --git a/fs/partitions/check.c b/fs/partitions/check.c index 36fc86dcff3e..b4ba922cffeb 100644 --- a/fs/partitions/check.c +++ b/fs/partitions/check.c @@ -13,14 +13,9 @@ * Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl} */ -#include <linux/config.h> +#include <linux/init.h> #include <linux/fs.h> -#include <linux/genhd.h> -#include <linux/kernel.h> -#include <linux/major.h> #include <linux/blk.h> -#include <linux/init.h> -#include <linux/raid/md.h> #include <linux/buffer_head.h> /* for invalidate_bdev() */ #include <linux/kmod.h> diff --git a/fs/proc/array.c b/fs/proc/array.c index 200adb72d9ac..e0b09b3ced45 100644 --- a/fs/proc/array.c +++ b/fs/proc/array.c @@ -539,11 +539,11 @@ int proc_pid_statm(struct task_struct *task, char * buffer) * + (index into the line) */ /* for systems with sizeof(void*) == 4: */ -#define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %08lx %s %lu" +#define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %08lx %02x:%02x %lu" #define MAPS_LINE_MAX4 49 /* sum of 8 1 8 1 4 1 8 1 5 1 10 1 */ /* for systems with sizeof(void*) == 8: */ -#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016lx %s %lu" +#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016lx %02x:%02x %lu" #define MAPS_LINE_MAX8 73 /* sum of 16 1 16 1 4 1 16 1 5 1 10 1 */ #define MAPS_LINE_FORMAT (sizeof(void*) == 4 ? MAPS_LINE_FORMAT4 : MAPS_LINE_FORMAT8) @@ -555,7 +555,7 @@ static int proc_pid_maps_get_line (char *buf, struct vm_area_struct *map) char *line; char str[5]; int flags; - kdev_t dev; + dev_t dev; unsigned long ino; int len; @@ -567,7 +567,7 @@ static int proc_pid_maps_get_line (char *buf, struct vm_area_struct *map) str[3] = flags & VM_MAYSHARE ? 's' : 'p'; str[4] = 0; - dev = NODEV; + dev = 0; ino = 0; if (map->vm_file != NULL) { dev = map->vm_file->f_dentry->d_inode->i_dev; @@ -585,7 +585,7 @@ static int proc_pid_maps_get_line (char *buf, struct vm_area_struct *map) len = sprintf(line, MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT, - kdevname(dev), ino); + MAJOR(dev), MINOR(dev), ino); if(map->vm_file) { int i; diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c index c0b5997f0b7d..0d439b0b1508 100644 --- a/fs/smbfs/inode.c +++ b/fs/smbfs/inode.c @@ -145,7 +145,6 @@ smb_get_inode_attr(struct inode *inode, struct smb_fattr *fattr) fattr->f_ino = inode->i_ino; fattr->f_uid = inode->i_uid; fattr->f_gid = inode->i_gid; - fattr->f_rdev = inode->i_rdev; fattr->f_size = inode->i_size; fattr->f_mtime = inode->i_mtime; fattr->f_ctime = inode->i_ctime; @@ -183,7 +182,6 @@ smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr) inode->i_nlink = fattr->f_nlink; inode->i_uid = fattr->f_uid; inode->i_gid = fattr->f_gid; - inode->i_rdev = fattr->f_rdev; inode->i_ctime = fattr->f_ctime; inode->i_blksize= fattr->f_blksize; inode->i_blocks = fattr->f_blocks; diff --git a/fs/stat.c b/fs/stat.c index 3f87e0e823ec..bce88512b2b5 100644 --- a/fs/stat.c +++ b/fs/stat.c @@ -17,7 +17,7 @@ void generic_fillattr(struct inode *inode, struct kstat *stat) { - stat->dev = kdev_t_to_nr(inode->i_dev); + stat->dev = inode->i_dev; stat->ino = inode->i_ino; stat->mode = inode->i_mode; stat->nlink = inode->i_nlink; diff --git a/include/linux/bio.h b/include/linux/bio.h index ffc38fca9c1e..1b4004652cde 100644 --- a/include/linux/bio.h +++ b/include/linux/bio.h @@ -203,8 +203,6 @@ extern struct bio *bio_copy(struct bio *, int, int); extern inline void bio_init(struct bio *); -extern int bio_ioctl(kdev_t, unsigned int, unsigned long); - #ifdef CONFIG_HIGHMEM /* * remember to add offset! and never ever reenable interrupts between a diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h index a94644322d86..f22fdecee5a9 100644 --- a/include/linux/buffer_head.h +++ b/include/linux/buffer_head.h @@ -121,7 +121,6 @@ BUFFER_FNS(Boundary, boundary) #define page_has_buffers(page) PagePrivate(page) #define invalidate_buffers(dev) __invalidate_buffers((dev), 0) -#define destroy_buffers(dev) __invalidate_buffers((dev), 1) /* @@ -156,7 +155,6 @@ int sync_blockdev(struct block_device *bdev); void __wait_on_buffer(struct buffer_head *); void sleep_on_buffer(struct buffer_head *bh); void wake_up_buffer(struct buffer_head *bh); -int fsync_dev(kdev_t); int fsync_bdev(struct block_device *); int fsync_super(struct super_block *); int fsync_no_super(struct block_device *); diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h index 296ffe2cdfd4..19a318fe8ce6 100644 --- a/include/linux/cdrom.h +++ b/include/linux/cdrom.h @@ -807,11 +807,8 @@ typedef struct { long error; } tracktype; -extern void cdrom_count_tracks(struct cdrom_device_info *cdi,tracktype* tracks); -extern int cdrom_get_next_writable(kdev_t dev, long *next_writable); -extern int cdrom_get_last_written(kdev_t dev, long *last_written); +extern int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written); extern int cdrom_number_of_slots(struct cdrom_device_info *cdi); -extern int cdrom_select_disc(struct cdrom_device_info *cdi, int slot); extern int cdrom_mode_select(struct cdrom_device_info *cdi, struct cdrom_generic_command *cgc); extern int cdrom_mode_sense(struct cdrom_device_info *cdi, @@ -819,7 +816,6 @@ extern int cdrom_mode_sense(struct cdrom_device_info *cdi, int page_code, int page_control); extern void init_cdrom_command(struct cdrom_generic_command *cgc, void *buffer, int len, int type); -extern struct cdrom_device_info *cdrom_find_device(kdev_t dev); typedef struct { __u16 disc_information_length; @@ -903,10 +899,6 @@ typedef struct { __u32 last_rec_address; } track_information; -extern int cdrom_get_disc_info(kdev_t dev, disc_information *di); -extern int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type, - track_information *ti); - /* The SCSI spec says there could be 256 slots. */ #define CDROM_MAX_SLOTS 256 diff --git a/include/linux/devpts_fs.h b/include/linux/devpts_fs.h index 38164e6b2bbf..4def3512b355 100644 --- a/include/linux/devpts_fs.h +++ b/include/linux/devpts_fs.h @@ -10,64 +10,23 @@ * * ------------------------------------------------------------------------- */ -/* - * Prototypes for the pty driver <-> devpts filesystem interface. Most - * of this is really just a hack so we can exclude it or build it as a - * module, and probably should go away eventually. - */ - #ifndef _LINUX_DEVPTS_FS_H #define _LINUX_DEVPTS_FS_H 1 -#include <linux/config.h> -#include <linux/kdev_t.h> -#include <linux/tty.h> - #ifdef CONFIG_DEVPTS_FS -void devpts_pty_new(int, kdev_t); -void devpts_pty_kill(int); -#define unix98_max_ptys NR_PTYS * UNIX98_NR_MAJORS; - -#elif defined(CONFIG_DEVPTS_FS_MODULE) +void devpts_pty_new(int, dev_t); /* mknod in devpts */ +void devpts_pty_kill(int); /* unlink */ -#ifdef BUILDING_PTY_C -void (*devpts_upcall_new)(int,kdev_t) = NULL; -void (*devpts_upcall_kill)(int) = NULL; -unsigned int unix98_max_ptys = NR_PTYS * UNIX98_NR_MAJORS; - -EXPORT_SYMBOL(devpts_upcall_new); -EXPORT_SYMBOL(devpts_upcall_kill); -EXPORT_SYMBOL(unix98_max_ptys); #else -extern void (*devpts_upcall_new)(int,kdev_t); -extern void (*devpts_upcall_kill)(int); -extern unsigned int unix98_max_ptys; -#endif -#ifndef BUILDING_DEVPTS -static inline void -devpts_pty_new(int line, kdev_t device) +static inline void devpts_pty_new(int line, dev_t device) { - if ( devpts_upcall_new ) - return devpts_upcall_new(line,device); } -static inline void -devpts_pty_kill(int line) +static inline void devpts_pty_kill(int line) { - if ( devpts_upcall_kill ) - return devpts_upcall_kill(line); } -#endif - -#else /* No /dev/pts filesystem at all */ - -static inline void -devpts_pty_new(int line, kdev_t device) { } - -static inline void -devpts_pty_kill(int line) { } #endif diff --git a/include/linux/fs.h b/include/linux/fs.h index 002e02289155..db86a9686640 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -359,7 +359,7 @@ struct inode { struct list_head i_dentry; unsigned long i_ino; atomic_t i_count; - kdev_t i_dev; + dev_t i_dev; umode_t i_mode; nlink_t i_nlink; uid_t i_uid; @@ -1223,7 +1223,6 @@ extern void ll_rw_block(int, int, struct buffer_head * bh[]); extern int submit_bh(int, struct buffer_head *); struct bio; extern int submit_bio(int, struct bio *); -extern int is_read_only(kdev_t); extern int bdev_read_only(struct block_device *); extern int set_blocksize(struct block_device *, int); extern int sb_set_blocksize(struct super_block *, int); diff --git a/include/linux/kdev_t.h b/include/linux/kdev_t.h index 2c61fc5161b6..1721915141c7 100644 --- a/include/linux/kdev_t.h +++ b/include/linux/kdev_t.h @@ -36,8 +36,7 @@ typedef struct { unsigned short major, minor; } kdev_t; Admissible operations on an object of type kdev_t: - passing it along - comparing it for equality with another such object -- storing it in inode->i_dev, inode->i_rdev, req->rq_dev, de->dc_dev, -- tty->device +- storing it in inode->i_rdev, req->rq_dev, de->dc_dev, tty->device - using its bit pattern as argument in a hash function - finding its major and minor - complaining about it diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h index ab7b149a3f84..9de10bf92e32 100644 --- a/include/linux/nfsd/export.h +++ b/include/linux/nfsd/export.h @@ -70,7 +70,7 @@ struct svc_export { int ex_flags; struct vfsmount * ex_mnt; struct dentry * ex_dentry; - kdev_t ex_dev; + dev_t ex_dev; ino_t ex_ino; uid_t ex_anon_uid; gid_t ex_anon_gid; @@ -94,7 +94,7 @@ void exp_readlock(void); void exp_readunlock(void); struct svc_client * exp_getclient(struct sockaddr_in *sin); void exp_putclient(struct svc_client *clp); -struct svc_export * exp_get(struct svc_client *clp, kdev_t dev, ino_t ino); +struct svc_export * exp_get(struct svc_client *clp, dev_t dev, ino_t ino); struct svc_export * exp_get_fsid(struct svc_client *clp, int fsid); struct svc_export * exp_get_by_name(struct svc_client *clp, struct vfsmount *mnt, diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h index 84c72958f99b..53f55cc17a50 100644 --- a/include/linux/nfsd/nfsfh.h +++ b/include/linux/nfsd/nfsfh.h @@ -143,13 +143,13 @@ static inline __u32 kdev_t_to_u32(kdev_t dev) return udev; } -static inline kdev_t u32_to_kdev_t(__u32 udev) +static inline dev_t u32_to_dev_t(__u32 udev) { unsigned int minor, major; minor = (udev & 0xff) | ((udev >> 8) & 0xfff00); major = ((udev >> 8) & 0xff) | ((udev >> 20) & 0xf00); - return mk_kdev(major, minor); + return MKDEV(major, minor); } static inline __u32 ino_t_to_u32(ino_t ino) diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h index 56e7c06e1086..dfb588a60ea6 100644 --- a/include/linux/raid/linear.h +++ b/include/linux/raid/linear.h @@ -4,7 +4,6 @@ #include <linux/raid/md.h> struct dev_info { - kdev_t dev; struct block_device *bdev; unsigned long size; unsigned long offset; diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h index 19ebeb0a4988..280092c6e95b 100644 --- a/include/linux/raid/md.h +++ b/include/linux/raid/md.h @@ -66,7 +66,7 @@ extern struct hd_struct md_hd_struct[MAX_MD_DEVS]; extern char * partition_name (kdev_t dev); extern inline char * bdev_partition_name (struct block_device *bdev) { - return partition_name(to_kdev_t(bdev->bd_dev)); + return partition_name(bdev ? to_kdev_t(bdev->bd_dev) : NODEV); } extern int register_md_personality (int p_num, mdk_personality_t *p); extern int unregister_md_personality (int p_num); @@ -77,7 +77,7 @@ extern void md_wakeup_thread(mdk_thread_t *thread); extern void md_interrupt_thread (mdk_thread_t *thread); extern void md_update_sb (mddev_t *mddev); extern void md_done_sync(mddev_t *mddev, int blocks, int ok); -extern void md_sync_acct(kdev_t dev, unsigned long nr_sectors); +extern void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors); extern int md_error (mddev_t *mddev, struct block_device *bdev); extern int md_run_setup(void); diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h index e238bd222ea2..7b02c3c82a33 100644 --- a/include/linux/raid/md_k.h +++ b/include/linux/raid/md_k.h @@ -160,16 +160,6 @@ struct mdk_rdev_s int desc_nr; /* descriptor index in the superblock */ }; - -/* - * disk operations in a working array: - */ -#define DISKOP_SPARE_INACTIVE 0 -#define DISKOP_SPARE_WRITE 1 -#define DISKOP_SPARE_ACTIVE 2 -#define DISKOP_HOT_REMOVE_DISK 3 -#define DISKOP_HOT_ADD_DISK 4 - typedef struct mdk_personality_s mdk_personality_t; struct mddev_s @@ -213,19 +203,12 @@ struct mdk_personality_s int (*run)(mddev_t *mddev); int (*stop)(mddev_t *mddev); int (*status)(char *page, mddev_t *mddev); - int (*error_handler)(mddev_t *mddev, kdev_t dev); - -/* - * Some personalities (RAID-1, RAID-5) can have disks hot-added and - * hot-removed. Hot removal is different from failure. (failure marks - * a disk inactive, but the disk is still part of the array) The interface - * to such operations is the 'pers->diskop()' function, can be NULL. - * - * the diskop function can change the pointer pointing to the incoming - * descriptor, but must do so very carefully. (currently only - * SPARE_ACTIVE expects such a change) - */ - int (*diskop) (mddev_t *mddev, mdp_disk_t **descriptor, int state); + int (*error_handler)(mddev_t *mddev, struct block_device *bdev); + int (*hot_add_disk) (mddev_t *mddev, mdp_disk_t *descriptor, mdk_rdev_t *rdev); + int (*hot_remove_disk) (mddev_t *mddev, int number); + int (*spare_write) (mddev_t *mddev, int number); + int (*spare_inactive) (mddev_t *mddev); + int (*spare_active) (mddev_t *mddev, mdp_disk_t **descriptor); int (*sync_request)(mddev_t *mddev, sector_t sector_nr, int go_faster); }; diff --git a/include/linux/raid/multipath.h b/include/linux/raid/multipath.h index 9c9cdc77fa05..e4f3e6189b7b 100644 --- a/include/linux/raid/multipath.h +++ b/include/linux/raid/multipath.h @@ -6,7 +6,6 @@ struct multipath_info { int number; int raid_disk; - kdev_t dev; struct block_device *bdev; /* diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h index f9f02ab19bd3..f63d68e55c11 100644 --- a/include/linux/raid/raid1.h +++ b/include/linux/raid/raid1.h @@ -8,7 +8,6 @@ typedef struct mirror_info mirror_info_t; struct mirror_info { int number; int raid_disk; - kdev_t dev; struct block_device *bdev; sector_t head_position; atomic_t nr_pending; diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h index e14864259ffd..7f8beb8acdaa 100644 --- a/include/linux/raid/raid5.h +++ b/include/linux/raid/raid5.h @@ -192,7 +192,6 @@ struct stripe_head { struct disk_info { - kdev_t dev; struct block_device *bdev; int operational; int number; diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h index 29f6063b3546..d8b3fa0a7ba0 100644 --- a/include/linux/reiserfs_fs.h +++ b/include/linux/reiserfs_fs.h @@ -1675,13 +1675,10 @@ int pop_journal_writer(int windex) ; int journal_transaction_should_end(struct reiserfs_transaction_handle *, int) ; int reiserfs_in_journal(struct super_block *p_s_sb, unsigned long bl, int searchall, unsigned long *next) ; int journal_begin(struct reiserfs_transaction_handle *, struct super_block *p_s_sb, unsigned long) ; -struct super_block *reiserfs_get_super(kdev_t dev) ; void flush_async_commits(struct super_block *p_s_sb) ; int buffer_journaled(const struct buffer_head *bh) ; int mark_buffer_journal_new(struct buffer_head *bh) ; -int reiserfs_sync_all_buffers(kdev_t dev, int wait) ; -int reiserfs_sync_buffers(kdev_t dev, int wait) ; int reiserfs_add_page_to_flush_list(struct reiserfs_transaction_handle *, struct inode *, struct buffer_head *) ; int reiserfs_remove_page_from_flush_list(struct reiserfs_transaction_handle *, diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h index 04ec2e907f90..534d8e20bdb7 100644 --- a/include/linux/reiserfs_fs_sb.h +++ b/include/linux/reiserfs_fs_sb.h @@ -160,7 +160,7 @@ struct reiserfs_transaction_handle { int t_blocks_allocated ; /* number of blocks this writer allocated */ unsigned long t_trans_id ; /* sanity check, equals the current trans id */ struct super_block *t_super ; /* super for this FS when journal_begin was - called. saves calls to reiserfs_get_super */ + called. */ } ; /* diff --git a/include/linux/smb.h b/include/linux/smb.h index a9d88d856df5..5b8dce292377 100644 --- a/include/linux/smb.h +++ b/include/linux/smb.h @@ -10,7 +10,6 @@ #define _LINUX_SMB_H #include <linux/types.h> -#include <linux/kdev_t.h> enum smb_protocol { SMB_PROTOCOL_NONE, @@ -85,7 +84,6 @@ struct smb_fattr { nlink_t f_nlink; uid_t f_uid; gid_t f_gid; - kdev_t f_rdev; loff_t f_size; time_t f_atime; time_t f_mtime; diff --git a/kernel/ksyms.c b/kernel/ksyms.c index 5b95da9d8a9a..f18263655052 100644 --- a/kernel/ksyms.c +++ b/kernel/ksyms.c @@ -185,7 +185,6 @@ EXPORT_SYMBOL(invalidate_inodes); EXPORT_SYMBOL(invalidate_device); EXPORT_SYMBOL(invalidate_inode_pages); EXPORT_SYMBOL(truncate_inode_pages); -EXPORT_SYMBOL(fsync_dev); EXPORT_SYMBOL(fsync_bdev); EXPORT_SYMBOL(permission); EXPORT_SYMBOL(vfs_permission); @@ -327,7 +326,6 @@ EXPORT_SYMBOL(tty_std_termios); /* block device driver support */ EXPORT_SYMBOL(blk_size); EXPORT_SYMBOL(blk_dev); -EXPORT_SYMBOL(is_read_only); EXPORT_SYMBOL(bdev_read_only); EXPORT_SYMBOL(set_device_ro); EXPORT_SYMBOL(bmap); diff --git a/net/socket.c b/net/socket.c index bed470afb5ed..798eeab2f47c 100644 --- a/net/socket.c +++ b/net/socket.c @@ -465,7 +465,7 @@ struct socket *sock_alloc(void) if (!inode) return NULL; - inode->i_dev = NODEV; + inode->i_dev = 0; sock = SOCKET_I(inode); inode->i_mode = S_IFSOCK|S_IRWXUGO; |