SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/md/dm-log-userspace-base.c

   1 /*
   2  * Copyright (C) 2006-2009 Red Hat, Inc.
   3  *
   4  * This file is released under the LGPL.
   5  */
   6
   7 #include <linux/bio.h>
   8 #include <linux/slab.h>
   9 #include <linux/dm-dirty-log.h>
  10 #include <linux/device-mapper.h>
  11 #include <linux/dm-log-userspace.h>
  12
  13 #include "dm-log-userspace-transfer.h"
  14
  15 struct flush_entry {
  16         int type;
  17         region_t region;
  18         struct list_head list;
  19 };
  20
  21 struct log_c {
  22         struct dm_target *ti;
  23         uint32_t region_size;
  24         region_t region_count;
  25         uint64_t luid;
  26         char uuid[DM_UUID_LEN];
  27
  28         char *usr_argv_str;
  29         uint32_t usr_argc;
  30
  31         /*
  32          * in_sync_hint gets set when doing is_remote_recovering.  It
  33          * represents the first region that needs recovery.  IOW, the
  34          * first zero bit of sync_bits.  This can be useful for to limit
  35          * traffic for calls like is_remote_recovering and get_resync_work,
  36          * but be take care in its use for anything else.
  37          */
  38         uint64_t in_sync_hint;
  39
  40         spinlock_t flush_lock;
  41         struct list_head flush_list;  /* only for clear and mark requests */
  42 };
  43
  44 static mempool_t *flush_entry_pool;
  45
  46 static void *flush_entry_alloc(gfp_t gfp_mask, void *pool_data)
  47 {
  48         return kmalloc(sizeof(struct flush_entry), gfp_mask);
  49 }
  50
  51 static void flush_entry_free(void *element, void *pool_data)
  52 {
  53         kfree(element);
  54 }
  55
  56 static int userspace_do_request(struct log_c *lc, const char *uuid,
  57                                 int request_type, char *data, size_t data_size,
  58                                 char *rdata, size_t *rdata_size)
  59 {
  60         int r;
  61
  62         /*
  63          * If the server isn't there, -ESRCH is returned,
  64          * and we must keep trying until the server is
  65          * restored.
  66          */
  67 retry:
  68         r = dm_consult_userspace(uuid, lc->luid, request_type, data,
  69                                  data_size, rdata, rdata_size);
  70
  71         if (r != -ESRCH)
  72                 return r;
  73
  74         DMERR(" Userspace log server not found.");
  75         while (1) {
  76                 set_current_state(TASK_INTERRUPTIBLE);
  77                 schedule_timeout(2*HZ);
  78                 DMWARN("Attempting to contact userspace log server...");
  79                 r = dm_consult_userspace(uuid, lc->luid, DM_ULOG_CTR,
  80                                          lc->usr_argv_str,
  81                                          strlen(lc->usr_argv_str) + 1,
  82                                          NULL, NULL);
  83                 if (!r)
  84                         break;
  85         }
  86         DMINFO("Reconnected to userspace log server... DM_ULOG_CTR complete");
  87         r = dm_consult_userspace(uuid, lc->luid, DM_ULOG_RESUME, NULL,
  88                                  0, NULL, NULL);
  89         if (!r)
  90                 goto retry;
  91
  92         DMERR("Error trying to resume userspace log: %d", r);
  93
  94         return -ESRCH;
  95 }
  96
  97 static int build_constructor_string(struct dm_target *ti,
  98                                     unsigned argc, char **argv,
  99                                     char **ctr_str)
 100 {
 101         int i, str_size;
 102         char *str = NULL;
 103
 104         *ctr_str = NULL;
 105
 106         for (i = 0, str_size = 0; i < argc; i++)
 107                 str_size += strlen(argv[i]) + 1; /* +1 for space between args */
 108
 109         str_size += 20; /* Max number of chars in a printed u64 number */
 110
 111         str = kzalloc(str_size, GFP_KERNEL);
 112         if (!str) {
 113                 DMWARN("Unable to allocate memory for constructor string");
 114                 return -ENOMEM;
 115         }
 116
 117         str_size = sprintf(str, "%llu", (unsigned long long)ti->len);
 118         for (i = 0; i < argc; i++)
 119                 str_size += sprintf(str + str_size, " %s", argv[i]);
 120
 121         *ctr_str = str;
 122         return str_size;
 123 }
 124
 125 /*
 126  * userspace_ctr
 127  *
 128  * argv contains:
 129  *      <UUID> <other args>
 130  * Where 'other args' is the userspace implementation specific log
 131  * arguments.  An example might be:
 132  *      <UUID> clustered_disk <arg count> <log dev> <region_size> [[no]sync]
 133  *
 134  * So, this module will strip off the <UUID> for identification purposes
 135  * when communicating with userspace about a log; but will pass on everything
 136  * else.
 137  */
 138 static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
 139                          unsigned argc, char **argv)
 140 {
 141         int r = 0;
 142         int str_size;
 143         char *ctr_str = NULL;
 144         struct log_c *lc = NULL;
 145         uint64_t rdata;
 146         size_t rdata_size = sizeof(rdata);
 147
 148         if (argc < 3) {
 149                 DMWARN("Too few arguments to userspace dirty log");
 150                 return -EINVAL;
 151         }
 152
 153         lc = kmalloc(sizeof(*lc), GFP_KERNEL);
 154         if (!lc) {
 155                 DMWARN("Unable to allocate userspace log context.");
 156                 return -ENOMEM;
 157         }
 158
 159         /* The ptr value is sufficient for local unique id */
 160         lc->luid = (unsigned long)lc;
 161
 162         lc->ti = ti;
 163
 164         if (strlen(argv[0]) > (DM_UUID_LEN - 1)) {
 165                 DMWARN("UUID argument too long.");
 166                 kfree(lc);
 167                 return -EINVAL;
 168         }
 169
 170         strncpy(lc->uuid, argv[0], DM_UUID_LEN);
 171         spin_lock_init(&lc->flush_lock);
 172         INIT_LIST_HEAD(&lc->flush_list);
 173
 174         str_size = build_constructor_string(ti, argc - 1, argv + 1, &ctr_str);
 175         if (str_size < 0) {
 176                 kfree(lc);
 177                 return str_size;
 178         }
 179
 180         /* Send table string */
 181         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_CTR,
 182                                  ctr_str, str_size, NULL, NULL);
 183
 184         if (r == -ESRCH) {
 185                 DMERR("Userspace log server not found");
 186                 goto out;
 187         }
 188
 189         /* Since the region size does not change, get it now */
 190         rdata_size = sizeof(rdata);
 191         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_GET_REGION_SIZE,
 192                                  NULL, 0, (char *)&rdata, &rdata_size);
 193
 194         if (r) {
 195                 DMERR("Failed to get region size of dirty log");
 196                 goto out;
 197         }
 198
 199         lc->region_size = (uint32_t)rdata;
 200         lc->region_count = dm_sector_div_up(ti->len, lc->region_size);
 201
 202 out:
 203         if (r) {
 204                 kfree(lc);
 205                 kfree(ctr_str);
 206         } else {
 207                 lc->usr_argv_str = ctr_str;
 208                 lc->usr_argc = argc;
 209                 log->context = lc;
 210         }
 211
 212         return r;
 213 }
 214
 215 static void userspace_dtr(struct dm_dirty_log *log)
 216 {
 217         int r;
 218         struct log_c *lc = log->context;
 219
 220         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_DTR,
 221                                  NULL, 0,
 222                                  NULL, NULL);
 223
 224         kfree(lc->usr_argv_str);
 225         kfree(lc);
 226
 227         return;
 228 }
 229
 230 static int userspace_presuspend(struct dm_dirty_log *log)
 231 {
 232         int r;
 233         struct log_c *lc = log->context;
 234
 235         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_PRESUSPEND,
 236                                  NULL, 0,
 237                                  NULL, NULL);
 238
 239         return r;
 240 }
 241
 242 static int userspace_postsuspend(struct dm_dirty_log *log)
 243 {
 244         int r;
 245         struct log_c *lc = log->context;
 246
 247         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_POSTSUSPEND,
 248                                  NULL, 0,
 249                                  NULL, NULL);
 250
 251         return r;
 252 }
 253
 254 static int userspace_resume(struct dm_dirty_log *log)
 255 {
 256         int r;
 257         struct log_c *lc = log->context;
 258
 259         lc->in_sync_hint = 0;
 260         r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_RESUME,
 261                                  NULL, 0,
 262                                  NULL, NULL);
 263
 264         return r;
 265 }
 266
 267 static uint32_t userspace_get_region_size(struct dm_dirty_log *log)
 268 {
 269         struct log_c *lc = log->context;
 270
 271         return lc->region_size;
 272 }
 273
 274 /*
 275  * userspace_is_clean
 276  *
 277  * Check whether a region is clean.  If there is any sort of
 278  * failure when consulting the server, we return not clean.
 279  *
 280  * Returns: 1 if clean, 0 otherwise
 281  */
 282 static int userspace_is_clean(struct dm_dirty_log *log, region_t region)
 283 {
 284         int r;
 285         uint64_t region64 = (uint64_t)region;
 286         int64_t is_clean;
 287         size_t rdata_size;
 288         struct log_c *lc = log->context;
 289
 290         rdata_size = sizeof(is_clean);
 291         r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_CLEAN,
 292                                  (char *)&region64, sizeof(region64),
 293                                  (char *)&is_clean, &rdata_size);
 294
 295         return (r) ? 0 : (int)is_clean;
 296 }
 297
 298 /*
 299  * userspace_in_sync
 300  *
 301  * Check if the region is in-sync.  If there is any sort
 302  * of failure when consulting the server, we assume that
 303  * the region is not in sync.
 304  *
 305  * If 'can_block' is set, return immediately
 306  *
 307  * Returns: 1 if in-sync, 0 if not-in-sync, -EWOULDBLOCK
 308  */
 309 static int userspace_in_sync(struct dm_dirty_log *log, region_t region,
 310                              int can_block)
 311 {
 312         int r;
 313         uint64_t region64 = region;
 314         int64_t in_sync;
 315         size_t rdata_size;
 316         struct log_c *lc = log->context;
 317
 318         /*
 319          * We can never respond directly - even if in_sync_hint is
 320          * set.  This is because another machine could see a device
 321          * failure and mark the region out-of-sync.  If we don't go
 322          * to userspace to ask, we might think the region is in-sync
 323          * and allow a read to pick up data that is stale.  (This is
 324          * very unlikely if a device actually fails; but it is very
 325          * likely if a connection to one device from one machine fails.)
 326          *
 327          * There still might be a problem if the mirror caches the region
 328          * state as in-sync... but then this call would not be made.  So,
 329          * that is a mirror problem.
 330          */
 331         if (!can_block)
 332                 return -EWOULDBLOCK;
 333
 334         rdata_size = sizeof(in_sync);
 335         r = userspace_do_request(lc, lc->uuid, DM_ULOG_IN_SYNC,
 336                                  (char *)&region64, sizeof(region64),
 337                                  (char *)&in_sync, &rdata_size);
 338         return (r) ? 0 : (int)in_sync;
 339 }
 340
 341 /*
 342  * userspace_flush
 343  *
 344  * This function is ok to block.
 345  * The flush happens in two stages.  First, it sends all
 346  * clear/mark requests that are on the list.  Then it
 347  * tells the server to commit them.  This gives the
 348  * server a chance to optimise the commit, instead of
 349  * doing it for every request.
 350  *
 351  * Additionally, we could implement another thread that
 352  * sends the requests up to the server - reducing the
 353  * load on flush.  Then the flush would have less in
 354  * the list and be responsible for the finishing commit.
 355  *
 356  * Returns: 0 on success, < 0 on failure
 357  */
 358 static int userspace_flush(struct dm_dirty_log *log)
 359 {
 360         int r = 0;
 361         unsigned long flags;
 362         struct log_c *lc = log->context;
 363         LIST_HEAD(flush_list);
 364         struct flush_entry *fe, *tmp_fe;
 365
 366         spin_lock_irqsave(&lc->flush_lock, flags);
 367         list_splice_init(&lc->flush_list, &flush_list);
 368         spin_unlock_irqrestore(&lc->flush_lock, flags);
 369
 370         if (list_empty(&flush_list))
 371                 return 0;
 372
 373         /*
 374          * FIXME: Count up requests, group request types,
 375          * allocate memory to stick all requests in and
 376          * send to server in one go.  Failing the allocation,
 377          * do it one by one.
 378          */
 379
 380         list_for_each_entry(fe, &flush_list, list) {
 381                 r = userspace_do_request(lc, lc->uuid, fe->type,
 382                                          (char *)&fe->region,
 383                                          sizeof(fe->region),
 384                                          NULL, NULL);
 385                 if (r)
 386                         goto fail;
 387         }
 388
 389         r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
 390                                  NULL, 0, NULL, NULL);
 391
 392 fail:
 393         /*
 394          * We can safely remove these entries, even if failure.
 395          * Calling code will receive an error and will know that
 396          * the log facility has failed.
 397          */
 398         list_for_each_entry_safe(fe, tmp_fe, &flush_list, list) {
 399                 list_del(&fe->list);
 400                 mempool_free(fe, flush_entry_pool);
 401         }
 402
 403         if (r)
 404                 dm_table_event(lc->ti->table);
 405
 406         return r;
 407 }
 408
 409 /*
 410  * userspace_mark_region
 411  *
 412  * This function should avoid blocking unless absolutely required.
 413  * (Memory allocation is valid for blocking.)
 414  */
 415 static void userspace_mark_region(struct dm_dirty_log *log, region_t region)
 416 {
 417         unsigned long flags;
 418         struct log_c *lc = log->context;
 419         struct flush_entry *fe;
 420
 421         /* Wait for an allocation, but _never_ fail */
 422         fe = mempool_alloc(flush_entry_pool, GFP_NOIO);
 423         BUG_ON(!fe);
 424
 425         spin_lock_irqsave(&lc->flush_lock, flags);
 426         fe->type = DM_ULOG_MARK_REGION;
 427         fe->region = region;
 428         list_add(&fe->list, &lc->flush_list);
 429         spin_unlock_irqrestore(&lc->flush_lock, flags);
 430
 431         return;
 432 }
 433
 434 /*
 435  * userspace_clear_region
 436  *
 437  * This function must not block.
 438  * So, the alloc can't block.  In the worst case, it is ok to
 439  * fail.  It would simply mean we can't clear the region.
 440  * Does nothing to current sync context, but does mean
 441  * the region will be re-sync'ed on a reload of the mirror
 442  * even though it is in-sync.
 443  */
 444 static void userspace_clear_region(struct dm_dirty_log *log, region_t region)
 445 {
 446         unsigned long flags;
 447         struct log_c *lc = log->context;
 448         struct flush_entry *fe;
 449
 450         /*
 451          * If we fail to allocate, we skip the clearing of
 452          * the region.  This doesn't hurt us in any way, except
 453          * to cause the region to be resync'ed when the
 454          * device is activated next time.
 455          */
 456         fe = mempool_alloc(flush_entry_pool, GFP_ATOMIC);
 457         if (!fe) {
 458                 DMERR("Failed to allocate memory to clear region.");
 459                 return;
 460         }
 461
 462         spin_lock_irqsave(&lc->flush_lock, flags);
 463         fe->type = DM_ULOG_CLEAR_REGION;
 464         fe->region = region;
 465         list_add(&fe->list, &lc->flush_list);
 466         spin_unlock_irqrestore(&lc->flush_lock, flags);
 467
 468         return;
 469 }
 470
 471 /*
 472  * userspace_get_resync_work
 473  *
 474  * Get a region that needs recovery.  It is valid to return
 475  * an error for this function.
 476  *
 477  * Returns: 1 if region filled, 0 if no work, <0 on error
 478  */
 479 static int userspace_get_resync_work(struct dm_dirty_log *log, region_t *region)
 480 {
 481         int r;
 482         size_t rdata_size;
 483         struct log_c *lc = log->context;
 484         struct {
 485                 int64_t i; /* 64-bit for mix arch compatibility */
 486                 region_t r;
 487         } pkg;
 488
 489         if (lc->in_sync_hint >= lc->region_count)
 490                 return 0;
 491
 492         rdata_size = sizeof(pkg);
 493         r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_RESYNC_WORK,
 494                                  NULL, 0,
 495                                  (char *)&pkg, &rdata_size);
 496
 497         *region = pkg.r;
 498         return (r) ? r : (int)pkg.i;
 499 }
 500
 501 /*
 502  * userspace_set_region_sync
 503  *
 504  * Set the sync status of a given region.  This function
 505  * must not fail.
 506  */
 507 static void userspace_set_region_sync(struct dm_dirty_log *log,
 508                                       region_t region, int in_sync)
 509 {
 510         int r;
 511         struct log_c *lc = log->context;
 512         struct {
 513                 region_t r;
 514                 int64_t i;
 515         } pkg;
 516
 517         pkg.r = region;
 518         pkg.i = (int64_t)in_sync;
 519
 520         r = userspace_do_request(lc, lc->uuid, DM_ULOG_SET_REGION_SYNC,
 521                                  (char *)&pkg, sizeof(pkg),
 522                                  NULL, NULL);
 523
 524         /*
 525          * It would be nice to be able to report failures.
 526          * However, it is easy emough to detect and resolve.
 527          */
 528         return;
 529 }
 530
 531 /*
 532  * userspace_get_sync_count
 533  *
 534  * If there is any sort of failure when consulting the server,
 535  * we assume that the sync count is zero.
 536  *
 537  * Returns: sync count on success, 0 on failure
 538  */
 539 static region_t userspace_get_sync_count(struct dm_dirty_log *log)
 540 {
 541         int r;
 542         size_t rdata_size;
 543         uint64_t sync_count;
 544         struct log_c *lc = log->context;
 545
 546         rdata_size = sizeof(sync_count);
 547         r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_SYNC_COUNT,
 548                                  NULL, 0,
 549                                  (char *)&sync_count, &rdata_size);
 550
 551         if (r)
 552                 return 0;
 553
 554         if (sync_count >= lc->region_count)
 555                 lc->in_sync_hint = lc->region_count;
 556
 557         return (region_t)sync_count;
 558 }
 559
 560 /*
 561  * userspace_status
 562  *
 563  * Returns: amount of space consumed
 564  */
 565 static int userspace_status(struct dm_dirty_log *log, status_type_t status_type,
 566                             char *result, unsigned maxlen)
 567 {
 568         int r = 0;
 569         char *table_args;
 570         size_t sz = (size_t)maxlen;
 571         struct log_c *lc = log->context;
 572
 573         switch (status_type) {
 574         case STATUSTYPE_INFO:
 575                 r = userspace_do_request(lc, lc->uuid, DM_ULOG_STATUS_INFO,
 576                                          NULL, 0,
 577                                          result, &sz);
 578
 579                 if (r) {
 580                         sz = 0;
 581                         DMEMIT("%s 1 COM_FAILURE", log->type->name);
 582                 }
 583                 break;
 584         case STATUSTYPE_TABLE:
 585                 sz = 0;
 586                 table_args = strchr(lc->usr_argv_str, ' ');
 587                 BUG_ON(!table_args); /* There will always be a ' ' */
 588                 table_args++;
 589
 590                 DMEMIT("%s %u %s %s ", log->type->name, lc->usr_argc,
 591                        lc->uuid, table_args);
 592                 break;
 593         }
 594         return (r) ? 0 : (int)sz;
 595 }
 596
 597 /*
 598  * userspace_is_remote_recovering
 599  *
 600  * Returns: 1 if region recovering, 0 otherwise
 601  */
 602 static int userspace_is_remote_recovering(struct dm_dirty_log *log,
 603                                           region_t region)
 604 {
 605         int r;
 606         uint64_t region64 = region;
 607         struct log_c *lc = log->context;
 608         static unsigned long long limit;
 609         struct {
 610                 int64_t is_recovering;
 611                 uint64_t in_sync_hint;
 612         } pkg;
 613         size_t rdata_size = sizeof(pkg);
 614
 615         /*
 616          * Once the mirror has been reported to be in-sync,
 617          * it will never again ask for recovery work.  So,
 618          * we can safely say there is not a remote machine
 619          * recovering if the device is in-sync.  (in_sync_hint
 620          * must be reset at resume time.)
 621          */
 622         if (region < lc->in_sync_hint)
 623                 return 0;
 624         else if (jiffies < limit)
 625                 return 1;
 626
 627         limit = jiffies + (HZ / 4);
 628         r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_REMOTE_RECOVERING,
 629                                  (char *)&region64, sizeof(region64),
 630                                  (char *)&pkg, &rdata_size);
 631         if (r)
 632                 return 1;
 633
 634         lc->in_sync_hint = pkg.in_sync_hint;
 635
 636         return (int)pkg.is_recovering;
 637 }
 638
 639 static struct dm_dirty_log_type _userspace_type = {
 640         .name = "userspace",
 641         .module = THIS_MODULE,
 642         .ctr = userspace_ctr,
 643         .dtr = userspace_dtr,
 644         .presuspend = userspace_presuspend,
 645         .postsuspend = userspace_postsuspend,
 646         .resume = userspace_resume,
 647         .get_region_size = userspace_get_region_size,
 648         .is_clean = userspace_is_clean,
 649         .in_sync = userspace_in_sync,
 650         .flush = userspace_flush,
 651         .mark_region = userspace_mark_region,
 652         .clear_region = userspace_clear_region,
 653         .get_resync_work = userspace_get_resync_work,
 654         .set_region_sync = userspace_set_region_sync,
 655         .get_sync_count = userspace_get_sync_count,
 656         .status = userspace_status,
 657         .is_remote_recovering = userspace_is_remote_recovering,
 658 };
 659
 660 static int __init userspace_dirty_log_init(void)
 661 {
 662         int r = 0;
 663
 664         flush_entry_pool = mempool_create(100, flush_entry_alloc,
 665                                           flush_entry_free, NULL);
 666
 667         if (!flush_entry_pool) {
 668                 DMWARN("Unable to create flush_entry_pool:  No memory.");
 669                 return -ENOMEM;
 670         }
 671
 672         r = dm_ulog_tfr_init();
 673         if (r) {
 674                 DMWARN("Unable to initialize userspace log communications");
 675                 mempool_destroy(flush_entry_pool);
 676                 return r;
 677         }
 678
 679         r = dm_dirty_log_type_register(&_userspace_type);
 680         if (r) {
 681                 DMWARN("Couldn't register userspace dirty log type");
 682                 dm_ulog_tfr_exit();
 683                 mempool_destroy(flush_entry_pool);
 684                 return r;
 685         }
 686
 687         DMINFO("version 1.0.0 loaded");
 688         return 0;
 689 }
 690
 691 static void __exit userspace_dirty_log_exit(void)
 692 {
 693         dm_dirty_log_type_unregister(&_userspace_type);
 694         dm_ulog_tfr_exit();
 695         mempool_destroy(flush_entry_pool);
 696
 697         DMINFO("version 1.0.0 unloaded");
 698         return;
 699 }
 700
 701 module_init(userspace_dirty_log_init);
 702 module_exit(userspace_dirty_log_exit);
 703
 704 MODULE_DESCRIPTION(DM_NAME " userspace dirty log link");
 705 MODULE_AUTHOR("Jonathan Brassow <dm-devel@redhat.com>");
 706 MODULE_LICENSE("GPL");