A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-28 18:51:56 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/viro/bdev

Browse source 
* git://git.kernel.org/pub/scm/linux/kernel/git/viro/bdev: (66 commits)
  [PATCH] kill the rest of struct file propagation in block ioctls
  [PATCH] get rid of struct file use in blkdev_ioctl() BLKBSZSET
  [PATCH] get rid of blkdev_locked_ioctl()
  [PATCH] get rid of blkdev_driver_ioctl()
  [PATCH] sanitize blkdev_get() and friends
  [PATCH] remember mode of reiserfs journal
  [PATCH] propagate mode through swsusp_close()
  [PATCH] propagate mode through open_bdev_excl/close_bdev_excl
  [PATCH] pass fmode_t to blkdev_put()
  [PATCH] kill the unused bsize on the send side of /dev/loop
  [PATCH] trim file propagation in block/compat_ioctl.c
  [PATCH] end of methods switch: remove the old ones
  [PATCH] switch sr
  [PATCH] switch sd
  [PATCH] switch ide-scsi
  [PATCH] switch tape_block
  [PATCH] switch dcssblk
  [PATCH] switch dasd
  [PATCH] switch mtd_blkdevs
  [PATCH] switch mmc
  ...
This commit is contained in:
Linus Torvalds 2008-10-23 10:23:07 -07:00
commit 2248485640
107 changed files with 868 additions and 1002 deletions
Download patch file Download diff file Expand all files Collapse all files

4
drivers/md/dm-ioctl.c
View file

