Source of dm-kcopyd.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
    mempool_t job_pool;
​
    struct workqueue_struct *kcopyd_wq;
    struct work_struct kcopyd_work;
​
    struct dm_kcopyd_throttle *throttle;
​
    atomic_t nr_jobs;
​
/*
 * We maintain three lists of jobs:
 * We maintain four 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.
 * iii) jobs that don't need to do any IO and just run a callback
 * iv) jobs that have completed.
 *
 * All three of these are protected by job_lock.
 * All four of these are protected by job_lock.
 */
    spinlock_t job_lock;
    struct list_head callback_jobs;
    struct list_head complete_jobs;
    struct list_head io_jobs;
    struct list_head pages_jobs;
};
​
static struct page_list zero_page_list;
​
static DEFINE_SPINLOCK(throttle_spinlock);
​
/*
Show more
}
​
/*
 * kcopyd does this every time it's woken up.
 */
static void do_work(struct work_struct *work)
{
    struct dm_kcopyd_client *kc = container_of(work,
                    struct dm_kcopyd_client, kcopyd_work);
    struct blk_plug plug;
    unsigned long flags;
​
    /*
     * 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.
     */
    spin_lock_irqsave(&kc->job_lock, flags);
    list_splice_tail_init(&kc->callback_jobs, &kc->complete_jobs);
    spin_unlock_irqrestore(&kc->job_lock, flags);
​
    blk_start_plug(&plug);
    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);
    blk_finish_plug(&plug);
}
​
/*
 * 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)
{
    struct dm_kcopyd_client *kc = job->kc;
    atomic_inc(&kc->nr_jobs);
    if (unlikely(!job->source.count))
        push(&kc->complete_jobs, job);
        push(&kc->callback_jobs, job);
    else if (job->pages == &zero_page_list)
        push(&kc->io_jobs, job);
    else
        push(&kc->pages_jobs, job);
    wake(kc);
}
​
static void segment_complete(int read_err, unsigned long write_err,
                 void *context)
{
Show more
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);
    push(&kc->callback_jobs, job);
    wake(kc);
}
EXPORT_SYMBOL(dm_kcopyd_do_callback);
​
/*
 * Cancels a kcopyd job, eg. someone might be deactivating a
 * mirror.
 */
#if 0
int kcopyd_cancel(struct kcopyd_job *job, int block)
Show more
struct dm_kcopyd_client *dm_kcopyd_client_create(struct dm_kcopyd_throttle *throttle)
{
    int r;
    struct dm_kcopyd_client *kc;
​
    kc = kzalloc(sizeof(*kc), GFP_KERNEL);
    if (!kc)
        return ERR_PTR(-ENOMEM);
​
    spin_lock_init(&kc->job_lock);
    INIT_LIST_HEAD(&kc->callback_jobs);
    INIT_LIST_HEAD(&kc->complete_jobs);
    INIT_LIST_HEAD(&kc->io_jobs);
    INIT_LIST_HEAD(&kc->pages_jobs);
    kc->throttle = throttle;
​
    r = mempool_init_slab_pool(&kc->job_pool, MIN_JOBS, _job_cache);
    if (r)
        goto bad_slab;
​
    INIT_WORK(&kc->kcopyd_work, do_work);
Show more
​
    return ERR_PTR(r);
}
EXPORT_SYMBOL(dm_kcopyd_client_create);
​
void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc)
{
    /* Wait for completion of all jobs submitted by this client. */
    wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
​
    BUG_ON(!list_empty(&kc->callback_jobs));
    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);
    dm_io_client_destroy(kc->io_client);
    client_free_pages(kc);
    mempool_exit(&kc->job_pool);
    kfree(kc);
}
EXPORT_SYMBOL(dm_kcopyd_client_destroy);