/* $NetBSD: xenbus_xs.c,v 1.28 2022/09/01 16:25:18 bouyer Exp $ */
/******************************************************************************
* xenbus_xs.c
*
* This is the kernel equivalent of the "xs" library.  We don't need everything
* and we use xenbus_comms for communication.
*
* Copyright (C) 2005 Rusty Russell, IBM Corporation
*
* This file may be distributed separately from the Linux kernel, or
* incorporated into other software packages, subject to the following license:
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this source file (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy, modify,
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: xenbus_xs.c,v 1.28 2022/09/01 16:25:18 bouyer Exp $");

#if 0
#define DPRINTK(fmt, args...) \
   printf("xenbus_xs (%s:%d) " fmt ".\n", __func__, __LINE__, ##args)
#else
#define DPRINTK(fmt, args...) ((void)0)
#endif

#include <sys/types.h>
#include <sys/null.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/systm.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/mutex.h>
#include <sys/kthread.h>

#include <xen/xen.h>    /* for xendomain_is_dom0() */
#include <xen/xenbus.h>
#include "xenbus_comms.h"

#define streq(a, b) (strcmp((a), (b)) == 0)

struct xs_stored_msg {
       SIMPLEQ_ENTRY(xs_stored_msg) msg_next;

       struct xsd_sockmsg hdr;

       union {
               /* Queued replies. */
               struct {
                       char *body;
               } reply;

               /* Queued watch events. */
               struct {
                       struct xenbus_watch *handle;
                       char **vec;
                       unsigned int vec_size;
               } watch;
       } u;
};

struct xs_handle {
       /* A list of replies. Currently only one will ever be outstanding. */
       SIMPLEQ_HEAD(, xs_stored_msg) reply_list;
       kmutex_t reply_lock;
       kcondvar_t reply_cv;
       kmutex_t xs_lock; /* serialize access to xenstore */
       int suspend_spl;

};

static struct xs_handle xs_state;

/* List of registered watches, and a lock to protect it. */
static SLIST_HEAD(, xenbus_watch) watches;
static kmutex_t watches_lock;

/* List of pending watch callback events, and a lock to protect it. */
static SIMPLEQ_HEAD(, xs_stored_msg) watch_events;
static kmutex_t watch_events_lock;
static kcondvar_t watch_cv;

static int
get_error(const char *errorstring)
{
       unsigned int i;

       for (i = 0; !streq(errorstring, xsd_errors[i].errstring); i++) {
               if (i == (sizeof(xsd_errors) / sizeof(xsd_errors[0]) - 1)) {
                       printf(
                              "XENBUS xen store gave: unknown error %s",
                              errorstring);
                       return EINVAL;
               }
       }
       return xsd_errors[i].errnum;
}

static void *
read_reply(enum xsd_sockmsg_type *type, unsigned int *len)
{
       struct xs_stored_msg *msg;
       char *body;

       mutex_enter(&xs_state.reply_lock);
       while (SIMPLEQ_EMPTY(&xs_state.reply_list)) {
               cv_wait(&xs_state.reply_cv, &xs_state.reply_lock);
       }
       msg = SIMPLEQ_FIRST(&xs_state.reply_list);
       SIMPLEQ_REMOVE_HEAD(&xs_state.reply_list, msg_next);
       mutex_exit(&xs_state.reply_lock);

       *type = msg->hdr.type;
       if (len)
               *len = msg->hdr.len;
       body = msg->u.reply.body;
       DPRINTK("read_reply: type %d body %s",
           msg->hdr.type, body);

       free(msg, M_DEVBUF);

       return body;
}

#if 0
/* Emergency write. */
void
xenbus_debug_write(const char *str, unsigned int count)
{
       struct xsd_sockmsg msg = { 0 };

       msg.type = XS_DEBUG;
       msg.len = sizeof("print") + count + 1;

       xb_write(&msg, sizeof(msg));
       xb_write("print", sizeof("print"));
       xb_write(str, count);
       xb_write("", 1);
}
#endif

