Darkangeel_hd
/
lineage_android_kernel_xiaomi_sdm845
mirror of https://github.com/Darkangeel-hd/lineage_android_kernel_xiaomi_sdm845.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull more vfs updates from Al Viro:
 "A couple of fixes + getting rid of __blkdev_put() return value"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  proc: Use PDE attribute setting accessor functions
  make blkdev_put() return void
  block_device_operations->release() should return void
  mtd_blktrans_ops->release() should return void
  hfs: SMP race on directory close()
This commit is contained in:
Linus Torvalds 2013-05-07 15:14:53 -07:00
parent bc2d968f0e 254844d3b9
commit 292088ee03
50 changed files with 93 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/mach-msm/last_radio_log.c
View File

@ -66,6 +66,6 @@ void msm_init_last_radio_log(struct module *owner)
pr_err("%s: last radio log is %d bytes long\n", __func__, pr_err("%s: last radio log is %d bytes long\n", __func__,
radio_log_size); radio_log_size);
last_radio_log_fops.owner = owner; last_radio_log_fops.owner = owner;
entry->size = radio_log_size; proc_set_size(entry, radio_log_size);
} }
EXPORT_SYMBOL(msm_init_last_radio_log); EXPORT_SYMBOL(msm_init_last_radio_log);

2
arch/cris/kernel/profile.c
View File

@ -76,7 +76,7 @@ static int __init init_cris_profile(void)
entry = proc_create("system_profile", S_IWUSR | S_IRUGO, NULL, entry = proc_create("system_profile", S_IWUSR | S_IRUGO, NULL,
&cris_proc_profile_operations); &cris_proc_profile_operations);
if (entry) { if (entry) {
entry->size = SAMPLE_BUFFER_SIZE; proc_set_size(entry, SAMPLE_BUFFER_SIZE);
} }
prof_running = 1; prof_running = 1;

5
arch/um/drivers/ubd_kern.c
View File

@ -87,7 +87,7 @@ static DEFINE_MUTEX(ubd_lock);
static DEFINE_MUTEX(ubd_mutex); /* replaces BKL, might not be needed */ static DEFINE_MUTEX(ubd_mutex); /* replaces BKL, might not be needed */
static int ubd_open(struct block_device *bdev, fmode_t mode); static int ubd_open(struct block_device *bdev, fmode_t mode);
static int ubd_release(struct gendisk *disk, fmode_t mode); static void ubd_release(struct gendisk *disk, fmode_t mode);
static int ubd_ioctl(struct block_device *bdev, fmode_t mode, static int ubd_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo); static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
@ -1138,7 +1138,7 @@ out:
return err; return err;
} }
static int ubd_release(struct gendisk *disk, fmode_t mode) static void ubd_release(struct gendisk *disk, fmode_t mode)
{ {
struct ubd *ubd_dev = disk->private_data; struct ubd *ubd_dev = disk->private_data;
@ -1146,7 +1146,6 @@ static int ubd_release(struct gendisk *disk, fmode_t mode)
if(--ubd_dev->count == 0) if(--ubd_dev->count == 0)
ubd_close_dev(ubd_dev); ubd_close_dev(ubd_dev);
mutex_unlock(&ubd_mutex); mutex_unlock(&ubd_mutex);
return 0;
} }
static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask, static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask,

3
arch/xtensa/platforms/iss/simdisk.c
View File

