xen-vtx-unstable

annotate tools/xenstore/xs.c @ 5423:61f0cf22d5cd

find changesets by author, revision, files, or words in the commit message
bitkeeper revision 1.1705.1.13 (42a99a6dV4rHEyZ-t7znDZXeW50z5Q)

Some functions of xenstore library dont have xs_ as prefix. This patch
fixes the problem.
Signed-off-by: Nguyen Anh Quynh <aquynh@gmail.com>
author kaf24@firebug.cl.cam.ac.uk
date Fri Jun 10 13:49:33 2005 +0000 (2005-06-10)
parents 6d3e8f90c2df
children d44caae57112
rev   line source
cl349@5357 1 /*
cl349@5357 2 Xen Store Daemon interface providing simple tree-like database.
cl349@5357 3 Copyright (C) 2005 Rusty Russell IBM Corporation
cl349@5357 4
cl349@5357 5 This program is free software; you can redistribute it and/or modify
cl349@5357 6 it under the terms of the GNU General Public License as published by
cl349@5357 7 the Free Software Foundation; either version 2 of the License, or
cl349@5357 8 (at your option) any later version.
cl349@5357 9
cl349@5357 10 This program is distributed in the hope that it will be useful,
cl349@5357 11 but WITHOUT ANY WARRANTY; without even the implied warranty of
cl349@5357 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
cl349@5357 13 GNU General Public License for more details.
cl349@5357 14
cl349@5357 15 You should have received a copy of the GNU General Public License
cl349@5357 16 along with this program; if not, write to the Free Software
cl349@5357 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
cl349@5357 18 */
cl349@5357 19
cl349@5357 20 #include <sys/types.h>
cl349@5357 21 #include <sys/stat.h>
cl349@5357 22 #include <fcntl.h>
cl349@5357 23 #include <sys/socket.h>
cl349@5357 24 #include <sys/un.h>
cl349@5357 25 #include <string.h>
cl349@5357 26 #include <unistd.h>
cl349@5357 27 #include <stdbool.h>
cl349@5357 28 #include <stdlib.h>
cl349@5357 29 #include <assert.h>
cl349@5357 30 #include <stdio.h>
cl349@5357 31 #include <signal.h>
cl349@5357 32 #include <stdint.h>
cl349@5357 33 #include <errno.h>
cl349@5357 34 #include "xs.h"
cl349@5357 35 #include "xenstored.h"
cl349@5357 36 #include "xs_lib.h"
cl349@5357 37 #include "utils.h"
cl349@5357 38
cl349@5357 39 struct xs_handle
cl349@5357 40 {
cl349@5357 41 int fd;
cl349@5357 42 };
cl349@5357 43
cl349@5357 44 /* Get the socket from the store daemon handle.
cl349@5357 45 */
cl349@5357 46 int xs_fileno(struct xs_handle *h)
cl349@5357 47 {
cl349@5357 48 return h->fd;
cl349@5357 49 }
cl349@5357 50
cl349@5357 51 static struct xs_handle *get_socket(const char *connect_to)
cl349@5357 52 {
cl349@5357 53 struct sockaddr_un addr;
cl349@5357 54 int sock, saved_errno;
cl349@5357 55 struct xs_handle *h = NULL;
cl349@5357 56
cl349@5357 57 sock = socket(PF_UNIX, SOCK_STREAM, 0);
cl349@5357 58 if (sock < 0)
cl349@5357 59 return NULL;
cl349@5357 60
cl349@5357 61 addr.sun_family = AF_UNIX;
cl349@5357 62 strcpy(addr.sun_path, connect_to);
cl349@5357 63
cl349@5357 64 if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == 0) {
cl349@5357 65 h = malloc(sizeof(*h));
cl349@5357 66 if (h) {
cl349@5357 67 h->fd = sock;
cl349@5357 68 return h;
cl349@5357 69 }
cl349@5357 70 }
cl349@5357 71
cl349@5357 72 saved_errno = errno;
cl349@5357 73 close(sock);
cl349@5357 74 free(h);
cl349@5357 75 errno = saved_errno;
cl349@5357 76 return NULL;
cl349@5357 77 }
cl349@5357 78
cl349@5357 79 struct xs_handle *xs_daemon_open(void)
cl349@5357 80 {
cl349@5357 81 return get_socket(xs_daemon_socket());
cl349@5357 82 }
cl349@5357 83
cl349@5357 84 struct xs_handle *xs_daemon_open_readonly(void)
cl349@5357 85 {
cl349@5357 86 return get_socket(xs_daemon_socket_ro());
cl349@5357 87 }
cl349@5357 88
cl349@5357 89 void xs_daemon_close(struct xs_handle *h)
cl349@5357 90 {
cl349@5357 91 if (h->fd >= 0)
cl349@5357 92 close(h->fd);
cl349@5357 93 free(h);
cl349@5357 94 }
cl349@5357 95
cl349@5357 96 static bool read_all(int fd, void *data, unsigned int len)
cl349@5357 97 {
cl349@5357 98 while (len) {
cl349@5357 99 int done;
cl349@5357 100
cl349@5357 101 done = read(fd, data, len);
cl349@5357 102 if (done < 0) {
cl349@5357 103 if (errno == EINTR)
cl349@5357 104 continue;
cl349@5357 105 return false;
cl349@5357 106 }
cl349@5357 107 if (done == 0) {
cl349@5357 108 /* It closed fd on us? EBADF is appropriate. */
cl349@5357 109 errno = EBADF;
cl349@5357 110 return false;
cl349@5357 111 }
cl349@5357 112 data += done;
cl349@5357 113 len -= done;
cl349@5357 114 }
cl349@5357 115
cl349@5357 116 return true;
cl349@5357 117 }
cl349@5357 118
cl349@5357 119 #ifdef XSTEST
cl349@5357 120 #define read_all read_all_choice
kaf24@5423 121 #define xs_write_all write_all_choice
cl349@5357 122 #endif
cl349@5357 123
cl349@5357 124 static int get_error(const char *errorstring)
cl349@5357 125 {
cl349@5357 126 unsigned int i;
cl349@5357 127
cl349@5357 128 for (i = 0; !streq(errorstring, xsd_errors[i].errstring); i++)
cl349@5357 129 if (i == ARRAY_SIZE(xsd_errors) - 1)
cl349@5357 130 return EINVAL;
cl349@5357 131 return xsd_errors[i].errnum;
cl349@5357 132 }
cl349@5357 133
cl349@5357 134 static void *read_reply(int fd, enum xsd_sockmsg_type *type, unsigned int *len)
cl349@5357 135 {
cl349@5357 136 struct xsd_sockmsg msg;
cl349@5357 137 void *ret;
cl349@5357 138 int saved_errno;
cl349@5357 139
cl349@5357 140 if (!read_all(fd, &msg, sizeof(msg)))
cl349@5357 141 return NULL;
cl349@5357 142
cl349@5357 143 ret = malloc(msg.len);
cl349@5357 144 if (!ret)
cl349@5357 145 return NULL;
cl349@5357 146
cl349@5357 147 if (!read_all(fd, ret, msg.len)) {
cl349@5357 148 saved_errno = errno;
cl349@5357 149 free(ret);
cl349@5357 150 errno = saved_errno;
cl349@5357 151 return NULL;
cl349@5357 152 }
cl349@5357 153
cl349@5357 154 *type = msg.type;
cl349@5357 155 if (len)
cl349@5357 156 *len = msg.len;
cl349@5357 157 return ret;
cl349@5357 158 }
cl349@5357 159
cl349@5357 160 /* Send message to xs, get malloc'ed reply. NULL and set errno on error. */
cl349@5357 161 static void *xs_talkv(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@5357 162 const struct iovec *iovec,
cl349@5357 163 unsigned int num_vecs,
cl349@5357 164 unsigned int *len)
cl349@5357 165 {
cl349@5357 166 struct xsd_sockmsg msg;
cl349@5357 167 void *ret = NULL;
cl349@5357 168 int saved_errno;
cl349@5357 169 unsigned int i;
cl349@5357 170 struct sigaction ignorepipe, oldact;
cl349@5357 171
cl349@5357 172 msg.type = type;
cl349@5357 173 msg.len = 0;
cl349@5357 174 for (i = 0; i < num_vecs; i++)
cl349@5357 175 msg.len += iovec[i].iov_len;
cl349@5357 176
cl349@5357 177 ignorepipe.sa_handler = SIG_IGN;
cl349@5357 178 sigemptyset(&ignorepipe.sa_mask);
cl349@5357 179 ignorepipe.sa_flags = 0;
cl349@5357 180 sigaction(SIGPIPE, &ignorepipe, &oldact);
cl349@5357 181
kaf24@5423 182 if (!xs_write_all(h->fd, &msg, sizeof(msg)))
cl349@5357 183 goto fail;
cl349@5357 184
cl349@5357 185 for (i = 0; i < num_vecs; i++)
kaf24@5423 186 if (!xs_write_all(h->fd, iovec[i].iov_base, iovec[i].iov_len))
cl349@5357 187 goto fail;
cl349@5357 188
cl349@5357 189 /* Watches can have fired before reply comes: daemon detects
cl349@5357 190 * and re-transmits, so we can ignore this. */
cl349@5357 191 do {
cl349@5357 192 free(ret);
cl349@5357 193 ret = read_reply(h->fd, &msg.type, len);
cl349@5357 194 if (!ret)
cl349@5357 195 goto fail;
cl349@5357 196 } while (msg.type == XS_WATCH_EVENT);
cl349@5357 197
cl349@5357 198 sigaction(SIGPIPE, &oldact, NULL);
cl349@5357 199 if (msg.type == XS_ERROR) {
cl349@5357 200 saved_errno = get_error(ret);
cl349@5357 201 free(ret);
cl349@5357 202 errno = saved_errno;
cl349@5357 203 return NULL;
cl349@5357 204 }
cl349@5357 205
cl349@5357 206 assert(msg.type == type);
cl349@5357 207 return ret;
cl349@5357 208
cl349@5357 209 fail:
cl349@5357 210 /* We're in a bad state, so close fd. */
cl349@5357 211 saved_errno = errno;
cl349@5357 212 sigaction(SIGPIPE, &oldact, NULL);
cl349@5357 213 close(h->fd);
cl349@5357 214 h->fd = -1;
cl349@5357 215 errno = saved_errno;
cl349@5357 216 return NULL;
cl349@5357 217 }
cl349@5357 218
cl349@5357 219 /* free(), but don't change errno. */
cl349@5357 220 static void free_no_errno(void *p)
cl349@5357 221 {
cl349@5357 222 int saved_errno = errno;
cl349@5357 223 free(p);
cl349@5357 224 errno = saved_errno;
cl349@5357 225 }
cl349@5357 226
cl349@5357 227 /* Simplified version of xs_talkv: single message. */
cl349@5357 228 static void *xs_single(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@5357 229 const char *string, unsigned int *len)
cl349@5357 230 {
cl349@5357 231 struct iovec iovec;
cl349@5357 232
cl349@5357 233 iovec.iov_base = (void *)string;
cl349@5357 234 iovec.iov_len = strlen(string) + 1;
cl349@5357 235 return xs_talkv(h, type, &iovec, 1, len);
cl349@5357 236 }
cl349@5357 237
cl349@5357 238 static bool xs_bool(char *reply)
cl349@5357 239 {
cl349@5357 240 if (!reply)
cl349@5357 241 return false;
cl349@5357 242 free(reply);
cl349@5357 243 return true;
cl349@5357 244 }
cl349@5357 245
cl349@5357 246 char **xs_directory(struct xs_handle *h, const char *path, unsigned int *num)
cl349@5357 247 {
cl349@5357 248 char *strings, *p, **ret;
cl349@5357 249 unsigned int len;
cl349@5357 250
cl349@5357 251 strings = xs_single(h, XS_DIRECTORY, path, &len);
cl349@5357 252 if (!strings)
cl349@5357 253 return NULL;
cl349@5357 254
cl349@5357 255 /* Count the strings. */
kaf24@5423 256 *num = xs_count_strings(strings, len);
cl349@5357 257
cl349@5357 258 /* Transfer to one big alloc for easy freeing. */
cl349@5357 259 ret = malloc(*num * sizeof(char *) + len);
cl349@5357 260 if (!ret) {
cl349@5357 261 free_no_errno(strings);
cl349@5357 262 return NULL;
cl349@5357 263 }
cl349@5357 264 memcpy(&ret[*num], strings, len);
cl349@5357 265 free_no_errno(strings);
cl349@5357 266
cl349@5357 267 strings = (char *)&ret[*num];
cl349@5357 268 for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
cl349@5357 269 ret[(*num)++] = p;
cl349@5357 270 return ret;
cl349@5357 271 }
cl349@5357 272
cl349@5357 273 /* Get the value of a single file.
cl349@5357 274 * Returns a malloced value: call free() on it after use.
cl349@5357 275 * len indicates length in bytes.
cl349@5357 276 */
cl349@5357 277 void *xs_read(struct xs_handle *h, const char *path, unsigned int *len)
cl349@5357 278 {
cl349@5357 279 return xs_single(h, XS_READ, path, len);
cl349@5357 280 }
cl349@5357 281
cl349@5357 282 /* Write the value of a single file.
cl349@5357 283 * Returns false on failure. createflags can be 0, O_CREAT, or O_CREAT|O_EXCL.
cl349@5357 284 */
cl349@5357 285 bool xs_write(struct xs_handle *h, const char *path,
cl349@5357 286 const void *data, unsigned int len, int createflags)
cl349@5357 287 {
cl349@5357 288 const char *flags;
cl349@5357 289 struct iovec iovec[3];
cl349@5357 290
cl349@5357 291 /* Format: Flags (as string), path, data. */
cl349@5357 292 if (createflags == 0)
cl349@5357 293 flags = XS_WRITE_NONE;
cl349@5357 294 else if (createflags == O_CREAT)
cl349@5357 295 flags = XS_WRITE_CREATE;
cl349@5357 296 else if (createflags == (O_CREAT|O_EXCL))
cl349@5357 297 flags = XS_WRITE_CREATE_EXCL;
cl349@5357 298 else {
cl349@5357 299 errno = EINVAL;
cl349@5357 300 return false;
cl349@5357 301 }
cl349@5357 302
cl349@5357 303 iovec[0].iov_base = (void *)path;
cl349@5357 304 iovec[0].iov_len = strlen(path) + 1;
cl349@5357 305 iovec[1].iov_base = (void *)flags;
cl349@5357 306 iovec[1].iov_len = strlen(flags) + 1;
cl349@5357 307 iovec[2].iov_base = (void *)data;
cl349@5357 308 iovec[2].iov_len = len;
cl349@5357 309
cl349@5357 310 return xs_bool(xs_talkv(h, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
cl349@5357 311 }
cl349@5357 312
cl349@5357 313 /* Create a new directory.
cl349@5357 314 * Returns false on failure.
cl349@5357 315 */
cl349@5357 316 bool xs_mkdir(struct xs_handle *h, const char *path)
cl349@5357 317 {
cl349@5357 318 return xs_bool(xs_single(h, XS_MKDIR, path, NULL));
cl349@5357 319 }
cl349@5357 320
cl349@5357 321 /* Destroy a file or directory (directories must be empty).
cl349@5357 322 * Returns false on failure.
cl349@5357 323 */
cl349@5357 324 bool xs_rm(struct xs_handle *h, const char *path)
cl349@5357 325 {
cl349@5357 326 return xs_bool(xs_single(h, XS_RM, path, NULL));
cl349@5357 327 }
cl349@5357 328
cl349@5357 329 /* Get permissions of node (first element is owner).
cl349@5357 330 * Returns malloced array, or NULL: call free() after use.
cl349@5357 331 */
cl349@5357 332 struct xs_permissions *xs_get_permissions(struct xs_handle *h,
cl349@5357 333 const char *path,
cl349@5357 334 unsigned int *num)
cl349@5357 335 {
cl349@5357 336 char *strings;
cl349@5357 337 unsigned int len;
cl349@5357 338 struct xs_permissions *ret;
cl349@5357 339
cl349@5357 340 strings = xs_single(h, XS_GET_PERMS, path, &len);
cl349@5357 341 if (!strings)
cl349@5357 342 return NULL;
cl349@5357 343
cl349@5357 344 /* Count the strings: each one perms then domid. */
kaf24@5423 345 *num = xs_count_strings(strings, len);
cl349@5357 346
cl349@5357 347 /* Transfer to one big alloc for easy freeing. */
cl349@5357 348 ret = malloc(*num * sizeof(struct xs_permissions));
cl349@5357 349 if (!ret) {
cl349@5357 350 free_no_errno(strings);
cl349@5357 351 return NULL;
cl349@5357 352 }
cl349@5357 353
kaf24@5423 354 if (!xs_strings_to_perms(ret, *num, strings)) {
cl349@5357 355 free_no_errno(ret);
cl349@5357 356 ret = NULL;
cl349@5357 357 }
cl349@5357 358
cl349@5357 359 free(strings);
cl349@5357 360 return ret;
cl349@5357 361 }
cl349@5357 362
cl349@5357 363 /* Set permissions of node (must be owner).
cl349@5357 364 * Returns false on failure.
cl349@5357 365 */
cl349@5357 366 bool xs_set_permissions(struct xs_handle *h, const char *path,
cl349@5357 367 struct xs_permissions *perms,
cl349@5357 368 unsigned int num_perms)
cl349@5357 369 {
cl349@5357 370 unsigned int i;
cl349@5357 371 struct iovec iov[1+num_perms];
cl349@5357 372
cl349@5357 373 iov[0].iov_base = (void *)path;
cl349@5357 374 iov[0].iov_len = strlen(path) + 1;
cl349@5357 375
cl349@5357 376 for (i = 0; i < num_perms; i++) {
cl349@5357 377 char buffer[MAX_STRLEN(domid_t)+1];
cl349@5357 378
kaf24@5423 379 if (!xs_perm_to_string(&perms[i], buffer))
cl349@5357 380 goto unwind;
cl349@5357 381
cl349@5357 382 iov[i+1].iov_base = strdup(buffer);
cl349@5357 383 iov[i+1].iov_len = strlen(buffer) + 1;
cl349@5357 384 if (!iov[i+1].iov_base)
cl349@5357 385 goto unwind;
cl349@5357 386 }
cl349@5357 387
cl349@5357 388 if (!xs_bool(xs_talkv(h, XS_SET_PERMS, iov, 1+num_perms, NULL)))
cl349@5357 389 goto unwind;
cl349@5357 390 for (i = 0; i < num_perms; i++)
cl349@5357 391 free(iov[i+1].iov_base);
cl349@5357 392 return true;
cl349@5357 393
cl349@5357 394 unwind:
cl349@5357 395 num_perms = i;
cl349@5357 396 for (i = 0; i < num_perms; i++)
cl349@5357 397 free_no_errno(iov[i+1].iov_base);
cl349@5357 398 return false;
cl349@5357 399 }
cl349@5357 400
cl349@5357 401 /* Watch a node for changes (poll on fd to detect, or call read_watch()).
cl349@5357 402 * When the node (or any child) changes, fd will become readable.
cl349@5357 403 * Priority indicates order if multiple watchers: higher is first.
cl349@5357 404 * Returns false on failure.
cl349@5357 405 */
cl349@5357 406 bool xs_watch(struct xs_handle *h, const char *path, unsigned int priority)
cl349@5357 407 {
cl349@5357 408 char prio[MAX_STRLEN(priority)];
cl349@5357 409 struct iovec iov[2];
cl349@5357 410
cl349@5357 411 sprintf(prio, "%u", priority);
cl349@5357 412 iov[0].iov_base = (void *)path;
cl349@5357 413 iov[0].iov_len = strlen(path) + 1;
cl349@5357 414 iov[1].iov_base = prio;
cl349@5357 415 iov[1].iov_len = strlen(prio) + 1;
cl349@5357 416
cl349@5357 417 return xs_bool(xs_talkv(h, XS_WATCH, iov, ARRAY_SIZE(iov), NULL));
cl349@5357 418 }
cl349@5357 419
cl349@5357 420 /* Find out what node change was on (will block if nothing pending).
cl349@5357 421 * Returns malloced path, or NULL: call free() after use.
cl349@5357 422 */
cl349@5357 423 char *xs_read_watch(struct xs_handle *h)
cl349@5357 424 {
cl349@5357 425 struct xsd_sockmsg msg;
cl349@5357 426 char *path;
cl349@5357 427
cl349@5357 428 if (!read_all(h->fd, &msg, sizeof(msg)))
cl349@5357 429 return NULL;
cl349@5357 430
cl349@5357 431 assert(msg.type == XS_WATCH_EVENT);
cl349@5357 432 path = malloc(msg.len);
cl349@5357 433 if (!path)
cl349@5357 434 return NULL;
cl349@5357 435
cl349@5357 436 if (!read_all(h->fd, path, msg.len)) {
cl349@5357 437 free_no_errno(path);
cl349@5357 438 return NULL;
cl349@5357 439 }
cl349@5357 440 return path;
cl349@5357 441 }
cl349@5357 442
cl349@5357 443 /* Acknowledge watch on node. Watches must be acknowledged before
cl349@5357 444 * any other watches can be read.
cl349@5357 445 * Returns false on failure.
cl349@5357 446 */
cl349@5357 447 bool xs_acknowledge_watch(struct xs_handle *h)
cl349@5357 448 {
cl349@5357 449 return xs_bool(xs_single(h, XS_WATCH_ACK, "OK", NULL));
cl349@5357 450 }
cl349@5357 451
cl349@5357 452 /* Remove a watch on a node.
cl349@5357 453 * Returns false on failure (no watch on that node).
cl349@5357 454 */
cl349@5357 455 bool xs_unwatch(struct xs_handle *h, const char *path)
cl349@5357 456 {
cl349@5357 457 return xs_bool(xs_single(h, XS_UNWATCH, path, NULL));
cl349@5357 458 }
cl349@5357 459
cl349@5357 460 /* Start a transaction: changes by others will not be seen during this
cl349@5357 461 * transaction, and changes will not be visible to others until end.
cl349@5357 462 * Transaction only applies to the given subtree.
cl349@5357 463 * You can only have one transaction at any time.
cl349@5357 464 * Returns false on failure.
cl349@5357 465 */
cl349@5357 466 bool xs_transaction_start(struct xs_handle *h, const char *subtree)
cl349@5357 467 {
cl349@5357 468 return xs_bool(xs_single(h, XS_TRANSACTION_START, subtree, NULL));
cl349@5357 469 }
cl349@5357 470
cl349@5357 471 /* End a transaction.
cl349@5357 472 * If abandon is true, transaction is discarded instead of committed.
cl349@5357 473 * Returns false on failure, which indicates an error: transactions will
cl349@5357 474 * not fail spuriously.
cl349@5357 475 */
cl349@5357 476 bool xs_transaction_end(struct xs_handle *h, bool abort)
cl349@5357 477 {
cl349@5357 478 char abortstr[2];
cl349@5357 479
cl349@5357 480 if (abort)
cl349@5357 481 strcpy(abortstr, "F");
cl349@5357 482 else
cl349@5357 483 strcpy(abortstr, "T");
cl349@5357 484 return xs_bool(xs_single(h, XS_TRANSACTION_END, abortstr, NULL));
cl349@5357 485 }
cl349@5357 486
cl349@5357 487 /* Introduce a new domain.
cl349@5357 488 * This tells the store daemon about a shared memory page and event channel
cl349@5357 489 * associated with a domain: the domain uses these to communicate.
cl349@5357 490 */
cl349@5357 491 bool xs_introduce_domain(struct xs_handle *h,
cl349@5357 492 domid_t domid,
cl349@5357 493 unsigned long mfn,
cl349@5357 494 unsigned int eventchn,
cl349@5357 495 const char *path)
cl349@5357 496 {
cl349@5357 497 char domid_str[MAX_STRLEN(domid)];
cl349@5357 498 char mfn_str[MAX_STRLEN(mfn)];
cl349@5357 499 char eventchn_str[MAX_STRLEN(eventchn)];
cl349@5357 500 struct iovec iov[4];
cl349@5357 501
cl349@5357 502 sprintf(domid_str, "%u", domid);
cl349@5357 503 sprintf(mfn_str, "%lu", mfn);
cl349@5357 504 sprintf(eventchn_str, "%u", eventchn);
cl349@5357 505
cl349@5357 506 iov[0].iov_base = domid_str;
cl349@5357 507 iov[0].iov_len = strlen(domid_str) + 1;
cl349@5357 508 iov[1].iov_base = mfn_str;
cl349@5357 509 iov[1].iov_len = strlen(mfn_str) + 1;
cl349@5357 510 iov[2].iov_base = eventchn_str;
cl349@5357 511 iov[2].iov_len = strlen(eventchn_str) + 1;
cl349@5357 512 iov[3].iov_base = (char *)path;
cl349@5357 513 iov[3].iov_len = strlen(path) + 1;
cl349@5357 514
cl349@5357 515 return xs_bool(xs_talkv(h, XS_INTRODUCE, iov, ARRAY_SIZE(iov), NULL));
cl349@5357 516 }
cl349@5357 517
cl349@5357 518 bool xs_release_domain(struct xs_handle *h,
cl349@5357 519 domid_t domid)
cl349@5357 520 {
cl349@5357 521 char domid_str[MAX_STRLEN(domid)];
cl349@5357 522
cl349@5357 523 sprintf(domid_str, "%u", domid);
cl349@5357 524
cl349@5357 525 return xs_bool(xs_single(h, XS_RELEASE, domid_str, NULL));
cl349@5357 526 }
cl349@5357 527
cl349@5357 528 bool xs_shutdown(struct xs_handle *h)
cl349@5357 529 {
cl349@5357 530 bool ret = xs_bool(xs_single(h, XS_SHUTDOWN, "", NULL));
cl349@5357 531 if (ret) {
cl349@5357 532 char c;
cl349@5357 533 /* Wait for it to actually shutdown. */
cl349@5357 534 read(h->fd, &c, 1);
cl349@5357 535 }
cl349@5357 536 return ret;
cl349@5357 537 }
cl349@5357 538
cl349@5357 539 /* Only useful for DEBUG versions */
cl349@5357 540 char *xs_debug_command(struct xs_handle *h, const char *cmd,
cl349@5357 541 void *data, unsigned int len)
cl349@5357 542 {
cl349@5357 543 struct iovec iov[2];
cl349@5357 544
cl349@5357 545 iov[0].iov_base = (void *)cmd;
cl349@5357 546 iov[0].iov_len = strlen(cmd) + 1;
cl349@5357 547 iov[1].iov_base = data;
cl349@5357 548 iov[1].iov_len = len;
cl349@5357 549
cl349@5357 550 return xs_talkv(h, XS_DEBUG, iov, ARRAY_SIZE(iov), NULL);
cl349@5357 551 }