int
xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void**reply)
{
       int err = 0;

       mutex_enter(&xs_state.xs_lock);
       err = xb_write(msg, sizeof(*msg) + msg->len);
       if (err) {
               msg->type = XS_ERROR;
               *reply = NULL;
       } else {
               *reply = read_reply(&msg->type, &msg->len);
       }
       mutex_exit(&xs_state.xs_lock);

       return err;
}

void
xenbus_dev_reply_free(struct xsd_sockmsg *msg, void *reply)
{
       free(reply, M_DEVBUF);
}

/* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
static int
xs_talkv(struct xenbus_transaction *t,
                     enum xsd_sockmsg_type type,
                     const struct iovec *iovec,
                     unsigned int num_vecs,
                     unsigned int *len,
                     char **retbuf)
{
       struct xsd_sockmsg msg;
       unsigned int i;
       int err;
       void *ret;

       msg.tx_id = (uint32_t)(unsigned long)t;
       msg.req_id = 0;
       msg.type = type;
       msg.len = 0;
       for (i = 0; i < num_vecs; i++)
               msg.len += iovec[i].iov_len;

       mutex_enter(&xs_state.xs_lock);

       DPRINTK("write msg");
       err = xb_write(&msg, sizeof(msg));
       DPRINTK("write msg err %d", err);
       if (err) {
               mutex_exit(&xs_state.xs_lock);
               return (err);
       }

       for (i = 0; i < num_vecs; i++) {
               DPRINTK("write iovect");
               err = xb_write(iovec[i].iov_base, iovec[i].iov_len);
               DPRINTK("write iovect err %d", err);
               if (err) {
                       mutex_exit(&xs_state.xs_lock);
                       return (err);
               }
       }

       DPRINTK("read");
       ret = read_reply(&msg.type, len);
       DPRINTK("read done");

       mutex_exit(&xs_state.xs_lock);

       if (msg.type == XS_ERROR) {
               err = get_error(ret);
               free(ret, M_DEVBUF);
               return (err);
       }

       KASSERT(msg.type == type);
       if (retbuf != NULL)
               *retbuf = ret;
       else
               free(ret, M_DEVBUF);
       return 0;
}

/* Simplified version of xs_talkv: single message. */
static int
xs_single(struct xenbus_transaction *t,
                      enum xsd_sockmsg_type type,
                      const char *string,
                      unsigned int *len,
                      char **ret)
{
       struct iovec iovec;

       /* xs_talkv only reads iovec */
       iovec.iov_base = __UNCONST(string);
       iovec.iov_len = strlen(string) + 1;
       return xs_talkv(t, type, &iovec, 1, len, ret);
}

static unsigned int
count_strings(const char *strings, unsigned int len)
{
       unsigned int num;
       const char *p;

       for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1)
               num++;

       return num;
}

/* Return the path to dir with /name appended. Buffer must be kfree()'ed. */
static char *
join(const char *dir, const char *name)
{
       char *buffer;

       buffer = malloc(strlen(dir) + strlen("/") + strlen(name) + 1,
                        M_DEVBUF, M_NOWAIT);
       if (buffer == NULL)
               return NULL;

       strcpy(buffer, dir);
       if (!streq(name, "")) {
               strcat(buffer, "/");
               strcat(buffer, name);
       }

       return buffer;
}

static char **
split(char *strings, unsigned int len, unsigned int *num)
{
       char *p, **ret;

       /* Count the strings. */
       *num = count_strings(strings, len);

       /* Transfer to one big alloc for easy freeing. */
       ret = malloc(*num * sizeof(char *) + len, M_DEVBUF, M_NOWAIT);
       if (!ret) {
               free(strings, M_DEVBUF);
               return NULL;
       }
       memcpy(&ret[*num], strings, len);
       free(strings, M_DEVBUF);

       strings = (char *)&ret[*num];
       for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
               ret[(*num)++] = p;

       return ret;
}