@ -139,13 +139,12 @@ static int simdisk_open(struct block_device *bdev, fmode_t mode)
return 0; return 0;
} }
static int simdisk_release(struct gendisk *disk, fmode_t mode) static void simdisk_release(struct gendisk *disk, fmode_t mode)
{ {
struct simdisk *dev = disk->private_data; struct simdisk *dev = disk->private_data;
spin_lock(&dev->lock); spin_lock(&dev->lock);
--dev->users; --dev->users;
spin_unlock(&dev->lock); spin_unlock(&dev->lock);
return 0;
} }
static const struct block_device_operations simdisk_ops = { static const struct block_device_operations simdisk_ops = {

3
drivers/block/amiflop.c
View File

@ -1634,7 +1634,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
return 0; return 0;
} }
static int floppy_release(struct gendisk *disk, fmode_t mode) static void floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct amiga_floppy_struct *p = disk->private_data; struct amiga_floppy_struct *p = disk->private_data;
int drive = p - unit; int drive = p - unit;
@ -1654,7 +1654,6 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
floppy_off (drive | 0x40000000); floppy_off (drive | 0x40000000);
#endif #endif
mutex_unlock(&amiflop_mutex); mutex_unlock(&amiflop_mutex);
return 0;
} }
/* /*

6
drivers/block/aoe/aoeblk.c
View File

@ -169,7 +169,7 @@ aoeblk_open(struct block_device *bdev, fmode_t mode)
return -ENODEV; return -ENODEV;
} }
static int static void
aoeblk_release(struct gendisk *disk, fmode_t mode) aoeblk_release(struct gendisk *disk, fmode_t mode)
{ {
struct aoedev *d = disk->private_data; struct aoedev *d = disk->private_data;
@ -180,11 +180,9 @@ aoeblk_release(struct gendisk *disk, fmode_t mode)
if (--d->nopen == 0) { if (--d->nopen == 0) {
spin_unlock_irqrestore(&d->lock, flags); spin_unlock_irqrestore(&d->lock, flags);
aoecmd_cfg(d->aoemajor, d->aoeminor); aoecmd_cfg(d->aoemajor, d->aoeminor);
return 0; return;
} }
spin_unlock_irqrestore(&d->lock, flags); spin_unlock_irqrestore(&d->lock, flags);
return 0;
} }
static void static void

5
drivers/block/ataflop.c
View File

@ -367,7 +367,7 @@ static void fd_probe( int drive );
static int fd_test_drive_present( int drive ); static int fd_test_drive_present( int drive );
static void config_types( void ); static void config_types( void );
static int floppy_open(struct block_device *bdev, fmode_t mode); static int floppy_open(struct block_device *bdev, fmode_t mode);
static int floppy_release(struct gendisk *disk, fmode_t mode); static void floppy_release(struct gendisk *disk, fmode_t mode);
/************************* End of Prototypes **************************/ /************************* End of Prototypes **************************/
@ -1886,7 +1886,7 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int floppy_release(struct gendisk *disk, fmode_t mode) static void floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct atari_floppy_struct *p = disk->private_data; struct atari_floppy_struct *p = disk->private_data;
mutex_lock(&ataflop_mutex); mutex_lock(&ataflop_mutex);
@ -1897,7 +1897,6 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
p->ref = 0; p->ref = 0;
} }
mutex_unlock(&ataflop_mutex); mutex_unlock(&ataflop_mutex);
return 0;
} }
static const struct block_device_operations floppy_fops = { static const struct block_device_operations floppy_fops = {

5
drivers/block/cciss.c
View File

@ -161,7 +161,7 @@ static irqreturn_t do_cciss_intx(int irq, void *dev_id);
static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id); static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id);
static int cciss_open(struct block_device *bdev, fmode_t mode); static int cciss_open(struct block_device *bdev, fmode_t mode);
static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode); static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode);
static int cciss_release(struct gendisk *disk, fmode_t mode); static void cciss_release(struct gendisk *disk, fmode_t mode);
static int do_ioctl(struct block_device *bdev, fmode_t mode, static int do_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
static int cciss_ioctl(struct block_device *bdev, fmode_t mode, static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
@ -1123,7 +1123,7 @@ static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode)
/* /*
* Close. Sync first. * Close. Sync first.
*/ */
static int cciss_release(struct gendisk *disk, fmode_t mode) static void cciss_release(struct gendisk *disk, fmode_t mode)
{ {
ctlr_info_t *h; ctlr_info_t *h;
drive_info_struct *drv; drive_info_struct *drv;
@ -1135,7 +1135,6 @@ static int cciss_release(struct gendisk *disk, fmode_t mode)
drv->usage_count--; drv->usage_count--;
h->usage_count--; h->usage_count--;
mutex_unlock(&cciss_mutex); mutex_unlock(&cciss_mutex);
return 0;
} }
static int do_ioctl(struct block_device *bdev, fmode_t mode, static int do_ioctl(struct block_device *bdev, fmode_t mode,

6
drivers/block/cpqarray.c
View File

@ -160,7 +160,7 @@ static int sendcmd(
unsigned int log_unit ); unsigned int log_unit );
static int ida_unlocked_open(struct block_device *bdev, fmode_t mode); static int ida_unlocked_open(struct block_device *bdev, fmode_t mode);
static int ida_release(struct gendisk *disk, fmode_t mode); static void ida_release(struct gendisk *disk, fmode_t mode);
static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg); static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg);
static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo); static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo);
static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io); static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io);
@ -856,7 +856,7 @@ static int ida_unlocked_open(struct block_device *bdev, fmode_t mode)
/* /*
* Close. Sync first. * Close. Sync first.
*/ */
static int ida_release(struct gendisk *disk, fmode_t mode) static void ida_release(struct gendisk *disk, fmode_t mode)
{ {
ctlr_info_t *host; ctlr_info_t *host;
@ -864,8 +864,6 @@ static int ida_release(struct gendisk *disk, fmode_t mode)
host = get_host(disk); host = get_host(disk);
host->usage_count--; host->usage_count--;
mutex_unlock(&cpqarray_mutex); mutex_unlock(&cpqarray_mutex);
return 0;
} }
/* /*

5
drivers/block/drbd/drbd_main.c
View File

@ -63,7 +63,7 @@ int drbd_asender(struct drbd_thread *);
int drbd_init(void); int drbd_init(void);
static int drbd_open(struct block_device *bdev, fmode_t mode); static int drbd_open(struct block_device *bdev, fmode_t mode);
static int drbd_release(struct gendisk *gd, fmode_t mode); static void drbd_release(struct gendisk *gd, fmode_t mode);
static int w_md_sync(struct drbd_work *w, int unused); static int w_md_sync(struct drbd_work *w, int unused);
static void md_sync_timer_fn(unsigned long data); static void md_sync_timer_fn(unsigned long data);
static int w_bitmap_io(struct drbd_work *w, int unused); static int w_bitmap_io(struct drbd_work *w, int unused);
@ -1849,13 +1849,12 @@ static int drbd_open(struct block_device *bdev, fmode_t mode)
return rv; return rv;
} }
static int drbd_release(struct gendisk *gd, fmode_t mode) static void drbd_release(struct gendisk *gd, fmode_t mode)
{ {
struct drbd_conf *mdev = gd->private_data; struct drbd_conf *mdev = gd->private_data;
mutex_lock(&drbd_main_mutex); mutex_lock(&drbd_main_mutex);
mdev->open_cnt--; mdev->open_cnt--;
mutex_unlock(&drbd_main_mutex); mutex_unlock(&drbd_main_mutex);
return 0;
} }
static void drbd_set_defaults(struct drbd_conf *mdev) static void drbd_set_defaults(struct drbd_conf *mdev)

4
drivers/block/floppy.c
View File

@ -3601,7 +3601,7 @@ static void __init config_types(void)
pr_cont("\n"); pr_cont("\n");
} }
static int floppy_release(struct gendisk *disk, fmode_t mode) static void floppy_release(struct gendisk *disk, fmode_t mode)
{ {
int drive = (long)disk->private_data; int drive = (long)disk->private_data;
@ -3615,8 +3615,6 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
opened_bdev[drive] = NULL; opened_bdev[drive] = NULL;
mutex_unlock(&open_lock); mutex_unlock(&open_lock);
mutex_unlock(&floppy_mutex); mutex_unlock(&floppy_mutex);
return 0;
} }
/* /*

6
drivers/block/loop.c
View File

@ -1518,7 +1518,7 @@ out:
return err; return err;
} }
static int lo_release(struct gendisk *disk, fmode_t mode) static void lo_release(struct gendisk *disk, fmode_t mode)
{ {
struct loop_device *lo = disk->private_data; struct loop_device *lo = disk->private_data;
int err; int err;
@ -1535,7 +1535,7 @@ static int lo_release(struct gendisk *disk, fmode_t mode)
*/ */
err = loop_clr_fd(lo); err = loop_clr_fd(lo);
if (!err) if (!err)
goto out_unlocked; return;
} else { } else {
/* /*
* Otherwise keep thread (if running) and config, * Otherwise keep thread (if running) and config,
@ -1546,8 +1546,6 @@ static int lo_release(struct gendisk *disk, fmode_t mode)
out: out:
mutex_unlock(&lo->lo_ctl_mutex); mutex_unlock(&lo->lo_ctl_mutex);
out_unlocked:
return 0;
} }
static const struct block_device_operations lo_fops = { static const struct block_device_operations lo_fops = {

3
drivers/block/paride/pcd.c
View File

@ -236,13 +236,12 @@ static int pcd_block_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int pcd_block_release(struct gendisk *disk, fmode_t mode) static void pcd_block_release(struct gendisk *disk, fmode_t mode)
{ {
struct pcd_unit *cd = disk->private_data; struct pcd_unit *cd = disk->private_data;
mutex_lock(&pcd_mutex); mutex_lock(&pcd_mutex);
cdrom_release(&cd->info, mode); cdrom_release(&cd->info, mode);
mutex_unlock(&pcd_mutex); mutex_unlock(&pcd_mutex);
return 0;
} }
static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode, static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,

4
drivers/block/paride/pd.c
View File

@ -783,7 +783,7 @@ static int pd_ioctl(struct block_device *bdev, fmode_t mode,
} }
} }
static int pd_release(struct gendisk *p, fmode_t mode) static void pd_release(struct gendisk *p, fmode_t mode)
{ {
struct pd_unit *disk = p->private_data; struct pd_unit *disk = p->private_data;
@ -791,8 +791,6 @@ static int pd_release(struct gendisk *p, fmode_t mode)
if (!--disk->access && disk->removable) if (!--disk->access && disk->removable)
pd_special_command(disk, pd_door_unlock); pd_special_command(disk, pd_door_unlock);
mutex_unlock(&pd_mutex); mutex_unlock(&pd_mutex);
return 0;
} }
static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing) static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)

9
drivers/block/paride/pf.c
View File

@ -211,7 +211,7 @@ static int pf_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo); static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
static int pf_release(struct gendisk *disk, fmode_t mode); static void pf_release(struct gendisk *disk, fmode_t mode);
static int pf_detect(void); static int pf_detect(void);
static void do_pf_read(void); static void do_pf_read(void);
@ -360,14 +360,15 @@ static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, u
return 0; return 0;
} }
static int pf_release(struct gendisk *disk, fmode_t mode) static void pf_release(struct gendisk *disk, fmode_t mode)
{ {
struct pf_unit *pf = disk->private_data; struct pf_unit *pf = disk->private_data;
mutex_lock(&pf_mutex); mutex_lock(&pf_mutex);
if (pf->access <= 0) { if (pf->access <= 0) {
mutex_unlock(&pf_mutex); mutex_unlock(&pf_mutex);
return -EINVAL; WARN_ON(1);
return;
} }
pf->access--; pf->access--;
@ -376,8 +377,6 @@ static int pf_release(struct gendisk *disk, fmode_t mode)
pf_lock(pf, 0); pf_lock(pf, 0);
mutex_unlock(&pf_mutex); mutex_unlock(&pf_mutex);
return 0;
} }
static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing) static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)

4
drivers/block/pktcdvd.c
View File

@ -2376,10 +2376,9 @@ out:
return ret; return ret;
} }
static int pkt_close(struct gendisk *disk, fmode_t mode) static void pkt_close(struct gendisk *disk, fmode_t mode)
{ {
struct pktcdvd_device *pd = disk->private_data; struct pktcdvd_device *pd = disk->private_data;
int ret = 0;
mutex_lock(&pktcdvd_mutex); mutex_lock(&pktcdvd_mutex);
mutex_lock(&ctl_mutex); mutex_lock(&ctl_mutex);
@ -2391,7 +2390,6 @@ static int pkt_close(struct gendisk *disk, fmode_t mode)
} }
mutex_unlock(&ctl_mutex); mutex_unlock(&ctl_mutex);
mutex_unlock(&pktcdvd_mutex); mutex_unlock(&pktcdvd_mutex);
return ret;
} }

4
drivers/block/rbd.c
View File

@ -460,7 +460,7 @@ static int rbd_open(struct block_device *bdev, fmode_t mode)
return 0; return 0;
} }
static int rbd_release(struct gendisk *disk, fmode_t mode) static void rbd_release(struct gendisk *disk, fmode_t mode)
{ {
struct rbd_device *rbd_dev = disk->private_data; struct rbd_device *rbd_dev = disk->private_data;
unsigned long open_count_before; unsigned long open_count_before;
@ -473,8 +473,6 @@ static int rbd_release(struct gendisk *disk, fmode_t mode)
mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
put_device(&rbd_dev->dev); put_device(&rbd_dev->dev);
mutex_unlock(&ctl_mutex); mutex_unlock(&ctl_mutex);
return 0;
} }
static const struct block_device_operations rbd_bd_ops = { static const struct block_device_operations rbd_bd_ops = {

4
drivers/block/swim.c
View File

@ -673,7 +673,7 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int floppy_release(struct gendisk *disk, fmode_t mode) static void floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct floppy_state *fs = disk->private_data; struct floppy_state *fs = disk->private_data;
struct swim __iomem *base = fs->swd->base; struct swim __iomem *base = fs->swd->base;
@ -687,8 +687,6 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
if (fs->ref_count == 0) if (fs->ref_count == 0)
swim_motor(base, OFF); swim_motor(base, OFF);
mutex_unlock(&swim_mutex); mutex_unlock(&swim_mutex);
return 0;
} }
static int floppy_ioctl(struct block_device *bdev, fmode_t mode, static int floppy_ioctl(struct block_device *bdev, fmode_t mode,

5
drivers/block/swim3.c
View File

@ -251,7 +251,7 @@ static int fd_eject(struct floppy_state *fs);
static int floppy_ioctl(struct block_device *bdev, fmode_t mode, static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long param); unsigned int cmd, unsigned long param);
static int floppy_open(struct block_device *bdev, fmode_t mode); static int floppy_open(struct block_device *bdev, fmode_t mode);
static int floppy_release(struct gendisk *disk, fmode_t mode); static void floppy_release(struct gendisk *disk, fmode_t mode);
static unsigned int floppy_check_events(struct gendisk *disk, static unsigned int floppy_check_events(struct gendisk *disk,
unsigned int clearing); unsigned int clearing);
static int floppy_revalidate(struct gendisk *disk); static int floppy_revalidate(struct gendisk *disk);
@ -1017,7 +1017,7 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int floppy_release(struct gendisk *disk, fmode_t mode) static void floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct floppy_state *fs = disk->private_data; struct floppy_state *fs = disk->private_data;
struct swim3 __iomem *sw = fs->swim3; struct swim3 __iomem *sw = fs->swim3;
@ -1029,7 +1029,6 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
swim3_select(fs, RELAX); swim3_select(fs, RELAX);
} }
mutex_unlock(&swim3_mutex); mutex_unlock(&swim3_mutex);
return 0;
} }
static unsigned int floppy_check_events(struct gendisk *disk, static unsigned int floppy_check_events(struct gendisk *disk,

3
drivers/block/xen-blkfront.c
View File

@ -1617,7 +1617,7 @@ out:
return err; return err;
} }
static int blkif_release(struct gendisk *disk, fmode_t mode) static void blkif_release(struct gendisk *disk, fmode_t mode)
{ {
struct blkfront_info *info = disk->private_data; struct blkfront_info *info = disk->private_data;
struct block_device *bdev; struct block_device *bdev;
@ -1658,7 +1658,6 @@ static int blkif_release(struct gendisk *disk, fmode_t mode)
out: out:
bdput(bdev); bdput(bdev);
mutex_unlock(&blkfront_mutex); mutex_unlock(&blkfront_mutex);
return 0;
} }
static const struct block_device_operations xlvbd_block_fops = static const struct block_device_operations xlvbd_block_fops =

3
drivers/block/xsysace.c
View File

@ -915,7 +915,7 @@ static int ace_open(struct block_device *bdev, fmode_t mode)
return 0; return 0;
} }
static int ace_release(struct gendisk *disk, fmode_t mode) static void ace_release(struct gendisk *disk, fmode_t mode)
{ {
struct ace_device *ace = disk->private_data; struct ace_device *ace = disk->private_data;
unsigned long flags; unsigned long flags;
@ -932,7 +932,6 @@ static int ace_release(struct gendisk *disk, fmode_t mode)
} }
spin_unlock_irqrestore(&ace->lock, flags); spin_unlock_irqrestore(&ace->lock, flags);
mutex_unlock(&xsysace_mutex); mutex_unlock(&xsysace_mutex);
return 0;
} }
static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo)

6
drivers/block/z2ram.c
View File

@ -309,20 +309,18 @@ err_out:
return rc; return rc;
} }
static int static void
z2_release(struct gendisk *disk, fmode_t mode) z2_release(struct gendisk *disk, fmode_t mode)
{ {
mutex_lock(&z2ram_mutex); mutex_lock(&z2ram_mutex);
if ( current_device == -1 ) { if ( current_device == -1 ) {
mutex_unlock(&z2ram_mutex); mutex_unlock(&z2ram_mutex);
return 0; return;
} }
mutex_unlock(&z2ram_mutex); mutex_unlock(&z2ram_mutex);
/* /*
* FIXME: unmap memory * FIXME: unmap memory
*/ */
return 0;
} }
static const struct block_device_operations z2_fops = static const struct block_device_operations z2_fops =

