* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, Whamcloud, Inc.
+ * Copyright (c) 2011, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <lustre_lite.h>
#include "llite_internal.h"
-#define LLOOP_MAX_SEGMENTS PTLRPC_MAX_BRW_PAGES
+#define LLOOP_MAX_SEGMENTS LNET_MAX_IOV
/* Possible states of device */
enum {
offset = (pgoff_t)(bio->bi_sector << 9) + lo->lo_offset;
bio_for_each_segment(bvec, bio, i) {
BUG_ON(bvec->bv_offset != 0);
- BUG_ON(bvec->bv_len != CFS_PAGE_SIZE);
+ BUG_ON(bvec->bv_len != PAGE_CACHE_SIZE);
pages[page_count] = bvec->bv_page;
offsets[page_count] = offset;
* Unfortunately this is NOT easy to fix.
* Thoughts on solution:
* 0. Define a reserved pool for cl_pages, which could be a list of
- * pre-allocated cl_pages from cl_page_kmem;
+ * pre-allocated cl_pages;
* 1. Define a new operation in cl_object_operations{}, says clo_depth,
* which measures how many layers for this lustre object. Generally
* speaking, the depth would be 2, one for llite, and one for lovsub.
int refcheck;
int ret = 0;
- daemonize("lloop%d", lo->lo_number);
-
set_user_nice(current, -20);
lo->lo_state = LLOOP_BOUND;
set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
- lo->lo_blocksize = CFS_PAGE_SIZE;
+ lo->lo_blocksize = PAGE_CACHE_SIZE;
lo->lo_device = bdev;
lo->lo_flags = lo_flags;
lo->lo_backing_file = file;
lo->lo_queue->unplug_fn = loop_unplug;
#endif
- /* queue parameters */
- CLASSERT(CFS_PAGE_SIZE < (1 << (sizeof(unsigned short) * 8)));
- blk_queue_logical_block_size(lo->lo_queue,
- (unsigned short)CFS_PAGE_SIZE);
- blk_queue_max_hw_sectors(lo->lo_queue,
- LLOOP_MAX_SEGMENTS << (CFS_PAGE_SHIFT - 9));
- blk_queue_max_segments(lo->lo_queue, LLOOP_MAX_SEGMENTS);
+ /* queue parameters */
+ CLASSERT(PAGE_CACHE_SIZE < (1 << (sizeof(unsigned short) * 8)));
+ blk_queue_logical_block_size(lo->lo_queue,
+ (unsigned short)PAGE_CACHE_SIZE);
+ blk_queue_max_hw_sectors(lo->lo_queue,
+ LLOOP_MAX_SEGMENTS << (PAGE_CACHE_SHIFT - 9));
+ blk_queue_max_segments(lo->lo_queue, LLOOP_MAX_SEGMENTS);
set_capacity(disks[lo->lo_number], size);
bd_set_size(bdev, size << 9);
- set_blocksize(bdev, lo->lo_blocksize);
+ set_blocksize(bdev, lo->lo_blocksize);
- cfs_create_thread(loop_thread, lo, CLONE_KERNEL);
+ kthread_run(loop_thread, lo, "lloop%d", lo->lo_number);
down(&lo->lo_sem);
- return 0;
+ return 0;
- out:
+out:
/* This is safe: open() is still holding a reference. */
cfs_module_put(THIS_MODULE);
return error;
lo->lo_offset = 0;
lo->lo_sizelimit = 0;
lo->lo_flags = 0;
- ll_invalidate_bdev(bdev, 0);
+ invalidate_bdev(bdev);
set_capacity(disks[lo->lo_number], 0);
bd_set_size(bdev, 0);
mapping_set_gfp_mask(filp->f_mapping, gfp);
return 0;
}
-#ifdef HAVE_BLKDEV_PUT_2ARGS
static int lo_open(struct block_device *bdev, fmode_t mode)
{
struct lloop_device *lo = bdev->bd_disk->private_data;
-#else
-static int lo_open(struct inode *inode, struct file *file)
-{
- struct lloop_device *lo = inode->i_bdev->bd_disk->private_data;
-#endif
mutex_lock(&lo->lo_ctl_mutex);
lo->lo_refcnt++;
return 0;
}
-#ifdef HAVE_BLKDEV_PUT_2ARGS
static int lo_release(struct gendisk *disk, fmode_t mode)
{
struct lloop_device *lo = disk->private_data;
-#else
-static int lo_release(struct inode *inode, struct file *file)
-{
- struct lloop_device *lo = inode->i_bdev->bd_disk->private_data;
-#endif
mutex_lock(&lo->lo_ctl_mutex);
--lo->lo_refcnt;
}
/* lloop device node's ioctl function. */
-#ifdef HAVE_BLKDEV_PUT_2ARGS
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;
-#else
-static int lo_ioctl(struct inode *inode, struct file *unused,
- unsigned int cmd, unsigned long arg)
-{
- struct lloop_device *lo = inode->i_bdev->bd_disk->private_data;
- struct block_device *bdev = inode->i_bdev;
- int err = 0;
-#endif
mutex_lock(&lloop_mutex);
switch (cmd) {
case LL_IOC_LLOOP_DETACH: {
err = loop_clr_fd(lo, bdev, 2);
if (err == 0)
- ll_blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
+ blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
break;
}
err = loop_set_fd(lo, NULL, bdev, file);
if (err) {
fput(file);
- ll_blkdev_put(bdev, 0);
+ blkdev_put(bdev, 0);
}
break;
bdev = lo->lo_device;
err = loop_clr_fd(lo, bdev, 1);
if (err == 0)
- ll_blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
+ blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
break;
}
blk_cleanup_queue(loop_dev[i].lo_queue);
put_disk(disks[i]);
}
- if (ll_unregister_blkdev(lloop_major, "lloop"))
- CWARN("lloop: cannot unregister blkdev\n");
- else
- CDEBUG(D_CONFIG, "unregistered lloop major %d\n", lloop_major);
+ unregister_blkdev(lloop_major, "lloop");
OBD_FREE(disks, max_loop * sizeof(*disks));
OBD_FREE(loop_dev, max_loop * sizeof(*loop_dev));
git://git.whamcloud.com / fs / lustre-release.git / blobdiff