1 /****************************************************************************** 2 * xenbus_xs.c 3 * 4 * This is the kernel equivalent of the "xs" library. We don't need everything 5 * and we use xenbus_comms for communication. 6 * 7 * Copyright (C) 2005 Rusty Russell, IBM Corporation 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License version 2 11 * as published by the Free Software Foundation; or, when distributed 12 * separately from the Linux kernel or incorporated into other 13 * software packages, subject to the following license: 14 * 15 * Permission is hereby granted, free of charge, to any person obtaining a copy 16 * of this source file (the "Software"), to deal in the Software without 17 * restriction, including without limitation the rights to use, copy, modify, 18 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 19 * and to permit persons to whom the Software is furnished to do so, subject to 20 * the following conditions: 21 * 22 * The above copyright notice and this permission notice shall be included in 23 * all copies or substantial portions of the Software. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 28 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 29 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 30 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 31 * IN THE SOFTWARE. 32 */ 33 34 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 35 36 #include <linux/unistd.h> 37 #include <linux/errno.h> 38 #include <linux/types.h> 39 #include <linux/uio.h> 40 #include <linux/kernel.h> 41 #include <linux/string.h> 42 #include <linux/err.h> 43 #include <linux/slab.h> 44 #include <linux/fcntl.h> 45 #include <linux/kthread.h> 46 #include <linux/rwsem.h> 47 #include <linux/mutex.h> 48 #include <asm/xen/hypervisor.h> 49 #include <xen/xenbus.h> 50 #include <xen/xen.h> 51 #include "xenbus_comms.h" 52 #include "xenbus_probe.h" 53 54 struct xs_stored_msg { 55 struct list_head list; 56 57 struct xsd_sockmsg hdr; 58 59 union { 60 /* Queued replies. */ 61 struct { 62 char *body; 63 } reply; 64 65 /* Queued watch events. */ 66 struct { 67 struct xenbus_watch *handle; 68 char **vec; 69 unsigned int vec_size; 70 } watch; 71 } u; 72 }; 73 74 struct xs_handle { 75 /* A list of replies. Currently only one will ever be outstanding. */ 76 struct list_head reply_list; 77 spinlock_t reply_lock; 78 wait_queue_head_t reply_waitq; 79 80 /* 81 * Mutex ordering: transaction_mutex -> watch_mutex -> request_mutex. 82 * response_mutex is never taken simultaneously with the other three. 83 * 84 * transaction_mutex must be held before incrementing 85 * transaction_count. The mutex is held when a suspend is in 86 * progress to prevent new transactions starting. 87 * 88 * When decrementing transaction_count to zero the wait queue 89 * should be woken up, the suspend code waits for count to 90 * reach zero. 91 */ 92 93 /* One request at a time. */ 94 struct mutex request_mutex; 95 96 /* Protect xenbus reader thread against save/restore. */ 97 struct mutex response_mutex; 98 99 /* Protect transactions against save/restore. */ 100 struct mutex transaction_mutex; 101 atomic_t transaction_count; 102 wait_queue_head_t transaction_wq; 103 104 /* Protect watch (de)register against save/restore. */ 105 struct rw_semaphore watch_mutex; 106 }; 107 108 static struct xs_handle xs_state; 109 110 /* List of registered watches, and a lock to protect it. */ 111 static LIST_HEAD(watches); 112 static DEFINE_SPINLOCK(watches_lock); 113 114 /* List of pending watch callback events, and a lock to protect it. */ 115 static LIST_HEAD(watch_events); 116 static DEFINE_SPINLOCK(watch_events_lock); 117 118 /* 119 * Details of the xenwatch callback kernel thread. The thread waits on the 120 * watch_events_waitq for work to do (queued on watch_events list). When it 121 * wakes up it acquires the xenwatch_mutex before reading the list and 122 * carrying out work. 123 */ 124 static pid_t xenwatch_pid; 125 static DEFINE_MUTEX(xenwatch_mutex); 126 static DECLARE_WAIT_QUEUE_HEAD(watch_events_waitq); 127 128 static int get_error(const char *errorstring) 129 { 130 unsigned int i; 131 132 for (i = 0; strcmp(errorstring, xsd_errors[i].errstring) != 0; i++) { 133 if (i == ARRAY_SIZE(xsd_errors) - 1) { 134 pr_warn("xen store gave: unknown error %s\n", 135 errorstring); 136 return EINVAL; 137 } 138 } 139 return xsd_errors[i].errnum; 140 } 141 142 static bool xenbus_ok(void) 143 { 144 switch (xen_store_domain_type) { 145 case XS_LOCAL: 146 switch (system_state) { 147 case SYSTEM_POWER_OFF: 148 case SYSTEM_RESTART: 149 case SYSTEM_HALT: 150 return false; 151 default: 152 break; 153 } 154 return true; 155 case XS_PV: 156 case XS_HVM: 157 /* FIXME: Could check that the remote domain is alive, 158 * but it is normally initial domain. */ 159 return true; 160 default: 161 break; 162 } 163 return false; 164 } 165 static void *read_reply(enum xsd_sockmsg_type *type, unsigned int *len) 166 { 167 struct xs_stored_msg *msg; 168 char *body; 169 170 spin_lock(&xs_state.reply_lock); 171 172 while (list_empty(&xs_state.reply_list)) { 173 spin_unlock(&xs_state.reply_lock); 174 if (xenbus_ok()) 175 /* XXX FIXME: Avoid synchronous wait for response here. */ 176 wait_event_timeout(xs_state.reply_waitq, 177 !list_empty(&xs_state.reply_list), 178 msecs_to_jiffies(500)); 179 else { 180 /* 181 * If we are in the process of being shut-down there is 182 * no point of trying to contact XenBus - it is either 183 * killed (xenstored application) or the other domain 184 * has been killed or is unreachable. 185 */ 186 return ERR_PTR(-EIO); 187 } 188 spin_lock(&xs_state.reply_lock); 189 } 190 191 msg = list_entry(xs_state.reply_list.next, 192 struct xs_stored_msg, list); 193 list_del(&msg->list); 194 195 spin_unlock(&xs_state.reply_lock); 196 197 *type = msg->hdr.type; 198 if (len) 199 *len = msg->hdr.len; 200 body = msg->u.reply.body; 201 202 kfree(msg); 203 204 return body; 205 } 206 207 static void transaction_start(void) 208 { 209 mutex_lock(&xs_state.transaction_mutex); 210 atomic_inc(&xs_state.transaction_count); 211 mutex_unlock(&xs_state.transaction_mutex); 212 } 213 214 static void transaction_end(void) 215 { 216 if (atomic_dec_and_test(&xs_state.transaction_count)) 217 wake_up(&xs_state.transaction_wq); 218 } 219 220 static void transaction_suspend(void) 221 { 222 mutex_lock(&xs_state.transaction_mutex); 223 wait_event(xs_state.transaction_wq, 224 atomic_read(&xs_state.transaction_count) == 0); 225 } 226 227 static void transaction_resume(void) 228 { 229 mutex_unlock(&xs_state.transaction_mutex); 230 } 231 232 void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg) 233 { 234 void *ret; 235 enum xsd_sockmsg_type type = msg->type; 236 int err; 237 238 if (type == XS_TRANSACTION_START) 239 transaction_start(); 240 241 mutex_lock(&xs_state.request_mutex); 242 243 err = xb_write(msg, sizeof(*msg) + msg->len); 244 if (err) { 245 msg->type = XS_ERROR; 246 ret = ERR_PTR(err); 247 } else 248 ret = read_reply(&msg->type, &msg->len); 249 250 mutex_unlock(&xs_state.request_mutex); 251 252 if ((msg->type == XS_TRANSACTION_END) || 253 ((type == XS_TRANSACTION_START) && (msg->type == XS_ERROR))) 254 transaction_end(); 255 256 return ret; 257 } 258 EXPORT_SYMBOL(xenbus_dev_request_and_reply); 259 260 /* Send message to xs, get kmalloc'ed reply. ERR_PTR() on error. */ 261 static void *xs_talkv(struct xenbus_transaction t, 262 enum xsd_sockmsg_type type, 263 const struct kvec *iovec, 264 unsigned int num_vecs, 265 unsigned int *len) 266 { 267 struct xsd_sockmsg msg; 268 void *ret = NULL; 269 unsigned int i; 270 int err; 271 272 msg.tx_id = t.id; 273 msg.req_id = 0; 274 msg.type = type; 275 msg.len = 0; 276 for (i = 0; i < num_vecs; i++) 277 msg.len += iovec[i].iov_len; 278 279 mutex_lock(&xs_state.request_mutex); 280 281 err = xb_write(&msg, sizeof(msg)); 282 if (err) { 283 mutex_unlock(&xs_state.request_mutex); 284 return ERR_PTR(err); 285 } 286 287 for (i = 0; i < num_vecs; i++) { 288 err = xb_write(iovec[i].iov_base, iovec[i].iov_len); 289 if (err) { 290 mutex_unlock(&xs_state.request_mutex); 291 return ERR_PTR(err); 292 } 293 } 294 295 ret = read_reply(&msg.type, len); 296 297 mutex_unlock(&xs_state.request_mutex); 298 299 if (IS_ERR(ret)) 300 return ret; 301 302 if (msg.type == XS_ERROR) { 303 err = get_error(ret); 304 kfree(ret); 305 return ERR_PTR(-err); 306 } 307 308 if (msg.type != type) { 309 pr_warn_ratelimited("unexpected type [%d], expected [%d]\n", 310 msg.type, type); 311 kfree(ret); 312 return ERR_PTR(-EINVAL); 313 } 314 return ret; 315 } 316 317 /* Simplified version of xs_talkv: single message. */ 318 static void *xs_single(struct xenbus_transaction t, 319 enum xsd_sockmsg_type type, 320 const char *string, 321 unsigned int *len) 322 { 323 struct kvec iovec; 324 325 iovec.iov_base = (void *)string; 326 iovec.iov_len = strlen(string) + 1; 327 return xs_talkv(t, type, &iovec, 1, len); 328 } 329 330 /* Many commands only need an ack, don't care what it says. */ 331 static int xs_error(char *reply) 332 { 333 if (IS_ERR(reply)) 334 return PTR_ERR(reply); 335 kfree(reply); 336 return 0; 337 } 338 339 static unsigned int count_strings(const char *strings, unsigned int len) 340 { 341 unsigned int num; 342 const char *p; 343 344 for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1) 345 num++; 346 347 return num; 348 } 349 350 /* Return the path to dir with /name appended. Buffer must be kfree()'ed. */ 351 static char *join(const char *dir, const char *name) 352 { 353 char *buffer; 354 355 if (strlen(name) == 0) 356 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s", dir); 357 else 358 buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/%s", dir, name); 359 return (!buffer) ? ERR_PTR(-ENOMEM) : buffer; 360 } 361 362 static char **split(char *strings, unsigned int len, unsigned int *num) 363 { 364 char *p, **ret; 365 366 /* Count the strings. */ 367 *num = count_strings(strings, len); 368 369 /* Transfer to one big alloc for easy freeing. */ 370 ret = kmalloc(*num * sizeof(char *) + len, GFP_NOIO | __GFP_HIGH); 371 if (!ret) { 372 kfree(strings); 373 return ERR_PTR(-ENOMEM); 374 } 375 memcpy(&ret[*num], strings, len); 376 kfree(strings); 377 378 strings = (char *)&ret[*num]; 379 for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1) 380 ret[(*num)++] = p; 381 382 return ret; 383 } 384 385 char **xenbus_directory(struct xenbus_transaction t, 386 const char *dir, const char *node, unsigned int *num) 387 { 388 char *strings, *path; 389 unsigned int len; 390 391 path = join(dir, node); 392 if (IS_ERR(path)) 393 return (char **)path; 394 395 strings = xs_single(t, XS_DIRECTORY, path, &len); 396 kfree(path); 397 if (IS_ERR(strings)) 398 return (char **)strings; 399 400 return split(strings, len, num); 401 } 402 EXPORT_SYMBOL_GPL(xenbus_directory); 403 404 /* Check if a path exists. Return 1 if it does. */ 405 int xenbus_exists(struct xenbus_transaction t, 406 const char *dir, const char *node) 407 { 408 char **d; 409 int dir_n; 410 411 d = xenbus_directory(t, dir, node, &dir_n); 412 if (IS_ERR(d)) 413 return 0; 414 kfree(d); 415 return 1; 416 } 417 EXPORT_SYMBOL_GPL(xenbus_exists); 418 419 /* Get the value of a single file. 420 * Returns a kmalloced value: call free() on it after use. 421 * len indicates length in bytes. 422 */ 423 void *xenbus_read(struct xenbus_transaction t, 424 const char *dir, const char *node, unsigned int *len) 425 { 426 char *path; 427 void *ret; 428 429 path = join(dir, node); 430 if (IS_ERR(path)) 431 return (void *)path; 432 433 ret = xs_single(t, XS_READ, path, len); 434 kfree(path); 435 return ret; 436 } 437 EXPORT_SYMBOL_GPL(xenbus_read); 438 439 /* Write the value of a single file. 440 * Returns -err on failure. 441 */ 442 int xenbus_write(struct xenbus_transaction t, 443 const char *dir, const char *node, const char *string) 444 { 445 const char *path; 446 struct kvec iovec[2]; 447 int ret; 448 449 path = join(dir, node); 450 if (IS_ERR(path)) 451 return PTR_ERR(path); 452 453 iovec[0].iov_base = (void *)path; 454 iovec[0].iov_len = strlen(path) + 1; 455 iovec[1].iov_base = (void *)string; 456 iovec[1].iov_len = strlen(string); 457 458 ret = xs_error(xs_talkv(t, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL)); 459 kfree(path); 460 return ret; 461 } 462 EXPORT_SYMBOL_GPL(xenbus_write); 463 464 /* Create a new directory. */ 465 int xenbus_mkdir(struct xenbus_transaction t, 466 const char *dir, const char *node) 467 { 468 char *path; 469 int ret; 470 471 path = join(dir, node); 472 if (IS_ERR(path)) 473 return PTR_ERR(path); 474 475 ret = xs_error(xs_single(t, XS_MKDIR, path, NULL)); 476 kfree(path); 477 return ret; 478 } 479 EXPORT_SYMBOL_GPL(xenbus_mkdir); 480 481 /* Destroy a file or directory (directories must be empty). */ 482 int xenbus_rm(struct xenbus_transaction t, const char *dir, const char *node) 483 { 484 char *path; 485 int ret; 486 487 path = join(dir, node); 488 if (IS_ERR(path)) 489 return PTR_ERR(path); 490 491 ret = xs_error(xs_single(t, XS_RM, path, NULL)); 492 kfree(path); 493 return ret; 494 } 495 EXPORT_SYMBOL_GPL(xenbus_rm); 496 497 /* Start a transaction: changes by others will not be seen during this 498 * transaction, and changes will not be visible to others until end. 499 */ 500 int xenbus_transaction_start(struct xenbus_transaction *t) 501 { 502 char *id_str; 503 504 transaction_start(); 505 506 id_str = xs_single(XBT_NIL, XS_TRANSACTION_START, "", NULL); 507 if (IS_ERR(id_str)) { 508 transaction_end(); 509 return PTR_ERR(id_str); 510 } 511 512 t->id = simple_strtoul(id_str, NULL, 0); 513 kfree(id_str); 514 return 0; 515 } 516 EXPORT_SYMBOL_GPL(xenbus_transaction_start); 517 518 /* End a transaction. 519 * If abandon is true, transaction is discarded instead of committed. 520 */ 521 int xenbus_transaction_end(struct xenbus_transaction t, int abort) 522 { 523 char abortstr[2]; 524 int err; 525 526 if (abort) 527 strcpy(abortstr, "F"); 528 else 529 strcpy(abortstr, "T"); 530 531 err = xs_error(xs_single(t, XS_TRANSACTION_END, abortstr, NULL)); 532 533 transaction_end(); 534 535 return err; 536 } 537 EXPORT_SYMBOL_GPL(xenbus_transaction_end); 538 539 /* Single read and scanf: returns -errno or num scanned. */ 540 int xenbus_scanf(struct xenbus_transaction t, 541 const char *dir, const char *node, const char *fmt, ...) 542 { 543 va_list ap; 544 int ret; 545 char *val; 546 547 val = xenbus_read(t, dir, node, NULL); 548 if (IS_ERR(val)) 549 return PTR_ERR(val); 550 551 va_start(ap, fmt); 552 ret = vsscanf(val, fmt, ap); 553 va_end(ap); 554 kfree(val); 555 /* Distinctive errno. */ 556 if (ret == 0) 557 return -ERANGE; 558 return ret; 559 } 560 EXPORT_SYMBOL_GPL(xenbus_scanf); 561 562 /* Single printf and write: returns -errno or 0. */ 563 int xenbus_printf(struct xenbus_transaction t, 564 const char *dir, const char *node, const char *fmt, ...) 565 { 566 va_list ap; 567 int ret; 568 char *buf; 569 570 va_start(ap, fmt); 571 buf = kvasprintf(GFP_NOIO | __GFP_HIGH, fmt, ap); 572 va_end(ap); 573 574 if (!buf) 575 return -ENOMEM; 576 577 ret = xenbus_write(t, dir, node, buf); 578 579 kfree(buf); 580 581 return ret; 582 } 583 EXPORT_SYMBOL_GPL(xenbus_printf); 584 585 /* Takes tuples of names, scanf-style args, and void **, NULL terminated. */ 586 int xenbus_gather(struct xenbus_transaction t, const char *dir, ...) 587 { 588 va_list ap; 589 const char *name; 590 int ret = 0; 591 592 va_start(ap, dir); 593 while (ret == 0 && (name = va_arg(ap, char *)) != NULL) { 594 const char *fmt = va_arg(ap, char *); 595 void *result = va_arg(ap, void *); 596 char *p; 597 598 p = xenbus_read(t, dir, name, NULL); 599 if (IS_ERR(p)) { 600 ret = PTR_ERR(p); 601 break; 602 } 603 if (fmt) { 604 if (sscanf(p, fmt, result) == 0) 605 ret = -EINVAL; 606 kfree(p); 607 } else 608 *(char **)result = p; 609 } 610 va_end(ap); 611 return ret; 612 } 613 EXPORT_SYMBOL_GPL(xenbus_gather); 614 615 static int xs_watch(const char *path, const char *token) 616 { 617 struct kvec iov[2]; 618 619 iov[0].iov_base = (void *)path; 620 iov[0].iov_len = strlen(path) + 1; 621 iov[1].iov_base = (void *)token; 622 iov[1].iov_len = strlen(token) + 1; 623 624 return xs_error(xs_talkv(XBT_NIL, XS_WATCH, iov, 625 ARRAY_SIZE(iov), NULL)); 626 } 627 628 static int xs_unwatch(const char *path, const char *token) 629 { 630 struct kvec iov[2]; 631 632 iov[0].iov_base = (char *)path; 633 iov[0].iov_len = strlen(path) + 1; 634 iov[1].iov_base = (char *)token; 635 iov[1].iov_len = strlen(token) + 1; 636 637 return xs_error(xs_talkv(XBT_NIL, XS_UNWATCH, iov, 638 ARRAY_SIZE(iov), NULL)); 639 } 640 641 static struct xenbus_watch *find_watch(const char *token) 642 { 643 struct xenbus_watch *i, *cmp; 644 645 cmp = (void *)simple_strtoul(token, NULL, 16); 646 647 list_for_each_entry(i, &watches, list) 648 if (i == cmp) 649 return i; 650 651 return NULL; 652 } 653 /* 654 * Certain older XenBus toolstack cannot handle reading values that are 655 * not populated. Some Xen 3.4 installation are incapable of doing this 656 * so if we are running on anything older than 4 do not attempt to read 657 * control/platform-feature-xs_reset_watches. 658 */ 659 static bool xen_strict_xenbus_quirk(void) 660 { 661 #ifdef CONFIG_X86 662 uint32_t eax, ebx, ecx, edx, base; 663 664 base = xen_cpuid_base(); 665 cpuid(base + 1, &eax, &ebx, &ecx, &edx); 666 667 if ((eax >> 16) < 4) 668 return true; 669 #endif 670 return false; 671 672 } 673 static void xs_reset_watches(void) 674 { 675 int err, supported = 0; 676 677 if (!xen_hvm_domain() || xen_initial_domain()) 678 return; 679 680 if (xen_strict_xenbus_quirk()) 681 return; 682 683 err = xenbus_scanf(XBT_NIL, "control", 684 "platform-feature-xs_reset_watches", "%d", &supported); 685 if (err != 1 || !supported) 686 return; 687 688 err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL)); 689 if (err && err != -EEXIST) 690 pr_warn("xs_reset_watches failed: %d\n", err); 691 } 692 693 /* Register callback to watch this node. */ 694 int register_xenbus_watch(struct xenbus_watch *watch) 695 { 696 /* Pointer in ascii is the token. */ 697 char token[sizeof(watch) * 2 + 1]; 698 int err; 699 700 sprintf(token, "%lX", (long)watch); 701 702 down_read(&xs_state.watch_mutex); 703 704 spin_lock(&watches_lock); 705 BUG_ON(find_watch(token)); 706 list_add(&watch->list, &watches); 707 spin_unlock(&watches_lock); 708 709 err = xs_watch(watch->node, token); 710 711 if (err) { 712 spin_lock(&watches_lock); 713 list_del(&watch->list); 714 spin_unlock(&watches_lock); 715 } 716 717 up_read(&xs_state.watch_mutex); 718 719 return err; 720 } 721 EXPORT_SYMBOL_GPL(register_xenbus_watch); 722 723 void unregister_xenbus_watch(struct xenbus_watch *watch) 724 { 725 struct xs_stored_msg *msg, *tmp; 726 char token[sizeof(watch) * 2 + 1]; 727 int err; 728 729 sprintf(token, "%lX", (long)watch); 730 731 down_read(&xs_state.watch_mutex); 732 733 spin_lock(&watches_lock); 734 BUG_ON(!find_watch(token)); 735 list_del(&watch->list); 736 spin_unlock(&watches_lock); 737 738 err = xs_unwatch(watch->node, token); 739 if (err) 740 pr_warn("Failed to release watch %s: %i\n", watch->node, err); 741 742 up_read(&xs_state.watch_mutex); 743 744 /* Make sure there are no callbacks running currently (unless 745 its us) */ 746 if (current->pid != xenwatch_pid) 747 mutex_lock(&xenwatch_mutex); 748 749 /* Cancel pending watch events. */ 750 spin_lock(&watch_events_lock); 751 list_for_each_entry_safe(msg, tmp, &watch_events, list) { 752 if (msg->u.watch.handle != watch) 753 continue; 754 list_del(&msg->list); 755 kfree(msg->u.watch.vec); 756 kfree(msg); 757 } 758 spin_unlock(&watch_events_lock); 759 760 if (current->pid != xenwatch_pid) 761 mutex_unlock(&xenwatch_mutex); 762 } 763 EXPORT_SYMBOL_GPL(unregister_xenbus_watch); 764 765 void xs_suspend(void) 766 { 767 transaction_suspend(); 768 down_write(&xs_state.watch_mutex); 769 mutex_lock(&xs_state.request_mutex); 770 mutex_lock(&xs_state.response_mutex); 771 } 772 773 void xs_resume(void) 774 { 775 struct xenbus_watch *watch; 776 char token[sizeof(watch) * 2 + 1]; 777 778 xb_init_comms(); 779 780 mutex_unlock(&xs_state.response_mutex); 781 mutex_unlock(&xs_state.request_mutex); 782 transaction_resume(); 783 784 /* No need for watches_lock: the watch_mutex is sufficient. */ 785 list_for_each_entry(watch, &watches, list) { 786 sprintf(token, "%lX", (long)watch); 787 xs_watch(watch->node, token); 788 } 789 790 up_write(&xs_state.watch_mutex); 791 } 792 793 void xs_suspend_cancel(void) 794 { 795 mutex_unlock(&xs_state.response_mutex); 796 mutex_unlock(&xs_state.request_mutex); 797 up_write(&xs_state.watch_mutex); 798 mutex_unlock(&xs_state.transaction_mutex); 799 } 800 801 static int xenwatch_thread(void *unused) 802 { 803 struct list_head *ent; 804 struct xs_stored_msg *msg; 805 806 for (;;) { 807 wait_event_interruptible(watch_events_waitq, 808 !list_empty(&watch_events)); 809 810 if (kthread_should_stop()) 811 break; 812 813 mutex_lock(&xenwatch_mutex); 814 815 spin_lock(&watch_events_lock); 816 ent = watch_events.next; 817 if (ent != &watch_events) 818 list_del(ent); 819 spin_unlock(&watch_events_lock); 820 821 if (ent != &watch_events) { 822 msg = list_entry(ent, struct xs_stored_msg, list); 823 msg->u.watch.handle->callback( 824 msg->u.watch.handle, 825 (const char **)msg->u.watch.vec, 826 msg->u.watch.vec_size); 827 kfree(msg->u.watch.vec); 828 kfree(msg); 829 } 830 831 mutex_unlock(&xenwatch_mutex); 832 } 833 834 return 0; 835 } 836 837 static int process_msg(void) 838 { 839 struct xs_stored_msg *msg; 840 char *body; 841 int err; 842 843 /* 844 * We must disallow save/restore while reading a xenstore message. 845 * A partial read across s/r leaves us out of sync with xenstored. 846 */ 847 for (;;) { 848 err = xb_wait_for_data_to_read(); 849 if (err) 850 return err; 851 mutex_lock(&xs_state.response_mutex); 852 if (xb_data_to_read()) 853 break; 854 /* We raced with save/restore: pending data 'disappeared'. */ 855 mutex_unlock(&xs_state.response_mutex); 856 } 857 858 859 msg = kmalloc(sizeof(*msg), GFP_NOIO | __GFP_HIGH); 860 if (msg == NULL) { 861 err = -ENOMEM; 862 goto out; 863 } 864 865 err = xb_read(&msg->hdr, sizeof(msg->hdr)); 866 if (err) { 867 kfree(msg); 868 goto out; 869 } 870 871 if (msg->hdr.len > XENSTORE_PAYLOAD_MAX) { 872 kfree(msg); 873 err = -EINVAL; 874 goto out; 875 } 876 877 body = kmalloc(msg->hdr.len + 1, GFP_NOIO | __GFP_HIGH); 878 if (body == NULL) { 879 kfree(msg); 880 err = -ENOMEM; 881 goto out; 882 } 883 884 err = xb_read(body, msg->hdr.len); 885 if (err) { 886 kfree(body); 887 kfree(msg); 888 goto out; 889 } 890 body[msg->hdr.len] = '\0'; 891 892 if (msg->hdr.type == XS_WATCH_EVENT) { 893 msg->u.watch.vec = split(body, msg->hdr.len, 894 &msg->u.watch.vec_size); 895 if (IS_ERR(msg->u.watch.vec)) { 896 err = PTR_ERR(msg->u.watch.vec); 897 kfree(msg); 898 goto out; 899 } 900 901 spin_lock(&watches_lock); 902 msg->u.watch.handle = find_watch( 903 msg->u.watch.vec[XS_WATCH_TOKEN]); 904 if (msg->u.watch.handle != NULL) { 905 spin_lock(&watch_events_lock); 906 list_add_tail(&msg->list, &watch_events); 907 wake_up(&watch_events_waitq); 908 spin_unlock(&watch_events_lock); 909 } else { 910 kfree(msg->u.watch.vec); 911 kfree(msg); 912 } 913 spin_unlock(&watches_lock); 914 } else { 915 msg->u.reply.body = body; 916 spin_lock(&xs_state.reply_lock); 917 list_add_tail(&msg->list, &xs_state.reply_list); 918 spin_unlock(&xs_state.reply_lock); 919 wake_up(&xs_state.reply_waitq); 920 } 921 922 out: 923 mutex_unlock(&xs_state.response_mutex); 924 return err; 925 } 926 927 static int xenbus_thread(void *unused) 928 { 929 int err; 930 931 for (;;) { 932 err = process_msg(); 933 if (err) 934 pr_warn("error %d while reading message\n", err); 935 if (kthread_should_stop()) 936 break; 937 } 938 939 return 0; 940 } 941 942 int xs_init(void) 943 { 944 int err; 945 struct task_struct *task; 946 947 INIT_LIST_HEAD(&xs_state.reply_list); 948 spin_lock_init(&xs_state.reply_lock); 949 init_waitqueue_head(&xs_state.reply_waitq); 950 951 mutex_init(&xs_state.request_mutex); 952 mutex_init(&xs_state.response_mutex); 953 mutex_init(&xs_state.transaction_mutex); 954 init_rwsem(&xs_state.watch_mutex); 955 atomic_set(&xs_state.transaction_count, 0); 956 init_waitqueue_head(&xs_state.transaction_wq); 957 958 /* Initialize the shared memory rings to talk to xenstored */ 959 err = xb_init_comms(); 960 if (err) 961 return err; 962 963 task = kthread_run(xenwatch_thread, NULL, "xenwatch"); 964 if (IS_ERR(task)) 965 return PTR_ERR(task); 966 xenwatch_pid = task->pid; 967 968 task = kthread_run(xenbus_thread, NULL, "xenbus"); 969 if (IS_ERR(task)) 970 return PTR_ERR(task); 971 972 /* shutdown watches for kexec boot */ 973 xs_reset_watches(); 974 975 return 0; 976 } 977