3
drivers/cdrom/gdrom.c
View File

@ -503,12 +503,11 @@ static int gdrom_bdops_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int gdrom_bdops_release(struct gendisk *disk, fmode_t mode) static void gdrom_bdops_release(struct gendisk *disk, fmode_t mode)
{ {
mutex_lock(&gdrom_mutex); mutex_lock(&gdrom_mutex);
cdrom_release(gd.cd_info, mode); cdrom_release(gd.cd_info, mode);
mutex_unlock(&gdrom_mutex); mutex_unlock(&gdrom_mutex);
return 0;
} }
static unsigned int gdrom_bdops_check_events(struct gendisk *disk, static unsigned int gdrom_bdops_check_events(struct gendisk *disk,

4
drivers/ide/ide-cd.c
View File

@ -1606,7 +1606,7 @@ out:
return rc; return rc;
} }
static int idecd_release(struct gendisk *disk, fmode_t mode) static void idecd_release(struct gendisk *disk, fmode_t mode)
{ {
struct cdrom_info *info = ide_drv_g(disk, cdrom_info); struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
@ -1615,8 +1615,6 @@ static int idecd_release(struct gendisk *disk, fmode_t mode)
ide_cd_put(info); ide_cd_put(info);
mutex_unlock(&ide_cd_mutex); mutex_unlock(&ide_cd_mutex);
return 0;
} }
static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg) static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)

