drivers/md/kcopyd.c

   1 /*
   2  * Copyright (C) 2002 Sistina Software (UK) Limited.
   3  *
   4  * This file is released under the GPL.
   5  *
   6  * Kcopyd provides a simple interface for copying an area of one
   7  * block-device to one or more other block-devices, with an asynchronous
   8  * completion notification.
   9  */
  10
  11 #include <asm/types.h>
  12 #include <asm/atomic.h>
  13
  14 #include <linux/blkdev.h>
  15 #include <linux/config.h>
  16 #include <linux/fs.h>
  17 #include <linux/init.h>
  18 #include <linux/list.h>
  19 #include <linux/mempool.h>
  20 #include <linux/module.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/slab.h>
  23 #include <linux/vmalloc.h>
  24 #include <linux/workqueue.h>
  25
  26 #include "kcopyd.h"
  27
  28 static struct workqueue_struct *_kcopyd_wq;
  29 static struct work_struct _kcopyd_work;
  30
  31 static inline void wake(void)
  32 {
  33         queue_work(_kcopyd_wq, &_kcopyd_work);
  34 }
  35
  36 /*-----------------------------------------------------------------
  37  * Each kcopyd client has its own little pool of preallocated
  38  * pages for kcopyd io.
  39  *---------------------------------------------------------------*/
  40 struct kcopyd_client {
  41         struct list_head list;
  42
  43         spinlock_t lock;
  44         struct page_list *pages;
  45         unsigned int nr_pages;
  46         unsigned int nr_free_pages;
  47 };
  48
  49 static struct page_list *alloc_pl(void)
  50 {
  51         struct page_list *pl;
  52
  53         pl = kmalloc(sizeof(*pl), GFP_KERNEL);
  54         if (!pl)
  55                 return NULL;
  56
  57         pl->page = alloc_page(GFP_KERNEL);
  58         if (!pl->page) {
  59                 kfree(pl);
  60                 return NULL;
  61         }
  62
  63         return pl;
  64 }
  65
  66 static void free_pl(struct page_list *pl)
  67 {
  68         __free_page(pl->page);
  69         kfree(pl);
  70 }
  71
  72 static int kcopyd_get_pages(struct kcopyd_client *kc,
  73                             unsigned int nr, struct page_list **pages)
  74 {
  75         struct page_list *pl;
  76
  77         spin_lock(&kc->lock);
  78         if (kc->nr_free_pages < nr) {
  79                 spin_unlock(&kc->lock);
  80                 return -ENOMEM;
  81         }
  82
  83         kc->nr_free_pages -= nr;
  84         for (*pages = pl = kc->pages; --nr; pl = pl->next)
  85                 ;
  86
  87         kc->pages = pl->next;
  88         pl->next = NULL;
  89
  90         spin_unlock(&kc->lock);
  91
  92         return 0;
  93 }
  94
  95 static void kcopyd_put_pages(struct kcopyd_client *kc, struct page_list *pl)
  96 {
  97         struct page_list *cursor;
  98
  99         spin_lock(&kc->lock);
 100         for (cursor = pl; cursor->next; cursor = cursor->next)
 101                 kc->nr_free_pages++;
 102
 103         kc->nr_free_pages++;
 104         cursor->next = kc->pages;
 105         kc->pages = pl;
 106         spin_unlock(&kc->lock);
 107 }
 108
 109 /*
 110  * These three functions resize the page pool.
 111  */
 112 static void drop_pages(struct page_list *pl)
 113 {
 114         struct page_list *next;
 115
 116         while (pl) {
 117                 next = pl->next;
 118                 free_pl(pl);
 119                 pl = next;
 120         }
 121 }
 122
 123 static int client_alloc_pages(struct kcopyd_client *kc, unsigned int nr)
 124 {
 125         unsigned int i;
 126         struct page_list *pl = NULL, *next;
 127
 128         for (i = 0; i < nr; i++) {
 129                 next = alloc_pl();
 130                 if (!next) {
 131                         if (pl)
 132                                 drop_pages(pl);
 133                         return -ENOMEM;
 134                 }
 135                 next->next = pl;
 136                 pl = next;
 137         }
 138
 139         kcopyd_put_pages(kc, pl);
 140         kc->nr_pages += nr;
 141         return 0;
 142 }
 143
 144 static void client_free_pages(struct kcopyd_client *kc)
 145 {
 146         BUG_ON(kc->nr_free_pages != kc->nr_pages);
 147         drop_pages(kc->pages);
 148         kc->pages = NULL;
 149         kc->nr_free_pages = kc->nr_pages = 0;
 150 }
 151
 152 /*-----------------------------------------------------------------
 153  * kcopyd_jobs need to be allocated by the *clients* of kcopyd,
 154  * for this reason we use a mempool to prevent the client from
 155  * ever having to do io (which could cause a deadlock).
 156  *---------------------------------------------------------------*/
 157 struct kcopyd_job {
 158         struct kcopyd_client *kc;
 159         struct list_head list;
 160         unsigned long flags;
 161
 162         /*
 163          * Error state of the job.
 164          */
 165         int read_err;
 166         unsigned int write_err;
 167
 168         /*
 169          * Either READ or WRITE
 170          */
 171         int rw;
 172         struct io_region source;
 173
 174         /*
 175          * The destinations for the transfer.
 176          */
 177         unsigned int num_dests;
 178         struct io_region dests[KCOPYD_MAX_REGIONS];
 179
 180         sector_t offset;
 181         unsigned int nr_pages;
 182         struct page_list *pages;
 183
 184         /*
 185          * Set this to ensure you are notified when the job has
 186          * completed.  'context' is for callback to use.
 187          */
 188         kcopyd_notify_fn fn;
 189         void *context;
 190
 191         /*
 192          * These fields are only used if the job has been split
 193          * into more manageable parts.
 194          */
 195         struct semaphore lock;
 196         atomic_t sub_jobs;
 197         sector_t progress;
 198 };
 199
 200 /* FIXME: this should scale with the number of pages */
 201 #define MIN_JOBS 512
 202
 203 static kmem_cache_t *_job_cache;
 204 static mempool_t *_job_pool;
 205
 206 /*
 207  * We maintain three lists of jobs:
 208  *
 209  * i)   jobs waiting for pages
 210  * ii)  jobs that have pages, and are waiting for the io to be issued.
 211  * iii) jobs that have completed.
 212  *
 213  * All three of these are protected by job_lock.
 214  */
 215 static DEFINE_SPINLOCK(_job_lock);
 216
 217 static LIST_HEAD(_complete_jobs);
 218 static LIST_HEAD(_io_jobs);
 219 static LIST_HEAD(_pages_jobs);
 220
 221 static int jobs_init(void)
 222 {
 223         _job_cache = kmem_cache_create("kcopyd-jobs",
 224                                        sizeof(struct kcopyd_job),
 225                                        __alignof__(struct kcopyd_job),
 226                                        0, NULL, NULL);
 227         if (!_job_cache)
 228                 return -ENOMEM;
 229
 230         _job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
 231         if (!_job_pool) {
 232                 kmem_cache_destroy(_job_cache);
 233                 return -ENOMEM;
 234         }
 235
 236         return 0;
 237 }
 238
 239 static void jobs_exit(void)
 240 {
 241         BUG_ON(!list_empty(&_complete_jobs));
 242         BUG_ON(!list_empty(&_io_jobs));
 243         BUG_ON(!list_empty(&_pages_jobs));
 244
 245         mempool_destroy(_job_pool);
 246         kmem_cache_destroy(_job_cache);
 247         _job_pool = NULL;
 248         _job_cache = NULL;
 249 }
 250
 251 /*
 252  * Functions to push and pop a job onto the head of a given job
 253  * list.
 254  */
 255 static inline struct kcopyd_job *pop(struct list_head *jobs)
 256 {
 257         struct kcopyd_job *job = NULL;
 258         unsigned long flags;
 259
 260         spin_lock_irqsave(&_job_lock, flags);
 261
 262         if (!list_empty(jobs)) {
 263                 job = list_entry(jobs->next, struct kcopyd_job, list);
 264                 list_del(&job->list);
 265         }
 266         spin_unlock_irqrestore(&_job_lock, flags);
 267
 268         return job;
 269 }
 270
 271 static inline void push(struct list_head *jobs, struct kcopyd_job *job)
 272 {
 273         unsigned long flags;
 274
 275         spin_lock_irqsave(&_job_lock, flags);
 276         list_add_tail(&job->list, jobs);
 277         spin_unlock_irqrestore(&_job_lock, flags);
 278 }
 279
 280 /*
 281  * These three functions process 1 item from the corresponding
 282  * job list.
 283  *
 284  * They return:
 285  * < 0: error
 286  *   0: success
 287  * > 0: can't process yet.
 288  */
 289 static int run_complete_job(struct kcopyd_job *job)
 290 {
 291         void *context = job->context;
 292         int read_err = job->read_err;
 293         unsigned int write_err = job->write_err;
 294         kcopyd_notify_fn fn = job->fn;
 295
 296         kcopyd_put_pages(job->kc, job->pages);
 297         mempool_free(job, _job_pool);
 298         fn(read_err, write_err, context);
 299         return 0;
 300 }
 301
 302 static void complete_io(unsigned long error, void *context)
 303 {
 304         struct kcopyd_job *job = (struct kcopyd_job *) context;
 305
 306         if (error) {
 307                 if (job->rw == WRITE)
 308                         job->write_err &= error;
 309                 else
 310                         job->read_err = 1;
 311
 312                 if (!test_bit(KCOPYD_IGNORE_ERROR, &job->flags)) {
 313                         push(&_complete_jobs, job);
 314                         wake();
 315                         return;
 316                 }
 317         }
 318
 319         if (job->rw == WRITE)
 320                 push(&_complete_jobs, job);
 321
 322         else {
 323                 job->rw = WRITE;
 324                 push(&_io_jobs, job);
 325         }
 326
 327         wake();
 328 }
 329
 330 /*
 331  * Request io on as many buffer heads as we can currently get for
 332  * a particular job.
 333  */
 334 static int run_io_job(struct kcopyd_job *job)
 335 {
 336         int r;
 337
 338         if (job->rw == READ)
 339                 r = dm_io_async(1, &job->source, job->rw,
 340                                 job->pages,
 341                                 job->offset, complete_io, job);
 342
 343         else
 344                 r = dm_io_async(job->num_dests, job->dests, job->rw,
 345                                 job->pages,
 346                                 job->offset, complete_io, job);
 347
 348         return r;
 349 }
 350
 351 static int run_pages_job(struct kcopyd_job *job)
 352 {
 353         int r;
 354
 355         job->nr_pages = dm_div_up(job->dests[0].count + job->offset,
 356                                   PAGE_SIZE >> 9);
 357         r = kcopyd_get_pages(job->kc, job->nr_pages, &job->pages);
 358         if (!r) {
 359                 /* this job is ready for io */
 360                 push(&_io_jobs, job);
 361                 return 0;
 362         }
 363
 364         if (r == -ENOMEM)
 365                 /* can't complete now */
 366                 return 1;
 367
 368         return r;
 369 }
 370
 371 /*
 372  * Run through a list for as long as possible.  Returns the count
 373  * of successful jobs.
 374  */
 375 static int process_jobs(struct list_head *jobs, int (*fn) (struct kcopyd_job *))
 376 {
 377         struct kcopyd_job *job;
 378         int r, count = 0;
 379
 380         while ((job = pop(jobs))) {
 381
 382                 r = fn(job);
 383
 384                 if (r < 0) {
 385                         /* error this rogue job */
 386                         if (job->rw == WRITE)
 387                                 job->write_err = (unsigned int) -1;
 388                         else
 389                                 job->read_err = 1;
 390                         push(&_complete_jobs, job);
 391                         break;
 392                 }
 393
 394                 if (r > 0) {
 395                         /*
 396                          * We couldn't service this job ATM, so
 397                          * push this job back onto the list.
 398                          */
 399                         push(jobs, job);
 400                         break;
 401                 }
 402
 403                 count++;
 404         }
 405
 406         return count;
 407 }
 408
 409 /*
 410  * kcopyd does this every time it's woken up.
 411  */
 412 static void do_work(void *ignored)
 413 {
 414         /*
 415          * The order that these are called is *very* important.
 416          * complete jobs can free some pages for pages jobs.
 417          * Pages jobs when successful will jump onto the io jobs
 418          * list.  io jobs call wake when they complete and it all
 419          * starts again.
 420          */
 421         process_jobs(&_complete_jobs, run_complete_job);
 422         process_jobs(&_pages_jobs, run_pages_job);
 423         process_jobs(&_io_jobs, run_io_job);
 424 }
 425
 426 /*
 427  * If we are copying a small region we just dispatch a single job
 428  * to do the copy, otherwise the io has to be split up into many
 429  * jobs.
 430  */
 431 static void dispatch_job(struct kcopyd_job *job)
 432 {
 433         push(&_pages_jobs, job);
 434         wake();
 435 }
 436
 437 #define SUB_JOB_SIZE 128
 438 static void segment_complete(int read_err,
 439                              unsigned int write_err, void *context)
 440 {
 441         /* FIXME: tidy this function */
 442         sector_t progress = 0;
 443         sector_t count = 0;
 444         struct kcopyd_job *job = (struct kcopyd_job *) context;
 445
 446         down(&job->lock);
 447
 448         /* update the error */
 449         if (read_err)
 450                 job->read_err = 1;
 451
 452         if (write_err)
 453                 job->write_err &= write_err;
 454
 455         /*
 456          * Only dispatch more work if there hasn't been an error.
 457          */
 458         if ((!job->read_err && !job->write_err) ||
 459             test_bit(KCOPYD_IGNORE_ERROR, &job->flags)) {
 460                 /* get the next chunk of work */
 461                 progress = job->progress;
 462                 count = job->source.count - progress;
 463                 if (count) {
 464                         if (count > SUB_JOB_SIZE)
 465                                 count = SUB_JOB_SIZE;
 466
 467                         job->progress += count;
 468                 }
 469         }
 470         up(&job->lock);
 471
 472         if (count) {
 473                 int i;
 474                 struct kcopyd_job *sub_job = mempool_alloc(_job_pool, GFP_NOIO);
 475
 476                 *sub_job = *job;
 477                 sub_job->source.sector += progress;
 478                 sub_job->source.count = count;
 479
 480                 for (i = 0; i < job->num_dests; i++) {
 481                         sub_job->dests[i].sector += progress;
 482                         sub_job->dests[i].count = count;
 483                 }
 484
 485                 sub_job->fn = segment_complete;
 486                 sub_job->context = job;
 487                 dispatch_job(sub_job);
 488
 489         } else if (atomic_dec_and_test(&job->sub_jobs)) {
 490
 491                 /*
 492                  * To avoid a race we must keep the job around
 493                  * until after the notify function has completed.
 494                  * Otherwise the client may try and stop the job
 495                  * after we've completed.
 496                  */
 497                 job->fn(read_err, write_err, job->context);
 498                 mempool_free(job, _job_pool);
 499         }
 500 }
 501
 502 /*
 503  * Create some little jobs that will do the move between
 504  * them.
 505  */
 506 #define SPLIT_COUNT 8
 507 static void split_job(struct kcopyd_job *job)
 508 {
 509         int i;
 510
 511         atomic_set(&job->sub_jobs, SPLIT_COUNT);
 512         for (i = 0; i < SPLIT_COUNT; i++)
 513                 segment_complete(0, 0u, job);
 514 }
 515
 516 int kcopyd_copy(struct kcopyd_client *kc, struct io_region *from,
 517                 unsigned int num_dests, struct io_region *dests,
 518                 unsigned int flags, kcopyd_notify_fn fn, void *context)
 519 {
 520         struct kcopyd_job *job;
 521
 522         /*
 523          * Allocate a new job.
 524          */
 525         job = mempool_alloc(_job_pool, GFP_NOIO);
 526
 527         /*
 528          * set up for the read.
 529          */
 530         job->kc = kc;
 531         job->flags = flags;
 532         job->read_err = 0;
 533         job->write_err = 0;
 534         job->rw = READ;
 535
 536         job->source = *from;
 537
 538         job->num_dests = num_dests;
 539         memcpy(&job->dests, dests, sizeof(*dests) * num_dests);
 540
 541         job->offset = 0;
 542         job->nr_pages = 0;
 543         job->pages = NULL;
 544
 545         job->fn = fn;
 546         job->context = context;
 547
 548         if (job->source.count < SUB_JOB_SIZE)
 549                 dispatch_job(job);
 550
 551         else {
 552                 init_MUTEX(&job->lock);
 553                 job->progress = 0;
 554                 split_job(job);
 555         }
 556
 557         return 0;
 558 }
 559
 560 /*
 561  * Cancels a kcopyd job, eg. someone might be deactivating a
 562  * mirror.
 563  */
 564 #if 0
 565 int kcopyd_cancel(struct kcopyd_job *job, int block)
 566 {
 567         /* FIXME: finish */
 568         return -1;
 569 }
 570 #endif  /*  0  */
 571
 572 /*-----------------------------------------------------------------
 573  * Unit setup
 574  *---------------------------------------------------------------*/
 575 static DECLARE_MUTEX(_client_lock);
 576 static LIST_HEAD(_clients);
 577
 578 static void client_add(struct kcopyd_client *kc)
 579 {
 580         down(&_client_lock);
 581         list_add(&kc->list, &_clients);
 582         up(&_client_lock);
 583 }
 584
 585 static void client_del(struct kcopyd_client *kc)
 586 {
 587         down(&_client_lock);
 588         list_del(&kc->list);
 589         up(&_client_lock);
 590 }
 591
 592 static DEFINE_MUTEX(kcopyd_init_lock);
 593 static int kcopyd_clients = 0;
 594
 595 static int kcopyd_init(void)
 596 {
 597         int r;
 598
 599         mutex_lock(&kcopyd_init_lock);
 600
 601         if (kcopyd_clients) {
 602                 /* Already initialized. */
 603                 kcopyd_clients++;
 604                 mutex_unlock(&kcopyd_init_lock);
 605                 return 0;
 606         }
 607
 608         r = jobs_init();
 609         if (r) {
 610                 mutex_unlock(&kcopyd_init_lock);
 611                 return r;
 612         }
 613
 614         _kcopyd_wq = create_singlethread_workqueue("kcopyd");
 615         if (!_kcopyd_wq) {
 616                 jobs_exit();
 617                 mutex_unlock(&kcopyd_init_lock);
 618                 return -ENOMEM;
 619         }
 620
 621         kcopyd_clients++;
 622         INIT_WORK(&_kcopyd_work, do_work, NULL);
 623         mutex_unlock(&kcopyd_init_lock);
 624         return 0;
 625 }
 626
 627 static void kcopyd_exit(void)
 628 {
 629         mutex_lock(&kcopyd_init_lock);
 630         kcopyd_clients--;
 631         if (!kcopyd_clients) {
 632                 jobs_exit();
 633                 destroy_workqueue(_kcopyd_wq);
 634                 _kcopyd_wq = NULL;
 635         }
 636         mutex_unlock(&kcopyd_init_lock);
 637 }
 638
 639 int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
 640 {
 641         int r = 0;
 642         struct kcopyd_client *kc;
 643
 644         r = kcopyd_init();
 645         if (r)
 646                 return r;
 647
 648         kc = kmalloc(sizeof(*kc), GFP_KERNEL);
 649         if (!kc) {
 650                 kcopyd_exit();
 651                 return -ENOMEM;
 652         }
 653
 654         spin_lock_init(&kc->lock);
 655         kc->pages = NULL;
 656         kc->nr_pages = kc->nr_free_pages = 0;
 657         r = client_alloc_pages(kc, nr_pages);
 658         if (r) {
 659                 kfree(kc);
 660                 kcopyd_exit();
 661                 return r;
 662         }
 663
 664         r = dm_io_get(nr_pages);
 665         if (r) {
 666                 client_free_pages(kc);
 667                 kfree(kc);
 668                 kcopyd_exit();
 669                 return r;
 670         }
 671
 672         client_add(kc);
 673         *result = kc;
 674         return 0;
 675 }
 676
 677 void kcopyd_client_destroy(struct kcopyd_client *kc)
 678 {
 679         dm_io_put(kc->nr_pages);
 680         client_free_pages(kc);
 681         client_del(kc);
 682         kfree(kc);
 683         kcopyd_exit();
 684 }
 685
 686 EXPORT_SYMBOL(kcopyd_client_create);
 687 EXPORT_SYMBOL(kcopyd_client_destroy);
 688 EXPORT_SYMBOL(kcopyd_copy);