xen-vtx-unstable

annotate tools/xenstore/xs.c @ 6636:8f21344e7817

find changesets by author, revision, files, or words in the commit message
Avoid warn_unused error on read() return value.
Signed-off-by: Keir Fraser <keir@xensource.com>
author kaf24@firebug.cl.cam.ac.uk
date Tue Sep 06 16:10:22 2005 +0000 (2005-09-06)
parents 2a1b32bb4df4
children d4d69c509371
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
kaf24@6008 5 This library is free software; you can redistribute it and/or
kaf24@6008 6 modify it under the terms of the GNU Lesser General Public
kaf24@6008 7 License as published by the Free Software Foundation; either
kaf24@6008 8 version 2.1 of the License, or (at your option) any later version.
cl349@5357 9
kaf24@6008 10 This library is distributed in the hope that it will be useful,
cl349@5357 11 but WITHOUT ANY WARRANTY; without even the implied warranty of
kaf24@6008 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
kaf24@6008 13 Lesser General Public License for more details.
cl349@5357 14
kaf24@6008 15 You should have received a copy of the GNU Lesser General Public
kaf24@6008 16 License along with this library; if not, write to the Free Software
kaf24@6008 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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@6601 34 #include <sys/ioctl.h>
cl349@5357 35 #include "xs.h"
cl349@5357 36 #include "xenstored.h"
cl349@5357 37 #include "xs_lib.h"
cl349@5357 38 #include "utils.h"
cl349@6601 39 #include "xenbus_dev.h"
cl349@5357 40
cl349@5357 41 struct xs_handle
cl349@5357 42 {
cl349@5357 43 int fd;
cl349@6601 44 enum { SOCK, DEV } type;
cl349@5357 45 };
cl349@5357 46
cl349@5357 47 /* Get the socket from the store daemon handle.
cl349@5357 48 */
cl349@5357 49 int xs_fileno(struct xs_handle *h)
cl349@5357 50 {
cl349@5357 51 return h->fd;
cl349@5357 52 }
cl349@5357 53
cl349@5357 54 static struct xs_handle *get_socket(const char *connect_to)
cl349@5357 55 {
cl349@5357 56 struct sockaddr_un addr;
cl349@5357 57 int sock, saved_errno;
cl349@5357 58 struct xs_handle *h = NULL;
cl349@5357 59
cl349@5357 60 sock = socket(PF_UNIX, SOCK_STREAM, 0);
cl349@5357 61 if (sock < 0)
cl349@5357 62 return NULL;
cl349@5357 63
cl349@5357 64 addr.sun_family = AF_UNIX;
cl349@5357 65 strcpy(addr.sun_path, connect_to);
cl349@5357 66
cl349@5357 67 if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == 0) {
cl349@5357 68 h = malloc(sizeof(*h));
cl349@5357 69 if (h) {
cl349@5357 70 h->fd = sock;
cl349@6601 71 h->type = SOCK;
cl349@5357 72 return h;
cl349@5357 73 }
cl349@5357 74 }
cl349@5357 75
cl349@5357 76 saved_errno = errno;
cl349@5357 77 close(sock);
cl349@6601 78 errno = saved_errno;
cl349@6601 79 return NULL;
cl349@6601 80 }
cl349@6601 81
cl349@6601 82 static struct xs_handle *get_dev(const char *connect_to)
cl349@6601 83 {
cl349@6601 84 int fd, saved_errno;
cl349@6601 85 struct xs_handle *h = NULL;
cl349@6601 86
cl349@6601 87 fd = open(connect_to, O_RDONLY);
cl349@6601 88 if (fd < 0)
cl349@6601 89 return NULL;
cl349@6601 90
cl349@6601 91 h = malloc(sizeof(*h));
cl349@6601 92 if (h) {
cl349@6601 93 h->fd = fd;
cl349@6601 94 h->type = DEV;
cl349@6601 95 return h;
cl349@6601 96 }
cl349@6601 97
cl349@6601 98 saved_errno = errno;
cl349@6601 99 close(fd);
cl349@5357 100 errno = saved_errno;
cl349@5357 101 return NULL;
cl349@5357 102 }
cl349@5357 103
cl349@5357 104 struct xs_handle *xs_daemon_open(void)
cl349@5357 105 {
cl349@5357 106 return get_socket(xs_daemon_socket());
cl349@5357 107 }
cl349@5357 108
cl349@5357 109 struct xs_handle *xs_daemon_open_readonly(void)
cl349@5357 110 {
cl349@5357 111 return get_socket(xs_daemon_socket_ro());
cl349@5357 112 }
cl349@5357 113
cl349@6601 114 struct xs_handle *xs_domain_open(void)
cl349@6601 115 {
cl349@6601 116 return get_dev(xs_domain_dev());
cl349@6601 117 }
cl349@6601 118
cl349@5357 119 void xs_daemon_close(struct xs_handle *h)
cl349@5357 120 {
cl349@5357 121 if (h->fd >= 0)
cl349@5357 122 close(h->fd);
cl349@5357 123 free(h);
cl349@5357 124 }
cl349@5357 125
cl349@5357 126 static bool read_all(int fd, void *data, unsigned int len)
cl349@5357 127 {
cl349@5357 128 while (len) {
cl349@5357 129 int done;
cl349@5357 130
cl349@5357 131 done = read(fd, data, len);
cl349@5357 132 if (done < 0) {
cl349@5357 133 if (errno == EINTR)
cl349@5357 134 continue;
cl349@5357 135 return false;
cl349@5357 136 }
cl349@5357 137 if (done == 0) {
cl349@5357 138 /* It closed fd on us? EBADF is appropriate. */
cl349@5357 139 errno = EBADF;
cl349@5357 140 return false;
cl349@5357 141 }
cl349@5357 142 data += done;
cl349@5357 143 len -= done;
cl349@5357 144 }
cl349@5357 145
cl349@5357 146 return true;
cl349@5357 147 }
cl349@5357 148
cl349@5357 149 #ifdef XSTEST
cl349@5357 150 #define read_all read_all_choice
kaf24@5423 151 #define xs_write_all write_all_choice
cl349@5357 152 #endif
cl349@5357 153
cl349@5357 154 static int get_error(const char *errorstring)
cl349@5357 155 {
cl349@5357 156 unsigned int i;
cl349@5357 157
cl349@5357 158 for (i = 0; !streq(errorstring, xsd_errors[i].errstring); i++)
cl349@5357 159 if (i == ARRAY_SIZE(xsd_errors) - 1)
cl349@5357 160 return EINVAL;
cl349@5357 161 return xsd_errors[i].errnum;
cl349@5357 162 }
cl349@5357 163
cl349@5522 164 /* Adds extra nul terminator, because we generally (always?) hold strings. */
cl349@5357 165 static void *read_reply(int fd, enum xsd_sockmsg_type *type, unsigned int *len)
cl349@5357 166 {
cl349@5357 167 struct xsd_sockmsg msg;
cl349@5357 168 void *ret;
cl349@5357 169 int saved_errno;
cl349@5357 170
cl349@5357 171 if (!read_all(fd, &msg, sizeof(msg)))
cl349@5357 172 return NULL;
cl349@5357 173
cl349@5522 174 ret = malloc(msg.len + 1);
cl349@5357 175 if (!ret)
cl349@5357 176 return NULL;
cl349@5357 177
cl349@5357 178 if (!read_all(fd, ret, msg.len)) {
cl349@5357 179 saved_errno = errno;
cl349@5357 180 free(ret);
cl349@5357 181 errno = saved_errno;
cl349@5357 182 return NULL;
cl349@5357 183 }
cl349@5357 184
cl349@5357 185 *type = msg.type;
cl349@5357 186 if (len)
cl349@5357 187 *len = msg.len;
cl349@5522 188 ((char *)ret)[msg.len] = '\0';
cl349@5357 189 return ret;
cl349@5357 190 }
cl349@5357 191
cl349@5357 192 /* Send message to xs, get malloc'ed reply. NULL and set errno on error. */
cl349@6601 193 static void *xs_talkv_sock(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@6601 194 const struct iovec *iovec, unsigned int num_vecs,
cl349@6601 195 unsigned int *len)
cl349@5357 196 {
cl349@5357 197 struct xsd_sockmsg msg;
cl349@5357 198 void *ret = NULL;
cl349@5357 199 int saved_errno;
cl349@5357 200 unsigned int i;
cl349@5357 201 struct sigaction ignorepipe, oldact;
cl349@5357 202
cl349@5357 203 msg.type = type;
cl349@5357 204 msg.len = 0;
cl349@5357 205 for (i = 0; i < num_vecs; i++)
cl349@5357 206 msg.len += iovec[i].iov_len;
cl349@5357 207
cl349@5357 208 ignorepipe.sa_handler = SIG_IGN;
cl349@5357 209 sigemptyset(&ignorepipe.sa_mask);
cl349@5357 210 ignorepipe.sa_flags = 0;
cl349@5357 211 sigaction(SIGPIPE, &ignorepipe, &oldact);
cl349@5357 212
kaf24@5423 213 if (!xs_write_all(h->fd, &msg, sizeof(msg)))
cl349@5357 214 goto fail;
cl349@5357 215
cl349@5357 216 for (i = 0; i < num_vecs; i++)
kaf24@5423 217 if (!xs_write_all(h->fd, iovec[i].iov_base, iovec[i].iov_len))
cl349@5357 218 goto fail;
cl349@5357 219
cl349@5357 220 /* Watches can have fired before reply comes: daemon detects
cl349@5357 221 * and re-transmits, so we can ignore this. */
cl349@5357 222 do {
cl349@5357 223 free(ret);
cl349@5357 224 ret = read_reply(h->fd, &msg.type, len);
cl349@5357 225 if (!ret)
cl349@5357 226 goto fail;
cl349@5357 227 } while (msg.type == XS_WATCH_EVENT);
cl349@5357 228
cl349@5357 229 sigaction(SIGPIPE, &oldact, NULL);
cl349@5357 230 if (msg.type == XS_ERROR) {
cl349@5357 231 saved_errno = get_error(ret);
cl349@5357 232 free(ret);
cl349@5357 233 errno = saved_errno;
cl349@5357 234 return NULL;
cl349@5357 235 }
cl349@5357 236
kaf24@6043 237 if (msg.type != type) {
kaf24@6043 238 free(ret);
kaf24@6043 239 saved_errno = EBADF;
kaf24@6043 240 goto close_fd;
kaf24@6043 241
kaf24@6043 242 }
cl349@5357 243 return ret;
cl349@5357 244
cl349@5357 245 fail:
cl349@5357 246 /* We're in a bad state, so close fd. */
cl349@5357 247 saved_errno = errno;
cl349@5357 248 sigaction(SIGPIPE, &oldact, NULL);
kaf24@6043 249 close_fd:
cl349@5357 250 close(h->fd);
cl349@5357 251 h->fd = -1;
cl349@5357 252 errno = saved_errno;
cl349@5357 253 return NULL;
cl349@5357 254 }
cl349@5357 255
cl349@6601 256 /* Send message to xs, get malloc'ed reply. NULL and set errno on error. */
cl349@6601 257 static void *xs_talkv_dev(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@6601 258 const struct iovec *iovec, unsigned int num_vecs,
cl349@6601 259 unsigned int *len)
cl349@6601 260 {
cl349@6601 261 struct xenbus_dev_talkv dt;
cl349@6601 262 char *buf;
cl349@6601 263 int err, buflen = 1024;
cl349@6601 264
cl349@6601 265 again:
cl349@6601 266 buf = malloc(buflen);
cl349@6601 267 if (buf == NULL) {
cl349@6601 268 errno = ENOMEM;
cl349@6601 269 return NULL;
cl349@6601 270 }
cl349@6601 271 dt.type = type;
cl349@6601 272 dt.iovec = (struct kvec *)iovec;
cl349@6601 273 dt.num_vecs = num_vecs;
cl349@6601 274 dt.buf = buf;
cl349@6601 275 dt.len = buflen;
cl349@6601 276 err = ioctl(h->fd, IOCTL_XENBUS_DEV_TALKV, &dt);
cl349@6601 277 if (err < 0) {
cl349@6601 278 free(buf);
cl349@6601 279 errno = err;
cl349@6601 280 return NULL;
cl349@6601 281 }
cl349@6601 282 if (err > buflen) {
cl349@6601 283 free(buf);
cl349@6601 284 buflen = err;
cl349@6601 285 goto again;
cl349@6601 286 }
cl349@6601 287 if (len)
cl349@6601 288 *len = err;
cl349@6601 289 return buf;
cl349@6601 290 }
cl349@6601 291
cl349@6601 292 /* Send message to xs, get malloc'ed reply. NULL and set errno on error. */
cl349@6601 293 static void *xs_talkv(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@6601 294 const struct iovec *iovec, unsigned int num_vecs,
cl349@6601 295 unsigned int *len)
cl349@6601 296 {
cl349@6601 297 if (h->type == SOCK)
cl349@6601 298 return xs_talkv_sock(h, type, iovec, num_vecs, len);
cl349@6601 299 if (h->type == DEV)
cl349@6601 300 return xs_talkv_dev(h, type, iovec, num_vecs, len);
cl349@6601 301 return NULL;
cl349@6601 302 }
cl349@6601 303
cl349@5357 304 /* free(), but don't change errno. */
cl349@5357 305 static void free_no_errno(void *p)
cl349@5357 306 {
cl349@5357 307 int saved_errno = errno;
cl349@5357 308 free(p);
cl349@5357 309 errno = saved_errno;
cl349@5357 310 }
cl349@5357 311
cl349@5357 312 /* Simplified version of xs_talkv: single message. */
cl349@5357 313 static void *xs_single(struct xs_handle *h, enum xsd_sockmsg_type type,
cl349@5357 314 const char *string, unsigned int *len)
cl349@5357 315 {
cl349@5357 316 struct iovec iovec;
cl349@5357 317
cl349@5357 318 iovec.iov_base = (void *)string;
cl349@5357 319 iovec.iov_len = strlen(string) + 1;
cl349@5357 320 return xs_talkv(h, type, &iovec, 1, len);
cl349@5357 321 }
cl349@5357 322
cl349@5357 323 static bool xs_bool(char *reply)
cl349@5357 324 {
cl349@5357 325 if (!reply)
cl349@5357 326 return false;
cl349@5357 327 free(reply);
cl349@5357 328 return true;
cl349@5357 329 }
cl349@5357 330
cl349@5357 331 char **xs_directory(struct xs_handle *h, const char *path, unsigned int *num)
cl349@5357 332 {
cl349@5357 333 char *strings, *p, **ret;
cl349@5357 334 unsigned int len;
cl349@5357 335
cl349@5357 336 strings = xs_single(h, XS_DIRECTORY, path, &len);
cl349@5357 337 if (!strings)
cl349@5357 338 return NULL;
cl349@5357 339
cl349@5357 340 /* Count the strings. */
kaf24@5423 341 *num = xs_count_strings(strings, len);
cl349@5357 342
cl349@5357 343 /* Transfer to one big alloc for easy freeing. */
cl349@5357 344 ret = malloc(*num * sizeof(char *) + len);
cl349@5357 345 if (!ret) {
cl349@5357 346 free_no_errno(strings);
cl349@5357 347 return NULL;
cl349@5357 348 }
cl349@5357 349 memcpy(&ret[*num], strings, len);
cl349@5357 350 free_no_errno(strings);
cl349@5357 351
cl349@5357 352 strings = (char *)&ret[*num];
cl349@5357 353 for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
cl349@5357 354 ret[(*num)++] = p;
cl349@5357 355 return ret;
cl349@5357 356 }
cl349@5357 357
cl349@5522 358 /* Get the value of a single file, nul terminated.
cl349@5357 359 * Returns a malloced value: call free() on it after use.
cl349@5522 360 * len indicates length in bytes, not including the nul.
cl349@5357 361 */
cl349@5357 362 void *xs_read(struct xs_handle *h, const char *path, unsigned int *len)
cl349@5357 363 {
cl349@5357 364 return xs_single(h, XS_READ, path, len);
cl349@5357 365 }
cl349@5357 366
cl349@5357 367 /* Write the value of a single file.
cl349@5357 368 * Returns false on failure. createflags can be 0, O_CREAT, or O_CREAT|O_EXCL.
cl349@5357 369 */
cl349@5357 370 bool xs_write(struct xs_handle *h, const char *path,
cl349@5357 371 const void *data, unsigned int len, int createflags)
cl349@5357 372 {
cl349@5357 373 const char *flags;
cl349@5357 374 struct iovec iovec[3];
cl349@5357 375
cl349@5357 376 /* Format: Flags (as string), path, data. */
cl349@5357 377 if (createflags == 0)
cl349@5357 378 flags = XS_WRITE_NONE;
cl349@5357 379 else if (createflags == O_CREAT)
cl349@5357 380 flags = XS_WRITE_CREATE;
cl349@5357 381 else if (createflags == (O_CREAT|O_EXCL))
cl349@5357 382 flags = XS_WRITE_CREATE_EXCL;
cl349@5357 383 else {
cl349@5357 384 errno = EINVAL;
cl349@5357 385 return false;
cl349@5357 386 }
cl349@5357 387
cl349@5357 388 iovec[0].iov_base = (void *)path;
cl349@5357 389 iovec[0].iov_len = strlen(path) + 1;
cl349@5357 390 iovec[1].iov_base = (void *)flags;
cl349@5357 391 iovec[1].iov_len = strlen(flags) + 1;
cl349@5357 392 iovec[2].iov_base = (void *)data;
cl349@5357 393 iovec[2].iov_len = len;
cl349@5357 394
cl349@5357 395 return xs_bool(xs_talkv(h, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
cl349@5357 396 }
cl349@5357 397
cl349@5357 398 /* Create a new directory.
cl349@5357 399 * Returns false on failure.
cl349@5357 400 */
cl349@5357 401 bool xs_mkdir(struct xs_handle *h, const char *path)
cl349@5357 402 {
cl349@5357 403 return xs_bool(xs_single(h, XS_MKDIR, path, NULL));
cl349@5357 404 }
cl349@5357 405
cl349@5357 406 /* Destroy a file or directory (directories must be empty).
cl349@5357 407 * Returns false on failure.
cl349@5357 408 */
cl349@5357 409 bool xs_rm(struct xs_handle *h, const char *path)
cl349@5357 410 {
cl349@5357 411 return xs_bool(xs_single(h, XS_RM, path, NULL));
cl349@5357 412 }
cl349@5357 413
cl349@5357 414 /* Get permissions of node (first element is owner).
cl349@5357 415 * Returns malloced array, or NULL: call free() after use.
cl349@5357 416 */
cl349@5357 417 struct xs_permissions *xs_get_permissions(struct xs_handle *h,
cl349@5478 418 const char *path, unsigned int *num)
cl349@5357 419 {
cl349@5357 420 char *strings;
cl349@5357 421 unsigned int len;
cl349@5357 422 struct xs_permissions *ret;
cl349@5357 423
cl349@5357 424 strings = xs_single(h, XS_GET_PERMS, path, &len);
cl349@5357 425 if (!strings)
cl349@5357 426 return NULL;
cl349@5357 427
cl349@5357 428 /* Count the strings: each one perms then domid. */
kaf24@5423 429 *num = xs_count_strings(strings, len);
cl349@5357 430
cl349@5357 431 /* Transfer to one big alloc for easy freeing. */
cl349@5357 432 ret = malloc(*num * sizeof(struct xs_permissions));
cl349@5357 433 if (!ret) {
cl349@5357 434 free_no_errno(strings);
cl349@5357 435 return NULL;
cl349@5357 436 }
cl349@5357 437
kaf24@5423 438 if (!xs_strings_to_perms(ret, *num, strings)) {
cl349@5357 439 free_no_errno(ret);
cl349@5357 440 ret = NULL;
cl349@5357 441 }
cl349@5357 442
cl349@5357 443 free(strings);
cl349@5357 444 return ret;
cl349@5357 445 }
cl349@5357 446
cl349@5357 447 /* Set permissions of node (must be owner).
cl349@5357 448 * Returns false on failure.
cl349@5357 449 */
cl349@5357 450 bool xs_set_permissions(struct xs_handle *h, const char *path,
cl349@5357 451 struct xs_permissions *perms,
cl349@5357 452 unsigned int num_perms)
cl349@5357 453 {
cl349@5357 454 unsigned int i;
cl349@5357 455 struct iovec iov[1+num_perms];
cl349@5357 456
cl349@5357 457 iov[0].iov_base = (void *)path;
cl349@5357 458 iov[0].iov_len = strlen(path) + 1;
cl349@5357 459
cl349@5357 460 for (i = 0; i < num_perms; i++) {
cl349@5357 461 char buffer[MAX_STRLEN(domid_t)+1];
cl349@5357 462
kaf24@5423 463 if (!xs_perm_to_string(&perms[i], buffer))
cl349@5357 464 goto unwind;
cl349@5357 465
cl349@5357 466 iov[i+1].iov_base = strdup(buffer);
cl349@5357 467 iov[i+1].iov_len = strlen(buffer) + 1;
cl349@5357 468 if (!iov[i+1].iov_base)
cl349@5357 469 goto unwind;
cl349@5357 470 }
cl349@5357 471
cl349@5357 472 if (!xs_bool(xs_talkv(h, XS_SET_PERMS, iov, 1+num_perms, NULL)))
cl349@5357 473 goto unwind;
cl349@5357 474 for (i = 0; i < num_perms; i++)
cl349@5357 475 free(iov[i+1].iov_base);
cl349@5357 476 return true;
cl349@5357 477
cl349@5357 478 unwind:
cl349@5357 479 num_perms = i;
cl349@5357 480 for (i = 0; i < num_perms; i++)
cl349@5357 481 free_no_errno(iov[i+1].iov_base);
cl349@5357 482 return false;
cl349@5357 483 }
cl349@5357 484
cl349@5357 485 /* Watch a node for changes (poll on fd to detect, or call read_watch()).
cl349@5357 486 * When the node (or any child) changes, fd will become readable.
cl349@5478 487 * Token is returned when watch is read, to allow matching.
cl349@5357 488 * Returns false on failure.
cl349@5357 489 */
cl349@5856 490 bool xs_watch(struct xs_handle *h, const char *path, const char *token)
cl349@5357 491 {
cl349@5856 492 struct iovec iov[2];
cl349@5357 493
cl349@5357 494 iov[0].iov_base = (void *)path;
cl349@5357 495 iov[0].iov_len = strlen(path) + 1;
cl349@5478 496 iov[1].iov_base = (void *)token;
cl349@5478 497 iov[1].iov_len = strlen(token) + 1;
cl349@5357 498
cl349@5357 499 return xs_bool(xs_talkv(h, XS_WATCH, iov, ARRAY_SIZE(iov), NULL));
cl349@5357 500 }
cl349@5357 501
cl349@5357 502 /* Find out what node change was on (will block if nothing pending).
cl349@5478 503 * Returns array of two pointers: path and token, or NULL.
cl349@5478 504 * Call free() after use.
cl349@5357 505 */
cl349@5478 506 char **xs_read_watch(struct xs_handle *h)
cl349@5357 507 {
cl349@5357 508 struct xsd_sockmsg msg;
cl349@5478 509 char **ret;
cl349@5357 510
cl349@5357 511 if (!read_all(h->fd, &msg, sizeof(msg)))
cl349@5357 512 return NULL;
cl349@5357 513
cl349@5357 514 assert(msg.type == XS_WATCH_EVENT);
cl349@5478 515 ret = malloc(sizeof(char *)*2 + msg.len);
cl349@5478 516 if (!ret)
cl349@5357 517 return NULL;
cl349@5357 518
cl349@5478 519 ret[0] = (char *)(ret + 2);
cl349@5478 520 if (!read_all(h->fd, ret[0], msg.len)) {
cl349@5478 521 free_no_errno(ret);
cl349@5357 522 return NULL;
cl349@5357 523 }
cl349@5478 524 ret[1] = ret[0] + strlen(ret[0]) + 1;
cl349@5478 525 return ret;
cl349@5357 526 }
cl349@5357 527
cl349@5357 528 /* Acknowledge watch on node. Watches must be acknowledged before
cl349@5357 529 * any other watches can be read.
cl349@5357 530 * Returns false on failure.
cl349@5357 531 */
cl349@5478 532 bool xs_acknowledge_watch(struct xs_handle *h, const char *token)
cl349@5357 533 {
cl349@5478 534 return xs_bool(xs_single(h, XS_WATCH_ACK, token, NULL));
cl349@5357 535 }
cl349@5357 536
cl349@5357 537 /* Remove a watch on a node.
cl349@5357 538 * Returns false on failure (no watch on that node).
cl349@5357 539 */
cl349@5478 540 bool xs_unwatch(struct xs_handle *h, const char *path, const char *token)
cl349@5357 541 {
cl349@5478 542 struct iovec iov[2];
cl349@5478 543
cl349@5478 544 iov[0].iov_base = (char *)path;
cl349@5478 545 iov[0].iov_len = strlen(path) + 1;
cl349@5478 546 iov[1].iov_base = (char *)token;
cl349@5478 547 iov[1].iov_len = strlen(token) + 1;
cl349@5478 548
cl349@5478 549 return xs_bool(xs_talkv(h, XS_UNWATCH, iov, ARRAY_SIZE(iov), NULL));
cl349@5357 550 }
cl349@5357 551
cl349@5357 552 /* Start a transaction: changes by others will not be seen during this
cl349@5357 553 * transaction, and changes will not be visible to others until end.
cl349@5357 554 * Transaction only applies to the given subtree.
cl349@5357 555 * You can only have one transaction at any time.
cl349@5357 556 * Returns false on failure.
cl349@5357 557 */
cl349@5357 558 bool xs_transaction_start(struct xs_handle *h, const char *subtree)
cl349@5357 559 {
cl349@5357 560 return xs_bool(xs_single(h, XS_TRANSACTION_START, subtree, NULL));
cl349@5357 561 }
cl349@5357 562
cl349@5357 563 /* End a transaction.
cl349@5357 564 * If abandon is true, transaction is discarded instead of committed.
cl349@5357 565 * Returns false on failure, which indicates an error: transactions will
cl349@5357 566 * not fail spuriously.
cl349@5357 567 */
cl349@5357 568 bool xs_transaction_end(struct xs_handle *h, bool abort)
cl349@5357 569 {
cl349@5357 570 char abortstr[2];
cl349@5357 571
cl349@5357 572 if (abort)
cl349@5357 573 strcpy(abortstr, "F");
cl349@5357 574 else
cl349@5357 575 strcpy(abortstr, "T");
cl349@5357 576 return xs_bool(xs_single(h, XS_TRANSACTION_END, abortstr, NULL));
cl349@5357 577 }
cl349@5357 578
cl349@5357 579 /* Introduce a new domain.
cl349@5357 580 * This tells the store daemon about a shared memory page and event channel
cl349@5357 581 * associated with a domain: the domain uses these to communicate.
cl349@5357 582 */
cl349@5478 583 bool xs_introduce_domain(struct xs_handle *h, domid_t domid, unsigned long mfn,
cl349@5478 584 unsigned int eventchn, const char *path)
cl349@5357 585 {
cl349@5357 586 char domid_str[MAX_STRLEN(domid)];
cl349@5357 587 char mfn_str[MAX_STRLEN(mfn)];
cl349@5357 588 char eventchn_str[MAX_STRLEN(eventchn)];
cl349@5357 589 struct iovec iov[4];
cl349@5357 590
cl349@5357 591 sprintf(domid_str, "%u", domid);
cl349@5357 592 sprintf(mfn_str, "%lu", mfn);
cl349@5357 593 sprintf(eventchn_str, "%u", eventchn);
cl349@5357 594
cl349@5357 595 iov[0].iov_base = domid_str;
cl349@5357 596 iov[0].iov_len = strlen(domid_str) + 1;
cl349@5357 597 iov[1].iov_base = mfn_str;
cl349@5357 598 iov[1].iov_len = strlen(mfn_str) + 1;
cl349@5357 599 iov[2].iov_base = eventchn_str;
cl349@5357 600 iov[2].iov_len = strlen(eventchn_str) + 1;
cl349@5357 601 iov[3].iov_base = (char *)path;
cl349@5357 602 iov[3].iov_len = strlen(path) + 1;
cl349@5357 603
cl349@5357 604 return xs_bool(xs_talkv(h, XS_INTRODUCE, iov, ARRAY_SIZE(iov), NULL));
cl349@5357 605 }
cl349@5357 606
cl349@5478 607 bool xs_release_domain(struct xs_handle *h, domid_t domid)
cl349@5357 608 {
cl349@5357 609 char domid_str[MAX_STRLEN(domid)];
cl349@5357 610
cl349@5357 611 sprintf(domid_str, "%u", domid);
cl349@5357 612
cl349@5357 613 return xs_bool(xs_single(h, XS_RELEASE, domid_str, NULL));
cl349@5357 614 }
cl349@5357 615
cl349@6625 616 char *xs_get_domain_path(struct xs_handle *h, domid_t domid)
cl349@6625 617 {
cl349@6625 618 char domid_str[MAX_STRLEN(domid)];
cl349@6625 619
cl349@6625 620 sprintf(domid_str, "%u", domid);
cl349@6625 621
cl349@6625 622 return xs_single(h, XS_GET_DOMAIN_PATH, domid_str, NULL);
cl349@6625 623 }
cl349@6625 624
cl349@5357 625 bool xs_shutdown(struct xs_handle *h)
cl349@5357 626 {
cl349@5357 627 bool ret = xs_bool(xs_single(h, XS_SHUTDOWN, "", NULL));
cl349@5357 628 if (ret) {
cl349@5357 629 char c;
cl349@5357 630 /* Wait for it to actually shutdown. */
kaf24@6636 631 while ((read(h->fd, &c, 1) < 0) && (errno == EINTR))
kaf24@6636 632 continue;
cl349@5357 633 }
cl349@5357 634 return ret;
cl349@5357 635 }
cl349@5357 636
cl349@5357 637 /* Only useful for DEBUG versions */
cl349@5357 638 char *xs_debug_command(struct xs_handle *h, const char *cmd,
cl349@5357 639 void *data, unsigned int len)
cl349@5357 640 {
cl349@5357 641 struct iovec iov[2];
cl349@5357 642
cl349@5357 643 iov[0].iov_base = (void *)cmd;
cl349@5357 644 iov[0].iov_len = strlen(cmd) + 1;
cl349@5357 645 iov[1].iov_base = data;
cl349@5357 646 iov[1].iov_len = len;
cl349@5357 647
cl349@5357 648 return xs_talkv(h, XS_DEBUG, iov, ARRAY_SIZE(iov), NULL);
cl349@5357 649 }