2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2002 Sistina Software (UK) Limited.
|
2007-05-09 03:33:02 -06:00
|
|
|
* Copyright (C) 2006 Red Hat GmbH
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*
|
|
|
|
* Kcopyd provides a simple interface for copying an area of one
|
|
|
|
* block-device to one or more other block-devices, with an asynchronous
|
|
|
|
* completion notification.
|
|
|
|
*/
|
|
|
|
|
2008-04-24 14:43:19 -06:00
|
|
|
#include <linux/types.h>
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/workqueue.h>
|
2006-03-27 02:18:20 -07:00
|
|
|
#include <linux/mutex.h>
|
2013-03-01 15:45:49 -07:00
|
|
|
#include <linux/delay.h>
|
2008-10-21 10:44:59 -06:00
|
|
|
#include <linux/device-mapper.h>
|
2008-04-24 15:02:01 -06:00
|
|
|
#include <linux/dm-kcopyd.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-24 14:43:17 -06:00
|
|
|
#include "dm.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:00 -06:00
|
|
|
#define SUB_JOB_SIZE 128
|
|
|
|
#define SPLIT_COUNT 8
|
|
|
|
#define MIN_JOBS 8
|
2011-05-29 06:03:11 -06:00
|
|
|
#define RESERVE_PAGES (DIV_ROUND_UP(SUB_JOB_SIZE << SECTOR_SHIFT, PAGE_SIZE))
|
2011-05-29 06:03:00 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* Each kcopyd client has its own little pool of preallocated
|
|
|
|
* pages for kcopyd io.
|
|
|
|
*---------------------------------------------------------------*/
|
2008-04-24 14:43:19 -06:00
|
|
|
struct dm_kcopyd_client {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct page_list *pages;
|
2011-05-29 06:03:07 -06:00
|
|
|
unsigned nr_reserved_pages;
|
|
|
|
unsigned nr_free_pages;
|
2006-03-27 02:17:50 -07:00
|
|
|
|
2007-05-09 03:33:02 -06:00
|
|
|
struct dm_io_client *io_client;
|
|
|
|
|
2006-03-27 02:17:50 -07:00
|
|
|
wait_queue_head_t destroyq;
|
|
|
|
atomic_t nr_jobs;
|
2008-04-24 14:43:44 -06:00
|
|
|
|
2008-04-24 14:43:46 -06:00
|
|
|
mempool_t *job_pool;
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
struct workqueue_struct *kcopyd_wq;
|
|
|
|
struct work_struct kcopyd_work;
|
|
|
|
|
2013-03-01 15:45:49 -07:00
|
|
|
struct dm_kcopyd_throttle *throttle;
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
/*
|
|
|
|
* We maintain three lists of jobs:
|
|
|
|
*
|
|
|
|
* i) jobs waiting for pages
|
|
|
|
* ii) jobs that have pages, and are waiting for the io to be issued.
|
|
|
|
* iii) jobs that have completed.
|
|
|
|
*
|
|
|
|
* All three of these are protected by job_lock.
|
|
|
|
*/
|
|
|
|
spinlock_t job_lock;
|
|
|
|
struct list_head complete_jobs;
|
|
|
|
struct list_head io_jobs;
|
|
|
|
struct list_head pages_jobs;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2011-10-31 14:18:58 -06:00
|
|
|
static struct page_list zero_page_list;
|
|
|
|
|
2013-03-01 15:45:49 -07:00
|
|
|
static DEFINE_SPINLOCK(throttle_spinlock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IO/IDLE accounting slowly decays after (1 << ACCOUNT_INTERVAL_SHIFT) period.
|
|
|
|
* When total_period >= (1 << ACCOUNT_INTERVAL_SHIFT) the counters are divided
|
|
|
|
* by 2.
|
|
|
|
*/
|
|
|
|
#define ACCOUNT_INTERVAL_SHIFT SHIFT_HZ
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sleep this number of milliseconds.
|
|
|
|
*
|
|
|
|
* The value was decided experimentally.
|
|
|
|
* Smaller values seem to cause an increased copy rate above the limit.
|
|
|
|
* The reason for this is unknown but possibly due to jiffies rounding errors
|
|
|
|
* or read/write cache inside the disk.
|
|
|
|
*/
|
|
|
|
#define SLEEP_MSEC 100
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maximum number of sleep events. There is a theoretical livelock if more
|
|
|
|
* kcopyd clients do work simultaneously which this limit avoids.
|
|
|
|
*/
|
|
|
|
#define MAX_SLEEPS 10
|
|
|
|
|
|
|
|
static void io_job_start(struct dm_kcopyd_throttle *t)
|
|
|
|
{
|
|
|
|
unsigned throttle, now, difference;
|
|
|
|
int slept = 0, skew;
|
|
|
|
|
|
|
|
if (unlikely(!t))
|
|
|
|
return;
|
|
|
|
|
|
|
|
try_again:
|
|
|
|
spin_lock_irq(&throttle_spinlock);
|
|
|
|
|
|
|
|
throttle = ACCESS_ONCE(t->throttle);
|
|
|
|
|
|
|
|
if (likely(throttle >= 100))
|
|
|
|
goto skip_limit;
|
|
|
|
|
|
|
|
now = jiffies;
|
|
|
|
difference = now - t->last_jiffies;
|
|
|
|
t->last_jiffies = now;
|
|
|
|
if (t->num_io_jobs)
|
|
|
|
t->io_period += difference;
|
|
|
|
t->total_period += difference;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maintain sane values if we got a temporary overflow.
|
|
|
|
*/
|
|
|
|
if (unlikely(t->io_period > t->total_period))
|
|
|
|
t->io_period = t->total_period;
|
|
|
|
|
|
|
|
if (unlikely(t->total_period >= (1 << ACCOUNT_INTERVAL_SHIFT))) {
|
|
|
|
int shift = fls(t->total_period >> ACCOUNT_INTERVAL_SHIFT);
|
|
|
|
t->total_period >>= shift;
|
|
|
|
t->io_period >>= shift;
|
|
|
|
}
|
|
|
|
|
|
|
|
skew = t->io_period - throttle * t->total_period / 100;
|
|
|
|
|
|
|
|
if (unlikely(skew > 0) && slept < MAX_SLEEPS) {
|
|
|
|
slept++;
|
|
|
|
spin_unlock_irq(&throttle_spinlock);
|
|
|
|
msleep(SLEEP_MSEC);
|
|
|
|
goto try_again;
|
|
|
|
}
|
|
|
|
|
|
|
|
skip_limit:
|
|
|
|
t->num_io_jobs++;
|
|
|
|
|
|
|
|
spin_unlock_irq(&throttle_spinlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void io_job_finish(struct dm_kcopyd_throttle *t)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (unlikely(!t))
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&throttle_spinlock, flags);
|
|
|
|
|
|
|
|
t->num_io_jobs--;
|
|
|
|
|
|
|
|
if (likely(ACCESS_ONCE(t->throttle) >= 100))
|
|
|
|
goto skip_limit;
|
|
|
|
|
|
|
|
if (!t->num_io_jobs) {
|
|
|
|
unsigned now, difference;
|
|
|
|
|
|
|
|
now = jiffies;
|
|
|
|
difference = now - t->last_jiffies;
|
|
|
|
t->last_jiffies = now;
|
|
|
|
|
|
|
|
t->io_period += difference;
|
|
|
|
t->total_period += difference;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maintain sane values if we got a temporary overflow.
|
|
|
|
*/
|
|
|
|
if (unlikely(t->io_period > t->total_period))
|
|
|
|
t->io_period = t->total_period;
|
|
|
|
}
|
|
|
|
|
|
|
|
skip_limit:
|
|
|
|
spin_unlock_irqrestore(&throttle_spinlock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
static void wake(struct dm_kcopyd_client *kc)
|
|
|
|
{
|
|
|
|
queue_work(kc->kcopyd_wq, &kc->kcopyd_work);
|
|
|
|
}
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
/*
|
|
|
|
* Obtain one page for the use of kcopyd.
|
|
|
|
*/
|
2011-05-29 06:03:04 -06:00
|
|
|
static struct page_list *alloc_pl(gfp_t gfp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct page_list *pl;
|
|
|
|
|
2011-05-29 06:03:04 -06:00
|
|
|
pl = kmalloc(sizeof(*pl), gfp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pl)
|
|
|
|
return NULL;
|
|
|
|
|
2011-05-29 06:03:04 -06:00
|
|
|
pl->page = alloc_page(gfp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pl->page) {
|
|
|
|
kfree(pl);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_pl(struct page_list *pl)
|
|
|
|
{
|
|
|
|
__free_page(pl->page);
|
|
|
|
kfree(pl);
|
|
|
|
}
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
/*
|
|
|
|
* Add the provided pages to a client's free page list, releasing
|
|
|
|
* back to the system any beyond the reserved_pages limit.
|
|
|
|
*/
|
|
|
|
static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-29 06:03:07 -06:00
|
|
|
struct page_list *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
do {
|
|
|
|
next = pl->next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
if (kc->nr_free_pages >= kc->nr_reserved_pages)
|
|
|
|
free_pl(pl);
|
|
|
|
else {
|
|
|
|
pl->next = kc->pages;
|
|
|
|
kc->pages = pl;
|
|
|
|
kc->nr_free_pages++;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
pl = next;
|
|
|
|
} while (pl);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
|
|
|
|
unsigned int nr, struct page_list **pages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-29 06:03:07 -06:00
|
|
|
struct page_list *pl;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
*pages = NULL;
|
|
|
|
|
|
|
|
do {
|
2015-11-06 17:28:21 -07:00
|
|
|
pl = alloc_pl(__GFP_NOWARN | __GFP_NORETRY | __GFP_KSWAPD_RECLAIM);
|
2011-05-29 06:03:07 -06:00
|
|
|
if (unlikely(!pl)) {
|
|
|
|
/* Use reserved pages */
|
|
|
|
pl = kc->pages;
|
|
|
|
if (unlikely(!pl))
|
|
|
|
goto out_of_memory;
|
|
|
|
kc->pages = pl->next;
|
|
|
|
kc->nr_free_pages--;
|
|
|
|
}
|
|
|
|
pl->next = *pages;
|
|
|
|
*pages = pl;
|
|
|
|
} while (--nr);
|
|
|
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
out_of_memory:
|
|
|
|
if (*pages)
|
|
|
|
kcopyd_put_pages(kc, *pages);
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These three functions resize the page pool.
|
|
|
|
*/
|
|
|
|
static void drop_pages(struct page_list *pl)
|
|
|
|
{
|
|
|
|
struct page_list *next;
|
|
|
|
|
|
|
|
while (pl) {
|
|
|
|
next = pl->next;
|
|
|
|
free_pl(pl);
|
|
|
|
pl = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
/*
|
|
|
|
* Allocate and reserve nr_pages for the use of a specific client.
|
|
|
|
*/
|
|
|
|
static int client_reserve_pages(struct dm_kcopyd_client *kc, unsigned nr_pages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-29 06:03:07 -06:00
|
|
|
unsigned i;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct page_list *pl = NULL, *next;
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
for (i = 0; i < nr_pages; i++) {
|
2011-05-29 06:03:04 -06:00
|
|
|
next = alloc_pl(GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!next) {
|
|
|
|
if (pl)
|
|
|
|
drop_pages(pl);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
next->next = pl;
|
|
|
|
pl = next;
|
|
|
|
}
|
|
|
|
|
2011-05-29 06:03:07 -06:00
|
|
|
kc->nr_reserved_pages += nr_pages;
|
2005-04-16 16:20:36 -06:00
|
|
|
kcopyd_put_pages(kc, pl);
|
2011-05-29 06:03:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-24 14:43:19 -06:00
|
|
|
static void client_free_pages(struct dm_kcopyd_client *kc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-29 06:03:07 -06:00
|
|
|
BUG_ON(kc->nr_free_pages != kc->nr_reserved_pages);
|
2005-04-16 16:20:36 -06:00
|
|
|
drop_pages(kc->pages);
|
|
|
|
kc->pages = NULL;
|
2011-05-29 06:03:07 -06:00
|
|
|
kc->nr_free_pages = kc->nr_reserved_pages = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* kcopyd_jobs need to be allocated by the *clients* of kcopyd,
|
|
|
|
* for this reason we use a mempool to prevent the client from
|
|
|
|
* ever having to do io (which could cause a deadlock).
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
struct kcopyd_job {
|
2008-04-24 14:43:19 -06:00
|
|
|
struct dm_kcopyd_client *kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct list_head list;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Error state of the job.
|
|
|
|
*/
|
|
|
|
int read_err;
|
2008-03-28 15:16:10 -06:00
|
|
|
unsigned long write_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Either READ or WRITE
|
|
|
|
*/
|
|
|
|
int rw;
|
2008-04-24 14:43:17 -06:00
|
|
|
struct dm_io_region source;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The destinations for the transfer.
|
|
|
|
*/
|
|
|
|
unsigned int num_dests;
|
2008-04-24 14:43:19 -06:00
|
|
|
struct dm_io_region dests[DM_KCOPYD_MAX_REGIONS];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct page_list *pages;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set this to ensure you are notified when the job has
|
|
|
|
* completed. 'context' is for callback to use.
|
|
|
|
*/
|
2008-04-24 14:43:19 -06:00
|
|
|
dm_kcopyd_notify_fn fn;
|
2005-04-16 16:20:36 -06:00
|
|
|
void *context;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These fields are only used if the job has been split
|
|
|
|
* into more manageable parts.
|
|
|
|
*/
|
2007-10-19 15:38:52 -06:00
|
|
|
struct mutex lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_t sub_jobs;
|
|
|
|
sector_t progress;
|
|
|
|
|
2011-05-29 06:03:00 -06:00
|
|
|
struct kcopyd_job *master_job;
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *_job_cache;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-24 14:43:49 -06:00
|
|
|
int __init dm_kcopyd_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-29 06:03:00 -06:00
|
|
|
_job_cache = kmem_cache_create("kcopyd_job",
|
|
|
|
sizeof(struct kcopyd_job) * (SPLIT_COUNT + 1),
|
|
|
|
__alignof__(struct kcopyd_job), 0, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!_job_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-10-31 14:18:58 -06:00
|
|
|
zero_page_list.next = &zero_page_list;
|
|
|
|
zero_page_list.page = ZERO_PAGE(0);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-24 14:43:49 -06:00
|
|
|
void dm_kcopyd_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
kmem_cache_destroy(_job_cache);
|
|
|
|
_job_cache = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions to push and pop a job onto the head of a given job
|
|
|
|
* list.
|
|
|
|
*/
|
2008-04-24 14:43:44 -06:00
|
|
|
static struct kcopyd_job *pop(struct list_head *jobs,
|
|
|
|
struct dm_kcopyd_client *kc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kcopyd_job *job = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
spin_lock_irqsave(&kc->job_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!list_empty(jobs)) {
|
|
|
|
job = list_entry(jobs->next, struct kcopyd_job, list);
|
|
|
|
list_del(&job->list);
|
|
|
|
}
|
2008-04-24 14:43:44 -06:00
|
|
|
spin_unlock_irqrestore(&kc->job_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return job;
|
|
|
|
}
|
|
|
|
|
2007-07-12 10:26:32 -06:00
|
|
|
static void push(struct list_head *jobs, struct kcopyd_job *job)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2008-04-24 14:43:44 -06:00
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
spin_lock_irqsave(&kc->job_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
list_add_tail(&job->list, jobs);
|
2008-04-24 14:43:44 -06:00
|
|
|
spin_unlock_irqrestore(&kc->job_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
dm kcopyd: avoid queue shuffle
Write throughput to LVM snapshot origin volume is an order
of magnitude slower than those to LV without snapshots or
snapshot target volumes, especially in the case of sequential
writes with O_SYNC on.
The following patch originally written by Kevin Jamieson and
Jan Blunck and slightly modified for the current RCs by myself
tries to improve the performance by modifying the behaviour
of kcopyd, so that it pushes back an I/O job to the head of
the job queue instead of the tail as process_jobs() currently
does when it has to wait for free pages. This way, write
requests aren't shuffled to cause extra seeks.
I tested the patch against 2.6.27-rc5 and got the following results.
The test is a dd command writing to snapshot origin followed by fsync
to the file just created/updated. A couple of filesystem benchmarks
gave me similar results in case of sequential writes, while random
writes didn't suffer much.
dd if=/dev/zero of=<somewhere on snapshot origin> bs=4096 count=...
[conv=notrunc when updating]
1) linux 2.6.27-rc5 without the patch, write to snapshot origin,
average throughput (MB/s)
10M 100M 1000M
create,dd 511.46 610.72 11.81
create,dd+fsync 7.10 6.77 8.13
update,dd 431.63 917.41 12.75
update,dd+fsync 7.79 7.43 8.12
compared with write throughput to LV without any snapshots,
all dd+fsync and 1000 MiB writes perform very poorly.
10M 100M 1000M
create,dd 555.03 608.98 123.29
create,dd+fsync 114.27 72.78 76.65
update,dd 152.34 1267.27 124.04
update,dd+fsync 130.56 77.81 77.84
2) linux 2.6.27-rc5 with the patch, write to snapshot origin,
average throughput (MB/s)
10M 100M 1000M
create,dd 537.06 589.44 46.21
create,dd+fsync 31.63 29.19 29.23
update,dd 487.59 897.65 37.76
update,dd+fsync 34.12 30.07 26.85
Although still not on par with plain LV performance -
cannot be avoided because it's copy on write anyway -
this simple patch successfully improves throughtput
of dd+fsync while not affecting the rest.
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Kazuo Ito <ito.kazuo@oss.ntt.co.jp>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: stable@kernel.org
2008-10-21 10:44:50 -06:00
|
|
|
|
|
|
|
static void push_head(struct list_head *jobs, struct kcopyd_job *job)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&kc->job_lock, flags);
|
|
|
|
list_add(&job->list, jobs);
|
|
|
|
spin_unlock_irqrestore(&kc->job_lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* These three functions process 1 item from the corresponding
|
|
|
|
* job list.
|
|
|
|
*
|
|
|
|
* They return:
|
|
|
|
* < 0: error
|
|
|
|
* 0: success
|
|
|
|
* > 0: can't process yet.
|
|
|
|
*/
|
|
|
|
static int run_complete_job(struct kcopyd_job *job)
|
|
|
|
{
|
|
|
|
void *context = job->context;
|
|
|
|
int read_err = job->read_err;
|
2008-03-28 15:16:10 -06:00
|
|
|
unsigned long write_err = job->write_err;
|
2008-04-24 14:43:19 -06:00
|
|
|
dm_kcopyd_notify_fn fn = job->fn;
|
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-10-31 14:18:58 -06:00
|
|
|
if (job->pages && job->pages != &zero_page_list)
|
2009-04-08 17:27:16 -06:00
|
|
|
kcopyd_put_pages(kc, job->pages);
|
2011-05-29 06:03:00 -06:00
|
|
|
/*
|
|
|
|
* If this is the master job, the sub jobs have already
|
|
|
|
* completed so we can free everything.
|
|
|
|
*/
|
|
|
|
if (job->master_job == job)
|
|
|
|
mempool_free(job, kc->job_pool);
|
2005-04-16 16:20:36 -06:00
|
|
|
fn(read_err, write_err, context);
|
2006-03-27 02:17:50 -07:00
|
|
|
|
|
|
|
if (atomic_dec_and_test(&kc->nr_jobs))
|
|
|
|
wake_up(&kc->destroyq);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void complete_io(unsigned long error, void *context)
|
|
|
|
{
|
|
|
|
struct kcopyd_job *job = (struct kcopyd_job *) context;
|
2008-04-24 14:43:44 -06:00
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-03-01 15:45:49 -07:00
|
|
|
io_job_finish(kc->throttle);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error) {
|
2012-12-21 13:23:37 -07:00
|
|
|
if (job->rw & WRITE)
|
2006-06-26 01:27:30 -06:00
|
|
|
job->write_err |= error;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
job->read_err = 1;
|
|
|
|
|
2008-04-24 14:43:19 -06:00
|
|
|
if (!test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
|
2008-04-24 14:43:44 -06:00
|
|
|
push(&kc->complete_jobs, job);
|
|
|
|
wake(kc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-21 13:23:37 -07:00
|
|
|
if (job->rw & WRITE)
|
2008-04-24 14:43:44 -06:00
|
|
|
push(&kc->complete_jobs, job);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
else {
|
|
|
|
job->rw = WRITE;
|
2008-04-24 14:43:44 -06:00
|
|
|
push(&kc->io_jobs, job);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
wake(kc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request io on as many buffer heads as we can currently get for
|
|
|
|
* a particular job.
|
|
|
|
*/
|
|
|
|
static int run_io_job(struct kcopyd_job *job)
|
|
|
|
{
|
|
|
|
int r;
|
2007-05-09 03:33:02 -06:00
|
|
|
struct dm_io_request io_req = {
|
dm kcopyd: delay unplugging
Make kcopyd merge more I/O requests by using device unplugging.
Without this patch, each I/O request is dispatched separately to the device.
If the device supports tagged queuing, there are many small requests sent
to the device. To improve performance, this patch will batch as many requests
as possible, allowing the queue to merge consecutive requests, and send them
to the device at once.
In my tests (15k SCSI disk), this patch improves sequential write throughput:
Sequential write throughput (chunksize of 4k, 32k, 512k)
unpatched: 15.2, 18.5, 17.5 MB/s
patched: 14.4, 22.6, 23.0 MB/s
In most common uses (snapshot or two-way mirror), kcopyd is only used for
two devices, one for reading and the other for writing, thus this optimization
is implemented only for two devices. The optimization may be extended to n-way
mirrors with some code complexity increase.
We keep track of two block devices to unplug (one for read and the
other for write) and unplug them when exiting "do_work" thread. If
there are more devices used (in theory it could happen, in practice it
is rare), we unplug immediately.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2011-01-13 12:59:50 -07:00
|
|
|
.bi_rw = job->rw,
|
2007-05-09 03:33:02 -06:00
|
|
|
.mem.type = DM_IO_PAGE_LIST,
|
|
|
|
.mem.ptr.pl = job->pages,
|
2011-08-02 05:32:02 -06:00
|
|
|
.mem.offset = 0,
|
2007-05-09 03:33:02 -06:00
|
|
|
.notify.fn = complete_io,
|
|
|
|
.notify.context = job,
|
|
|
|
.client = job->kc->io_client,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-03-01 15:45:49 -07:00
|
|
|
io_job_start(job->kc->throttle);
|
|
|
|
|
2011-03-10 00:52:07 -07:00
|
|
|
if (job->rw == READ)
|
2007-05-09 03:33:02 -06:00
|
|
|
r = dm_io(&io_req, 1, &job->source, NULL);
|
2011-03-09 03:56:30 -07:00
|
|
|
else
|
2007-05-09 03:33:02 -06:00
|
|
|
r = dm_io(&io_req, job->num_dests, job->dests, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int run_pages_job(struct kcopyd_job *job)
|
|
|
|
{
|
|
|
|
int r;
|
2011-08-02 05:32:02 -06:00
|
|
|
unsigned nr_pages = dm_div_up(job->dests[0].count, PAGE_SIZE >> 9);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-08-02 05:32:02 -06:00
|
|
|
r = kcopyd_get_pages(job->kc, nr_pages, &job->pages);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!r) {
|
|
|
|
/* this job is ready for io */
|
2008-04-24 14:43:44 -06:00
|
|
|
push(&job->kc->io_jobs, job);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == -ENOMEM)
|
|
|
|
/* can't complete now */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Run through a list for as long as possible. Returns the count
|
|
|
|
* of successful jobs.
|
|
|
|
*/
|
2008-04-24 14:43:44 -06:00
|
|
|
static int process_jobs(struct list_head *jobs, struct dm_kcopyd_client *kc,
|
|
|
|
int (*fn) (struct kcopyd_job *))
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kcopyd_job *job;
|
|
|
|
int r, count = 0;
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
while ((job = pop(jobs, kc))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
r = fn(job);
|
|
|
|
|
|
|
|
if (r < 0) {
|
|
|
|
/* error this rogue job */
|
2012-12-21 13:23:37 -07:00
|
|
|
if (job->rw & WRITE)
|
2008-03-28 15:16:10 -06:00
|
|
|
job->write_err = (unsigned long) -1L;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
job->read_err = 1;
|
2008-04-24 14:43:44 -06:00
|
|
|
push(&kc->complete_jobs, job);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
/*
|
|
|
|
* We couldn't service this job ATM, so
|
|
|
|
* push this job back onto the list.
|
|
|
|
*/
|
dm kcopyd: avoid queue shuffle
Write throughput to LVM snapshot origin volume is an order
of magnitude slower than those to LV without snapshots or
snapshot target volumes, especially in the case of sequential
writes with O_SYNC on.
The following patch originally written by Kevin Jamieson and
Jan Blunck and slightly modified for the current RCs by myself
tries to improve the performance by modifying the behaviour
of kcopyd, so that it pushes back an I/O job to the head of
the job queue instead of the tail as process_jobs() currently
does when it has to wait for free pages. This way, write
requests aren't shuffled to cause extra seeks.
I tested the patch against 2.6.27-rc5 and got the following results.
The test is a dd command writing to snapshot origin followed by fsync
to the file just created/updated. A couple of filesystem benchmarks
gave me similar results in case of sequential writes, while random
writes didn't suffer much.
dd if=/dev/zero of=<somewhere on snapshot origin> bs=4096 count=...
[conv=notrunc when updating]
1) linux 2.6.27-rc5 without the patch, write to snapshot origin,
average throughput (MB/s)
10M 100M 1000M
create,dd 511.46 610.72 11.81
create,dd+fsync 7.10 6.77 8.13
update,dd 431.63 917.41 12.75
update,dd+fsync 7.79 7.43 8.12
compared with write throughput to LV without any snapshots,
all dd+fsync and 1000 MiB writes perform very poorly.
10M 100M 1000M
create,dd 555.03 608.98 123.29
create,dd+fsync 114.27 72.78 76.65
update,dd 152.34 1267.27 124.04
update,dd+fsync 130.56 77.81 77.84
2) linux 2.6.27-rc5 with the patch, write to snapshot origin,
average throughput (MB/s)
10M 100M 1000M
create,dd 537.06 589.44 46.21
create,dd+fsync 31.63 29.19 29.23
update,dd 487.59 897.65 37.76
update,dd+fsync 34.12 30.07 26.85
Although still not on par with plain LV performance -
cannot be avoided because it's copy on write anyway -
this simple patch successfully improves throughtput
of dd+fsync while not affecting the rest.
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Kazuo Ito <ito.kazuo@oss.ntt.co.jp>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: stable@kernel.org
2008-10-21 10:44:50 -06:00
|
|
|
push_head(jobs, job);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* kcopyd does this every time it's woken up.
|
|
|
|
*/
|
2008-04-24 14:43:44 -06:00
|
|
|
static void do_work(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-24 14:43:44 -06:00
|
|
|
struct dm_kcopyd_client *kc = container_of(work,
|
|
|
|
struct dm_kcopyd_client, kcopyd_work);
|
2011-03-10 00:52:07 -07:00
|
|
|
struct blk_plug plug;
|
2008-04-24 14:43:44 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* The order that these are called is *very* important.
|
|
|
|
* complete jobs can free some pages for pages jobs.
|
|
|
|
* Pages jobs when successful will jump onto the io jobs
|
|
|
|
* list. io jobs call wake when they complete and it all
|
|
|
|
* starts again.
|
|
|
|
*/
|
2011-03-10 00:52:07 -07:00
|
|
|
blk_start_plug(&plug);
|
2008-04-24 14:43:44 -06:00
|
|
|
process_jobs(&kc->complete_jobs, kc, run_complete_job);
|
|
|
|
process_jobs(&kc->pages_jobs, kc, run_pages_job);
|
|
|
|
process_jobs(&kc->io_jobs, kc, run_io_job);
|
2011-03-10 00:52:07 -07:00
|
|
|
blk_finish_plug(&plug);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are copying a small region we just dispatch a single job
|
|
|
|
* to do the copy, otherwise the io has to be split up into many
|
|
|
|
* jobs.
|
|
|
|
*/
|
|
|
|
static void dispatch_job(struct kcopyd_job *job)
|
|
|
|
{
|
2008-04-24 14:43:44 -06:00
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
|
|
|
atomic_inc(&kc->nr_jobs);
|
2009-12-10 16:52:13 -07:00
|
|
|
if (unlikely(!job->source.count))
|
|
|
|
push(&kc->complete_jobs, job);
|
2011-10-31 14:18:58 -06:00
|
|
|
else if (job->pages == &zero_page_list)
|
|
|
|
push(&kc->io_jobs, job);
|
2009-12-10 16:52:13 -07:00
|
|
|
else
|
|
|
|
push(&kc->pages_jobs, job);
|
2008-04-24 14:43:44 -06:00
|
|
|
wake(kc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-03-28 15:16:10 -06:00
|
|
|
static void segment_complete(int read_err, unsigned long write_err,
|
|
|
|
void *context)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* FIXME: tidy this function */
|
|
|
|
sector_t progress = 0;
|
|
|
|
sector_t count = 0;
|
2011-05-29 06:03:00 -06:00
|
|
|
struct kcopyd_job *sub_job = (struct kcopyd_job *) context;
|
|
|
|
struct kcopyd_job *job = sub_job->master_job;
|
2009-04-08 17:27:16 -06:00
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-19 15:38:52 -06:00
|
|
|
mutex_lock(&job->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* update the error */
|
|
|
|
if (read_err)
|
|
|
|
job->read_err = 1;
|
|
|
|
|
|
|
|
if (write_err)
|
2006-06-26 01:27:30 -06:00
|
|
|
job->write_err |= write_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only dispatch more work if there hasn't been an error.
|
|
|
|
*/
|
|
|
|
if ((!job->read_err && !job->write_err) ||
|
2008-04-24 14:43:19 -06:00
|
|
|
test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* get the next chunk of work */
|
|
|
|
progress = job->progress;
|
|
|
|
count = job->source.count - progress;
|
|
|
|
if (count) {
|
|
|
|
if (count > SUB_JOB_SIZE)
|
|
|
|
count = SUB_JOB_SIZE;
|
|
|
|
|
|
|
|
job->progress += count;
|
|
|
|
}
|
|
|
|
}
|
2007-10-19 15:38:52 -06:00
|
|
|
mutex_unlock(&job->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (count) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*sub_job = *job;
|
|
|
|
sub_job->source.sector += progress;
|
|
|
|
sub_job->source.count = count;
|
|
|
|
|
|
|
|
for (i = 0; i < job->num_dests; i++) {
|
|
|
|
sub_job->dests[i].sector += progress;
|
|
|
|
sub_job->dests[i].count = count;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub_job->fn = segment_complete;
|
2011-05-29 06:03:00 -06:00
|
|
|
sub_job->context = sub_job;
|
2005-04-16 16:20:36 -06:00
|
|
|
dispatch_job(sub_job);
|
|
|
|
|
|
|
|
} else if (atomic_dec_and_test(&job->sub_jobs)) {
|
|
|
|
|
|
|
|
/*
|
2009-04-08 17:27:17 -06:00
|
|
|
* Queue the completion callback to the kcopyd thread.
|
|
|
|
*
|
|
|
|
* Some callers assume that all the completions are called
|
|
|
|
* from a single thread and don't race with each other.
|
|
|
|
*
|
|
|
|
* We must not call the callback directly here because this
|
|
|
|
* code may not be executing in the thread.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2009-04-08 17:27:17 -06:00
|
|
|
push(&kc->complete_jobs, job);
|
|
|
|
wake(kc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-05-29 06:03:00 -06:00
|
|
|
* Create some sub jobs to share the work between them.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-05-29 06:03:00 -06:00
|
|
|
static void split_job(struct kcopyd_job *master_job)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-05-29 06:03:00 -06:00
|
|
|
atomic_inc(&master_job->kc->nr_jobs);
|
2009-04-08 17:27:17 -06:00
|
|
|
|
2011-05-29 06:03:00 -06:00
|
|
|
atomic_set(&master_job->sub_jobs, SPLIT_COUNT);
|
|
|
|
for (i = 0; i < SPLIT_COUNT; i++) {
|
|
|
|
master_job[i + 1].master_job = master_job;
|
|
|
|
segment_complete(0, 0u, &master_job[i + 1]);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-04-24 14:43:19 -06:00
|
|
|
int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
|
|
|
|
unsigned int num_dests, struct dm_io_region *dests,
|
|
|
|
unsigned int flags, dm_kcopyd_notify_fn fn, void *context)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kcopyd_job *job;
|
2012-12-21 13:23:37 -07:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2011-05-29 06:03:00 -06:00
|
|
|
* Allocate an array of jobs consisting of one master job
|
|
|
|
* followed by SPLIT_COUNT sub jobs.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-04-24 14:43:46 -06:00
|
|
|
job = mempool_alloc(kc->job_pool, GFP_NOIO);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* set up for the read.
|
|
|
|
*/
|
|
|
|
job->kc = kc;
|
|
|
|
job->flags = flags;
|
|
|
|
job->read_err = 0;
|
|
|
|
job->write_err = 0;
|
|
|
|
|
|
|
|
job->num_dests = num_dests;
|
|
|
|
memcpy(&job->dests, dests, sizeof(*dests) * num_dests);
|
|
|
|
|
2011-10-31 14:18:58 -06:00
|
|
|
if (from) {
|
|
|
|
job->source = *from;
|
|
|
|
job->pages = NULL;
|
|
|
|
job->rw = READ;
|
|
|
|
} else {
|
|
|
|
memset(&job->source, 0, sizeof job->source);
|
|
|
|
job->source.count = job->dests[0].count;
|
|
|
|
job->pages = &zero_page_list;
|
2012-12-21 13:23:37 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use WRITE SAME to optimize zeroing if all dests support it.
|
|
|
|
*/
|
|
|
|
job->rw = WRITE | REQ_WRITE_SAME;
|
|
|
|
for (i = 0; i < job->num_dests; i++)
|
|
|
|
if (!bdev_write_same(job->dests[i].bdev)) {
|
|
|
|
job->rw = WRITE;
|
|
|
|
break;
|
|
|
|
}
|
2011-10-31 14:18:58 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
job->fn = fn;
|
|
|
|
job->context = context;
|
2011-05-29 06:03:00 -06:00
|
|
|
job->master_job = job;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:02:58 -06:00
|
|
|
if (job->source.count <= SUB_JOB_SIZE)
|
2005-04-16 16:20:36 -06:00
|
|
|
dispatch_job(job);
|
|
|
|
else {
|
2007-10-19 15:38:52 -06:00
|
|
|
mutex_init(&job->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
job->progress = 0;
|
|
|
|
split_job(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-04-24 14:43:19 -06:00
|
|
|
EXPORT_SYMBOL(dm_kcopyd_copy);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-10-31 14:18:58 -06:00
|
|
|
int dm_kcopyd_zero(struct dm_kcopyd_client *kc,
|
|
|
|
unsigned num_dests, struct dm_io_region *dests,
|
|
|
|
unsigned flags, dm_kcopyd_notify_fn fn, void *context)
|
|
|
|
{
|
|
|
|
return dm_kcopyd_copy(kc, NULL, num_dests, dests, flags, fn, context);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_kcopyd_zero);
|
|
|
|
|
2011-08-02 05:32:04 -06:00
|
|
|
void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
|
|
|
|
dm_kcopyd_notify_fn fn, void *context)
|
|
|
|
{
|
|
|
|
struct kcopyd_job *job;
|
|
|
|
|
|
|
|
job = mempool_alloc(kc->job_pool, GFP_NOIO);
|
|
|
|
|
|
|
|
memset(job, 0, sizeof(struct kcopyd_job));
|
|
|
|
job->kc = kc;
|
|
|
|
job->fn = fn;
|
|
|
|
job->context = context;
|
2011-10-23 13:55:17 -06:00
|
|
|
job->master_job = job;
|
2011-08-02 05:32:04 -06:00
|
|
|
|
|
|
|
atomic_inc(&kc->nr_jobs);
|
|
|
|
|
|
|
|
return job;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_kcopyd_prepare_callback);
|
|
|
|
|
|
|
|
void dm_kcopyd_do_callback(void *j, int read_err, unsigned long write_err)
|
|
|
|
{
|
|
|
|
struct kcopyd_job *job = j;
|
|
|
|
struct dm_kcopyd_client *kc = job->kc;
|
|
|
|
|
|
|
|
job->read_err = read_err;
|
|
|
|
job->write_err = write_err;
|
|
|
|
|
|
|
|
push(&kc->complete_jobs, job);
|
|
|
|
wake(kc);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_kcopyd_do_callback);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Cancels a kcopyd job, eg. someone might be deactivating a
|
|
|
|
* mirror.
|
|
|
|
*/
|
2006-01-06 01:20:08 -07:00
|
|
|
#if 0
|
2005-04-16 16:20:36 -06:00
|
|
|
int kcopyd_cancel(struct kcopyd_job *job, int block)
|
|
|
|
{
|
|
|
|
/* FIXME: finish */
|
|
|
|
return -1;
|
|
|
|
}
|
2006-01-06 01:20:08 -07:00
|
|
|
#endif /* 0 */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
2008-04-24 14:43:49 -06:00
|
|
|
* Client setup
|
2005-04-16 16:20:36 -06:00
|
|
|
*---------------------------------------------------------------*/
|
2013-03-01 15:45:49 -07:00
|
|
|
struct dm_kcopyd_client *dm_kcopyd_client_create(struct dm_kcopyd_throttle *throttle)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-24 14:43:49 -06:00
|
|
|
int r = -ENOMEM;
|
2008-04-24 14:43:19 -06:00
|
|
|
struct dm_kcopyd_client *kc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
kc = kmalloc(sizeof(*kc), GFP_KERNEL);
|
2008-04-24 14:43:49 -06:00
|
|
|
if (!kc)
|
2011-05-29 06:03:13 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
spin_lock_init(&kc->job_lock);
|
|
|
|
INIT_LIST_HEAD(&kc->complete_jobs);
|
|
|
|
INIT_LIST_HEAD(&kc->io_jobs);
|
|
|
|
INIT_LIST_HEAD(&kc->pages_jobs);
|
2013-03-01 15:45:49 -07:00
|
|
|
kc->throttle = throttle;
|
2008-04-24 14:43:44 -06:00
|
|
|
|
2008-04-24 14:43:46 -06:00
|
|
|
kc->job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
|
2008-04-24 14:43:49 -06:00
|
|
|
if (!kc->job_pool)
|
|
|
|
goto bad_slab;
|
2008-04-24 14:43:46 -06:00
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
INIT_WORK(&kc->kcopyd_work, do_work);
|
2013-07-30 06:40:21 -06:00
|
|
|
kc->kcopyd_wq = alloc_workqueue("kcopyd", WQ_MEM_RECLAIM, 0);
|
2008-04-24 14:43:49 -06:00
|
|
|
if (!kc->kcopyd_wq)
|
|
|
|
goto bad_workqueue;
|
2008-04-24 14:43:44 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
kc->pages = NULL;
|
2011-05-29 06:03:07 -06:00
|
|
|
kc->nr_reserved_pages = kc->nr_free_pages = 0;
|
2011-05-29 06:03:11 -06:00
|
|
|
r = client_reserve_pages(kc, RESERVE_PAGES);
|
2008-04-24 14:43:49 -06:00
|
|
|
if (r)
|
|
|
|
goto bad_client_pages;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-29 06:03:09 -06:00
|
|
|
kc->io_client = dm_io_client_create();
|
2007-05-09 03:33:02 -06:00
|
|
|
if (IS_ERR(kc->io_client)) {
|
|
|
|
r = PTR_ERR(kc->io_client);
|
2008-04-24 14:43:49 -06:00
|
|
|
goto bad_io_client;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-03-27 02:17:50 -07:00
|
|
|
init_waitqueue_head(&kc->destroyq);
|
|
|
|
atomic_set(&kc->nr_jobs, 0);
|
|
|
|
|
2011-05-29 06:03:13 -06:00
|
|
|
return kc;
|
2008-04-24 14:43:49 -06:00
|
|
|
|
|
|
|
bad_io_client:
|
|
|
|
client_free_pages(kc);
|
|
|
|
bad_client_pages:
|
|
|
|
destroy_workqueue(kc->kcopyd_wq);
|
|
|
|
bad_workqueue:
|
|
|
|
mempool_destroy(kc->job_pool);
|
|
|
|
bad_slab:
|
|
|
|
kfree(kc);
|
|
|
|
|
2011-05-29 06:03:13 -06:00
|
|
|
return ERR_PTR(r);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-04-24 14:43:19 -06:00
|
|
|
EXPORT_SYMBOL(dm_kcopyd_client_create);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-24 14:43:19 -06:00
|
|
|
void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-27 02:17:50 -07:00
|
|
|
/* Wait for completion of all jobs submitted by this client. */
|
|
|
|
wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
|
|
|
|
|
2008-04-24 14:43:44 -06:00
|
|
|
BUG_ON(!list_empty(&kc->complete_jobs));
|
|
|
|
BUG_ON(!list_empty(&kc->io_jobs));
|
|
|
|
BUG_ON(!list_empty(&kc->pages_jobs));
|
|
|
|
destroy_workqueue(kc->kcopyd_wq);
|
2007-05-09 03:33:02 -06:00
|
|
|
dm_io_client_destroy(kc->io_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
client_free_pages(kc);
|
2008-04-24 14:43:46 -06:00
|
|
|
mempool_destroy(kc->job_pool);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(kc);
|
|
|
|
}
|
2008-04-24 14:43:19 -06:00
|
|
|
EXPORT_SYMBOL(dm_kcopyd_client_destroy);
|