drivers/xen/xenbus/xenbus_comms.c

   1 /******************************************************************************
   2  * xenbus_comms.c
   3  *
   4  * Low level code to talks to Xen Store: ringbuffer and event channel.
   5  *
   6  * Copyright (C) 2005 Rusty Russell, IBM Corporation
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version 2
  10  * as published by the Free Software Foundation; or, when distributed
  11  * separately from the Linux kernel or incorporated into other
  12  * software packages, subject to the following license:
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a copy
  15  * of this source file (the "Software"), to deal in the Software without
  16  * restriction, including without limitation the rights to use, copy, modify,
  17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  18  * and to permit persons to whom the Software is furnished to do so, subject to
  19  * the following conditions:
  20  *
  21  * The above copyright notice and this permission notice shall be included in
  22  * all copies or substantial portions of the Software.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  30  * IN THE SOFTWARE.
  31  */
  32
  33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  34
  35 #include <linux/wait.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/kthread.h>
  38 #include <linux/sched.h>
  39 #include <linux/err.h>
  40 #include <xen/xenbus.h>
  41 #include <asm/xen/hypervisor.h>
  42 #include <xen/events.h>
  43 #include <xen/page.h>
  44 #include "xenbus.h"
  45
  46 /* A list of replies. Currently only one will ever be outstanding. */
  47 LIST_HEAD(xs_reply_list);
  48
  49 /* A list of write requests. */
  50 LIST_HEAD(xb_write_list);
  51 DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
  52 DEFINE_MUTEX(xb_write_mutex);
  53
  54 /* Protect xenbus reader thread against save/restore. */
  55 DEFINE_MUTEX(xs_response_mutex);
  56
  57 static int xenbus_irq;
  58 static struct task_struct *xenbus_task;
  59
  60 static DECLARE_WORK(probe_work, xenbus_probe);
  61
  62
  63 static irqreturn_t wake_waiting(int irq, void *unused)
  64 {
  65         if (unlikely(xenstored_ready == 0)) {
  66                 xenstored_ready = 1;
  67                 schedule_work(&probe_work);
  68         }
  69
  70         wake_up(&xb_waitq);
  71         return IRQ_HANDLED;
  72 }
  73
  74 static int check_indexes(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod)
  75 {
  76         return ((prod - cons) <= XENSTORE_RING_SIZE);
  77 }
  78
  79 static void *get_output_chunk(XENSTORE_RING_IDX cons,
  80                               XENSTORE_RING_IDX prod,
  81                               char *buf, uint32_t *len)
  82 {
  83         *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod);
  84         if ((XENSTORE_RING_SIZE - (prod - cons)) < *len)
  85                 *len = XENSTORE_RING_SIZE - (prod - cons);
  86         return buf + MASK_XENSTORE_IDX(prod);
  87 }
  88
  89 static const void *get_input_chunk(XENSTORE_RING_IDX cons,
  90                                    XENSTORE_RING_IDX prod,
  91                                    const char *buf, uint32_t *len)
  92 {
  93         *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(cons);
  94         if ((prod - cons) < *len)
  95                 *len = prod - cons;
  96         return buf + MASK_XENSTORE_IDX(cons);
  97 }
  98
  99 static int xb_data_to_write(void)
 100 {
 101         struct xenstore_domain_interface *intf = xen_store_interface;
 102
 103         return (intf->req_prod - intf->req_cons) != XENSTORE_RING_SIZE &&
 104                 !list_empty(&xb_write_list);
 105 }
 106
 107 /**
 108  * xb_write - low level write
 109  * @data: buffer to send
 110  * @len: length of buffer
 111  *
 112  * Returns number of bytes written or -err.
 113  */
 114 static int xb_write(const void *data, unsigned int len)
 115 {
 116         struct xenstore_domain_interface *intf = xen_store_interface;
 117         XENSTORE_RING_IDX cons, prod;
 118         unsigned int bytes = 0;
 119
 120         while (len != 0) {
 121                 void *dst;
 122                 unsigned int avail;
 123
 124                 /* Read indexes, then verify. */
 125                 cons = intf->req_cons;
 126                 prod = intf->req_prod;
 127                 if (!check_indexes(cons, prod)) {
 128                         intf->req_cons = intf->req_prod = 0;
 129                         return -EIO;
 130                 }
 131                 if (!xb_data_to_write())
 132                         return bytes;
 133
 134                 /* Must write data /after/ reading the consumer index. */
 135                 virt_mb();
 136
 137                 dst = get_output_chunk(cons, prod, intf->req, &avail);
 138                 if (avail == 0)
 139                         continue;
 140                 if (avail > len)
 141                         avail = len;
 142
 143                 memcpy(dst, data, avail);
 144                 data += avail;
 145                 len -= avail;
 146                 bytes += avail;
 147
 148                 /* Other side must not see new producer until data is there. */
 149                 virt_wmb();
 150                 intf->req_prod += avail;
 151
 152                 /* Implies mb(): other side will see the updated producer. */
 153                 if (prod <= intf->req_cons)
 154                         notify_remote_via_evtchn(xen_store_evtchn);
 155         }
 156
 157         return bytes;
 158 }
 159
 160 static int xb_data_to_read(void)
 161 {
 162         struct xenstore_domain_interface *intf = xen_store_interface;
 163         return (intf->rsp_cons != intf->rsp_prod);
 164 }
 165
 166 static int xb_read(void *data, unsigned int len)
 167 {
 168         struct xenstore_domain_interface *intf = xen_store_interface;
 169         XENSTORE_RING_IDX cons, prod;
 170         unsigned int bytes = 0;
 171
 172         while (len != 0) {
 173                 unsigned int avail;
 174                 const char *src;
 175
 176                 /* Read indexes, then verify. */
 177                 cons = intf->rsp_cons;
 178                 prod = intf->rsp_prod;
 179                 if (cons == prod)
 180                         return bytes;
 181
 182                 if (!check_indexes(cons, prod)) {
 183                         intf->rsp_cons = intf->rsp_prod = 0;
 184                         return -EIO;
 185                 }
 186
 187                 src = get_input_chunk(cons, prod, intf->rsp, &avail);
 188                 if (avail == 0)
 189                         continue;
 190                 if (avail > len)
 191                         avail = len;
 192
 193                 /* Must read data /after/ reading the producer index. */
 194                 virt_rmb();
 195
 196                 memcpy(data, src, avail);
 197                 data += avail;
 198                 len -= avail;
 199                 bytes += avail;
 200
 201                 /* Other side must not see free space until we've copied out */
 202                 virt_mb();
 203                 intf->rsp_cons += avail;
 204
 205                 /* Implies mb(): other side will see the updated consumer. */
 206                 if (intf->rsp_prod - cons >= XENSTORE_RING_SIZE)
 207                         notify_remote_via_evtchn(xen_store_evtchn);
 208         }
 209
 210         return bytes;
 211 }
 212
 213 static int process_msg(void)
 214 {
 215         static struct {
 216                 struct xsd_sockmsg msg;
 217                 char *body;
 218                 union {
 219                         void *alloc;
 220                         struct xs_watch_event *watch;
 221                 };
 222                 bool in_msg;
 223                 bool in_hdr;
 224                 unsigned int read;
 225         } state;
 226         struct xb_req_data *req;
 227         int err;
 228         unsigned int len;
 229
 230         if (!state.in_msg) {
 231                 state.in_msg = true;
 232                 state.in_hdr = true;
 233                 state.read = 0;
 234
 235                 /*
 236                  * We must disallow save/restore while reading a message.
 237                  * A partial read across s/r leaves us out of sync with
 238                  * xenstored.
 239                  * xs_response_mutex is locked as long as we are processing one
 240                  * message. state.in_msg will be true as long as we are holding
 241                  * the lock here.
 242                  */
 243                 mutex_lock(&xs_response_mutex);
 244
 245                 if (!xb_data_to_read()) {
 246                         /* We raced with save/restore: pending data 'gone'. */
 247                         mutex_unlock(&xs_response_mutex);
 248                         state.in_msg = false;
 249                         return 0;
 250                 }
 251         }
 252
 253         if (state.in_hdr) {
 254                 if (state.read != sizeof(state.msg)) {
 255                         err = xb_read((void *)&state.msg + state.read,
 256                                       sizeof(state.msg) - state.read);
 257                         if (err < 0)
 258                                 goto out;
 259                         state.read += err;
 260                         if (state.read != sizeof(state.msg))
 261                                 return 0;
 262                         if (state.msg.len > XENSTORE_PAYLOAD_MAX) {
 263                                 err = -EINVAL;
 264                                 goto out;
 265                         }
 266                 }
 267
 268                 len = state.msg.len + 1;
 269                 if (state.msg.type == XS_WATCH_EVENT)
 270                         len += sizeof(*state.watch);
 271
 272                 state.alloc = kmalloc(len, GFP_NOIO | __GFP_HIGH);
 273                 if (!state.alloc)
 274                         return -ENOMEM;
 275
 276                 if (state.msg.type == XS_WATCH_EVENT)
 277                         state.body = state.watch->body;
 278                 else
 279                         state.body = state.alloc;
 280                 state.in_hdr = false;
 281                 state.read = 0;
 282         }
 283
 284         err = xb_read(state.body + state.read, state.msg.len - state.read);
 285         if (err < 0)
 286                 goto out;
 287
 288         state.read += err;
 289         if (state.read != state.msg.len)
 290                 return 0;
 291
 292         state.body[state.msg.len] = '\0';
 293
 294         if (state.msg.type == XS_WATCH_EVENT) {
 295                 state.watch->len = state.msg.len;
 296                 err = xs_watch_msg(state.watch);
 297         } else {
 298                 err = -ENOENT;
 299                 mutex_lock(&xb_write_mutex);
 300                 list_for_each_entry(req, &xs_reply_list, list) {
 301                         if (req->msg.req_id == state.msg.req_id) {
 302                                 list_del(&req->list);
 303                                 err = 0;
 304                                 break;
 305                         }
 306                 }
 307                 mutex_unlock(&xb_write_mutex);
 308                 if (err)
 309                         goto out;
 310
 311                 if (req->state == xb_req_state_wait_reply) {
 312                         req->msg.type = state.msg.type;
 313                         req->msg.len = state.msg.len;
 314                         req->body = state.body;
 315                         req->state = xb_req_state_got_reply;
 316                         req->cb(req);
 317                 } else
 318                         kfree(req);
 319         }
 320
 321         mutex_unlock(&xs_response_mutex);
 322
 323         state.in_msg = false;
 324         state.alloc = NULL;
 325         return err;
 326
 327  out:
 328         mutex_unlock(&xs_response_mutex);
 329         state.in_msg = false;
 330         kfree(state.alloc);
 331         state.alloc = NULL;
 332         return err;
 333 }
 334
 335 static int process_writes(void)
 336 {
 337         static struct {
 338                 struct xb_req_data *req;
 339                 int idx;
 340                 unsigned int written;
 341         } state;
 342         void *base;
 343         unsigned int len;
 344         int err = 0;
 345
 346         if (!xb_data_to_write())
 347                 return 0;
 348
 349         mutex_lock(&xb_write_mutex);
 350
 351         if (!state.req) {
 352                 state.req = list_first_entry(&xb_write_list,
 353                                              struct xb_req_data, list);
 354                 state.idx = -1;
 355                 state.written = 0;
 356         }
 357
 358         if (state.req->state == xb_req_state_aborted)
 359                 goto out_err;
 360
 361         while (state.idx < state.req->num_vecs) {
 362                 if (state.idx < 0) {
 363                         base = &state.req->msg;
 364                         len = sizeof(state.req->msg);
 365                 } else {
 366                         base = state.req->vec[state.idx].iov_base;
 367                         len = state.req->vec[state.idx].iov_len;
 368                 }
 369                 err = xb_write(base + state.written, len - state.written);
 370                 if (err < 0)
 371                         goto out_err;
 372                 state.written += err;
 373                 if (state.written != len)
 374                         goto out;
 375
 376                 state.idx++;
 377                 state.written = 0;
 378         }
 379
 380         list_del(&state.req->list);
 381         state.req->state = xb_req_state_wait_reply;
 382         list_add_tail(&state.req->list, &xs_reply_list);
 383         state.req = NULL;
 384
 385  out:
 386         mutex_unlock(&xb_write_mutex);
 387
 388         return 0;
 389
 390  out_err:
 391         state.req->msg.type = XS_ERROR;
 392         state.req->err = err;
 393         list_del(&state.req->list);
 394         if (state.req->state == xb_req_state_aborted)
 395                 kfree(state.req);
 396         else {
 397                 state.req->state = xb_req_state_got_reply;
 398                 wake_up(&state.req->wq);
 399         }
 400
 401         mutex_unlock(&xb_write_mutex);
 402
 403         state.req = NULL;
 404
 405         return err;
 406 }
 407
 408 static int xb_thread_work(void)
 409 {
 410         return xb_data_to_read() || xb_data_to_write();
 411 }
 412
 413 static int xenbus_thread(void *unused)
 414 {
 415         int err;
 416
 417         while (!kthread_should_stop()) {
 418                 if (wait_event_interruptible(xb_waitq, xb_thread_work()))
 419                         continue;
 420
 421                 err = process_msg();
 422                 if (err == -ENOMEM)
 423                         schedule();
 424                 else if (err)
 425                         pr_warn_ratelimited("error %d while reading message\n",
 426                                             err);
 427
 428                 err = process_writes();
 429                 if (err)
 430                         pr_warn_ratelimited("error %d while writing message\n",
 431                                             err);
 432         }
 433
 434         xenbus_task = NULL;
 435         return 0;
 436 }
 437
 438 /**
 439  * xb_init_comms - Set up interrupt handler off store event channel.
 440  */
 441 int xb_init_comms(void)
 442 {
 443         struct xenstore_domain_interface *intf = xen_store_interface;
 444
 445         if (intf->req_prod != intf->req_cons)
 446                 pr_err("request ring is not quiescent (%08x:%08x)!\n",
 447                        intf->req_cons, intf->req_prod);
 448
 449         if (intf->rsp_prod != intf->rsp_cons) {
 450                 pr_warn("response ring is not quiescent (%08x:%08x): fixing up\n",
 451                         intf->rsp_cons, intf->rsp_prod);
 452                 /* breaks kdump */
 453                 if (!reset_devices)
 454                         intf->rsp_cons = intf->rsp_prod;
 455         }
 456
 457         if (xenbus_irq) {
 458                 /* Already have an irq; assume we're resuming */
 459                 rebind_evtchn_irq(xen_store_evtchn, xenbus_irq);
 460         } else {
 461                 int err;
 462
 463                 err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
 464                                                 0, "xenbus", &xb_waitq);
 465                 if (err < 0) {
 466                         pr_err("request irq failed %i\n", err);
 467                         return err;
 468                 }
 469
 470                 xenbus_irq = err;
 471
 472                 if (!xenbus_task) {
 473                         xenbus_task = kthread_run(xenbus_thread, NULL,
 474                                                   "xenbus");
 475                         if (IS_ERR(xenbus_task))
 476                                 return PTR_ERR(xenbus_task);
 477                 }
 478         }
 479
 480         return 0;
 481 }
 482
 483 void xb_deinit_comms(void)
 484 {
 485         unbind_from_irqhandler(xenbus_irq, &xb_waitq);
 486         xenbus_irq = 0;
 487 }