4
drivers/ide/ide-gd.c
View File

@ -250,7 +250,7 @@ static int ide_gd_unlocked_open(struct block_device *bdev, fmode_t mode)
} }
static int ide_gd_release(struct gendisk *disk, fmode_t mode) static void ide_gd_release(struct gendisk *disk, fmode_t mode)
{ {
struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
ide_drive_t *drive = idkp->drive; ide_drive_t *drive = idkp->drive;
@ -270,8 +270,6 @@ static int ide_gd_release(struct gendisk *disk, fmode_t mode)
ide_disk_put(idkp); ide_disk_put(idkp);
mutex_unlock(&ide_gd_mutex); mutex_unlock(&ide_gd_mutex);
return 0;
} }
static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)

4
drivers/ide/ide-tape.c
View File

@ -1918,15 +1918,13 @@ static int idetape_open(struct block_device *bdev, fmode_t mode)
return 0; return 0;
} }
static int idetape_release(struct gendisk *disk, fmode_t mode) static void idetape_release(struct gendisk *disk, fmode_t mode)
{ {
struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj); struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
mutex_lock(&ide_tape_mutex); mutex_lock(&ide_tape_mutex);
ide_tape_put(tape); ide_tape_put(tape);
mutex_unlock(&ide_tape_mutex); mutex_unlock(&ide_tape_mutex);
return 0;
} }
static int idetape_ioctl(struct block_device *bdev, fmode_t mode, static int idetape_ioctl(struct block_device *bdev, fmode_t mode,

4
drivers/md/dm.c
View File

@ -339,7 +339,7 @@ out:
return md ? 0 : -ENXIO; return md ? 0 : -ENXIO;
} }
static int dm_blk_close(struct gendisk *disk, fmode_t mode) static void dm_blk_close(struct gendisk *disk, fmode_t mode)
{ {
struct mapped_device *md = disk->private_data; struct mapped_device *md = disk->private_data;
@ -349,8 +349,6 @@ static int dm_blk_close(struct gendisk *disk, fmode_t mode)
dm_put(md); dm_put(md);
spin_unlock(&_minor_lock); spin_unlock(&_minor_lock);
return 0;
} }
int dm_open_count(struct mapped_device *md) int dm_open_count(struct mapped_device *md)