int
xenbus_directory(struct xenbus_transaction *t,
                       const char *dir, const char *node, unsigned int *num,
                       char ***retbuf)
{
       char *strings, *path;
       unsigned int len;
       int err;

       path = join(dir, node);
       if (path == NULL)
               return ENOMEM;

       err = xs_single(t, XS_DIRECTORY, path, &len, &strings);
       DPRINTK("xs_single %d %d", err, len);
       free(path, M_DEVBUF);
       if (err)
               return err;

       DPRINTK("xs_single strings %s", strings);
       *retbuf = split(strings, len, num);
       if (*retbuf == NULL)
               return ENOMEM;
       return 0;
}

void
xenbus_directory_free(unsigned int num, char **dir)
{
       free(dir, M_DEVBUF);
}

/* Check if a path exists. Return 1 if it does. */
int
xenbus_exists(struct xenbus_transaction *t,
                 const char *dir, const char *node)
{
       char **d;
       int dir_n, err;

       err = xenbus_directory(t, dir, node, &dir_n, &d);
       if (err)
               return 0;
       free(d, M_DEVBUF);
       return 1;
}

/* Get the value of a single file.
* Returns a kmalloced value: call free() on it after use.
* len indicates length in bytes.
*/
int
xenbus_read(struct xenbus_transaction *t,
                 const char *dir, const char *node,
                 char *buffer, size_t bufsz)
{
       char *path;
       int err;
       char *ret;
       unsigned int len;

       path = join(dir, node);
       if (path == NULL)
               return ENOMEM;

       err = xs_single(t, XS_READ, path, &len, &ret);

       if (err == 0) {
               if (len + 1 <= bufsz) {
                       strncpy(buffer, ret, bufsz);
               } else {
                       err = ENAMETOOLONG;
               }
               free(ret, M_DEVBUF);
       }

       free(path, M_DEVBUF);
       return err;
}

/* Read a node and convert it to unsigned long. */
int
xenbus_read_ul(struct xenbus_transaction *t,
                 const char *dir, const char *node, unsigned long *val,
                 int base)
{
       char string[32], *ep;
       int err;

       err = xenbus_read(t, dir, node, string, sizeof(string));
       if (err)
               return err;
       *val = strtoul(string, &ep, base);
       if (*ep != '\0') {
               return EFTYPE;
       }
       return 0;
}

/* Read a node and convert it to unsigned long long. */
int
xenbus_read_ull(struct xenbus_transaction *t,
                 const char *dir, const char *node, unsigned long long *val,
                 int base)
{
       char string[32], *ep;
       int err;

       err = xenbus_read(t, dir, node, string, sizeof(string));
       if (err)
               return err;
       *val = strtoull(string, &ep, base);
       if (*ep != '\0') {
               return EFTYPE;
       }
       return 0;
}

/* Write the value of a single file.
* Returns -err on failure.
*/
int
xenbus_write(struct xenbus_transaction *t,
                const char *dir, const char *node, const char *string)
{
       const char *path;
       struct iovec iovec[2];
       int ret;

       path = join(dir, node);
       if (path == NULL)
               return ENOMEM;

       /* xs_talkv only reads iovec */
       iovec[0].iov_base = __UNCONST(path);
       iovec[0].iov_len = strlen(path) + 1;
       iovec[1].iov_base = __UNCONST(string);
       iovec[1].iov_len = strlen(string);

       ret = xs_talkv(t, XS_WRITE, iovec, 2, NULL, NULL);
       return ret;
}

/* Create a new directory. */
int
xenbus_mkdir(struct xenbus_transaction *t,
                const char *dir, const char *node)
{
       char *path;
       int ret;

       path = join(dir, node);
       if (path == NULL)
               return ENOMEM;

       ret = xs_single(t, XS_MKDIR, path, NULL, NULL);
       free(path, M_DEVBUF);
       return ret;
}

/* Destroy a file or directory (directories must be empty). */
int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node)
{
       char *path;
       int ret;

       path = join(dir, node);
       if (path == NULL)
               return ENOMEM;

       ret = xs_single(t, XS_RM, path, NULL, NULL);
       free(path, M_DEVBUF);
       return ret;
}

/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
* MUST BE CALLED AT IPL_TTY !
*/
struct xenbus_transaction *
xenbus_transaction_start(void)
{
       char *id_str;
       unsigned long id, err;

       err = xs_single(NULL, XS_TRANSACTION_START, "", NULL, &id_str);
       if (err) {
               return NULL;
       }

       id = strtoul(id_str, NULL, 0);
       free(id_str, M_DEVBUF);

       return (struct xenbus_transaction *)id;
}

/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
* MUST BE CALLED AT IPL_TTY !
*/
int xenbus_transaction_end(struct xenbus_transaction *t, int abort)
{
       char abortstr[2];
       int err;

       if (abort)
               strcpy(abortstr, "F");
       else
               strcpy(abortstr, "T");

       err = xs_single(t, XS_TRANSACTION_END, abortstr, NULL, NULL);

       return err;
}

/* Single printf and write: returns -errno or 0. */
int
xenbus_printf(struct xenbus_transaction *t,
                 const char *dir, const char *node, const char *fmt, ...)
{
       va_list ap;
       int ret;
#define PRINTF_BUFFER_SIZE 4096
       char *printf_buffer;

       printf_buffer = malloc(PRINTF_BUFFER_SIZE, M_DEVBUF, M_NOWAIT);
       if (printf_buffer == NULL)
               return ENOMEM;

       va_start(ap, fmt);
       ret = vsnprintf(printf_buffer, PRINTF_BUFFER_SIZE, fmt, ap);
       va_end(ap);

       KASSERT(ret < PRINTF_BUFFER_SIZE);
       ret = xenbus_write(t, dir, node, printf_buffer);

       free(printf_buffer, M_DEVBUF);

       return ret;
}

static int
xs_watch(const char *path, const char *token)
{
       struct iovec iov[2];

       /* xs_talkv only reads iovec */
       iov[0].iov_base = __UNCONST(path);
       iov[0].iov_len = strlen(path) + 1;
       iov[1].iov_base = __UNCONST(token);
       iov[1].iov_len = strlen(token) + 1;

       return xs_talkv(NULL, XS_WATCH, iov, 2, NULL, NULL);
}

static int
xs_unwatch(const char *path, const char *token)
{
       struct iovec iov[2];

       /* xs_talkv only reads iovec */
       iov[0].iov_base = __UNCONST(path);
       iov[0].iov_len = strlen(path) + 1;
       iov[1].iov_base = __UNCONST(token);
       iov[1].iov_len = strlen(token) + 1;

       return xs_talkv(NULL, XS_UNWATCH, iov, 2, NULL, NULL);
}

static struct xenbus_watch *
find_watch(const char *token)
{
       struct xenbus_watch *i, *cmp;

       cmp = (void *)strtoul(token, NULL, 16);

       SLIST_FOREACH(i, &watches, watch_next) {
               if (i == cmp)
                       return i;
       }

       return NULL;
}

/* Register callback to watch this node. */
int
register_xenbus_watch(struct xenbus_watch *watch)
{
       /* Pointer in ascii is the token. */
       char token[sizeof(watch) * 2 + 1];
       int err;

       snprintf(token, sizeof(token), "%lX", (long)watch);

       mutex_enter(&watches_lock);
       KASSERT(find_watch(token) == 0);
       SLIST_INSERT_HEAD(&watches, watch, watch_next);
       mutex_exit(&watches_lock);

       err = xs_watch(watch->node, token);

       /* Ignore errors due to multiple registration. */
       if ((err != 0) && (err != EEXIST)) {
               mutex_enter(&watches_lock);
               SLIST_REMOVE(&watches, watch, xenbus_watch, watch_next);
               mutex_exit(&watches_lock);
       }
       return err;
}

void
unregister_xenbus_watch(struct xenbus_watch *watch)
{
       SIMPLEQ_HEAD(, xs_stored_msg) gclist;
       struct xs_stored_msg *msg, *next_msg;
       char token[sizeof(watch) * 2 + 1];
       int err;

       snprintf(token, sizeof(token), "%lX", (long)watch);

       mutex_enter(&watches_lock);
       KASSERT(find_watch(token));
       SLIST_REMOVE(&watches, watch, xenbus_watch, watch_next);
       mutex_exit(&watches_lock);

       err = xs_unwatch(watch->node, token);
       if (err) {
               printf(
                      "XENBUS Failed to release watch %s: %i\n",
                      watch->node, err);
       }

       /* Cancel pending watch events. */
       SIMPLEQ_INIT(&gclist);
       mutex_enter(&watch_events_lock);
       for (msg = SIMPLEQ_FIRST(&watch_events); msg != NULL; msg = next_msg) {
               next_msg = SIMPLEQ_NEXT(msg, msg_next);
               if (msg->u.watch.handle != watch)
                       continue;
               SIMPLEQ_REMOVE(&watch_events, msg, xs_stored_msg, msg_next);
               SIMPLEQ_INSERT_TAIL(&gclist, msg, msg_next);
       }
       mutex_exit(&watch_events_lock);

       while ((msg = SIMPLEQ_FIRST(&gclist)) != NULL) {
               SIMPLEQ_REMOVE(&gclist, msg, xs_stored_msg, msg_next);
               free(msg->u.watch.vec, M_DEVBUF);
               free(msg, M_DEVBUF);
       }
}

void
xs_suspend(void)
{
       xs_state.suspend_spl = spltty();
}

void
xs_resume(void)
{
       struct xenbus_watch *watch;
       char token[sizeof(watch) * 2 + 1];
       /* No need for watches_lock: the suspend_mutex is sufficient. */
       SLIST_FOREACH(watch, &watches, watch_next) {
               snprintf(token, sizeof(token), "%lX", (long)watch);
               xs_watch(watch->node, token);
       }

       splx(xs_state.suspend_spl);
}

static void
xenwatch_thread(void *unused)
{
       SIMPLEQ_HEAD(, xs_stored_msg) events_to_proces;
       struct xs_stored_msg *msg;

       SIMPLEQ_INIT(&events_to_proces);
       for (;;) {
               mutex_enter(&watch_events_lock);
               while (SIMPLEQ_EMPTY(&watch_events))
                       cv_wait(&watch_cv, &watch_events_lock);
               SIMPLEQ_CONCAT(&events_to_proces, &watch_events);
               mutex_exit(&watch_events_lock);

               DPRINTK("xenwatch_thread: processing events");

               while ((msg = SIMPLEQ_FIRST(&events_to_proces)) != NULL) {
                       DPRINTK("xenwatch_thread: got event");
                       SIMPLEQ_REMOVE_HEAD(&events_to_proces, msg_next);
                       msg->u.watch.handle->xbw_callback(
                               msg->u.watch.handle,
                               (void *)msg->u.watch.vec,
                               msg->u.watch.vec_size);
                       free(msg->u.watch.vec, M_DEVBUF);
                       free(msg, M_DEVBUF);
               }
       }
}

