sys/dev/xen/xenstore/xenstore_dev.c

   1 /*
   2  * xenstore_dev.c
   3  *
   4  * Driver giving user-space access to the kernel's connection to the
   5  * XenStore service.
   6  *
   7  * Copyright (c) 2005, Christian Limpach
   8  * Copyright (c) 2005, Rusty Russell, IBM Corporation
   9  *
  10  * This file may be distributed separately from the Linux kernel, or
  11  * incorporated into other software packages, subject to the following license:
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a copy
  14  * of this source file (the "Software"), to deal in the Software without
  15  * restriction, including without limitation the rights to use, copy, modify,
  16  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  17  * and to permit persons to whom the Software is furnished to do so, subject to
  18  * the following conditions:
  19  *
  20  * The above copyright notice and this permission notice shall be included in
  21  * all copies or substantial portions of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  26  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  27  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  28  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  29  * IN THE SOFTWARE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/types.h>
  36 #include <sys/cdefs.h>
  37 #include <sys/errno.h>
  38 #include <sys/uio.h>
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/proc.h>
  42 #include <sys/kernel.h>
  43 #include <sys/malloc.h>
  44 #include <sys/conf.h>
  45 #include <sys/module.h>
  46 #include <sys/selinfo.h>
  47 #include <sys/sysctl.h>
  48 #include <sys/poll.h>
  49
  50 #include <xen/xen-os.h>
  51
  52 #include <xen/hypervisor.h>
  53 #include <xen/xenstore/xenstorevar.h>
  54 #include <xen/xenstore/xenstore_internal.h>
  55
  56 static unsigned int max_pending_watches = 1000;
  57
  58 struct xs_dev_transaction {
  59         LIST_ENTRY(xs_dev_transaction) list;
  60         struct xs_transaction handle;
  61 };
  62
  63 struct xs_dev_watch {
  64         LIST_ENTRY(xs_dev_watch) list;
  65         struct xs_watch watch;
  66         char *token;
  67         struct xs_dev_data *user;
  68 };
  69
  70 struct xs_dev_data {
  71         /* In-progress transaction. */
  72         LIST_HEAD(, xs_dev_transaction) transactions;
  73
  74         /* Active watches. */
  75         LIST_HEAD(, xs_dev_watch) watches;
  76
  77         /* Partial request. */
  78         unsigned int len;
  79         union {
  80                 struct xsd_sockmsg msg;
  81                 char buffer[PAGE_SIZE];
  82         } u;
  83
  84         /* Response queue. */
  85 #define MASK_READ_IDX(idx) ((idx)&(PAGE_SIZE-1))
  86         char read_buffer[PAGE_SIZE];
  87         unsigned int read_cons, read_prod;
  88
  89         /* Serializes writes to the read buffer. */
  90         struct mtx lock;
  91
  92         /* Polling structure (for reads only ATM). */
  93         struct selinfo ev_rsel;
  94 };
  95
  96 static void
  97 xs_queue_reply(struct xs_dev_data *u, const char *data, unsigned int len)
  98 {
  99         unsigned int i;
 100
 101         for (i = 0; i < len; i++, u->read_prod++)
 102                 u->read_buffer[MASK_READ_IDX(u->read_prod)] = data[i];
 103
 104         KASSERT((u->read_prod - u->read_cons) <= sizeof(u->read_buffer),
 105             ("xenstore reply too big"));
 106
 107         wakeup(u);
 108         selwakeup(&u->ev_rsel);
 109 }
 110
 111 static const char *
 112 xs_dev_error_to_string(int error)
 113 {
 114         unsigned int i;
 115
 116         for (i = 0; i < nitems(xsd_errors); i++)
 117                 if (xsd_errors[i].errnum == error)
 118                         return (xsd_errors[i].errstring);
 119
 120         return (NULL);
 121 }
 122
 123 static void
 124 xs_dev_return_error(struct xs_dev_data *u, int error, int req_id, int tx_id)
 125 {
 126         struct xsd_sockmsg msg;
 127         const char *payload;
 128
 129         msg.type = XS_ERROR;
 130         msg.req_id = req_id;
 131         msg.tx_id = tx_id;
 132         payload = NULL;
 133
 134         payload = xs_dev_error_to_string(error);
 135         if (payload == NULL)
 136                 payload = xs_dev_error_to_string(EINVAL);
 137         KASSERT(payload != NULL, ("Unable to find string for EINVAL errno"));
 138
 139         msg.len = strlen(payload) + 1;
 140
 141         mtx_lock(&u->lock);
 142         xs_queue_reply(u, (char *)&msg, sizeof(msg));
 143         xs_queue_reply(u, payload, msg.len);
 144         mtx_unlock(&u->lock);
 145 }
 146
 147 static int
 148 xs_dev_watch_message_parse_string(const char **p, const char *end,
 149     const char **string_r)
 150 {
 151         const char *nul;
 152
 153         nul = memchr(*p, 0, end - *p);
 154         if (!nul)
 155                 return (EINVAL);
 156
 157         *string_r = *p;
 158         *p = nul+1;
 159
 160         return (0);
 161 }
 162
 163 static int
 164 xs_dev_watch_message_parse(const struct xsd_sockmsg *msg, const char **path_r,
 165     const char **token_r)
 166 {
 167         const char *p, *end;
 168         int error;
 169
 170         p = (const char *)msg + sizeof(*msg);
 171         end = p + msg->len;
 172         KASSERT(p <= end, ("payload overflow"));
 173
 174         error = xs_dev_watch_message_parse_string(&p, end, path_r);
 175         if (error)
 176                 return (error);
 177         error = xs_dev_watch_message_parse_string(&p, end, token_r);
 178         if (error)
 179                 return (error);
 180
 181         return (0);
 182 }
 183
 184 static struct xs_dev_watch *
 185 xs_dev_find_watch(struct xs_dev_data *u, const char *token)
 186 {
 187         struct xs_dev_watch *watch;
 188
 189         LIST_FOREACH(watch, &u->watches, list)
 190                 if (strcmp(watch->token, token) == 0)
 191                         return (watch);
 192
 193         return (NULL);
 194 }
 195
 196 static void
 197 xs_dev_watch_cb(struct xs_watch *watch, const char **vec, unsigned int len)
 198 {
 199         struct xs_dev_watch *dwatch;
 200         struct xsd_sockmsg msg;
 201         char *payload;
 202
 203         dwatch = (struct xs_dev_watch *)watch->callback_data;
 204         msg.type = XS_WATCH_EVENT;
 205         msg.req_id = msg.tx_id = 0;
 206         msg.len = strlen(vec[XS_WATCH_PATH]) + strlen(dwatch->token) + 2;
 207
 208         payload = malloc(msg.len, M_XENSTORE, M_WAITOK);
 209         strcpy(payload, vec[XS_WATCH_PATH]);
 210         strcpy(&payload[strlen(vec[XS_WATCH_PATH]) + 1], dwatch->token);
 211         mtx_lock(&dwatch->user->lock);
 212         xs_queue_reply(dwatch->user, (char *)&msg, sizeof(msg));
 213         xs_queue_reply(dwatch->user, payload, msg.len);
 214         mtx_unlock(&dwatch->user->lock);
 215         free(payload, M_XENSTORE);
 216 }
 217
 218 static struct xs_dev_transaction *
 219 xs_dev_find_transaction(struct xs_dev_data *u, uint32_t tx_id)
 220 {
 221         struct xs_dev_transaction *trans;
 222
 223         LIST_FOREACH(trans, &u->transactions, list)
 224                 if (trans->handle.id == tx_id)
 225                         return (trans);
 226
 227         return (NULL);
 228 }
 229
 230 static int
 231 xs_dev_read(struct cdev *dev, struct uio *uio, int ioflag)
 232 {
 233         int error;
 234         struct xs_dev_data *u;
 235
 236         error = devfs_get_cdevpriv((void **)&u);
 237         if (error != 0)
 238                 return (error);
 239
 240         while (u->read_prod == u->read_cons) {
 241                 error = tsleep(u, PCATCH, "xsdread", hz/10);
 242                 if (error && error != EWOULDBLOCK)
 243                         return (error);
 244         }
 245
 246         while (uio->uio_resid > 0) {
 247                 if (u->read_cons == u->read_prod)
 248                         break;
 249                 error = uiomove(&u->read_buffer[MASK_READ_IDX(u->read_cons)],
 250                     1, uio);
 251                 if (error)
 252                         return (error);
 253                 u->read_cons++;
 254         }
 255         return (0);
 256 }
 257
 258 static int
 259 xs_dev_write(struct cdev *dev, struct uio *uio, int ioflag)
 260 {
 261         int error;
 262         const char *wpath, *wtoken;
 263         struct xs_dev_data *u;
 264         struct xs_dev_transaction *trans;
 265         struct xs_dev_watch *watch;
 266         void *reply;
 267         static const char *ok = "OK";
 268         int len = uio->uio_resid;
 269
 270         error = devfs_get_cdevpriv((void **)&u);
 271         if (error != 0)
 272                 return (error);
 273
 274         if ((len + u->len) > sizeof(u->u.buffer))
 275                 return (EINVAL);
 276
 277         error = uiomove(u->u.buffer + u->len, len, uio);
 278         if (error)
 279                 return (error);
 280
 281         u->len += len;
 282         if (u->len < (sizeof(u->u.msg) + u->u.msg.len))
 283                 return (0);
 284
 285         switch (u->u.msg.type) {
 286         case XS_TRANSACTION_START:
 287         case XS_TRANSACTION_END:
 288         case XS_DIRECTORY:
 289         case XS_READ:
 290         case XS_GET_PERMS:
 291         case XS_RELEASE:
 292         case XS_GET_DOMAIN_PATH:
 293         case XS_WRITE:
 294         case XS_MKDIR:
 295         case XS_RM:
 296         case XS_SET_PERMS:
 297                 /* Check that this transaction id is not hijacked. */
 298                 if (u->u.msg.tx_id != 0 &&
 299                     xs_dev_find_transaction(u, u->u.msg.tx_id) == NULL) {
 300                         error = EINVAL;
 301                         break;
 302                 }
 303                 error = xs_dev_request_and_reply(&u->u.msg, &reply);
 304                 if (!error) {
 305                         if (u->u.msg.type == XS_TRANSACTION_START) {
 306                                 trans = malloc(sizeof(*trans), M_XENSTORE,
 307                                     M_WAITOK);
 308                                 trans->handle.id = strtoul(reply, NULL, 0);
 309                                 LIST_INSERT_HEAD(&u->transactions, trans, list);
 310                         } else if (u->u.msg.type == XS_TRANSACTION_END) {
 311                                 trans = xs_dev_find_transaction(u,
 312                                     u->u.msg.tx_id);
 313                                 KASSERT(trans != NULL,
 314                                     ("Unable to find transaction"));
 315                                 LIST_REMOVE(trans, list);
 316                                 free(trans, M_XENSTORE);
 317                         }
 318                         mtx_lock(&u->lock);
 319                         xs_queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
 320                         xs_queue_reply(u, (char *)reply, u->u.msg.len);
 321                         mtx_unlock(&u->lock);
 322                         free(reply, M_XENSTORE);
 323                 }
 324                 break;
 325         case XS_WATCH:
 326                 u->u.msg.tx_id = 0;
 327                 error = xs_dev_watch_message_parse(&u->u.msg, &wpath, &wtoken);
 328                 if (error)
 329                         break;
 330                 if (xs_dev_find_watch(u, wtoken) != NULL) {
 331                         error = EINVAL;
 332                         break;
 333                 }
 334
 335                 watch = malloc(sizeof(*watch), M_XENSTORE, M_WAITOK);
 336                 watch->watch.node = strdup(wpath, M_XENSTORE);
 337                 watch->watch.callback = xs_dev_watch_cb;
 338                 watch->watch.callback_data = (uintptr_t)watch;
 339                 watch->watch.max_pending = max_pending_watches;
 340                 watch->token = strdup(wtoken, M_XENSTORE);
 341                 watch->user = u;
 342
 343                 error = xs_register_watch(&watch->watch);
 344                 if (error != 0) {
 345                         free(watch->token, M_XENSTORE);
 346                         free(watch->watch.node, M_XENSTORE);
 347                         free(watch, M_XENSTORE);
 348                         break;
 349                 }
 350
 351                 LIST_INSERT_HEAD(&u->watches, watch, list);
 352                 u->u.msg.len = sizeof(ok);
 353                 mtx_lock(&u->lock);
 354                 xs_queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
 355                 xs_queue_reply(u, ok, sizeof(ok));
 356                 mtx_unlock(&u->lock);
 357                 break;
 358         case XS_UNWATCH:
 359                 u->u.msg.tx_id = 0;
 360                 error = xs_dev_watch_message_parse(&u->u.msg, &wpath, &wtoken);
 361                 if (error)
 362                         break;
 363                 watch = xs_dev_find_watch(u, wtoken);
 364                 if (watch == NULL) {
 365                         error = EINVAL;
 366                         break;
 367                 }
 368
 369                 LIST_REMOVE(watch, list);
 370                 xs_unregister_watch(&watch->watch);
 371                 free(watch->watch.node, M_XENSTORE);
 372                 free(watch->token, M_XENSTORE);
 373                 free(watch, M_XENSTORE);
 374                 u->u.msg.len = sizeof(ok);
 375                 mtx_lock(&u->lock);
 376                 xs_queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
 377                 xs_queue_reply(u, ok, sizeof(ok));
 378                 mtx_unlock(&u->lock);
 379                 break;
 380         default:
 381                 error = EINVAL;
 382                 break;
 383         }
 384
 385         if (error != 0)
 386                 xs_dev_return_error(u, error, u->u.msg.req_id, u->u.msg.tx_id);
 387
 388         /* Reset the write buffer. */
 389         u->len = 0;
 390
 391         return (0);
 392 }
 393
 394 static int
 395 xs_dev_poll(struct cdev *dev, int events, struct thread *td)
 396 {
 397         struct xs_dev_data *u;
 398         int error, mask;
 399
 400         error = devfs_get_cdevpriv((void **)&u);
 401         if (error != 0)
 402                 return (POLLERR);
 403
 404         /* we can always write */
 405         mask = events & (POLLOUT | POLLWRNORM);
 406
 407         if (events & (POLLIN | POLLRDNORM)) {
 408                 if (u->read_cons != u->read_prod) {
 409                         mask |= events & (POLLIN | POLLRDNORM);
 410                 } else {
 411                         /* Record that someone is waiting */
 412                         selrecord(td, &u->ev_rsel);
 413                 }
 414         }
 415
 416         return (mask);
 417 }
 418
 419 static void
 420 xs_dev_dtor(void *arg)
 421 {
 422         struct xs_dev_data *u = arg;
 423         struct xs_dev_transaction *trans, *tmpt;
 424         struct xs_dev_watch *watch, *tmpw;
 425
 426         seldrain(&u->ev_rsel);
 427
 428         LIST_FOREACH_SAFE(trans, &u->transactions, list, tmpt) {
 429                 xs_transaction_end(trans->handle, 1);
 430                 LIST_REMOVE(trans, list);
 431                 free(trans, M_XENSTORE);
 432         }
 433
 434         LIST_FOREACH_SAFE(watch, &u->watches, list, tmpw) {
 435                 LIST_REMOVE(watch, list);
 436                 xs_unregister_watch(&watch->watch);
 437                 free(watch->watch.node, M_XENSTORE);
 438                 free(watch->token, M_XENSTORE);
 439                 free(watch, M_XENSTORE);
 440         }
 441         mtx_destroy(&u->lock);
 442
 443         free(u, M_XENSTORE);
 444 }
 445
 446 static int
 447 xs_dev_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 448 {
 449         struct xs_dev_data *u;
 450         int error;
 451
 452         u = malloc(sizeof(*u), M_XENSTORE, M_WAITOK|M_ZERO);
 453         mtx_init(&u->lock, "xsdev_lock", NULL, MTX_DEF);
 454         LIST_INIT(&u->transactions);
 455         LIST_INIT(&u->watches);
 456         error = devfs_set_cdevpriv(u, xs_dev_dtor);
 457         if (error != 0)
 458                 free(u, M_XENSTORE);
 459
 460         return (error);
 461 }
 462
 463 static struct cdevsw xs_dev_cdevsw = {
 464         .d_version = D_VERSION,
 465         .d_read = xs_dev_read,
 466         .d_write = xs_dev_write,
 467         .d_open = xs_dev_open,
 468         .d_poll = xs_dev_poll,
 469         .d_name = "xs_dev",
 470 };
 471
 472 /*------------------ Private Device Attachment Functions  --------------------*/
 473 /**
 474  * \brief Identify instances of this device type in the system.
 475  *
 476  * \param driver  The driver performing this identify action.
 477  * \param parent  The NewBus parent device for any devices this method adds.
 478  */
 479 static void
 480 xs_dev_identify(driver_t *driver __unused, device_t parent)
 481 {
 482         /*
 483          * A single device instance for our driver is always present
 484          * in a system operating under Xen.
 485          */
 486         BUS_ADD_CHILD(parent, 0, driver->name, 0);
 487 }
 488
 489 /**
 490  * \brief Probe for the existence of the Xenstore device
 491  *
 492  * \param dev  NewBus device_t for this instance.
 493  *
 494  * \return  Always returns 0 indicating success.
 495  */
 496 static int
 497 xs_dev_probe(device_t dev)
 498 {
 499
 500         device_set_desc(dev, "Xenstore user-space device");
 501         return (0);
 502 }
 503
 504 /**
 505  * \brief Attach the Xenstore device.
 506  *
 507  * \param dev  NewBus device_t for this instance.
 508  *
 509  * \return  On success, 0. Otherwise an errno value indicating the
 510  *          type of failure.
 511  */
 512 static int
 513 xs_dev_attach(device_t dev)
 514 {
 515         struct cdev *xs_cdev;
 516         struct sysctl_ctx_list *sysctl_ctx;
 517         struct sysctl_oid *sysctl_tree;
 518
 519         sysctl_ctx = device_get_sysctl_ctx(dev);
 520         sysctl_tree = device_get_sysctl_tree(dev);
 521         if (sysctl_ctx == NULL || sysctl_tree == NULL)
 522             return (EINVAL);
 523
 524         SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
 525             "max_pending_watch_events", CTLFLAG_RW, &max_pending_watches, 0,
 526             "maximum amount of pending watch events to be delivered");
 527
 528         xs_cdev = make_dev_credf(MAKEDEV_ETERNAL, &xs_dev_cdevsw, 0, NULL,
 529             UID_ROOT, GID_WHEEL, 0400, "xen/xenstore");
 530         if (xs_cdev == NULL)
 531                 return (EINVAL);
 532
 533         return (0);
 534 }
 535
 536 /*-------------------- Private Device Attachment Data  -----------------------*/
 537 static device_method_t xs_dev_methods[] = {
 538         /* Device interface */
 539         DEVMETHOD(device_identify,      xs_dev_identify),
 540         DEVMETHOD(device_probe,         xs_dev_probe),
 541         DEVMETHOD(device_attach,        xs_dev_attach),
 542
 543         DEVMETHOD_END
 544 };
 545
 546 DEFINE_CLASS_0(xs_dev, xs_dev_driver, xs_dev_methods, 0);
 547 devclass_t xs_dev_devclass;
 548
 549 DRIVER_MODULE(xs_dev, xenstore, xs_dev_driver, xs_dev_devclass,
 550     NULL, NULL);