4
drivers/md/md.c
View File

@ -6674,15 +6674,13 @@ static int md_open(struct block_device *bdev, fmode_t mode)
return err; return err;
} }
static int md_release(struct gendisk *disk, fmode_t mode) static void md_release(struct gendisk *disk, fmode_t mode)
{ {
struct mddev *mddev = disk->private_data; struct mddev *mddev = disk->private_data;
BUG_ON(!mddev); BUG_ON(!mddev);
atomic_dec(&mddev->openers); atomic_dec(&mddev->openers);
mddev_put(mddev); mddev_put(mddev);
return 0;
} }
static int md_media_changed(struct gendisk *disk) static int md_media_changed(struct gendisk *disk)

8
drivers/memstick/core/mspro_block.c
View File

@ -204,7 +204,7 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
} }
static int mspro_block_disk_release(struct gendisk *disk) static void mspro_block_disk_release(struct gendisk *disk)
{ {
struct mspro_block_data *msb = disk->private_data; struct mspro_block_data *msb = disk->private_data;
int disk_id = MINOR(disk_devt(disk)) >> MSPRO_BLOCK_PART_SHIFT; int disk_id = MINOR(disk_devt(disk)) >> MSPRO_BLOCK_PART_SHIFT;
@ -224,13 +224,11 @@ static int mspro_block_disk_release(struct gendisk *disk)
} }
mutex_unlock(&mspro_block_disk_lock); mutex_unlock(&mspro_block_disk_lock);
return 0;
} }
static int mspro_block_bd_release(struct gendisk *disk, fmode_t mode) static void mspro_block_bd_release(struct gendisk *disk, fmode_t mode)
{ {
return mspro_block_disk_release(disk); mspro_block_disk_release(disk);
} }
static int mspro_block_bd_getgeo(struct block_device *bdev, static int mspro_block_bd_getgeo(struct block_device *bdev,

8
drivers/message/i2o/i2o_block.c
View File

@ -600,10 +600,8 @@ static int i2o_block_open(struct block_device *bdev, fmode_t mode)
* *
* Unlock and unmount the media, and power down the device. Gets called if * Unlock and unmount the media, and power down the device. Gets called if
* the block device is closed. * the block device is closed.
*
* Returns 0 on success or negative error code on failure.
*/ */
static int i2o_block_release(struct gendisk *disk, fmode_t mode) static void i2o_block_release(struct gendisk *disk, fmode_t mode)
{ {
struct i2o_block_device *dev = disk->private_data; struct i2o_block_device *dev = disk->private_data;
u8 operation; u8 operation;
@ -617,7 +615,7 @@ static int i2o_block_release(struct gendisk *disk, fmode_t mode)
* the TID no longer exists. * the TID no longer exists.
*/ */
if (!dev->i2o_dev) if (!dev->i2o_dev)
return 0; return;
mutex_lock(&i2o_block_mutex); mutex_lock(&i2o_block_mutex);
i2o_block_device_flush(dev->i2o_dev); i2o_block_device_flush(dev->i2o_dev);
@ -631,8 +629,6 @@ static int i2o_block_release(struct gendisk *disk, fmode_t mode)
i2o_block_device_power(dev, operation); i2o_block_device_power(dev, operation);
mutex_unlock(&i2o_block_mutex); mutex_unlock(&i2o_block_mutex);
return 0;
} }
static int i2o_block_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int i2o_block_getgeo(struct block_device *bdev, struct hd_geometry *geo)

3
drivers/mmc/card/block.c
View File

@ -304,14 +304,13 @@ static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int mmc_blk_release(struct gendisk *disk, fmode_t mode) static void mmc_blk_release(struct gendisk *disk, fmode_t mode)
{ {
struct mmc_blk_data *md = disk->private_data; struct mmc_blk_data *md = disk->private_data;
mutex_lock(&block_mutex); mutex_lock(&block_mutex);
mmc_blk_put(md); mmc_blk_put(md);
mutex_unlock(&block_mutex); mutex_unlock(&block_mutex);
return 0;
} }
static int static int

9
drivers/mtd/mtd_blkdevs.c
View File

@ -237,13 +237,12 @@ error_put:
return ret; return ret;
} }
static int blktrans_release(struct gendisk *disk, fmode_t mode) static void blktrans_release(struct gendisk *disk, fmode_t mode)
{ {
struct mtd_blktrans_dev *dev = blktrans_dev_get(disk); struct mtd_blktrans_dev *dev = blktrans_dev_get(disk);
int ret = 0;
if (!dev) if (!dev)
return ret; return;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
@ -254,13 +253,13 @@ static int blktrans_release(struct gendisk *disk, fmode_t mode)
module_put(dev->tr->owner); module_put(dev->tr->owner);
if (dev->mtd) { if (dev->mtd) {
ret = dev->tr->release ? dev->tr->release(dev) : 0; if (dev->tr->release)
dev->tr->release(dev);
__put_mtd_device(dev->mtd); __put_mtd_device(dev->mtd);
} }
unlock: unlock:
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
blktrans_dev_put(dev); blktrans_dev_put(dev);
return ret;
} }
static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)

