* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <linux/module.h>
#include <linux/sched.h>
+#include <linux/kthread.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <asm/uaccess.h>
#include <lustre_lib.h>
-#include <lustre_lite.h>
#include "llite_internal.h"
#define LLOOP_MAX_SEGMENTS LNET_MAX_IOV
{
const struct lu_env *env = lo->lo_env;
struct cl_io *io = &lo->lo_io;
- struct inode *inode = lo->lo_backing_file->f_dentry->d_inode;
+ struct dentry *de = lo->lo_backing_file->f_path.dentry;
+ struct inode *inode = de->d_inode;
struct cl_object *obj = ll_i2info(inode)->lli_clob;
pgoff_t offset;
int ret;
struct bio_vec *bvec;
#endif
int rw;
- obd_count page_count = 0;
+ size_t page_count = 0;
struct bio *bio;
ssize_t bytes;
#ifdef HAVE_BVEC_ITER
offset = (pgoff_t)(bio->bi_iter.bi_sector << 9) + lo->lo_offset;
- bio_for_each_segment(bvec, bio, iter) {
+ bio_for_each_segment_all(bvec, bio, iter) {
BUG_ON(bvec.bv_offset != 0);
BUG_ON(bvec.bv_len != PAGE_CACHE_SIZE);
offset += bvec.bv_len;
#else
offset = (pgoff_t)(bio->bi_sector << 9) + lo->lo_offset;
- bio_for_each_segment(bvec, bio, iter) {
+ bio_for_each_segment_all(bvec, bio, iter) {
BUG_ON(bvec->bv_offset != 0);
BUG_ON(bvec->bv_len != PAGE_CACHE_SIZE);
static inline void loop_handle_bio(struct lloop_device *lo, struct bio *bio)
{
- int ret;
- ret = do_bio_lustrebacked(lo, bio);
- while (bio) {
- struct bio *tmp = bio->bi_next;
- bio->bi_next = NULL;
+ int ret;
+
+ ret = do_bio_lustrebacked(lo, bio);
+ while (bio) {
+ struct bio *tmp = bio->bi_next;
+
+ bio->bi_next = NULL;
+#ifdef HAVE_BIO_ENDIO_USES_ONE_ARG
+ bio->bi_error = ret;
+ bio_endio(bio);
+#else
bio_endio(bio, ret);
- bio = tmp;
- }
+#endif
+ bio = tmp;
+ }
}
static inline int loop_active(struct lloop_device *lo)
unsigned long total_count = 0;
struct lu_env *env;
- int refcheck;
+ __u16 refcheck;
int ret = 0;
set_user_nice(current, -20);
static int lo_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
- struct lloop_device *lo = bdev->bd_disk->private_data;
- struct inode *inode = NULL;
- int err = 0;
+ struct lloop_device *lo = bdev->bd_disk->private_data;
+ int err = 0;
mutex_lock(&lloop_mutex);
switch (cmd) {
break;
}
- case LL_IOC_LLOOP_INFO: {
- struct lu_fid fid;
+ case LL_IOC_LLOOP_INFO: {
+ struct inode *inode;
+ struct lu_fid fid;
if (lo->lo_backing_file == NULL) {
err = -ENOENT;
break;
}
- if (inode == NULL)
- inode = lo->lo_backing_file->f_dentry->d_inode;
- if (lo->lo_state == LLOOP_BOUND)
+ inode = lo->lo_backing_file->f_path.dentry->d_inode;
+ if (inode != NULL && lo->lo_state == LLOOP_BOUND)
fid = ll_i2info(inode)->lli_fid;
else
fid_zero(&fid);
- if (copy_to_user((struct lu_fid *)arg, &fid, sizeof(fid)))
- err = -EFAULT;
- break;
+ if (copy_to_user((struct lu_fid __user *)arg,
+ &fid, sizeof(fid)))
+ err = -EFAULT;
+ break;
}
default:
CWARN("Enter llop_ioctl\n");
mutex_lock(&lloop_mutex);
- switch (cmd) {
- case LL_IOC_LLOOP_ATTACH: {
- struct lloop_device *lo_free = NULL;
- int i;
+ switch (cmd) {
+ case LL_IOC_LLOOP_ATTACH: {
+ struct inode *inode = file->f_path.dentry->d_inode;
+ struct lloop_device *lo_free = NULL;
+ int i;
for (i = 0; i < max_loop; i++, lo = NULL) {
lo = &loop_dev[i];
lo_free = lo;
continue;
}
- if (lo->lo_backing_file->f_dentry->d_inode ==
- file->f_dentry->d_inode)
- break;
- }
- if (lo || !lo_free)
- GOTO(out, err = -EBUSY);
+ if (lo->lo_backing_file->f_path.dentry->d_inode ==
+ inode)
+ break;
+ }
+ if (lo || !lo_free)
+ GOTO(out, err = -EBUSY);
lo = lo_free;
dev = MKDEV(lloop_major, lo->lo_number);
/* quit if the used pointer is writable */
- if (put_user((long)old_encode_dev(dev), (long*)arg))
- GOTO(out, err = -EFAULT);
+ if (put_user((long)old_encode_dev(dev), (long __user *)arg))
+ GOTO(out, err = -EFAULT);
bdev = blkdev_get_by_dev(dev, file->f_mode, NULL);
if (IS_ERR(bdev))
return -ENOMEM;
}
-static void lloop_exit(void)
+static void __exit lloop_exit(void)
{
- int i;
+ int i;
- ll_iocontrol_unregister(ll_iocontrol_magic);
- for (i = 0; i < max_loop; i++) {
- del_gendisk(disks[i]);
- blk_cleanup_queue(loop_dev[i].lo_queue);
- put_disk(disks[i]);
- }
+ ll_iocontrol_unregister(ll_iocontrol_magic);
+ for (i = 0; i < max_loop; i++) {
+ del_gendisk(disks[i]);
+ blk_cleanup_queue(loop_dev[i].lo_queue);
+ put_disk(disks[i]);
+ }
unregister_blkdev(lloop_major, "lloop");
- OBD_FREE(disks, max_loop * sizeof(*disks));
- OBD_FREE(loop_dev, max_loop * sizeof(*loop_dev));
+ OBD_FREE(disks, max_loop * sizeof(*disks));
+ OBD_FREE(loop_dev, max_loop * sizeof(*loop_dev));
}
-module_init(lloop_init);
-module_exit(lloop_exit);
-
-CFS_MODULE_PARM(max_loop, "i", int, 0444, "maximum of lloop_device");
-MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
+module_param(max_loop, int, 0444);
+MODULE_PARM_DESC(max_loop, "maximum of lloop_device");
+MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
MODULE_DESCRIPTION("Lustre virtual block device");
+MODULE_VERSION(LUSTRE_VERSION_STRING);
MODULE_LICENSE("GPL");
+
+module_init(lloop_init);
+module_exit(lloop_exit);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff