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
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/types.h>
  37 #include <sys/cdefs.h>
  38 #include <sys/errno.h>
  39 #include <sys/uio.h>
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/proc.h>
  43 #include <sys/kernel.h>
  44 #include <sys/malloc.h>
  45 #include <sys/conf.h>
  46 #include <sys/module.h>
  47
  48 #include <xen/xen-os.h>
  49
  50 #include <xen/hypervisor.h>
  51 #include <xen/xenstore/xenstorevar.h>
  52 #include <xen/xenstore/xenstore_internal.h>
  53
  54 struct xs_dev_transaction {
  55         LIST_ENTRY(xs_dev_transaction) list;
  56         struct xs_transaction handle;
  57 };
  58
  59 struct xs_dev_data {
  60         /* In-progress transaction. */
  61         LIST_HEAD(xdd_list_head, xs_dev_transaction) transactions;
  62
  63         /* Partial request. */
  64         unsigned int len;
  65         union {
  66                 struct xsd_sockmsg msg;
  67                 char buffer[PAGE_SIZE];
  68         } u;
  69
  70         /* Response queue. */
  71 #define MASK_READ_IDX(idx) ((idx)&(PAGE_SIZE-1))
  72         char read_buffer[PAGE_SIZE];
  73         unsigned int read_cons, read_prod;
  74 };
  75
  76 static int
  77 xs_dev_read(struct cdev *dev, struct uio *uio, int ioflag)
  78 {
  79         int error;
  80         struct xs_dev_data *u;
  81
  82         error = devfs_get_cdevpriv((void **)&u);
  83         if (error != 0)
  84                 return (error);
  85
  86         while (u->read_prod == u->read_cons) {
  87                 error = tsleep(u, PCATCH, "xsdread", hz/10);
  88                 if (error && error != EWOULDBLOCK)
  89                         return (error);
  90         }
  91
  92         while (uio->uio_resid > 0) {
  93                 if (u->read_cons == u->read_prod)
  94                         break;
  95                 error = uiomove(&u->read_buffer[MASK_READ_IDX(u->read_cons)],
  96                     1, uio);
  97                 if (error)
  98                         return (error);
  99                 u->read_cons++;
 100         }
 101         return (0);
 102 }
 103
 104 static void
 105 xs_queue_reply(struct xs_dev_data *u, char *data, unsigned int len)
 106 {
 107         int i;
 108
 109         for (i = 0; i < len; i++, u->read_prod++)
 110                 u->read_buffer[MASK_READ_IDX(u->read_prod)] = data[i];
 111
 112         KASSERT((u->read_prod - u->read_cons) <= sizeof(u->read_buffer),
 113             ("xenstore reply too big"));
 114
 115         wakeup(u);
 116 }
 117
 118 static int
 119 xs_dev_write(struct cdev *dev, struct uio *uio, int ioflag)
 120 {
 121         int error;
 122         struct xs_dev_data *u;
 123         struct xs_dev_transaction *trans;
 124         void *reply;
 125         int len = uio->uio_resid;
 126
 127         error = devfs_get_cdevpriv((void **)&u);
 128         if (error != 0)
 129                 return (error);
 130
 131         if ((len + u->len) > sizeof(u->u.buffer))
 132                 return (EINVAL);
 133
 134         error = uiomove(u->u.buffer + u->len, len, uio);
 135         if (error)
 136                 return (error);
 137
 138         u->len += len;
 139         if (u->len < (sizeof(u->u.msg) + u->u.msg.len))
 140                 return (0);
 141
 142         switch (u->u.msg.type) {
 143         case XS_TRANSACTION_START:
 144         case XS_TRANSACTION_END:
 145         case XS_DIRECTORY:
 146         case XS_READ:
 147         case XS_GET_PERMS:
 148         case XS_RELEASE:
 149         case XS_GET_DOMAIN_PATH:
 150         case XS_WRITE:
 151         case XS_MKDIR:
 152         case XS_RM:
 153         case XS_SET_PERMS:
 154                 error = xs_dev_request_and_reply(&u->u.msg, &reply);
 155                 if (!error) {
 156                         if (u->u.msg.type == XS_TRANSACTION_START) {
 157                                 trans = malloc(sizeof(*trans), M_XENSTORE,
 158                                     M_WAITOK);
 159                                 trans->handle.id = strtoul(reply, NULL, 0);
 160                                 LIST_INSERT_HEAD(&u->transactions, trans, list);
 161                         } else if (u->u.msg.type == XS_TRANSACTION_END) {
 162                                 LIST_FOREACH(trans, &u->transactions, list)
 163                                         if (trans->handle.id == u->u.msg.tx_id)
 164                                                 break;
 165 #if 0 /* XXX does this mean the list is empty? */
 166                                 BUG_ON(&trans->list == &u->transactions);
 167 #endif
 168                                 LIST_REMOVE(trans, list);
 169                                 free(trans, M_XENSTORE);
 170                         }
 171                         xs_queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
 172                         xs_queue_reply(u, (char *)reply, u->u.msg.len);
 173                         free(reply, M_XENSTORE);
 174                 }
 175                 break;
 176
 177         default:
 178                 error = EINVAL;
 179                 break;
 180         }
 181
 182         if (error == 0)
 183                 u->len = 0;
 184
 185         return (error);
 186 }
 187
 188 static void
 189 xs_dev_dtor(void *arg)
 190 {
 191         struct xs_dev_data *u = arg;
 192         struct xs_dev_transaction *trans, *tmp;
 193
 194         LIST_FOREACH_SAFE(trans, &u->transactions, list, tmp) {
 195                 xs_transaction_end(trans->handle, 1);
 196                 LIST_REMOVE(trans, list);
 197                 free(trans, M_XENSTORE);
 198         }
 199
 200         free(u, M_XENSTORE);
 201 }
 202
 203 static int
 204 xs_dev_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 205 {
 206         struct xs_dev_data *u;
 207         int error;
 208
 209         u = malloc(sizeof(*u), M_XENSTORE, M_WAITOK|M_ZERO);
 210         LIST_INIT(&u->transactions);
 211         error = devfs_set_cdevpriv(u, xs_dev_dtor);
 212         if (error != 0)
 213                 free(u, M_XENSTORE);
 214
 215         return (error);
 216 }
 217
 218 static struct cdevsw xs_dev_cdevsw = {
 219         .d_version = D_VERSION,
 220         .d_read = xs_dev_read,
 221         .d_write = xs_dev_write,
 222         .d_open = xs_dev_open,
 223         .d_name = "xs_dev",
 224 };
 225
 226 /*------------------ Private Device Attachment Functions  --------------------*/
 227 /**
 228  * \brief Identify instances of this device type in the system.
 229  *
 230  * \param driver  The driver performing this identify action.
 231  * \param parent  The NewBus parent device for any devices this method adds.
 232  */
 233 static void
 234 xs_dev_identify(driver_t *driver __unused, device_t parent)
 235 {
 236         /*
 237          * A single device instance for our driver is always present
 238          * in a system operating under Xen.
 239          */
 240         BUS_ADD_CHILD(parent, 0, driver->name, 0);
 241 }
 242
 243 /**
 244  * \brief Probe for the existence of the Xenstore device
 245  *
 246  * \param dev  NewBus device_t for this instance.
 247  *
 248  * \return  Always returns 0 indicating success.
 249  */
 250 static int
 251 xs_dev_probe(device_t dev)
 252 {
 253
 254         device_set_desc(dev, "Xenstore user-space device");
 255         return (0);
 256 }
 257
 258 /**
 259  * \brief Attach the Xenstore device.
 260  *
 261  * \param dev  NewBus device_t for this instance.
 262  *
 263  * \return  On success, 0. Otherwise an errno value indicating the
 264  *          type of failure.
 265  */
 266 static int
 267 xs_dev_attach(device_t dev)
 268 {
 269         struct cdev *xs_cdev;
 270
 271         xs_cdev = make_dev_credf(MAKEDEV_ETERNAL, &xs_dev_cdevsw, 0, NULL,
 272             UID_ROOT, GID_WHEEL, 0400, "xen/xenstore");
 273         if (xs_cdev == NULL)
 274                 return (EINVAL);
 275
 276         return (0);
 277 }
 278
 279 /*-------------------- Private Device Attachment Data  -----------------------*/
 280 static device_method_t xs_dev_methods[] = {
 281         /* Device interface */
 282         DEVMETHOD(device_identify,      xs_dev_identify),
 283         DEVMETHOD(device_probe,         xs_dev_probe),
 284         DEVMETHOD(device_attach,        xs_dev_attach),
 285
 286         DEVMETHOD_END
 287 };
 288
 289 DEFINE_CLASS_0(xs_dev, xs_dev_driver, xs_dev_methods, 0);
 290 devclass_t xs_dev_devclass;
 291
 292 DRIVER_MODULE(xs_dev, xenstore, xs_dev_driver, xs_dev_devclass,
 293     NULL, NULL);