4
drivers/mtd/mtdblock.c
View File

@ -308,7 +308,7 @@ static int mtdblock_open(struct mtd_blktrans_dev *mbd)
return 0; return 0;
} }
static int mtdblock_release(struct mtd_blktrans_dev *mbd) static void mtdblock_release(struct mtd_blktrans_dev *mbd)
{ {
struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd); struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd);
@ -333,8 +333,6 @@ static int mtdblock_release(struct mtd_blktrans_dev *mbd)
mutex_unlock(&mtdblks_lock); mutex_unlock(&mtdblks_lock);
pr_debug("ok\n"); pr_debug("ok\n");
return 0;
} }
static int mtdblock_flush(struct mtd_blktrans_dev *dev) static int mtdblock_flush(struct mtd_blktrans_dev *dev)

3
drivers/mtd/sm_ftl.c
View File

@ -1107,7 +1107,7 @@ static int sm_flush(struct mtd_blktrans_dev *dev)
} }
/* outside interface: device is released */ /* outside interface: device is released */
static int sm_release(struct mtd_blktrans_dev *dev) static void sm_release(struct mtd_blktrans_dev *dev)
{ {
struct sm_ftl *ftl = dev->priv; struct sm_ftl *ftl = dev->priv;
@ -1116,7 +1116,6 @@ static int sm_release(struct mtd_blktrans_dev *dev)
cancel_work_sync(&ftl->flush_work); cancel_work_sync(&ftl->flush_work);
sm_cache_flush(ftl); sm_cache_flush(ftl);
mutex_unlock(&ftl->mutex); mutex_unlock(&ftl->mutex);
return 0;
} }
/* outside interface: get geometry */ /* outside interface: get geometry */

12
drivers/s390/block/dasd.c
View File

@ -2997,18 +2997,14 @@ unlock:
return rc; return rc;
} }
static int dasd_release(struct gendisk *disk, fmode_t mode) static void dasd_release(struct gendisk *disk, fmode_t mode)
{ {
struct dasd_device *base; struct dasd_device *base = dasd_device_from_gendisk(disk);
if (base) {
base = dasd_device_from_gendisk(disk);
if (!base)
return -ENODEV;
atomic_dec(&base->block->open_count); atomic_dec(&base->block->open_count);
module_put(base->discipline->owner); module_put(base->discipline->owner);
dasd_put_device(base); dasd_put_device(base);
return 0; }
} }
/* /*

12
drivers/s390/block/dcssblk.c
View File

@ -26,7 +26,7 @@
#define DCSS_BUS_ID_SIZE 20 #define DCSS_BUS_ID_SIZE 20
static int dcssblk_open(struct block_device *bdev, fmode_t mode); static int dcssblk_open(struct block_device *bdev, fmode_t mode);
static int dcssblk_release(struct gendisk *disk, fmode_t mode); static void dcssblk_release(struct gendisk *disk, fmode_t mode);
static void dcssblk_make_request(struct request_queue *q, struct bio *bio); static void dcssblk_make_request(struct request_queue *q, struct bio *bio);
static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum, static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
void **kaddr, unsigned long *pfn); void **kaddr, unsigned long *pfn);
@ -781,16 +781,15 @@ out:
return rc; return rc;
} }
static int static void
dcssblk_release(struct gendisk *disk, fmode_t mode) dcssblk_release(struct gendisk *disk, fmode_t mode)
{ {
struct dcssblk_dev_info *dev_info = disk->private_data; struct dcssblk_dev_info *dev_info = disk->private_data;
struct segment_info *entry; struct segment_info *entry;
int rc;
if (!dev_info) { if (!dev_info) {
rc = -ENODEV; WARN_ON(1);
goto out; return;
} }
down_write(&dcssblk_devices_sem); down_write(&dcssblk_devices_sem);
if (atomic_dec_and_test(&dev_info->use_count) if (atomic_dec_and_test(&dev_info->use_count)
@ -803,9 +802,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode)
dev_info->save_pending = 0; dev_info->save_pending = 0;
} }
up_write(&dcssblk_devices_sem); up_write(&dcssblk_devices_sem);
rc = 0;
out:
return rc;
} }
static void static void

3
drivers/s390/block/scm_blk.c
View File

@ -123,10 +123,9 @@ static int scm_open(struct block_device *blkdev, fmode_t mode)
return scm_get_ref(); return scm_get_ref();
} }
static int scm_release(struct gendisk *gendisk, fmode_t mode) static void scm_release(struct gendisk *gendisk, fmode_t mode)
{ {
scm_put_ref(); scm_put_ref();
return 0;
} }
static const struct block_device_operations scm_blk_devops = { static const struct block_device_operations scm_blk_devops = {

3
drivers/scsi/sd.c
View File

@ -1188,7 +1188,7 @@ error_autopm:
* *
* Locking: called with bdev->bd_mutex held. * Locking: called with bdev->bd_mutex held.
**/ **/
static int sd_release(struct gendisk *disk, fmode_t mode) static void sd_release(struct gendisk *disk, fmode_t mode)
{ {
struct scsi_disk *sdkp = scsi_disk(disk); struct scsi_disk *sdkp = scsi_disk(disk);
struct scsi_device *sdev = sdkp->device; struct scsi_device *sdev = sdkp->device;
@ -1207,7 +1207,6 @@ static int sd_release(struct gendisk *disk, fmode_t mode)
scsi_autopm_put_device(sdev); scsi_autopm_put_device(sdev);
scsi_disk_put(sdkp); scsi_disk_put(sdkp);
return 0;
} }
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)