@ -988,9 +988,9 @@ static int dev_wait(struct dm_ioctl *param, size_t param_size)
return r;
}
static inline int get_mode(struct dm_ioctl *param)
static inline fmode_t get_mode(struct dm_ioctl *param)
{
int mode = FMODE_READ | FMODE_WRITE;
fmode_t mode = FMODE_READ | FMODE_WRITE;
if (param->flags & DM_READONLY_FLAG)
mode = FMODE_READ;

13
drivers/md/dm-linear.c
View file

@ -110,20 +110,11 @@ static int linear_status(struct dm_target *ti, status_type_t type,
return 0;
}
static int linear_ioctl(struct dm_target *ti, struct inode *inode,
struct file *filp, unsigned int cmd,
static int linear_ioctl(struct dm_target *ti, unsigned int cmd,
unsigned long arg)
{
struct linear_c *lc = (struct linear_c *) ti->private;
struct block_device *bdev = lc->dev->bdev;
struct file fake_file = {};
struct dentry fake_dentry = {};
fake_file.f_mode = lc->dev->mode;
fake_file.f_path.dentry = &fake_dentry;
fake_dentry.d_inode = bdev->bd_inode;
return blkdev_driver_ioctl(bdev->bd_inode, &fake_file, bdev->bd_disk, cmd, arg);
return __blkdev_driver_ioctl(lc->dev->bdev, lc->dev->mode, cmd, arg);
}
static int linear_merge(struct dm_target *ti, struct bvec_merge_data *bvm,

14
drivers/md/dm-mpath.c
View file

@ -1396,19 +1396,15 @@ error:
return -EINVAL;
}
static int multipath_ioctl(struct dm_target *ti, struct inode *inode,
struct file *filp, unsigned int cmd,
static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
unsigned long arg)
{
struct multipath *m = (struct multipath *) ti->private;
struct block_device *bdev = NULL;
fmode_t mode = 0;
unsigned long flags;
struct file fake_file = {};
struct dentry fake_dentry = {};
int r = 0;
fake_file.f_path.dentry = &fake_dentry;
spin_lock_irqsave(&m->lock, flags);
if (!m->current_pgpath)
@ -1416,8 +1412,7 @@ static int multipath_ioctl(struct dm_target *ti, struct inode *inode,
if (m->current_pgpath) {
bdev = m->current_pgpath->path.dev->bdev;
fake_dentry.d_inode = bdev->bd_inode;
fake_file.f_mode = m->current_pgpath->path.dev->mode;
mode = m->current_pgpath->path.dev->mode;
}
if (m->queue_io)
@ -1427,8 +1422,7 @@ static int multipath_ioctl(struct dm_target *ti, struct inode *inode,
spin_unlock_irqrestore(&m->lock, flags);
return r ? : blkdev_driver_ioctl(bdev->bd_inode, &fake_file,
bdev->bd_disk, cmd, arg);
return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
}
/*-----------------------------------------------------------------

16
drivers/md/dm-table.c
View file

@ -43,7 +43,7 @@ struct dm_table {
* device. This should be a combination of FMODE_READ
* and FMODE_WRITE.
*/
int mode;
fmode_t mode;
/* a list of devices used by this table */
struct list_head devices;
@ -217,7 +217,7 @@ static int alloc_targets(struct dm_table *t, unsigned int num)
return 0;
}
int dm_table_create(struct dm_table **result, int mode,
int dm_table_create(struct dm_table **result, fmode_t mode,
unsigned num_targets, struct mapped_device *md)
{
struct dm_table *t = kzalloc(sizeof(*t), GFP_KERNEL);
@ -344,7 +344,7 @@ static int open_dev(struct dm_dev_internal *d, dev_t dev,
return PTR_ERR(bdev);
r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md));
if (r)
blkdev_put(bdev);
blkdev_put(bdev, d->dm_dev.mode);
else
d->dm_dev.bdev = bdev;
return r;
@ -359,7 +359,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
return;
bd_release_from_disk(d->dm_dev.bdev, dm_disk(md));
blkdev_put(d->dm_dev.bdev);
blkdev_put(d->dm_dev.bdev, d->dm_dev.mode);
d->dm_dev.bdev = NULL;
}
@ -382,7 +382,7 @@ static int check_device_area(struct dm_dev_internal *dd, sector_t start,
* careful to leave things as they were if we fail to reopen the
* device.
*/
static int upgrade_mode(struct dm_dev_internal *dd, int new_mode,
static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode,
struct mapped_device *md)
{
int r;
@ -408,7 +408,7 @@ static int upgrade_mode(struct dm_dev_internal *dd, int new_mode,
*/
static int __table_get_device(struct dm_table *t, struct dm_target *ti,
const char *path, sector_t start, sector_t len,
int mode, struct dm_dev **result)
fmode_t mode, struct dm_dev **result)
{
int r;
dev_t uninitialized_var(dev);
@ -528,7 +528,7 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
EXPORT_SYMBOL_GPL(dm_set_device_limits);
int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
sector_t len, int mode, struct dm_dev **result)
sector_t len, fmode_t mode, struct dm_dev **result)
{
int r = __table_get_device(ti->table, ti, path,
start, len, mode, result);
@ -878,7 +878,7 @@ struct list_head *dm_table_get_devices(struct dm_table *t)
return &t->devices;
}
int dm_table_get_mode(struct dm_table *t)
fmode_t dm_table_get_mode(struct dm_table *t)
{
return t->mode;
}

27
drivers/md/dm.c
View file

@ -21,7 +21,6 @@
#include <linux/idr.h>
#include <linux/hdreg.h>
#include <linux/blktrace_api.h>
#include <linux/smp_lock.h>
#define DM_MSG_PREFIX "core"
@ -248,13 +247,13 @@ static void __exit dm_exit(void)
/*
* Block device functions
*/
static int dm_blk_open(struct inode *inode, struct file *file)
static int dm_blk_open(struct block_device *bdev, fmode_t mode)
{
struct mapped_device *md;
spin_lock(&_minor_lock);
md = inode->i_bdev->bd_disk->private_data;
md = bdev->bd_disk->private_data;
if (!md)
goto out;
@ -273,11 +272,9 @@ out:
return md ? 0 : -ENXIO;
}
static int dm_blk_close(struct inode *inode, struct file *file)
static int dm_blk_close(struct gendisk *disk, fmode_t mode)
{
struct mapped_device *md;
md = inode->i_bdev->bd_disk->private_data;
struct mapped_device *md = disk->private_data;
atomic_dec(&md->open_count);
dm_put(md);
return 0;
@ -314,21 +311,14 @@ static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
return dm_get_geometry(md, geo);
}
static int dm_blk_ioctl(struct inode *inode, struct file *file,
static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
struct mapped_device *md;
struct dm_table *map;
struct mapped_device *md = bdev->bd_disk->private_data;
struct dm_table *map = dm_get_table(md);
struct dm_target *tgt;
int r = -ENOTTY;
/* We don't really need this lock, but we do need 'inode'. */
unlock_kernel();
md = inode->i_bdev->bd_disk->private_data;
map = dm_get_table(md);
if (!map || !dm_table_get_size(map))
goto out;
@ -344,12 +334,11 @@ static int dm_blk_ioctl(struct inode *inode, struct file *file,
}
if (tgt->type->ioctl)
r = tgt->type->ioctl(tgt, inode, file, cmd, arg);
r = tgt->type->ioctl(tgt, cmd, arg);
out:
dm_table_put(map);
lock_kernel();
return r;
}

20
drivers/md/md.c
View file

@ -1520,7 +1520,7 @@ static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
if (err) {
printk(KERN_ERR "md: could not bd_claim %s.\n",
bdevname(bdev, b));
blkdev_put(bdev);
blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
return err;
}
if (!shared)
@ -1536,7 +1536,7 @@ static void unlock_rdev(mdk_rdev_t *rdev)
if (!bdev)
MD_BUG();
bd_release(bdev);
blkdev_put(bdev);
blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
}
void md_autodetect_dev(dev_t dev);
@ -4785,7 +4785,7 @@ static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
return 0;
}
static int md_ioctl(struct inode *inode, struct file *file,
static int md_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
int err = 0;
@ -4823,7 +4823,7 @@ static int md_ioctl(struct inode *inode, struct file *file,
* Commands creating/starting a new array:
*/
mddev = inode->i_bdev->bd_disk->private_data;
mddev = bdev->bd_disk->private_data;
if (!mddev) {
BUG();
@ -4996,13 +4996,13 @@ abort:
return err;
}
static int md_open(struct inode *inode, struct file *file)
static int md_open(struct block_device *bdev, fmode_t mode)
{
/*
* Succeed if we can lock the mddev, which confirms that
* it isn't being stopped right now.
*/
mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
mddev_t *mddev = bdev->bd_disk->private_data;
int err;
if ((err = mutex_lock_interruptible_nested(&mddev->reconfig_mutex, 1)))
@ -5013,14 +5013,14 @@ static int md_open(struct inode *inode, struct file *file)
atomic_inc(&mddev->openers);
mddev_unlock(mddev);
check_disk_change(inode->i_bdev);
check_disk_change(bdev);
out:
return err;
}
static int md_release(struct inode *inode, struct file * file)
static int md_release(struct gendisk *disk, fmode_t mode)
{
mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
mddev_t *mddev = disk->private_data;
BUG_ON(!mddev);
atomic_dec(&mddev->openers);
@ -5048,7 +5048,7 @@ static struct block_device_operations md_fops =
.owner = THIS_MODULE,
.open = md_open,
.release = md_release,
.ioctl = md_ioctl,
.locked_ioctl = md_ioctl,
.getgeo = md_getgeo,
.media_changed = md_media_changed,
.revalidate_disk= md_revalidate,