X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Flloop.c;h=cef0de614da3214078774445ab0d14ec7886e4e3;hb=039db07e46b8bf8ff41e3620ae32b738549ef75d;hp=b98f640935063f4132b7d410a8b6bda65636c307;hpb=11c2c0ec77125041e9c8143a80e7e51aede653ea;p=fs%2Flustre-release.git diff --git a/lustre/llite/lloop.c b/lustre/llite/lloop.c index b98f640..cef0de6 100644 --- a/lustre/llite/lloop.c +++ b/lustre/llite/lloop.c @@ -27,7 +27,7 @@ * 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/ @@ -108,7 +108,7 @@ #include #include "llite_internal.h" -#define LLOOP_MAX_SEGMENTS PTLRPC_MAX_BRW_PAGES +#define LLOOP_MAX_SEGMENTS LNET_MAX_IOV /* Possible states of device */ enum { @@ -118,40 +118,40 @@ enum { }; struct lloop_device { - int lo_number; - int lo_refcnt; - loff_t lo_offset; - loff_t lo_sizelimit; - int lo_flags; - int (*ioctl)(struct lloop_device *, int cmd, - unsigned long arg); - - struct file *lo_backing_file; - struct block_device *lo_device; - unsigned lo_blocksize; - - int old_gfp_mask; - - cfs_spinlock_t lo_lock; - struct bio *lo_bio; - struct bio *lo_biotail; - int lo_state; - cfs_semaphore_t lo_sem; - cfs_mutex_t lo_ctl_mutex; - cfs_atomic_t lo_pending; - cfs_waitq_t lo_bh_wait; - - struct request_queue *lo_queue; - - const struct lu_env *lo_env; - struct cl_io lo_io; - struct ll_dio_pages lo_pvec; - - /* data to handle bio for lustre. */ - struct lo_request_data { - struct page *lrd_pages[LLOOP_MAX_SEGMENTS]; - loff_t lrd_offsets[LLOOP_MAX_SEGMENTS]; - } lo_requests[1]; + int lo_number; + int lo_refcnt; + loff_t lo_offset; + loff_t lo_sizelimit; + int lo_flags; + int (*ioctl)(struct lloop_device *, int cmd, + unsigned long arg); + + struct file *lo_backing_file; + struct block_device *lo_device; + unsigned lo_blocksize; + + int old_gfp_mask; + + spinlock_t lo_lock; + struct bio *lo_bio; + struct bio *lo_biotail; + int lo_state; + struct semaphore lo_sem; + struct mutex lo_ctl_mutex; + cfs_atomic_t lo_pending; + wait_queue_head_t lo_bh_wait; + + struct request_queue *lo_queue; + + const struct lu_env *lo_env; + struct cl_io lo_io; + struct ll_dio_pages lo_pvec; + + /* data to handle bio for lustre. */ + struct lo_request_data { + struct page *lrd_pages[LLOOP_MAX_SEGMENTS]; + loff_t lrd_offsets[LLOOP_MAX_SEGMENTS]; + } lo_requests[1]; }; /* @@ -166,7 +166,7 @@ static int lloop_major; static int max_loop = MAX_LOOP_DEFAULT; static struct lloop_device *loop_dev; static struct gendisk **disks; -static cfs_mutex_t lloop_mutex; +static struct mutex lloop_mutex; static void *ll_iocontrol_magic = NULL; static loff_t get_loop_size(struct lloop_device *lo, struct file *file) @@ -224,7 +224,7 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head) 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; @@ -241,32 +241,32 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head) pvec->ldp_size = page_count << PAGE_CACHE_SHIFT; pvec->ldp_nr = page_count; - /* FIXME: in ll_direct_rw_pages, it has to allocate many cl_page{}s to - * write those pages into OST. Even worse case is that more pages - * would be asked to write out to swap space, and then finally get here - * again. - * 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; - * 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. - * However, for SNS, there will be more since we need additional page - * to store parity; - * 2. Reserve the # of (page_count * depth) cl_pages from the reserved - * pool. Afterwards, the clio would allocate the pages from reserved - * pool, this guarantees we neeedn't allocate the cl_pages from - * generic cl_page slab cache. - * Of course, if there is NOT enough pages in the pool, we might - * be asked to write less pages once, this purely depends on - * implementation. Anyway, we should be careful to avoid deadlocking. - */ - LOCK_INODE_MUTEX(inode); - bytes = ll_direct_rw_pages(env, io, rw, inode, pvec); - UNLOCK_INODE_MUTEX(inode); - cl_io_fini(env, io); - return (bytes == pvec->ldp_size) ? 0 : (int)bytes; + /* FIXME: in ll_direct_rw_pages, it has to allocate many cl_page{}s to + * write those pages into OST. Even worse case is that more pages + * would be asked to write out to swap space, and then finally get here + * again. + * 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; + * 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. + * However, for SNS, there will be more since we need additional page + * to store parity; + * 2. Reserve the # of (page_count * depth) cl_pages from the reserved + * pool. Afterwards, the clio would allocate the pages from reserved + * pool, this guarantees we neeedn't allocate the cl_pages from + * generic cl_page slab cache. + * Of course, if there is NOT enough pages in the pool, we might + * be asked to write less pages once, this purely depends on + * implementation. Anyway, we should be careful to avoid deadlocking. + */ + mutex_lock(&inode->i_mutex); + bytes = ll_direct_rw_pages(env, io, rw, inode, pvec); + mutex_unlock(&inode->i_mutex); + cl_io_fini(env, io); + return (bytes == pvec->ldp_size) ? 0 : (int)bytes; } /* @@ -274,19 +274,19 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head) */ static void loop_add_bio(struct lloop_device *lo, struct bio *bio) { - unsigned long flags; - - cfs_spin_lock_irqsave(&lo->lo_lock, flags); - if (lo->lo_biotail) { - lo->lo_biotail->bi_next = bio; - lo->lo_biotail = bio; - } else - lo->lo_bio = lo->lo_biotail = bio; - cfs_spin_unlock_irqrestore(&lo->lo_lock, flags); - - cfs_atomic_inc(&lo->lo_pending); - if (cfs_waitq_active(&lo->lo_bh_wait)) - cfs_waitq_signal(&lo->lo_bh_wait); + unsigned long flags; + + spin_lock_irqsave(&lo->lo_lock, flags); + if (lo->lo_biotail) { + lo->lo_biotail->bi_next = bio; + lo->lo_biotail = bio; + } else + lo->lo_bio = lo->lo_biotail = bio; + spin_unlock_irqrestore(&lo->lo_lock, flags); + + cfs_atomic_inc(&lo->lo_pending); + if (waitqueue_active(&lo->lo_bh_wait)) + wake_up(&lo->lo_bh_wait); } /* @@ -294,18 +294,18 @@ static void loop_add_bio(struct lloop_device *lo, struct bio *bio) */ static unsigned int loop_get_bio(struct lloop_device *lo, struct bio **req) { - struct bio *first; - struct bio **bio; - unsigned int count = 0; - unsigned int page_count = 0; - int rw; - - cfs_spin_lock_irq(&lo->lo_lock); - first = lo->lo_bio; - if (unlikely(first == NULL)) { - cfs_spin_unlock_irq(&lo->lo_lock); - return 0; - } + struct bio *first; + struct bio **bio; + unsigned int count = 0; + unsigned int page_count = 0; + int rw; + + spin_lock_irq(&lo->lo_lock); + first = lo->lo_bio; + if (unlikely(first == NULL)) { + spin_unlock_irq(&lo->lo_lock); + return 0; + } /* TODO: need to split the bio, too bad. */ LASSERT(first->bi_vcnt <= LLOOP_MAX_SEGMENTS); @@ -334,11 +334,12 @@ static unsigned int loop_get_bio(struct lloop_device *lo, struct bio **req) lo->lo_bio = NULL; } *req = first; - cfs_spin_unlock_irq(&lo->lo_lock); - return count; + spin_unlock_irq(&lo->lo_lock); + return count; } -static int loop_make_request(struct request_queue *q, struct bio *old_bio) +static ll_mrf_ret +loop_make_request(struct request_queue *q, struct bio *old_bio) { struct lloop_device *lo = q->queuedata; int rw = bio_rw(old_bio); @@ -350,9 +351,9 @@ static int loop_make_request(struct request_queue *q, struct bio *old_bio) CDEBUG(D_INFO, "submit bio sector %llu size %u\n", (unsigned long long)old_bio->bi_sector, old_bio->bi_size); - cfs_spin_lock_irq(&lo->lo_lock); - inactive = (lo->lo_state != LLOOP_BOUND); - cfs_spin_unlock_irq(&lo->lo_lock); + spin_lock_irq(&lo->lo_lock); + inactive = (lo->lo_state != LLOOP_BOUND); + spin_unlock_irq(&lo->lo_lock); if (inactive) goto err; @@ -366,10 +367,10 @@ static int loop_make_request(struct request_queue *q, struct bio *old_bio) goto err; } loop_add_bio(lo, old_bio); - return 0; + LL_MRF_RETURN(0); err: - cfs_bio_io_error(old_bio, old_bio->bi_size); - return 0; + bio_io_error(old_bio); + LL_MRF_RETURN(0); } #ifdef HAVE_REQUEST_QUEUE_UNPLUG_FN @@ -392,7 +393,7 @@ static inline void loop_handle_bio(struct lloop_device *lo, struct bio *bio) while (bio) { struct bio *tmp = bio->bi_next; bio->bi_next = NULL; - cfs_bio_endio(bio, bio->bi_size, ret); + bio_endio(bio, ret); bio = tmp; } } @@ -419,8 +420,6 @@ static int loop_thread(void *data) int refcheck; int ret = 0; - daemonize("lloop%d", lo->lo_number); - set_user_nice(current, -20); lo->lo_state = LLOOP_BOUND; @@ -437,15 +436,15 @@ static int loop_thread(void *data) /* * up sem, we are running */ - cfs_up(&lo->lo_sem); - - for (;;) { - cfs_wait_event(lo->lo_bh_wait, loop_active(lo)); - if (!cfs_atomic_read(&lo->lo_pending)) { - int exiting = 0; - cfs_spin_lock_irq(&lo->lo_lock); - exiting = (lo->lo_state == LLOOP_RUNDOWN); - cfs_spin_unlock_irq(&lo->lo_lock); + up(&lo->lo_sem); + + for (;;) { + wait_event(lo->lo_bh_wait, loop_active(lo)); + if (!cfs_atomic_read(&lo->lo_pending)) { + int exiting = 0; + spin_lock_irq(&lo->lo_lock); + exiting = (lo->lo_state == LLOOP_RUNDOWN); + spin_unlock_irq(&lo->lo_lock); if (exiting) break; } @@ -477,7 +476,7 @@ static int loop_thread(void *data) cl_env_put(env, &refcheck); out: - cfs_up(&lo->lo_sem); + up(&lo->lo_sem); return ret; } @@ -490,8 +489,8 @@ static int loop_set_fd(struct lloop_device *lo, struct file *unused, int error; loff_t size; - if (!cfs_try_module_get(THIS_MODULE)) - return -ENODEV; + if (!try_module_get(THIS_MODULE)) + return -ENODEV; error = -EBUSY; if (lo->lo_state != LLOOP_UNBOUND) @@ -519,7 +518,7 @@ static int loop_set_fd(struct lloop_device *lo, struct file *unused, 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; @@ -540,27 +539,24 @@ static int loop_set_fd(struct lloop_device *lo, struct file *unused, 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 */ + 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); - cfs_down(&lo->lo_sem); - return 0; + kthread_run(loop_thread, lo, "lloop%d", lo->lo_number); + down(&lo->lo_sem); + return 0; - out: - /* This is safe: open() is still holding a reference. */ - cfs_module_put(THIS_MODULE); - return error; +out: + /* This is safe: open() is still holding a reference. */ + module_put(THIS_MODULE); + return error; } static int loop_clr_fd(struct lloop_device *lo, struct block_device *bdev, @@ -578,86 +574,71 @@ static int loop_clr_fd(struct lloop_device *lo, struct block_device *bdev, if (filp == NULL) return -EINVAL; - cfs_spin_lock_irq(&lo->lo_lock); - lo->lo_state = LLOOP_RUNDOWN; - cfs_spin_unlock_irq(&lo->lo_lock); - cfs_waitq_signal(&lo->lo_bh_wait); + spin_lock_irq(&lo->lo_lock); + lo->lo_state = LLOOP_RUNDOWN; + spin_unlock_irq(&lo->lo_lock); + wake_up(&lo->lo_bh_wait); - cfs_down(&lo->lo_sem); + down(&lo->lo_sem); lo->lo_backing_file = NULL; lo->ioctl = NULL; lo->lo_device = NULL; 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); lo->lo_state = LLOOP_UNBOUND; - fput(filp); - /* This is safe: open() is still holding a reference. */ - cfs_module_put(THIS_MODULE); - return 0; + fput(filp); + /* This is safe: open() is still holding a reference. */ + module_put(THIS_MODULE); + 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 - cfs_mutex_lock(&lo->lo_ctl_mutex); + mutex_lock(&lo->lo_ctl_mutex); lo->lo_refcnt++; - cfs_mutex_unlock(&lo->lo_ctl_mutex); + mutex_unlock(&lo->lo_ctl_mutex); return 0; } -#ifdef HAVE_BLKDEV_PUT_2ARGS -static int lo_release(struct gendisk *disk, fmode_t mode) -{ - struct lloop_device *lo = disk->private_data; +#ifdef HAVE_BLKDEV_RELEASE_RETURN_INT +static int #else -static int lo_release(struct inode *inode, struct file *file) -{ - struct lloop_device *lo = inode->i_bdev->bd_disk->private_data; +static void #endif +lo_release(struct gendisk *disk, fmode_t mode) +{ + struct lloop_device *lo = disk->private_data; - cfs_mutex_lock(&lo->lo_ctl_mutex); - --lo->lo_refcnt; - cfs_mutex_unlock(&lo->lo_ctl_mutex); - - return 0; + mutex_lock(&lo->lo_ctl_mutex); + --lo->lo_refcnt; + mutex_unlock(&lo->lo_ctl_mutex); +#ifdef HAVE_BLKDEV_RELEASE_RETURN_INT + return 0; +#endif } /* 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 - cfs_mutex_lock(&lloop_mutex); + 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; } @@ -681,7 +662,7 @@ static int lo_ioctl(struct inode *inode, struct file *unused, err = -EINVAL; break; } - cfs_mutex_unlock(&lloop_mutex); + mutex_unlock(&lloop_mutex); return err; } @@ -717,7 +698,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file, CWARN("Enter llop_ioctl\n"); - cfs_mutex_lock(&lloop_mutex); + mutex_lock(&lloop_mutex); switch (cmd) { case LL_IOC_LLOOP_ATTACH: { struct lloop_device *lo_free = NULL; @@ -752,7 +733,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file, err = loop_set_fd(lo, NULL, bdev, file); if (err) { fput(file); - ll_blkdev_put(bdev, 0); + blkdev_put(bdev, 0); } break; @@ -776,7 +757,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file, 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; } @@ -787,7 +768,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file, } out: - cfs_mutex_unlock(&lloop_mutex); + mutex_unlock(&lloop_mutex); out1: if (rcp) *rcp = err; @@ -833,7 +814,7 @@ static int __init lloop_init(void) goto out_mem3; } - cfs_mutex_init(&lloop_mutex); + mutex_init(&lloop_mutex); for (i = 0; i < max_loop; i++) { struct lloop_device *lo = &loop_dev[i]; @@ -843,11 +824,11 @@ static int __init lloop_init(void) if (!lo->lo_queue) goto out_mem4; - cfs_mutex_init(&lo->lo_ctl_mutex); - cfs_sema_init(&lo->lo_sem, 0); - cfs_waitq_init(&lo->lo_bh_wait); - lo->lo_number = i; - cfs_spin_lock_init(&lo->lo_lock); + mutex_init(&lo->lo_ctl_mutex); + sema_init(&lo->lo_sem, 0); + init_waitqueue_head(&lo->lo_bh_wait); + lo->lo_number = i; + spin_lock_init(&lo->lo_lock); disk->major = lloop_major; disk->first_minor = i; disk->fops = &lo_fops; @@ -888,10 +869,7 @@ static void lloop_exit(void) 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));