3
drivers/scsi/sr.c
View File

@ -541,14 +541,13 @@ static int sr_block_open(struct block_device *bdev, fmode_t mode)
return ret; return ret;
} }
static int sr_block_release(struct gendisk *disk, fmode_t mode) static void sr_block_release(struct gendisk *disk, fmode_t mode)
{ {
struct scsi_cd *cd = scsi_cd(disk); struct scsi_cd *cd = scsi_cd(disk);
mutex_lock(&sr_mutex); mutex_lock(&sr_mutex);
cdrom_release(&cd->cdi, mode); cdrom_release(&cd->cdi, mode);
scsi_cd_put(cd); scsi_cd_put(cd);
mutex_unlock(&sr_mutex); mutex_unlock(&sr_mutex);
return 0;
} }
static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,

16
fs/block_dev.c
View File

@ -1045,7 +1045,7 @@ void bd_set_size(struct block_device *bdev, loff_t size)
} }
EXPORT_SYMBOL(bd_set_size); EXPORT_SYMBOL(bd_set_size);
static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part); static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
/* /*
* bd_mutex locking: * bd_mutex locking:
@ -1400,9 +1400,8 @@ static int blkdev_open(struct inode * inode, struct file * filp)
return blkdev_get(bdev, filp->f_mode, filp); return blkdev_get(bdev, filp->f_mode, filp);
} }
static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part) static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
{ {
int ret = 0;
struct gendisk *disk = bdev->bd_disk; struct gendisk *disk = bdev->bd_disk;
struct block_device *victim = NULL; struct block_device *victim = NULL;
@ -1422,7 +1421,7 @@ static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
} }
if (bdev->bd_contains == bdev) { if (bdev->bd_contains == bdev) {
if (disk->fops->release) if (disk->fops->release)
ret = disk->fops->release(disk, mode); disk->fops->release(disk, mode);
} }
if (!bdev->bd_openers) { if (!bdev->bd_openers) {
struct module *owner = disk->fops->owner; struct module *owner = disk->fops->owner;
@ -1441,10 +1440,9 @@ static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
bdput(bdev); bdput(bdev);
if (victim) if (victim)
__blkdev_put(victim, mode, 1); __blkdev_put(victim, mode, 1);
return ret;
} }
int blkdev_put(struct block_device *bdev, fmode_t mode) void blkdev_put(struct block_device *bdev, fmode_t mode)
{ {
mutex_lock(&bdev->bd_mutex); mutex_lock(&bdev->bd_mutex);
@ -1488,15 +1486,15 @@ int blkdev_put(struct block_device *bdev, fmode_t mode)
mutex_unlock(&bdev->bd_mutex); mutex_unlock(&bdev->bd_mutex);
return __blkdev_put(bdev, mode, 0); __blkdev_put(bdev, mode, 0);
} }
EXPORT_SYMBOL(blkdev_put); EXPORT_SYMBOL(blkdev_put);
static int blkdev_close(struct inode * inode, struct file * filp) static int blkdev_close(struct inode * inode, struct file * filp)
{ {
struct block_device *bdev = I_BDEV(filp->f_mapping->host); struct block_device *bdev = I_BDEV(filp->f_mapping->host);
blkdev_put(bdev, filp->f_mode);
return blkdev_put(bdev, filp->f_mode); return 0;
} }
static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg) static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)

11
fs/ext3/super.c
View File

@ -362,22 +362,19 @@ fail:
/* /*
* Release the journal device * Release the journal device
*/ */
static int ext3_blkdev_put(struct block_device *bdev) static void ext3_blkdev_put(struct block_device *bdev)
{ {
return blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL); blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
} }
static int ext3_blkdev_remove(struct ext3_sb_info *sbi) static void ext3_blkdev_remove(struct ext3_sb_info *sbi)
{ {
struct block_device *bdev; struct block_device *bdev;
int ret = -ENODEV;
bdev = sbi->journal_bdev; bdev = sbi->journal_bdev;
if (bdev) { if (bdev) {
ret = ext3_blkdev_put(bdev); ext3_blkdev_put(bdev);
sbi->journal_bdev = NULL; sbi->journal_bdev = NULL;
} }
return ret;
} }
static inline struct inode *orphan_list_entry(struct list_head *l) static inline struct inode *orphan_list_entry(struct list_head *l)

11
fs/ext4/super.c
View File

@ -703,22 +703,19 @@ fail:
/* /*
* Release the journal device * Release the journal device
*/ */
static int ext4_blkdev_put(struct block_device *bdev) static void ext4_blkdev_put(struct block_device *bdev)
{ {
return blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL); blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
} }
static int ext4_blkdev_remove(struct ext4_sb_info *sbi) static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
{ {
struct block_device *bdev; struct block_device *bdev;
int ret = -ENODEV;
bdev = sbi->journal_bdev; bdev = sbi->journal_bdev;
if (bdev) { if (bdev) {
ret = ext4_blkdev_put(bdev); ext4_blkdev_put(bdev);
sbi->journal_bdev = NULL; sbi->journal_bdev = NULL;
} }
return ret;
} }
static inline struct inode *orphan_list_entry(struct list_head *l) static inline struct inode *orphan_list_entry(struct list_head *l)

2
fs/hfs/dir.c
View File