static int
process_msg(void)
{
       struct xs_stored_msg *msg, *s_msg;
       char *body;
       int err;

       msg = malloc(sizeof(*msg), M_DEVBUF, M_WAITOK);
       if (msg == NULL)
               return ENOMEM;

       err = xb_read(&msg->hdr, sizeof(msg->hdr));
       DPRINTK("xb_read hdr %d", err);
       if (err) {
               free(msg, M_DEVBUF);
               return err;
       }

       body = malloc(msg->hdr.len + 1, M_DEVBUF, M_NOWAIT);
       if (body == NULL) {
               free(msg, M_DEVBUF);
               return ENOMEM;
       }

       err = xb_read(body, msg->hdr.len);
       DPRINTK("xb_read body %d", err);
       if (err) {
               free(body, M_DEVBUF);
               free(msg, M_DEVBUF);
               return err;
       }
       body[msg->hdr.len] = '\0';

       if (msg->hdr.type == XS_WATCH_EVENT) {
               bool found, repeated;

               DPRINTK("process_msg: XS_WATCH_EVENT");
               msg->u.watch.vec = split(body, msg->hdr.len,
                                        &msg->u.watch.vec_size);
               if (msg->u.watch.vec == NULL) {
                       free(msg, M_DEVBUF);
                       return ENOMEM;
               }

               mutex_enter(&watches_lock);
               msg->u.watch.handle = find_watch(
                   msg->u.watch.vec[XS_WATCH_TOKEN]);
               found = (msg->u.watch.handle != NULL);
               repeated = false;
               if (found) {
                       mutex_enter(&watch_events_lock);
                       /* Don't add duplicate events to the queue of pending watches */
                       SIMPLEQ_FOREACH(s_msg, &watch_events, msg_next) {
                               if (s_msg->u.watch.handle == msg->u.watch.handle) {
                                       repeated = true;
                                       break;
                               }
                       }
                       if (!repeated) {
                               SIMPLEQ_INSERT_TAIL(&watch_events, msg, msg_next);
                               cv_broadcast(&watch_cv);
                       }
                       mutex_exit(&watch_events_lock);
               }
               mutex_exit(&watches_lock);
               if (!found || repeated) {
                       free(msg->u.watch.vec, M_DEVBUF);
                       free(msg, M_DEVBUF);
               }
       } else {
               DPRINTK("process_msg: type %d body %s", msg->hdr.type, body);

               msg->u.reply.body = body;
               mutex_enter(&xs_state.reply_lock);
               SIMPLEQ_INSERT_TAIL(&xs_state.reply_list, msg, msg_next);
               cv_broadcast(&xs_state.reply_cv);
               mutex_exit(&xs_state.reply_lock);
       }

       return 0;
}

static void
xenbus_thread(void *unused)
{
       int err;

       for (;;) {
               err = process_msg();
               if (err)
                       printk("XENBUS error %d while reading message\n", err);
       }
}

int
xs_init(device_t dev)
{
       int err;

       SLIST_INIT(&watches);
       mutex_init(&watches_lock, MUTEX_DEFAULT, IPL_TTY);

       SIMPLEQ_INIT(&watch_events);
       mutex_init(&watch_events_lock, MUTEX_DEFAULT, IPL_TTY);
       cv_init(&watch_cv, "evtsq");

       SIMPLEQ_INIT(&xs_state.reply_list);
       mutex_init(&xs_state.xs_lock, MUTEX_DEFAULT, IPL_NONE);
       mutex_init(&xs_state.reply_lock, MUTEX_DEFAULT, IPL_TTY);
       cv_init(&xs_state.reply_cv, "rplq");

       err = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, xenwatch_thread,
           NULL, NULL, "xenwatch");
       if (err) {
               aprint_error_dev(dev, "kthread_create(xenwatch): %d\n", err);
               return err;
       }

       err = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, xenbus_thread,
           NULL, NULL, "xenbus");
       if (err) {
               aprint_error_dev(dev, "kthread_create(xenbus): %d\n", err);
               return err;
       }

       return 0;
}

/*
* Local variables:
*  c-file-style: "linux"
*  indent-tabs-mode: t
*  c-indent-level: 8
*  c-basic-offset: 8
*  tab-width: 8
* End:
*/

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.