@ -176,7 +176,9 @@ static int hfs_dir_release(struct inode *inode, struct file *file)
{ {
struct hfs_readdir_data *rd = file->private_data; struct hfs_readdir_data *rd = file->private_data;
if (rd) { if (rd) {
mutex_lock(&inode->i_mutex);
list_del(&rd->list); list_del(&rd->list);
mutex_unlock(&inode->i_mutex);
kfree(rd); kfree(rd);
} }
return 0; return 0;

2
fs/nfs/blocklayout/blocklayout.h
View File

@ -173,7 +173,7 @@ struct bl_msg_hdr {
/* blocklayoutdev.c */ /* blocklayoutdev.c */
ssize_t bl_pipe_downcall(struct file *, const char __user *, size_t); ssize_t bl_pipe_downcall(struct file *, const char __user *, size_t);
void bl_pipe_destroy_msg(struct rpc_pipe_msg *); void bl_pipe_destroy_msg(struct rpc_pipe_msg *);
int nfs4_blkdev_put(struct block_device *bdev); void nfs4_blkdev_put(struct block_device *bdev);
struct pnfs_block_dev *nfs4_blk_decode_device(struct nfs_server *server, struct pnfs_block_dev *nfs4_blk_decode_device(struct nfs_server *server,
struct pnfs_device *dev); struct pnfs_device *dev);
int nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo, int nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,

4
fs/nfs/blocklayout/blocklayoutdev.c
View File

@ -56,11 +56,11 @@ static int decode_sector_number(__be32 **rp, sector_t *sp)
/* /*
* Release the block device * Release the block device
*/ */
int nfs4_blkdev_put(struct block_device *bdev) void nfs4_blkdev_put(struct block_device *bdev)
{ {
dprintk("%s for device %d:%d\n", __func__, MAJOR(bdev->bd_dev), dprintk("%s for device %d:%d\n", __func__, MAJOR(bdev->bd_dev),
MINOR(bdev->bd_dev)); MINOR(bdev->bd_dev));
return blkdev_put(bdev, FMODE_READ); blkdev_put(bdev, FMODE_READ);
} }
ssize_t bl_pipe_downcall(struct file *filp, const char __user *src, ssize_t bl_pipe_downcall(struct file *filp, const char __user *src,

8
fs/nfs/blocklayout/blocklayoutdm.c
View File

@ -88,14 +88,8 @@ out:
*/ */
static void nfs4_blk_metadev_release(struct pnfs_block_dev *bdev) static void nfs4_blk_metadev_release(struct pnfs_block_dev *bdev)
{ {
int rv;
dprintk("%s Releasing\n", __func__); dprintk("%s Releasing\n", __func__);
rv = nfs4_blkdev_put(bdev->bm_mdev); nfs4_blkdev_put(bdev->bm_mdev);
if (rv)
printk(KERN_ERR "NFS: %s nfs4_blkdev_put returns %d\n",
__func__, rv);
dev_remove(bdev->net, bdev->bm_mdev->bd_dev); dev_remove(bdev->net, bdev->bm_mdev->bd_dev);
} }

16
fs/reiserfs/journal.c
View File

@ -97,7 +97,7 @@ static int flush_commit_list(struct super_block *s,
static int can_dirty(struct reiserfs_journal_cnode *cn); static int can_dirty(struct reiserfs_journal_cnode *cn);
static int journal_join(struct reiserfs_transaction_handle *th, static int journal_join(struct reiserfs_transaction_handle *th,
struct super_block *sb, unsigned long nblocks); struct super_block *sb, unsigned long nblocks);
static int release_journal_dev(struct super_block *super, static void release_journal_dev(struct super_block *super,
struct reiserfs_journal *journal); struct reiserfs_journal *journal);
static int dirty_one_transaction(struct super_block *s, static int dirty_one_transaction(struct super_block *s,
struct reiserfs_journal_list *jl); struct reiserfs_journal_list *jl);
@ -2532,23 +2532,13 @@ static void journal_list_init(struct super_block *sb)
SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb); SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb);
} }
static int release_journal_dev(struct super_block *super, static void release_journal_dev(struct super_block *super,
struct reiserfs_journal *journal) struct reiserfs_journal *journal)
{ {
int result;
result = 0;
if (journal->j_dev_bd != NULL) { if (journal->j_dev_bd != NULL) {
result = blkdev_put(journal->j_dev_bd, journal->j_dev_mode); blkdev_put(journal->j_dev_bd, journal->j_dev_mode);
journal->j_dev_bd = NULL; journal->j_dev_bd = NULL;
} }
if (result != 0) {
reiserfs_warning(super, "sh-457",
"Cannot release journal device: %i", result);
}
return result;
} }
static int journal_init_dev(struct super_block *super, static int journal_init_dev(struct super_block *super,

2
include/linux/blkdev.h
View File

@ -1484,7 +1484,7 @@ static inline bool blk_integrity_is_initialized(struct gendisk *g)
struct block_device_operations { struct block_device_operations {
int (*open) (struct block_device *, fmode_t); int (*open) (struct block_device *, fmode_t);
int (*release) (struct gendisk *, fmode_t); void (*release) (struct gendisk *, fmode_t);
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
int (*direct_access) (struct block_device *, sector_t, int (*direct_access) (struct block_device *, sector_t,

2
include/linux/fs.h
View File

@ -2091,7 +2091,7 @@ extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
void *holder); void *holder);
extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
void *holder); void *holder);
extern int blkdev_put(struct block_device *bdev, fmode_t mode); extern void blkdev_put(struct block_device *bdev, fmode_t mode);
#ifdef CONFIG_SYSFS #ifdef CONFIG_SYSFS
extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk); extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
extern void bd_unlink_disk_holder(struct block_device *bdev, extern void bd_unlink_disk_holder(struct block_device *bdev,

2
include/linux/mtd/blktrans.h
View File

@ -74,7 +74,7 @@ struct mtd_blktrans_ops {
/* Called with mtd_table_mutex held; no race with add/remove */ /* Called with mtd_table_mutex held; no race with add/remove */
int (*open)(struct mtd_blktrans_dev *dev); int (*open)(struct mtd_blktrans_dev *dev);
int (*release)(struct mtd_blktrans_dev *dev); void (*release)(struct mtd_blktrans_dev *dev);
/* Called on {de,}registration and on subsequent addition/removal /* Called on {de,}registration and on subsequent addition/removal
of devices, with mtd_table_mutex held. */ of devices, with mtd_table_mutex held. */