1.1 --- a/.rootkeys	Mon Jun 06 20:28:33 2005 +0000
     1.2 +++ b/.rootkeys	Tue Jun 07 12:43:58 2005 +0000
     1.3 @@ -996,6 +996,43 @@ 41d58ba6ijEF6fedqRO5vFu7uCirZg tools/xcs
     1.4  4292540couq-V0TPwyQ6bspNEWNcvw tools/xcutils/Makefile
     1.5  42925407VysDb9O06OK_RUzTZxfLoA tools/xcutils/xc_restore.c
     1.6  42936745WTLYamYsmXm_JGJ72JX-_Q tools/xcutils/xc_save.c
     1.7 +42a57d97mxMTlPnxBKep6R4ViI5rjg tools/xenstore/.gdbinit
     1.8 +42a57d97ZEoHuhMAFTuBMlLzA9v_ng tools/xenstore/Makefile
     1.9 +42a57d97ccA4uY-RxONvIH0P8U0gqg tools/xenstore/TODO
    1.10 +42a57d972RzmyLgsoH9b8qqk-UjcCA tools/xenstore/fake_libxc.c
    1.11 +42a57d97IjoPvbIVc4BUzwoKyM0VSw tools/xenstore/list.h
    1.12 +42a57d97fKgtf0HQLiQkAkVsOvuSyA tools/xenstore/talloc.c
    1.13 +42a57d98U3p0XP6xzCybTuaVQscUdw tools/xenstore/talloc.h
    1.14 +42a57d98LFN6Mug-uR4xgAxCE7lwUg tools/xenstore/talloc_guide.txt
    1.15 +42a57d98S69vKJYwO_WUjoFQZ6KzQg tools/xenstore/testsuite/01simple.sh
    1.16 +42a57d98BHcFpZz_fXHweylUEUU97Q tools/xenstore/testsuite/02directory.sh
    1.17 +42a57d98ua4Xeb6pmtbFNTAI833dyw tools/xenstore/testsuite/03write.sh
    1.18 +42a57d98nbuCUsVT0RJj1zA1JyMDsw tools/xenstore/testsuite/04rm.sh
    1.19 +42a57d98_ULKHP3_uX1PK2nPMTzWSQ tools/xenstore/testsuite/05filepermissions.sh
    1.20 +42a57d98YGCLyTDSGmoyFqRqQUlagQ tools/xenstore/testsuite/06dirpermissions.sh
    1.21 +42a57d98fdO519YyATk4_Zwr1STNfQ tools/xenstore/testsuite/07watch.sh
    1.22 +42a57d98zZUtvirUMjmHxFphJjmO7Q tools/xenstore/testsuite/08transaction.sh
    1.23 +42a57d98sn9RbpBgHRv1D99Kt7LwYA tools/xenstore/testsuite/09domain.sh
    1.24 +42a57d98tSuoFCHnnM2GgENXJrRQmw tools/xenstore/testsuite/test.sh
    1.25 +42a57d98zxDP2Ti7dTznGROi66rUGw tools/xenstore/utils.c
    1.26 +42a57d98SDvOYCEjmCjwHSk6390GLA tools/xenstore/utils.h
    1.27 +42a57d98hFKbOY9D0mCE4H4NDoKr1w tools/xenstore/xenstored.h
    1.28 +42a57d981KFHLmJ0CjKkn1_gZhYvdw tools/xenstore/xenstored_core.c
    1.29 +42a57d98bcgE13vYaFxGTusmWbrFDA tools/xenstore/xenstored_core.h
    1.30 +42a57d98cD9wOFyRYfaEP0QgtqL1Xw tools/xenstore/xenstored_domain.c
    1.31 +42a57d98noLWvXU8ePbcqvvmu4p2Gw tools/xenstore/xenstored_domain.h
    1.32 +42a57d98kxHaQ1ApS7RpqmFoEnDmbg tools/xenstore/xenstored_test.h
    1.33 +42a57d981c9P3aFkWtxWEIRUapt_FQ tools/xenstore/xenstored_transaction.c
    1.34 +42a57d99pVo__10bbckp_b_rm6i59A tools/xenstore/xenstored_transaction.h
    1.35 +42a57d99izTIjWfG-IjQAPqYlDWJNg tools/xenstore/xenstored_watch.c
    1.36 +42a57d99-zLxBjzC7rfj_perV-orUg tools/xenstore/xenstored_watch.h
    1.37 +42a57d99BnkhISKgCCRcUqhteyuxCw tools/xenstore/xs.c
    1.38 +42a57d99FyiYSz9AkKKROrRydnA-gQ tools/xenstore/xs.h
    1.39 +42a57d99SrtsJCDUlKyRPf3EX86A1Q tools/xenstore/xs_lib.c
    1.40 +42a57d99L2pYeMFyjQ_4Rnb17xTSMg tools/xenstore/xs_lib.h
    1.41 +42a57d99Kl6Ba8oCHv2fggl7QN9QZA tools/xenstore/xs_random.c
    1.42 +42a57d99SHYR1lQOD0shuErPDg9NKQ tools/xenstore/xs_stress.c
    1.43 +42a57d996aBawpkQNOWkNWXD6LrhPg tools/xenstore/xs_test.c
    1.44  403a3edbrr8RE34gkbR40zep98SXbg tools/xentrace/Makefile
    1.45  40a107afN60pFdURgBv9KwEzgRl5mQ tools/xentrace/formats
    1.46  420d52d2_znVbT4JAPIU36vQOme83g tools/xentrace/xenctx.c

     2.1 --- a/BitKeeper/etc/ignore	Mon Jun 06 20:28:33 2005 +0000
     2.2 +++ b/BitKeeper/etc/ignore	Tue Jun 07 12:43:58 2005 +0000
     2.3 @@ -128,8 +128,13 @@ tools/xcs/xcs
     2.4  tools/xcs/xcsdump
     2.5  tools/xcutils/xc_restore
     2.6  tools/xcutils/xc_save
     2.7 +tools/xenstore/testsuite/tmp/*
     2.8 +tools/xenstore/xen
     2.9 +tools/xenstore/xenstored_test
    2.10 +tools/xenstore/xs_random
    2.11 +tools/xenstore/xs_stress
    2.12 +tools/xenstore/xs_test
    2.13  tools/xentrace/xentrace
    2.14 -tools/xfrd/xfrd
    2.15  xen/BLOG
    2.16  xen/TAGS
    2.17  xen/arch/x86/asm-offsets.s

     3.1 --- a/tools/Makefile	Mon Jun 06 20:28:33 2005 +0000
     3.2 +++ b/tools/Makefile	Tue Jun 07 12:43:58 2005 +0000
     3.3 @@ -9,6 +9,7 @@ SUBDIRS += xentrace
     3.4  SUBDIRS += python
     3.5  SUBDIRS += xcs
     3.6  SUBDIRS += xcutils
     3.7 +SUBDIRS += xenstore
     3.8  SUBDIRS += pygrub
     3.9  
    3.10  .PHONY: all install clean check check_clean ioemu eioemuinstall ioemuclean

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/tools/xenstore/.gdbinit	Tue Jun 07 12:43:58 2005 +0000
     4.3 @@ -0,0 +1,4 @@
     4.4 +set environment XENSTORED_RUNDIR=testsuite/tmp
     4.5 +set environment XENSTORED_ROOTDIR=testsuite/tmp
     4.6 +handle SIGUSR1 noprint nostop
     4.7 +handle SIGPIPE noprint nostop

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/tools/xenstore/Makefile	Tue Jun 07 12:43:58 2005 +0000
     5.3 @@ -0,0 +1,97 @@
     5.4 +XEN_ROOT=../..
     5.5 +# This does something wrong to TARGET_ARCH.
     5.6 +#include $(XEN_ROOT)/tools/Rules.mk
     5.7 +LIBDIR = lib
     5.8 +XEN_LIBXC          = $(XEN_ROOT)/tools/libxc
     5.9 +
    5.10 +INSTALL         = install
    5.11 +INSTALL_DATA	= $(INSTALL) -m0644
    5.12 +INSTALL_PROG    = $(INSTALL) -m0755
    5.13 +INSTALL_DIR     = $(INSTALL) -d -m0755
    5.14 +
    5.15 +PROFILE=#-pg
    5.16 +BASECFLAGS=-Wall -W -g 
    5.17 +# Make gcc generate dependencies.
    5.18 +BASECFLAGS += -Wp,-MD,.$(@F).d
    5.19 +PROG_DEP = .*.d
    5.20 +#BASECFLAGS+= -O3 $(PROFILE)
    5.21 +#BASECFLAGS+= -I$(XEN_ROOT)/tools
    5.22 +BASECFLAGS+= -I$(XEN_ROOT)/tools/libxc
    5.23 +BASECFLAGS+= -I$(XEN_ROOT)/xen/include/public
    5.24 +BASECFLAGS+= -I.
    5.25 +
    5.26 +CFLAGS+=$(BASECFLAGS)
    5.27 +LDFLAGS=$(PROFILE) -L$(XEN_LIBXC)
    5.28 +TESTDIR=`pwd`/testsuite/tmp
    5.29 +TESTFLAGS=-DTESTING
    5.30 +TESTENV=XENSTORED_ROOTDIR=$(TESTDIR) XENSTORED_RUNDIR=$(TESTDIR)
    5.31 +
    5.32 +all: xen xenstored libxenstore.a
    5.33 +
    5.34 +testcode: xen xs_test xenstored_test xs_random
    5.35 +
    5.36 +xen:
    5.37 +	ln -sf $(XEN_ROOT)/xen/include/public $@
    5.38 +
    5.39 +xenstored: xenstored_core.o xenstored_watch.o xenstored_domain.o xenstored_transaction.o xs_lib.o talloc.o utils.o
    5.40 +	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -lxc -o $@
    5.41 +
    5.42 +xenstored_test: xenstored_core_test.o xenstored_watch_test.o xenstored_domain_test.o xenstored_transaction_test.o xs_lib.o talloc_test.o fake_libxc.o utils.o
    5.43 +	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@
    5.44 +
    5.45 +xs_test: xs_test.o xs_lib.o utils.o
    5.46 +xs_random: xs_random.o xs_test_lib.o xs_lib.o talloc.o utils.o
    5.47 +xs_stress: xs_stress.o xs_test_lib.o xs_lib.o talloc.o utils.o
    5.48 +
    5.49 +xs_test.o xs_stress.o xenstored_core_test.o xenstored_watch_test.o xenstored_transaction_test.o xenstored_domain_test.o xs_random.o xs_test_lib.o talloc_test.o fake_libxc.o: CFLAGS=$(BASECFLAGS) $(TESTFLAGS)
    5.50 +
    5.51 +xenstored_%_test.o: xenstored_%.c
    5.52 +	$(COMPILE.c) -o $@ $<
    5.53 +
    5.54 +xs_test_lib.o: xs.c
    5.55 +	$(COMPILE.c) -o $@ $<
    5.56 +
    5.57 +talloc_test.o: talloc.c
    5.58 +	$(COMPILE.c) -o $@ $<
    5.59 +
    5.60 +libxenstore.a: libxenstore.a(xs.o) libxenstore.a(xs_lib.o)
    5.61 +
    5.62 +clean: testsuite-clean
    5.63 +	rm -f *.o *.a xs_test xenstored xenstored_test xs_random xs_stress xen
    5.64 +	-$(RM) $(PROG_DEP)
    5.65 +
    5.66 +check: testsuite-run randomcheck stresstest
    5.67 +
    5.68 +testsuite-run: xen xenstored_test xs_test
    5.69 +	$(TESTENV) testsuite/test.sh
    5.70 +
    5.71 +testsuite-clean:
    5.72 +	rm -rf $(TESTDIR)
    5.73 +
    5.74 +# Make this visible so they can see repeat tests without --fast if they
    5.75 +# fail.
    5.76 +RANDSEED=$(shell date +%s)
    5.77 +randomcheck: xs_random xenstored_test
    5.78 +	$(TESTENV) ./xs_random --simple --fast /tmp/xs_random 200000 $(RANDSEED)
    5.79 +	$(TESTENV) ./xs_random --fast /tmp/xs_random 100000 $(RANDSEED)
    5.80 +	$(TESTENV) ./xs_random --fail /tmp/xs_random 10000 $(RANDSEED)
    5.81 +
    5.82 +stresstest: xs_stress xenstored_test
    5.83 +	rm -rf $(TESTDIR)/store
    5.84 +	export $(TESTENV); PID=`./xenstored_test --output-pid`; ./xs_stress 10000; ret=$$?; kill $$PID; exit $$ret
    5.85 +
    5.86 +TAGS:
    5.87 +	etags `find . -name '*.[ch]'`
    5.88 +
    5.89 +tarball: clean
    5.90 +	cd .. && tar -c -j -v -h -f xenstore.tar.bz2 xenstore/
    5.91 +
    5.92 +install: xenstored libxenstore.a
    5.93 +	$(INSTALL_DIR) -p $(DESTDIR)/var/run/xenstored
    5.94 +	$(INSTALL_DIR) -p $(DESTDIR)/var/lib/xenstored
    5.95 +	$(INSTALL_DIR) -p $(DESTDIR)/usr/sbin
    5.96 +	$(INSTALL_PROG) xenstored $(DESTDIR)/usr/sbin
    5.97 +	$(INSTALL_DIR) -p $(DESTDIR)/usr/$(LIBDIR)
    5.98 +	$(INSTALL_DATA) libxenstore.a $(DESTDIR)/usr/$(LIBDIR)
    5.99 +
   5.100 +-include $(PROG_DEP)

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/tools/xenstore/TODO	Tue Jun 07 12:43:58 2005 +0000
     6.3 @@ -0,0 +1,7 @@
     6.4 +TODO in no particular order.  Some of these will never be done.  There
     6.5 +are omissions of important but necessary things.  It is up to the
     6.6 +reader to fill in the blanks.
     6.7 +
     6.8 +- Remove calls to system() from daemon
     6.9 +- Timeout failed watch responses
    6.10 +- Timeout blocking transactions

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/tools/xenstore/fake_libxc.c	Tue Jun 07 12:43:58 2005 +0000
     7.3 @@ -0,0 +1,119 @@
     7.4 +/* 
     7.5 +    Fake libxc which doesn't require hypervisor but talks to xs_test.
     7.6 +    Copyright (C) 2005 Rusty Russell IBM Corporation
     7.7 +
     7.8 +    This program is free software; you can redistribute it and/or modify
     7.9 +    it under the terms of the GNU General Public License as published by
    7.10 +    the Free Software Foundation; either version 2 of the License, or
    7.11 +    (at your option) any later version.
    7.12 +
    7.13 +    This program is distributed in the hope that it will be useful,
    7.14 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
    7.15 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    7.16 +    GNU General Public License for more details.
    7.17 +
    7.18 +    You should have received a copy of the GNU General Public License
    7.19 +    along with this program; if not, write to the Free Software
    7.20 +    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    7.21 +*/
    7.22 +
    7.23 +#include <stdio.h>
    7.24 +#include <stdlib.h>
    7.25 +#include <sys/types.h>
    7.26 +#include <sys/stat.h>
    7.27 +#include <fcntl.h>
    7.28 +#include <sys/mman.h>
    7.29 +#include <unistd.h>
    7.30 +#include <assert.h>
    7.31 +#include <signal.h>
    7.32 +#include "utils.h"
    7.33 +#include "xenstored_core.h"
    7.34 +#include "xenstored_domain.h"
    7.35 +#include "xenstored_test.h"
    7.36 +
    7.37 +static int sigfd;
    7.38 +static int xs_test_pid;
    7.39 +static u16 port;
    7.40 +
    7.41 +/* The event channel maps to a signal, shared page to an mmapped file. */
    7.42 +int xc_evtchn_send(int xc_handle __attribute__((unused)), int local_port)
    7.43 +{
    7.44 +	assert(local_port == port);
    7.45 +	if (kill(xs_test_pid, SIGUSR2) != 0)
    7.46 +		barf_perror("fake event channel failed");
    7.47 +	return 0;
    7.48 +}
    7.49 +
    7.50 +void *xc_map_foreign_range(int xc_handle, u32 dom __attribute__((unused)),
    7.51 +			   int size, int prot,
    7.52 +			   unsigned long mfn __attribute__((unused)))
    7.53 +{
    7.54 +	void *ret;
    7.55 +
    7.56 +	ret = mmap(NULL, size, prot, MAP_SHARED, xc_handle, 0);
    7.57 +	if (ret == MAP_FAILED)
    7.58 +		return NULL;
    7.59 +
    7.60 +	/* xs_test tells us pid and port by putting it in buffer, we reply. */
    7.61 +	xs_test_pid = *(int *)(ret + 32);
    7.62 +	port = *(int *)(ret + 36);
    7.63 +	*(int *)(ret + 32) = getpid();
    7.64 +	return ret;
    7.65 +}
    7.66 +
    7.67 +int xc_interface_open(void)
    7.68 +{
    7.69 +	int fd;
    7.70 +	char page[getpagesize()];
    7.71 +
    7.72 +	fd = open("/tmp/xcmap", O_RDWR|O_CREAT|O_TRUNC, 0600);
    7.73 +	if (fd < 0)
    7.74 +		return fd;
    7.75 +
    7.76 +	memset(page, 0, sizeof(page));
    7.77 +	if (!write_all(fd, page, sizeof(page)))
    7.78 +		barf_perror("Failed to write /tmp/xcmap page");
    7.79 +	
    7.80 +	return fd;
    7.81 +}
    7.82 +
    7.83 +int xc_interface_close(int xc_handle)
    7.84 +{
    7.85 +	close(xc_handle);
    7.86 +	return 0;
    7.87 +}
    7.88 +
    7.89 +static void send_to_fd(int signo __attribute__((unused)))
    7.90 +{
    7.91 +	int saved_errno = errno;
    7.92 +	write(sigfd, &port, sizeof(port));
    7.93 +	errno = saved_errno;
    7.94 +}
    7.95 +
    7.96 +void fake_block_events(void)
    7.97 +{
    7.98 +	signal(SIGUSR2, SIG_IGN);
    7.99 +}
   7.100 +
   7.101 +void fake_ack_event(void)
   7.102 +{
   7.103 +	signal(SIGUSR2, send_to_fd);
   7.104 +}
   7.105 +
   7.106 +int fake_open_eventchn(void)
   7.107 +{
   7.108 +	int fds[2];
   7.109 +
   7.110 +	if (pipe(fds) != 0)
   7.111 +		return -1;
   7.112 +
   7.113 +	if (signal(SIGUSR2, send_to_fd) == SIG_ERR) {
   7.114 +		int saved_errno = errno;
   7.115 +		close(fds[0]);
   7.116 +		close(fds[1]);
   7.117 +		errno = saved_errno;
   7.118 +		return -1;
   7.119 +	}
   7.120 +	sigfd = fds[1];
   7.121 +	return fds[0];
   7.122 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/tools/xenstore/list.h	Tue Jun 07 12:43:58 2005 +0000
     8.3 @@ -0,0 +1,508 @@
     8.4 +#ifndef _LINUX_LIST_H
     8.5 +#define _LINUX_LIST_H
     8.6 +/* Taken from Linux kernel code, but de-kernelized for userspace. */
     8.7 +#include <stddef.h>
     8.8 +
     8.9 +/*
    8.10 + * These are non-NULL pointers that will result in page faults
    8.11 + * under normal circumstances, used to verify that nobody uses
    8.12 + * non-initialized list entries.
    8.13 + */
    8.14 +#define LIST_POISON1  ((void *) 0x00100100)
    8.15 +#define LIST_POISON2  ((void *) 0x00200200)
    8.16 +
    8.17 +#define container_of(ptr, type, member) ({			\
    8.18 +        const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
    8.19 +        (type *)( (char *)__mptr - offsetof(type,member) );})
    8.20 +
    8.21 +/*
    8.22 + * Simple doubly linked list implementation.
    8.23 + *
    8.24 + * Some of the internal functions ("__xxx") are useful when
    8.25 + * manipulating whole lists rather than single entries, as
    8.26 + * sometimes we already know the next/prev entries and we can
    8.27 + * generate better code by using them directly rather than
    8.28 + * using the generic single-entry routines.
    8.29 + */
    8.30 +
    8.31 +struct list_head {
    8.32 +	struct list_head *next, *prev;
    8.33 +};
    8.34 +
    8.35 +#define LIST_HEAD_INIT(name) { &(name), &(name) }
    8.36 +
    8.37 +#define LIST_HEAD(name) \
    8.38 +	struct list_head name = LIST_HEAD_INIT(name)
    8.39 +
    8.40 +#define INIT_LIST_HEAD(ptr) do { \
    8.41 +	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
    8.42 +} while (0)
    8.43 +
    8.44 +#define list_top(head, type, member)					  \
    8.45 +({ 									  \
    8.46 +	struct list_head *_head = (head);				  \
    8.47 +	list_empty(_head) ? NULL : list_entry(_head->next, type, member); \
    8.48 +})
    8.49 +
    8.50 +/*
    8.51 + * Insert a new entry between two known consecutive entries. 
    8.52 + *
    8.53 + * This is only for internal list manipulation where we know
    8.54 + * the prev/next entries already!
    8.55 + */
    8.56 +static inline void __list_add(struct list_head *new,
    8.57 +			      struct list_head *prev,
    8.58 +			      struct list_head *next)
    8.59 +{
    8.60 +	next->prev = new;
    8.61 +	new->next = next;
    8.62 +	new->prev = prev;
    8.63 +	prev->next = new;
    8.64 +}
    8.65 +
    8.66 +/**
    8.67 + * list_add - add a new entry
    8.68 + * @new: new entry to be added
    8.69 + * @head: list head to add it after
    8.70 + *
    8.71 + * Insert a new entry after the specified head.
    8.72 + * This is good for implementing stacks.
    8.73 + */
    8.74 +static inline void list_add(struct list_head *new, struct list_head *head)
    8.75 +{
    8.76 +	__list_add(new, head, head->next);
    8.77 +}
    8.78 +
    8.79 +/**
    8.80 + * list_add_tail - add a new entry
    8.81 + * @new: new entry to be added
    8.82 + * @head: list head to add it before
    8.83 + *
    8.84 + * Insert a new entry before the specified head.
    8.85 + * This is useful for implementing queues.
    8.86 + */
    8.87 +static inline void list_add_tail(struct list_head *new, struct list_head *head)
    8.88 +{
    8.89 +	__list_add(new, head->prev, head);
    8.90 +}
    8.91 +
    8.92 +/*
    8.93 + * Insert a new entry between two known consecutive entries. 
    8.94 + *
    8.95 + * This is only for internal list manipulation where we know
    8.96 + * the prev/next entries already!
    8.97 + */
    8.98 +static __inline__ void __list_add_rcu(struct list_head * new,
    8.99 +	struct list_head * prev,
   8.100 +	struct list_head * next)
   8.101 +{
   8.102 +	new->next = next;
   8.103 +	new->prev = prev;
   8.104 +	next->prev = new;
   8.105 +	prev->next = new;
   8.106 +}
   8.107 +
   8.108 +/**
   8.109 + * list_add_rcu - add a new entry to rcu-protected list
   8.110 + * @new: new entry to be added
   8.111 + * @head: list head to add it after
   8.112 + *
   8.113 + * Insert a new entry after the specified head.
   8.114 + * This is good for implementing stacks.
   8.115 + */
   8.116 +static __inline__ void list_add_rcu(struct list_head *new, struct list_head *head)
   8.117 +{
   8.118 +	__list_add_rcu(new, head, head->next);
   8.119 +}
   8.120 +
   8.121 +/**
   8.122 + * list_add_tail_rcu - add a new entry to rcu-protected list
   8.123 + * @new: new entry to be added
   8.124 + * @head: list head to add it before
   8.125 + *
   8.126 + * Insert a new entry before the specified head.
   8.127 + * This is useful for implementing queues.
   8.128 + */
   8.129 +static __inline__ void list_add_tail_rcu(struct list_head *new, struct list_head *head)
   8.130 +{
   8.131 +	__list_add_rcu(new, head->prev, head);
   8.132 +}
   8.133 +
   8.134 +/*
   8.135 + * Delete a list entry by making the prev/next entries
   8.136 + * point to each other.
   8.137 + *
   8.138 + * This is only for internal list manipulation where we know
   8.139 + * the prev/next entries already!
   8.140 + */
   8.141 +static inline void __list_del(struct list_head * prev, struct list_head * next)
   8.142 +{
   8.143 +	next->prev = prev;
   8.144 +	prev->next = next;
   8.145 +}
   8.146 +
   8.147 +/**
   8.148 + * list_del - deletes entry from list.
   8.149 + * @entry: the element to delete from the list.
   8.150 + * Note: list_empty on entry does not return true after this, the entry is
   8.151 + * in an undefined state.
   8.152 + */
   8.153 +static inline void list_del(struct list_head *entry)
   8.154 +{
   8.155 +	__list_del(entry->prev, entry->next);
   8.156 +	entry->next = LIST_POISON1;
   8.157 +	entry->prev = LIST_POISON2;
   8.158 +}
   8.159 +
   8.160 +/**
   8.161 + * list_del_rcu - deletes entry from list without re-initialization
   8.162 + * @entry: the element to delete from the list.
   8.163 + *
   8.164 + * Note: list_empty on entry does not return true after this, 
   8.165 + * the entry is in an undefined state. It is useful for RCU based
   8.166 + * lockfree traversal.
   8.167 + *
   8.168 + * In particular, it means that we can not poison the forward 
   8.169 + * pointers that may still be used for walking the list.
   8.170 + */
   8.171 +static inline void list_del_rcu(struct list_head *entry)
   8.172 +{
   8.173 +	__list_del(entry->prev, entry->next);
   8.174 +	entry->prev = LIST_POISON2;
   8.175 +}
   8.176 +
   8.177 +/**
   8.178 + * list_del_init - deletes entry from list and reinitialize it.
   8.179 + * @entry: the element to delete from the list.
   8.180 + */
   8.181 +static inline void list_del_init(struct list_head *entry)
   8.182 +{
   8.183 +	__list_del(entry->prev, entry->next);
   8.184 +	INIT_LIST_HEAD(entry); 
   8.185 +}
   8.186 +
   8.187 +/**
   8.188 + * list_move - delete from one list and add as another's head
   8.189 + * @list: the entry to move
   8.190 + * @head: the head that will precede our entry
   8.191 + */
   8.192 +static inline void list_move(struct list_head *list, struct list_head *head)
   8.193 +{
   8.194 +        __list_del(list->prev, list->next);
   8.195 +        list_add(list, head);
   8.196 +}
   8.197 +
   8.198 +/**
   8.199 + * list_move_tail - delete from one list and add as another's tail
   8.200 + * @list: the entry to move
   8.201 + * @head: the head that will follow our entry
   8.202 + */
   8.203 +static inline void list_move_tail(struct list_head *list,
   8.204 +				  struct list_head *head)
   8.205 +{
   8.206 +        __list_del(list->prev, list->next);
   8.207 +        list_add_tail(list, head);
   8.208 +}
   8.209 +
   8.210 +/**
   8.211 + * list_empty - tests whether a list is empty
   8.212 + * @head: the list to test.
   8.213 + */
   8.214 +static inline int list_empty(struct list_head *head)
   8.215 +{
   8.216 +	return head->next == head;
   8.217 +}
   8.218 +
   8.219 +static inline void __list_splice(struct list_head *list,
   8.220 +				 struct list_head *head)
   8.221 +{
   8.222 +	struct list_head *first = list->next;
   8.223 +	struct list_head *last = list->prev;
   8.224 +	struct list_head *at = head->next;
   8.225 +
   8.226 +	first->prev = head;
   8.227 +	head->next = first;
   8.228 +
   8.229 +	last->next = at;
   8.230 +	at->prev = last;
   8.231 +}
   8.232 +
   8.233 +/**
   8.234 + * list_splice - join two lists
   8.235 + * @list: the new list to add.
   8.236 + * @head: the place to add it in the first list.
   8.237 + */
   8.238 +static inline void list_splice(struct list_head *list, struct list_head *head)
   8.239 +{
   8.240 +	if (!list_empty(list))
   8.241 +		__list_splice(list, head);
   8.242 +}
   8.243 +
   8.244 +/**
   8.245 + * list_splice_init - join two lists and reinitialise the emptied list.
   8.246 + * @list: the new list to add.
   8.247 + * @head: the place to add it in the first list.
   8.248 + *
   8.249 + * The list at @list is reinitialised
   8.250 + */
   8.251 +static inline void list_splice_init(struct list_head *list,
   8.252 +				    struct list_head *head)
   8.253 +{
   8.254 +	if (!list_empty(list)) {
   8.255 +		__list_splice(list, head);
   8.256 +		INIT_LIST_HEAD(list);
   8.257 +	}
   8.258 +}
   8.259 +
   8.260 +/**
   8.261 + * list_entry - get the struct for this entry
   8.262 + * @ptr:	the &struct list_head pointer.
   8.263 + * @type:	the type of the struct this is embedded in.
   8.264 + * @member:	the name of the list_struct within the struct.
   8.265 + */
   8.266 +#define list_entry(ptr, type, member) \
   8.267 +	container_of(ptr, type, member)
   8.268 +
   8.269 +/**
   8.270 + * list_for_each	-	iterate over a list
   8.271 + * @pos:	the &struct list_head to use as a loop counter.
   8.272 + * @head:	the head for your list.
   8.273 + */
   8.274 +#define list_for_each(pos, head) \
   8.275 +	for (pos = (head)->next; pos != (head); pos = pos->next)
   8.276 +
   8.277 +/**
   8.278 + * list_for_each_prev	-	iterate over a list backwards
   8.279 + * @pos:	the &struct list_head to use as a loop counter.
   8.280 + * @head:	the head for your list.
   8.281 + */
   8.282 +#define list_for_each_prev(pos, head) \
   8.283 +	for (pos = (head)->prev; pos != (head); pos = pos->prev)
   8.284 +        	
   8.285 +/**
   8.286 + * list_for_each_safe	-	iterate over a list safe against removal of list entry
   8.287 + * @pos:	the &struct list_head to use as a loop counter.
   8.288 + * @n:		another &struct list_head to use as temporary storage
   8.289 + * @head:	the head for your list.
   8.290 + */
   8.291 +#define list_for_each_safe(pos, n, head) \
   8.292 +	for (pos = (head)->next, n = pos->next; pos != (head); \
   8.293 +		pos = n, n = pos->next)
   8.294 +
   8.295 +/**
   8.296 + * list_for_each_entry	-	iterate over list of given type
   8.297 + * @pos:	the type * to use as a loop counter.
   8.298 + * @head:	the head for your list.
   8.299 + * @member:	the name of the list_struct within the struct.
   8.300 + */
   8.301 +#define list_for_each_entry(pos, head, member)				\
   8.302 +	for (pos = list_entry((head)->next, typeof(*pos), member);	\
   8.303 +	     &pos->member != (head); 					\
   8.304 +	     pos = list_entry(pos->member.next, typeof(*pos), member))
   8.305 +
   8.306 +/**
   8.307 + * list_for_each_entry_reverse - iterate backwards over list of given type.
   8.308 + * @pos:	the type * to use as a loop counter.
   8.309 + * @head:	the head for your list.
   8.310 + * @member:	the name of the list_struct within the struct.
   8.311 + */
   8.312 +#define list_for_each_entry_reverse(pos, head, member)			\
   8.313 +	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
   8.314 +	     &pos->member != (head); 					\
   8.315 +	     pos = list_entry(pos->member.prev, typeof(*pos), member))
   8.316 +
   8.317 +
   8.318 +/**
   8.319 + * list_for_each_entry_continue -	iterate over list of given type
   8.320 + *			continuing after existing point
   8.321 + * @pos:	the type * to use as a loop counter.
   8.322 + * @head:	the head for your list.
   8.323 + * @member:	the name of the list_struct within the struct.
   8.324 + */
   8.325 +#define list_for_each_entry_continue(pos, head, member) 		\
   8.326 +	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
   8.327 +	     &pos->member != (head);	\
   8.328 +	     pos = list_entry(pos->member.next, typeof(*pos), member))
   8.329 +
   8.330 +/**
   8.331 + * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
   8.332 + * @pos:	the type * to use as a loop counter.
   8.333 + * @n:		another type * to use as temporary storage
   8.334 + * @head:	the head for your list.
   8.335 + * @member:	the name of the list_struct within the struct.
   8.336 + */
   8.337 +#define list_for_each_entry_safe(pos, n, head, member)			\
   8.338 +	for (pos = list_entry((head)->next, typeof(*pos), member),	\
   8.339 +		n = list_entry(pos->member.next, typeof(*pos), member);	\
   8.340 +	     &pos->member != (head); 					\
   8.341 +	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
   8.342 +
   8.343 +
   8.344 +/* 
   8.345 + * Double linked lists with a single pointer list head. 
   8.346 + * Mostly useful for hash tables where the two pointer list head is 
   8.347 + * too wasteful.
   8.348 + * You lose the ability to access the tail in O(1).
   8.349 + */ 
   8.350 +
   8.351 +struct hlist_head { 
   8.352 +	struct hlist_node *first; 
   8.353 +}; 
   8.354 +
   8.355 +struct hlist_node { 
   8.356 +	struct hlist_node *next, **pprev; 
   8.357 +}; 
   8.358 +
   8.359 +#define HLIST_HEAD_INIT { .first = NULL } 
   8.360 +#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
   8.361 +#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) 
   8.362 +#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)
   8.363 +
   8.364 +static __inline__ int hlist_unhashed(struct hlist_node *h) 
   8.365 +{ 
   8.366 +	return !h->pprev;
   8.367 +} 
   8.368 +
   8.369 +static __inline__ int hlist_empty(struct hlist_head *h) 
   8.370 +{ 
   8.371 +	return !h->first;
   8.372 +} 
   8.373 +
   8.374 +static __inline__ void __hlist_del(struct hlist_node *n) 
   8.375 +{
   8.376 +	struct hlist_node *next = n->next;
   8.377 +	struct hlist_node **pprev = n->pprev;
   8.378 +	*pprev = next;  
   8.379 +	if (next) 
   8.380 +		next->pprev = pprev;
   8.381 +}  
   8.382 +
   8.383 +static __inline__ void hlist_del(struct hlist_node *n)
   8.384 +{
   8.385 +	__hlist_del(n);
   8.386 +	n->next = LIST_POISON1;
   8.387 +	n->pprev = LIST_POISON2;
   8.388 +}
   8.389 +
   8.390 +/**
   8.391 + * hlist_del_rcu - deletes entry from hash list without re-initialization
   8.392 + * @entry: the element to delete from the hash list.
   8.393 + *
   8.394 + * Note: list_unhashed() on entry does not return true after this, 
   8.395 + * the entry is in an undefined state. It is useful for RCU based
   8.396 + * lockfree traversal.
   8.397 + *
   8.398 + * In particular, it means that we can not poison the forward
   8.399 + * pointers that may still be used for walking the hash list.
   8.400 + */
   8.401 +static inline void hlist_del_rcu(struct hlist_node *n)
   8.402 +{
   8.403 +	__hlist_del(n);
   8.404 +	n->pprev = LIST_POISON2;
   8.405 +}
   8.406 +
   8.407 +static __inline__ void hlist_del_init(struct hlist_node *n) 
   8.408 +{
   8.409 +	if (n->pprev)  {
   8.410 +		__hlist_del(n);
   8.411 +		INIT_HLIST_NODE(n);
   8.412 +	}
   8.413 +}  
   8.414 +
   8.415 +#define hlist_del_rcu_init hlist_del_init
   8.416 +
   8.417 +static __inline__ void hlist_add_head(struct hlist_node *n, struct hlist_head *h) 
   8.418 +{ 
   8.419 +	struct hlist_node *first = h->first;
   8.420 +	n->next = first; 
   8.421 +	if (first) 
   8.422 +		first->pprev = &n->next;
   8.423 +	h->first = n; 
   8.424 +	n->pprev = &h->first; 
   8.425 +} 
   8.426 +
   8.427 +static __inline__ void hlist_add_head_rcu(struct hlist_node *n, struct hlist_head *h) 
   8.428 +{ 
   8.429 +	struct hlist_node *first = h->first;
   8.430 +	n->next = first;
   8.431 +	n->pprev = &h->first; 
   8.432 +	if (first) 
   8.433 +		first->pprev = &n->next;
   8.434 +	h->first = n; 
   8.435 +} 
   8.436 +
   8.437 +/* next must be != NULL */
   8.438 +static __inline__ void hlist_add_before(struct hlist_node *n, struct hlist_node *next)
   8.439 +{
   8.440 +	n->pprev = next->pprev;
   8.441 +	n->next = next; 
   8.442 +	next->pprev = &n->next; 
   8.443 +	*(n->pprev) = n;
   8.444 +}
   8.445 +
   8.446 +static __inline__ void hlist_add_after(struct hlist_node *n,
   8.447 +				       struct hlist_node *next)
   8.448 +{
   8.449 +	next->next	= n->next;
   8.450 +	*(next->pprev)	= n;
   8.451 +	n->next		= next;
   8.452 +}
   8.453 +
   8.454 +#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
   8.455 +
   8.456 +/* Cannot easily do prefetch unfortunately */
   8.457 +#define hlist_for_each(pos, head) \
   8.458 +	for (pos = (head)->first; pos; pos = pos->next) 
   8.459 +
   8.460 +#define hlist_for_each_safe(pos, n, head) \
   8.461 +	for (pos = (head)->first; n = pos ? pos->next : 0, pos; \
   8.462 +	     pos = n)
   8.463 +
   8.464 +/**
   8.465 + * hlist_for_each_entry	- iterate over list of given type
   8.466 + * @tpos:	the type * to use as a loop counter.
   8.467 + * @pos:	the &struct hlist_node to use as a loop counter.
   8.468 + * @head:	the head for your list.
   8.469 + * @member:	the name of the hlist_node within the struct.
   8.470 + */
   8.471 +#define hlist_for_each_entry(tpos, pos, head, member)			 \
   8.472 +	for (pos = (head)->first;					 \
   8.473 +	     pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
   8.474 +	     pos = pos->next)
   8.475 +
   8.476 +/**
   8.477 + * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
   8.478 + * @tpos:	the type * to use as a loop counter.
   8.479 + * @pos:	the &struct hlist_node to use as a loop counter.
   8.480 + * @member:	the name of the hlist_node within the struct.
   8.481 + */
   8.482 +#define hlist_for_each_entry_continue(tpos, pos, member)		 \
   8.483 +	for (pos = (pos)->next;						 \
   8.484 +	     pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
   8.485 +	     pos = pos->next)
   8.486 +
   8.487 +/**
   8.488 + * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
   8.489 + * @tpos:	the type * to use as a loop counter.
   8.490 + * @pos:	the &struct hlist_node to use as a loop counter.
   8.491 + * @member:	the name of the hlist_node within the struct.
   8.492 + */
   8.493 +#define hlist_for_each_entry_from(tpos, pos, member)			 \
   8.494 +	for (; pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
   8.495 +	     pos = pos->next)
   8.496 +
   8.497 +/**
   8.498 + * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
   8.499 + * @tpos:	the type * to use as a loop counter.
   8.500 + * @pos:	the &struct hlist_node to use as a loop counter.
   8.501 + * @n:		another &struct hlist_node to use as temporary storage
   8.502 + * @head:	the head for your list.
   8.503 + * @member:	the name of the hlist_node within the struct.
   8.504 + */
   8.505 +#define hlist_for_each_entry_safe(tpos, pos, n, head, member) 		 \
   8.506 +	for (pos = (head)->first;					 \
   8.507 +	     pos && ({ n = pos->next; 1; }) && 				 \
   8.508 +		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
   8.509 +	     pos = n)
   8.510 +
   8.511 +#endif

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/tools/xenstore/talloc.c	Tue Jun 07 12:43:58 2005 +0000
     9.3 @@ -0,0 +1,1143 @@
     9.4 +/* 
     9.5 +   Samba Unix SMB/CIFS implementation.
     9.6 +
     9.7 +   Samba trivial allocation library - new interface
     9.8 +
     9.9 +   NOTE: Please read talloc_guide.txt for full documentation
    9.10 +
    9.11 +   Copyright (C) Andrew Tridgell 2004
    9.12 +   
    9.13 +   This program is free software; you can redistribute it and/or modify
    9.14 +   it under the terms of the GNU General Public License as published by
    9.15 +   the Free Software Foundation; either version 2 of the License, or
    9.16 +   (at your option) any later version.
    9.17 +   
    9.18 +   This program is distributed in the hope that it will be useful,
    9.19 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.20 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9.21 +   GNU General Public License for more details.
    9.22 +   
    9.23 +   You should have received a copy of the GNU General Public License
    9.24 +   along with this program; if not, write to the Free Software
    9.25 +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    9.26 +*/
    9.27 +
    9.28 +/*
    9.29 +  inspired by http://swapped.cc/halloc/
    9.30 +*/
    9.31 +
    9.32 +
    9.33 +#ifdef _SAMBA_BUILD_
    9.34 +#include "includes.h"
    9.35 +#if ((SAMBA_VERSION_MAJOR==3)&&(SAMBA_VERSION_MINOR<9))
    9.36 +/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
    9.37 + * we trust ourselves... */
    9.38 +#ifdef malloc
    9.39 +#undef malloc
    9.40 +#endif
    9.41 +#ifdef realloc
    9.42 +#undef realloc
    9.43 +#endif
    9.44 +#endif
    9.45 +#else
    9.46 +#include <stdio.h>
    9.47 +#include <stdlib.h>
    9.48 +#include <string.h>
    9.49 +#include <stdarg.h>
    9.50 +#include <stdint.h>
    9.51 +#include "talloc.h"
    9.52 +/* assume a modern system */
    9.53 +#define HAVE_VA_COPY
    9.54 +#endif
    9.55 +
    9.56 +/* use this to force every realloc to change the pointer, to stress test
    9.57 +   code that might not cope */
    9.58 +#ifdef TESTING
    9.59 +#define ALWAYS_REALLOC 1
    9.60 +void *test_malloc(size_t size);
    9.61 +#define malloc test_malloc
    9.62 +#endif
    9.63 +
    9.64 +#define MAX_TALLOC_SIZE 0x10000000
    9.65 +#define TALLOC_MAGIC 0xe814ec4f
    9.66 +#define TALLOC_MAGIC_FREE 0x7faebef3
    9.67 +#define TALLOC_MAGIC_REFERENCE ((const char *)1)
    9.68 +
    9.69 +/* by default we abort when given a bad pointer (such as when talloc_free() is called 
    9.70 +   on a pointer that came from malloc() */
    9.71 +#ifndef TALLOC_ABORT
    9.72 +#define TALLOC_ABORT(reason) abort()
    9.73 +#endif
    9.74 +
    9.75 +#ifndef discard_const_p
    9.76 +#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
    9.77 +# define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
    9.78 +#else
    9.79 +# define discard_const_p(type, ptr) ((type *)(ptr))
    9.80 +#endif
    9.81 +#endif
    9.82 +
    9.83 +/* this null_context is only used if talloc_enable_leak_report() or
    9.84 +   talloc_enable_leak_report_full() is called, otherwise it remains
    9.85 +   NULL
    9.86 +*/
    9.87 +static const void *null_context;
    9.88 +static void *cleanup_context;
    9.89 +static int (*malloc_fail_handler)(void *);
    9.90 +static void *malloc_fail_data;
    9.91 +
    9.92 +struct talloc_reference_handle {
    9.93 +	struct talloc_reference_handle *next, *prev;
    9.94 +	void *ptr;
    9.95 +};
    9.96 +
    9.97 +typedef int (*talloc_destructor_t)(void *);
    9.98 +
    9.99 +struct talloc_chunk {
   9.100 +	struct talloc_chunk *next, *prev;
   9.101 +	struct talloc_chunk *parent, *child;
   9.102 +	struct talloc_reference_handle *refs;
   9.103 +	size_t size;
   9.104 +	unsigned magic;
   9.105 +	talloc_destructor_t destructor;
   9.106 +	const char *name;
   9.107 +};
   9.108 +
   9.109 +/* panic if we get a bad magic value */
   9.110 +static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
   9.111 +{
   9.112 +	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
   9.113 +	if (tc->magic != TALLOC_MAGIC) { 
   9.114 +		if (tc->magic == TALLOC_MAGIC_FREE) {
   9.115 +			TALLOC_ABORT("Bad talloc magic value - double free"); 
   9.116 +		} else {
   9.117 +			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
   9.118 +		}
   9.119 +	}
   9.120 +
   9.121 +	return tc;
   9.122 +}
   9.123 +
   9.124 +/* hook into the front of the list */
   9.125 +#define _TLIST_ADD(list, p) \
   9.126 +do { \
   9.127 +        if (!(list)) { \
   9.128 +		(list) = (p); \
   9.129 +		(p)->next = (p)->prev = NULL; \
   9.130 +	} else { \
   9.131 +		(list)->prev = (p); \
   9.132 +		(p)->next = (list); \
   9.133 +		(p)->prev = NULL; \
   9.134 +		(list) = (p); \
   9.135 +	}\
   9.136 +} while (0)
   9.137 +
   9.138 +/* remove an element from a list - element doesn't have to be in list. */
   9.139 +#define _TLIST_REMOVE(list, p) \
   9.140 +do { \
   9.141 +	if ((p) == (list)) { \
   9.142 +		(list) = (p)->next; \
   9.143 +		if (list) (list)->prev = NULL; \
   9.144 +	} else { \
   9.145 +		if ((p)->prev) (p)->prev->next = (p)->next; \
   9.146 +		if ((p)->next) (p)->next->prev = (p)->prev; \
   9.147 +	} \
   9.148 +	if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
   9.149 +} while (0)
   9.150 +
   9.151 +
   9.152 +/*
   9.153 +  return the parent chunk of a pointer
   9.154 +*/
   9.155 +static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
   9.156 +{
   9.157 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.158 +	while (tc->prev) tc=tc->prev;
   9.159 +	return tc->parent;
   9.160 +}
   9.161 +
   9.162 +void *talloc_parent(const void *ptr)
   9.163 +{
   9.164 +	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
   9.165 +	return (void *)(tc+1);
   9.166 +}
   9.167 +
   9.168 +/* 
   9.169 +   Allocate a bit of memory as a child of an existing pointer
   9.170 +*/
   9.171 +void *_talloc(const void *context, size_t size)
   9.172 +{
   9.173 +	struct talloc_chunk *tc;
   9.174 +
   9.175 +	if (context == NULL) {
   9.176 +		context = null_context;
   9.177 +	}
   9.178 +
   9.179 +	if (size >= MAX_TALLOC_SIZE) {
   9.180 +		return NULL;
   9.181 +	}
   9.182 +
   9.183 +	tc = malloc(sizeof(*tc)+size);
   9.184 +	if (tc == NULL) {
   9.185 +		if (malloc_fail_handler)
   9.186 +			if (malloc_fail_handler(malloc_fail_data))
   9.187 +				tc = malloc(sizeof(*tc)+size);
   9.188 +		if (!tc)
   9.189 +			return NULL;
   9.190 +	}
   9.191 +
   9.192 +	tc->size = size;
   9.193 +	tc->magic = TALLOC_MAGIC;
   9.194 +	tc->destructor = NULL;
   9.195 +	tc->child = NULL;
   9.196 +	tc->name = NULL;
   9.197 +	tc->refs = NULL;
   9.198 +
   9.199 +	if (context) {
   9.200 +		struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
   9.201 +
   9.202 +		tc->parent = parent;
   9.203 +
   9.204 +		if (parent->child) {
   9.205 +			parent->child->parent = NULL;
   9.206 +		}
   9.207 +
   9.208 +		_TLIST_ADD(parent->child, tc);
   9.209 +	} else {
   9.210 +		tc->next = tc->prev = tc->parent = NULL;
   9.211 +	}
   9.212 +
   9.213 +	return (void *)(tc+1);
   9.214 +}
   9.215 +
   9.216 +
   9.217 +/*
   9.218 +  setup a destructor to be called on free of a pointer
   9.219 +  the destructor should return 0 on success, or -1 on failure.
   9.220 +  if the destructor fails then the free is failed, and the memory can
   9.221 +  be continued to be used
   9.222 +*/
   9.223 +void talloc_set_destructor(const void *ptr, int (*destructor)(void *))
   9.224 +{
   9.225 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.226 +	tc->destructor = destructor;
   9.227 +}
   9.228 +
   9.229 +/*
   9.230 +  increase the reference count on a piece of memory. 
   9.231 +*/
   9.232 +void talloc_increase_ref_count(const void *ptr)
   9.233 +{
   9.234 +	talloc_reference(null_context, ptr);
   9.235 +}
   9.236 +
   9.237 +/*
   9.238 +  helper for talloc_reference()
   9.239 +*/
   9.240 +static int talloc_reference_destructor(void *ptr)
   9.241 +{
   9.242 +	struct talloc_reference_handle *handle = ptr;
   9.243 +	struct talloc_chunk *tc1 = talloc_chunk_from_ptr(ptr);
   9.244 +	struct talloc_chunk *tc2 = talloc_chunk_from_ptr(handle->ptr);
   9.245 +	if (tc1->destructor != (talloc_destructor_t)-1) {
   9.246 +		tc1->destructor = NULL;
   9.247 +	}
   9.248 +	_TLIST_REMOVE(tc2->refs, handle);
   9.249 +	talloc_free(handle);
   9.250 +	return 0;
   9.251 +}
   9.252 +
   9.253 +/*
   9.254 +  make a secondary reference to a pointer, hanging off the given context.
   9.255 +  the pointer remains valid until both the original caller and this given
   9.256 +  context are freed.
   9.257 +  
   9.258 +  the major use for this is when two different structures need to reference the 
   9.259 +  same underlying data, and you want to be able to free the two instances separately,
   9.260 +  and in either order
   9.261 +*/
   9.262 +void *talloc_reference(const void *context, const void *ptr)
   9.263 +{
   9.264 +	struct talloc_chunk *tc;
   9.265 +	struct talloc_reference_handle *handle;
   9.266 +	if (ptr == NULL) return NULL;
   9.267 +
   9.268 +	tc = talloc_chunk_from_ptr(ptr);
   9.269 +	handle = talloc_named_const(context, sizeof(*handle), TALLOC_MAGIC_REFERENCE);
   9.270 +
   9.271 +	if (handle == NULL) return NULL;
   9.272 +
   9.273 +	/* note that we hang the destructor off the handle, not the
   9.274 +	   main context as that allows the caller to still setup their
   9.275 +	   own destructor on the context if they want to */
   9.276 +	talloc_set_destructor(handle, talloc_reference_destructor);
   9.277 +	handle->ptr = discard_const_p(void, ptr);
   9.278 +	_TLIST_ADD(tc->refs, handle);
   9.279 +	return handle->ptr;
   9.280 +}
   9.281 +
   9.282 +/*
   9.283 +  remove a secondary reference to a pointer. This undo's what
   9.284 +  talloc_reference() has done. The context and pointer arguments
   9.285 +  must match those given to a talloc_reference()
   9.286 +*/
   9.287 +static int talloc_unreference(const void *context, const void *ptr)
   9.288 +{
   9.289 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.290 +	struct talloc_reference_handle *h;
   9.291 +
   9.292 +	if (context == NULL) {
   9.293 +		context = null_context;
   9.294 +	}
   9.295 +
   9.296 +	for (h=tc->refs;h;h=h->next) {
   9.297 +		struct talloc_chunk *p = talloc_parent_chunk(h);
   9.298 +		if ((p==NULL && context==NULL) || p+1 == context) break;
   9.299 +	}
   9.300 +	if (h == NULL) {
   9.301 +		return -1;
   9.302 +	}
   9.303 +
   9.304 +	talloc_set_destructor(h, NULL);
   9.305 +	_TLIST_REMOVE(tc->refs, h);
   9.306 +	talloc_free(h);
   9.307 +	return 0;
   9.308 +}
   9.309 +
   9.310 +/*
   9.311 +  remove a specific parent context from a pointer. This is a more
   9.312 +  controlled varient of talloc_free()
   9.313 +*/
   9.314 +int talloc_unlink(const void *context, void *ptr)
   9.315 +{
   9.316 +	struct talloc_chunk *tc_p, *new_p;
   9.317 +	void *new_parent;
   9.318 +
   9.319 +	if (ptr == NULL) {
   9.320 +		return -1;
   9.321 +	}
   9.322 +
   9.323 +	if (context == NULL) {
   9.324 +		context = null_context;
   9.325 +	}
   9.326 +
   9.327 +	if (talloc_unreference(context, ptr) == 0) {
   9.328 +		return 0;
   9.329 +	}
   9.330 +
   9.331 +	if (context == NULL) {
   9.332 +		if (talloc_parent_chunk(ptr) != NULL) {
   9.333 +			return -1;
   9.334 +		}
   9.335 +	} else {
   9.336 +		if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
   9.337 +			return -1;
   9.338 +		}
   9.339 +	}
   9.340 +	
   9.341 +	tc_p = talloc_chunk_from_ptr(ptr);
   9.342 +
   9.343 +	if (tc_p->refs == NULL) {
   9.344 +		return talloc_free(ptr);
   9.345 +	}
   9.346 +
   9.347 +	new_p = talloc_parent_chunk(tc_p->refs);
   9.348 +	if (new_p) {
   9.349 +		new_parent = new_p+1;
   9.350 +	} else {
   9.351 +		new_parent = NULL;
   9.352 +	}
   9.353 +
   9.354 +	if (talloc_unreference(new_parent, ptr) != 0) {
   9.355 +		return -1;
   9.356 +	}
   9.357 +
   9.358 +	talloc_steal(new_parent, ptr);
   9.359 +
   9.360 +	return 0;
   9.361 +}
   9.362 +
   9.363 +/*
   9.364 +  add a name to an existing pointer - va_list version
   9.365 +*/
   9.366 +static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
   9.367 +
   9.368 +static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
   9.369 +{
   9.370 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.371 +	tc->name = talloc_vasprintf(ptr, fmt, ap);
   9.372 +	if (tc->name) {
   9.373 +		talloc_set_name_const(tc->name, ".name");
   9.374 +	}
   9.375 +}
   9.376 +
   9.377 +/*
   9.378 +  add a name to an existing pointer
   9.379 +*/
   9.380 +void talloc_set_name(const void *ptr, const char *fmt, ...)
   9.381 +{
   9.382 +	va_list ap;
   9.383 +	va_start(ap, fmt);
   9.384 +	talloc_set_name_v(ptr, fmt, ap);
   9.385 +	va_end(ap);
   9.386 +}
   9.387 +
   9.388 +/*
   9.389 +   more efficient way to add a name to a pointer - the name must point to a 
   9.390 +   true string constant
   9.391 +*/
   9.392 +void talloc_set_name_const(const void *ptr, const char *name)
   9.393 +{
   9.394 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.395 +	tc->name = name;
   9.396 +}
   9.397 +
   9.398 +/*
   9.399 +  create a named talloc pointer. Any talloc pointer can be named, and
   9.400 +  talloc_named() operates just like talloc() except that it allows you
   9.401 +  to name the pointer.
   9.402 +*/
   9.403 +void *talloc_named(const void *context, size_t size, const char *fmt, ...)
   9.404 +{
   9.405 +	va_list ap;
   9.406 +	void *ptr;
   9.407 +
   9.408 +	ptr = _talloc(context, size);
   9.409 +	if (ptr == NULL) return NULL;
   9.410 +
   9.411 +	va_start(ap, fmt);
   9.412 +	talloc_set_name_v(ptr, fmt, ap);
   9.413 +	va_end(ap);
   9.414 +
   9.415 +	return ptr;
   9.416 +}
   9.417 +
   9.418 +/*
   9.419 +  create a named talloc pointer. Any talloc pointer can be named, and
   9.420 +  talloc_named() operates just like talloc() except that it allows you
   9.421 +  to name the pointer.
   9.422 +*/
   9.423 +void *talloc_named_const(const void *context, size_t size, const char *name)
   9.424 +{
   9.425 +	void *ptr;
   9.426 +
   9.427 +	ptr = _talloc(context, size);
   9.428 +	if (ptr == NULL) {
   9.429 +		return NULL;
   9.430 +	}
   9.431 +
   9.432 +	talloc_set_name_const(ptr, name);
   9.433 +
   9.434 +	return ptr;
   9.435 +}
   9.436 +
   9.437 +/*
   9.438 +  return the name of a talloc ptr, or "UNNAMED"
   9.439 +*/
   9.440 +const char *talloc_get_name(const void *ptr)
   9.441 +{
   9.442 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.443 +	if (tc->name == TALLOC_MAGIC_REFERENCE) {
   9.444 +		return ".reference";
   9.445 +	}
   9.446 +	if (tc->name) {
   9.447 +		return tc->name;
   9.448 +	}
   9.449 +	return "UNNAMED";
   9.450 +}
   9.451 +
   9.452 +
   9.453 +/*
   9.454 +  check if a pointer has the given name. If it does, return the pointer,
   9.455 +  otherwise return NULL
   9.456 +*/
   9.457 +void *talloc_check_name(const void *ptr, const char *name)
   9.458 +{
   9.459 +	const char *pname;
   9.460 +	if (ptr == NULL) return NULL;
   9.461 +	pname = talloc_get_name(ptr);
   9.462 +	if (pname == name || strcmp(pname, name) == 0) {
   9.463 +		return discard_const_p(void, ptr);
   9.464 +	}
   9.465 +	return NULL;
   9.466 +}
   9.467 +
   9.468 +
   9.469 +/*
   9.470 +  this is for compatibility with older versions of talloc
   9.471 +*/
   9.472 +void *talloc_init(const char *fmt, ...)
   9.473 +{
   9.474 +	va_list ap;
   9.475 +	void *ptr;
   9.476 +
   9.477 +	ptr = _talloc(NULL, 0);
   9.478 +	if (ptr == NULL) return NULL;
   9.479 +
   9.480 +	va_start(ap, fmt);
   9.481 +	talloc_set_name_v(ptr, fmt, ap);
   9.482 +	va_end(ap);
   9.483 +
   9.484 +	return ptr;
   9.485 +}
   9.486 +
   9.487 +/*
   9.488 +  this is a replacement for the Samba3 talloc_destroy_pool functionality. It
   9.489 +  should probably not be used in new code. It's in here to keep the talloc
   9.490 +  code consistent across Samba 3 and 4.
   9.491 +*/
   9.492 +void talloc_free_children(void *ptr)
   9.493 +{
   9.494 +	struct talloc_chunk *tc;
   9.495 +
   9.496 +	if (ptr == NULL) {
   9.497 +		return;
   9.498 +	}
   9.499 +
   9.500 +	tc = talloc_chunk_from_ptr(ptr);
   9.501 +
   9.502 +	while (tc->child) {
   9.503 +		/* we need to work out who will own an abandoned child
   9.504 +		   if it cannot be freed. In priority order, the first
   9.505 +		   choice is owner of any remaining reference to this
   9.506 +		   pointer, the second choice is our parent, and the
   9.507 +		   final choice is the null context. */
   9.508 +		void *child = tc->child+1;
   9.509 +		const void *new_parent = null_context;
   9.510 +		if (tc->child->refs) {
   9.511 +			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
   9.512 +			if (p) new_parent = p+1;
   9.513 +		}
   9.514 +		if (talloc_free(child) == -1) {
   9.515 +			if (new_parent == null_context) {
   9.516 +				struct talloc_chunk *p = talloc_parent_chunk(ptr);
   9.517 +				if (p) new_parent = p+1;
   9.518 +			}
   9.519 +			talloc_steal(new_parent, child);
   9.520 +		}
   9.521 +	}
   9.522 +}
   9.523 +
   9.524 +/* 
   9.525 +   free a talloc pointer. This also frees all child pointers of this 
   9.526 +   pointer recursively
   9.527 +
   9.528 +   return 0 if the memory is actually freed, otherwise -1. The memory
   9.529 +   will not be freed if the ref_count is > 1 or the destructor (if
   9.530 +   any) returns non-zero
   9.531 +*/
   9.532 +int talloc_free(void *ptr)
   9.533 +{
   9.534 +	struct talloc_chunk *tc;
   9.535 +
   9.536 +	if (ptr == NULL) {
   9.537 +		return -1;
   9.538 +	}
   9.539 +
   9.540 +	tc = talloc_chunk_from_ptr(ptr);
   9.541 +
   9.542 +	if (tc->refs) {
   9.543 +		talloc_reference_destructor(tc->refs);
   9.544 +		return -1;
   9.545 +	}
   9.546 +
   9.547 +	if (tc->destructor) {
   9.548 +		talloc_destructor_t d = tc->destructor;
   9.549 +		if (d == (talloc_destructor_t)-1) {
   9.550 +			return -1;
   9.551 +		}
   9.552 +		tc->destructor = (talloc_destructor_t)-1;
   9.553 +		if (d(ptr) == -1) {
   9.554 +			tc->destructor = d;
   9.555 +			return -1;
   9.556 +		}
   9.557 +		tc->destructor = NULL;
   9.558 +	}
   9.559 +
   9.560 +	talloc_free_children(ptr);
   9.561 +
   9.562 +	if (tc->parent) {
   9.563 +		_TLIST_REMOVE(tc->parent->child, tc);
   9.564 +		if (tc->parent->child) {
   9.565 +			tc->parent->child->parent = tc->parent;
   9.566 +		}
   9.567 +	} else {
   9.568 +		if (tc->prev) tc->prev->next = tc->next;
   9.569 +		if (tc->next) tc->next->prev = tc->prev;
   9.570 +	}
   9.571 +
   9.572 +	tc->magic = TALLOC_MAGIC_FREE;
   9.573 +
   9.574 +	free(tc);
   9.575 +	return 0;
   9.576 +}
   9.577 +
   9.578 +
   9.579 +
   9.580 +/*
   9.581 +  A talloc version of realloc. The context argument is only used if
   9.582 +  ptr is NULL
   9.583 +*/
   9.584 +void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
   9.585 +{
   9.586 +	struct talloc_chunk *tc;
   9.587 +	void *new_ptr;
   9.588 +
   9.589 +	/* size zero is equivalent to free() */
   9.590 +	if (size == 0) {
   9.591 +		talloc_free(ptr);
   9.592 +		return NULL;
   9.593 +	}
   9.594 +
   9.595 +	if (size >= MAX_TALLOC_SIZE) {
   9.596 +		return NULL;
   9.597 +	}
   9.598 +
   9.599 +	/* realloc(NULL) is equavalent to malloc() */
   9.600 +	if (ptr == NULL) {
   9.601 +		return talloc_named_const(context, size, name);
   9.602 +	}
   9.603 +
   9.604 +	tc = talloc_chunk_from_ptr(ptr);
   9.605 +
   9.606 +	/* don't allow realloc on referenced pointers */
   9.607 +	if (tc->refs) {
   9.608 +		return NULL;
   9.609 +	}
   9.610 +
   9.611 +	/* by resetting magic we catch users of the old memory */
   9.612 +	tc->magic = TALLOC_MAGIC_FREE;
   9.613 +
   9.614 +#if ALWAYS_REALLOC
   9.615 +	new_ptr = malloc(size + sizeof(*tc));
   9.616 +	if (!new_ptr) {
   9.617 +		tc->magic = TALLOC_MAGIC; 
   9.618 +		if (malloc_fail_handler)
   9.619 +			if (malloc_fail_handler(malloc_fail_data))
   9.620 +				new_ptr = malloc(size + sizeof(*tc));
   9.621 +	}
   9.622 +	if (new_ptr) {
   9.623 +		memcpy(new_ptr, tc, tc->size + sizeof(*tc));
   9.624 +		free(tc);
   9.625 +	}
   9.626 +#else
   9.627 +	new_ptr = realloc(tc, size + sizeof(*tc));
   9.628 +	if (!new_ptr) {
   9.629 +		tc->magic = TALLOC_MAGIC; 
   9.630 +		if (malloc_fail_handler)
   9.631 +			if (malloc_fail_handler(malloc_fail_data))
   9.632 +				new_ptr = realloc(tc, size + sizeof(*tc));
   9.633 +	}
   9.634 +#endif
   9.635 +	if (!new_ptr) {	
   9.636 +		tc->magic = TALLOC_MAGIC; 
   9.637 +		return NULL; 
   9.638 +	}
   9.639 +
   9.640 +	tc = new_ptr;
   9.641 +	tc->magic = TALLOC_MAGIC;
   9.642 +	if (tc->parent) {
   9.643 +		tc->parent->child = new_ptr;
   9.644 +	}
   9.645 +	if (tc->child) {
   9.646 +		tc->child->parent = new_ptr;
   9.647 +	}
   9.648 +
   9.649 +	if (tc->prev) {
   9.650 +		tc->prev->next = tc;
   9.651 +	}
   9.652 +	if (tc->next) {
   9.653 +		tc->next->prev = tc;
   9.654 +	}
   9.655 +
   9.656 +	tc->size = size;
   9.657 +	talloc_set_name_const(tc+1, name);
   9.658 +
   9.659 +	return (void *)(tc+1);
   9.660 +}
   9.661 +
   9.662 +/* 
   9.663 +   move a lump of memory from one talloc context to another return the
   9.664 +   ptr on success, or NULL if it could not be transferred.
   9.665 +   passing NULL as ptr will always return NULL with no side effects.
   9.666 +*/
   9.667 +void *talloc_steal(const void *new_ctx, const void *ptr)
   9.668 +{
   9.669 +	struct talloc_chunk *tc, *new_tc;
   9.670 +
   9.671 +	if (!ptr) {
   9.672 +		return NULL;
   9.673 +	}
   9.674 +
   9.675 +	if (new_ctx == NULL) {
   9.676 +		new_ctx = null_context;
   9.677 +	}
   9.678 +
   9.679 +	tc = talloc_chunk_from_ptr(ptr);
   9.680 +
   9.681 +	if (new_ctx == NULL) {
   9.682 +		if (tc->parent) {
   9.683 +			_TLIST_REMOVE(tc->parent->child, tc);
   9.684 +			if (tc->parent->child) {
   9.685 +				tc->parent->child->parent = tc->parent;
   9.686 +			}
   9.687 +		} else {
   9.688 +			if (tc->prev) tc->prev->next = tc->next;
   9.689 +			if (tc->next) tc->next->prev = tc->prev;
   9.690 +		}
   9.691 +		
   9.692 +		tc->parent = tc->next = tc->prev = NULL;
   9.693 +		return discard_const_p(void, ptr);
   9.694 +	}
   9.695 +
   9.696 +	new_tc = talloc_chunk_from_ptr(new_ctx);
   9.697 +
   9.698 +	if (tc == new_tc) {
   9.699 +		return discard_const_p(void, ptr);
   9.700 +	}
   9.701 +
   9.702 +	if (tc->parent) {
   9.703 +		_TLIST_REMOVE(tc->parent->child, tc);
   9.704 +		if (tc->parent->child) {
   9.705 +			tc->parent->child->parent = tc->parent;
   9.706 +		}
   9.707 +	} else {
   9.708 +		if (tc->prev) tc->prev->next = tc->next;
   9.709 +		if (tc->next) tc->next->prev = tc->prev;
   9.710 +	}
   9.711 +
   9.712 +	tc->parent = new_tc;
   9.713 +	if (new_tc->child) new_tc->child->parent = NULL;
   9.714 +	_TLIST_ADD(new_tc->child, tc);
   9.715 +
   9.716 +	return discard_const_p(void, ptr);
   9.717 +}
   9.718 +
   9.719 +/*
   9.720 +  return the total size of a talloc pool (subtree)
   9.721 +*/
   9.722 +off_t talloc_total_size(const void *ptr)
   9.723 +{
   9.724 +	off_t total = 0;
   9.725 +	struct talloc_chunk *c, *tc;
   9.726 +	
   9.727 +	if (ptr == NULL) {
   9.728 +		ptr = null_context;
   9.729 +	}
   9.730 +	if (ptr == NULL) {
   9.731 +		return 0;
   9.732 +	}
   9.733 +
   9.734 +	tc = talloc_chunk_from_ptr(ptr);
   9.735 +
   9.736 +	total = tc->size;
   9.737 +	for (c=tc->child;c;c=c->next) {
   9.738 +		total += talloc_total_size(c+1);
   9.739 +	}
   9.740 +	return total;
   9.741 +}
   9.742 +
   9.743 +/*
   9.744 +  return the total number of blocks in a talloc pool (subtree)
   9.745 +*/
   9.746 +off_t talloc_total_blocks(const void *ptr)
   9.747 +{
   9.748 +	off_t total = 0;
   9.749 +	struct talloc_chunk *c, *tc;
   9.750 +
   9.751 +	if (ptr == NULL) {
   9.752 +		ptr = null_context;
   9.753 +	}
   9.754 +	if (ptr == NULL) {
   9.755 +		return 0;
   9.756 +	}
   9.757 +	tc = talloc_chunk_from_ptr(ptr);
   9.758 +
   9.759 +	total++;
   9.760 +	for (c=tc->child;c;c=c->next) {
   9.761 +		total += talloc_total_blocks(c+1);
   9.762 +	}
   9.763 +	return total;
   9.764 +}
   9.765 +
   9.766 +/*
   9.767 +  return the number of external references to a pointer
   9.768 +*/
   9.769 +static int talloc_reference_count(const void *ptr)
   9.770 +{
   9.771 +	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
   9.772 +	struct talloc_reference_handle *h;
   9.773 +	int ret = 0;
   9.774 +
   9.775 +	for (h=tc->refs;h;h=h->next) {
   9.776 +		ret++;
   9.777 +	}
   9.778 +	return ret;
   9.779 +}
   9.780 +
   9.781 +/*
   9.782 +  report on memory usage by all children of a pointer, giving a full tree view
   9.783 +*/
   9.784 +void talloc_report_depth(const void *ptr, FILE *f, int depth)
   9.785 +{
   9.786 +	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
   9.787 +
   9.788 +	for (c=tc->child;c;c=c->next) {
   9.789 +		if (c->name == TALLOC_MAGIC_REFERENCE) {
   9.790 +			struct talloc_reference_handle *handle = (void *)(c+1);
   9.791 +			const char *name2 = talloc_get_name(handle->ptr);
   9.792 +			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
   9.793 +		} else {
   9.794 +			const char *name = talloc_get_name(c+1);
   9.795 +			fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
   9.796 +				depth*4, "",
   9.797 +				name,
   9.798 +				(unsigned long)talloc_total_size(c+1),
   9.799 +				(unsigned long)talloc_total_blocks(c+1),
   9.800 +				talloc_reference_count(c+1));
   9.801 +			talloc_report_depth(c+1, f, depth+1);
   9.802 +		}
   9.803 +	}
   9.804 +
   9.805 +}
   9.806 +
   9.807 +/*
   9.808 +  report on memory usage by all children of a pointer, giving a full tree view
   9.809 +*/
   9.810 +void talloc_report_full(const void *ptr, FILE *f)
   9.811 +{
   9.812 +	if (ptr == NULL) {
   9.813 +		ptr = null_context;
   9.814 +	}
   9.815 +	if (ptr == NULL) return;
   9.816 +
   9.817 +	fprintf(f,"full talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
   9.818 +		talloc_get_name(ptr), 
   9.819 +		(unsigned long)talloc_total_size(ptr),
   9.820 +		(unsigned long)talloc_total_blocks(ptr));
   9.821 +
   9.822 +	talloc_report_depth(ptr, f, 1);
   9.823 +	fflush(f);
   9.824 +}
   9.825 +
   9.826 +/*
   9.827 +  report on memory usage by all children of a pointer
   9.828 +*/
   9.829 +void talloc_report(const void *ptr, FILE *f)
   9.830 +{
   9.831 +	struct talloc_chunk *c, *tc;
   9.832 +
   9.833 +	if (ptr == NULL) {
   9.834 +		ptr = null_context;
   9.835 +	}
   9.836 +	if (ptr == NULL) return;
   9.837 +       
   9.838 +	fprintf(f,"talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
   9.839 +		talloc_get_name(ptr), 
   9.840 +		(unsigned long)talloc_total_size(ptr),
   9.841 +		(unsigned long)talloc_total_blocks(ptr));
   9.842 +
   9.843 +	tc = talloc_chunk_from_ptr(ptr);
   9.844 +
   9.845 +	for (c=tc->child;c;c=c->next) {
   9.846 +		fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
   9.847 +			talloc_get_name(c+1),
   9.848 +			(unsigned long)talloc_total_size(c+1),
   9.849 +			(unsigned long)talloc_total_blocks(c+1));
   9.850 +	}
   9.851 +	fflush(f);
   9.852 +}
   9.853 +
   9.854 +/*
   9.855 +  report on any memory hanging off the null context
   9.856 +*/
   9.857 +static void talloc_report_null(void)
   9.858 +{
   9.859 +	if (talloc_total_size(null_context) != 0) {
   9.860 +		talloc_report(null_context, stderr);
   9.861 +	}
   9.862 +}
   9.863 +
   9.864 +/*
   9.865 +  report on any memory hanging off the null context
   9.866 +*/
   9.867 +static void talloc_report_null_full(void)
   9.868 +{
   9.869 +	if (talloc_total_size(null_context) != 0) {
   9.870 +		talloc_report_full(null_context, stderr);
   9.871 +	}
   9.872 +}
   9.873 +
   9.874 +/*
   9.875 +  enable tracking of the NULL context
   9.876 +*/
   9.877 +void talloc_enable_null_tracking(void)
   9.878 +{
   9.879 +	if (null_context == NULL) {
   9.880 +		null_context = talloc_named_const(NULL, 0, "null_context");
   9.881 +	}
   9.882 +}
   9.883 +
   9.884 +/*
   9.885 +  enable leak reporting on exit
   9.886 +*/
   9.887 +void talloc_enable_leak_report(void)
   9.888 +{
   9.889 +	talloc_enable_null_tracking();
   9.890 +	atexit(talloc_report_null);
   9.891 +}
   9.892 +
   9.893 +/*
   9.894 +  enable full leak reporting on exit
   9.895 +*/
   9.896 +void talloc_enable_leak_report_full(void)
   9.897 +{
   9.898 +	talloc_enable_null_tracking();
   9.899 +	atexit(talloc_report_null_full);
   9.900 +}
   9.901 +
   9.902 +/* 
   9.903 +   talloc and zero memory. 
   9.904 +*/
   9.905 +void *_talloc_zero(const void *ctx, size_t size, const char *name)
   9.906 +{
   9.907 +	void *p = talloc_named_const(ctx, size, name);
   9.908 +
   9.909 +	if (p) {
   9.910 +		memset(p, '\0', size);
   9.911 +	}
   9.912 +
   9.913 +	return p;
   9.914 +}
   9.915 +
   9.916 +
   9.917 +/*
   9.918 +  memdup with a talloc. 
   9.919 +*/
   9.920 +void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
   9.921 +{
   9.922 +	void *newp = talloc_named_const(t, size, name);
   9.923 +
   9.924 +	if (newp) {
   9.925 +		memcpy(newp, p, size);
   9.926 +	}
   9.927 +
   9.928 +	return newp;
   9.929 +}
   9.930 +
   9.931 +/*
   9.932 +  strdup with a talloc 
   9.933 +*/
   9.934 +char *talloc_strdup(const void *t, const char *p)
   9.935 +{
   9.936 +	char *ret;
   9.937 +	if (!p) {
   9.938 +		return NULL;
   9.939 +	}
   9.940 +	ret = talloc_memdup(t, p, strlen(p) + 1);
   9.941 +	if (ret) {
   9.942 +		talloc_set_name_const(ret, ret);
   9.943 +	}
   9.944 +	return ret;
   9.945 +}
   9.946 +
   9.947 +/*
   9.948 +  strndup with a talloc 
   9.949 +*/
   9.950 +char *talloc_strndup(const void *t, const char *p, size_t n)
   9.951 +{
   9.952 +	size_t len;
   9.953 +	char *ret;
   9.954 +
   9.955 +	for (len=0; p[len] && len<n; len++) ;
   9.956 +
   9.957 +	ret = _talloc(t, len + 1);
   9.958 +	if (!ret) { return NULL; }
   9.959 +	memcpy(ret, p, len);
   9.960 +	ret[len] = 0;
   9.961 +	talloc_set_name_const(ret, ret);
   9.962 +	return ret;
   9.963 +}
   9.964 +
   9.965 +#ifndef VA_COPY
   9.966 +#ifdef HAVE_VA_COPY
   9.967 +#define VA_COPY(dest, src) va_copy(dest, src)
   9.968 +#elif defined(HAVE___VA_COPY)
   9.969 +#define VA_COPY(dest, src) __va_copy(dest, src)
   9.970 +#else
   9.971 +#define VA_COPY(dest, src) (dest) = (src)
   9.972 +#endif
   9.973 +#endif
   9.974 +
   9.975 +char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
   9.976 +{	
   9.977 +	int len;
   9.978 +	char *ret;
   9.979 +	va_list ap2;
   9.980 +	
   9.981 +	VA_COPY(ap2, ap);
   9.982 +
   9.983 +	len = vsnprintf(NULL, 0, fmt, ap2);
   9.984 +
   9.985 +	ret = _talloc(t, len+1);
   9.986 +	if (ret) {
   9.987 +		VA_COPY(ap2, ap);
   9.988 +		vsnprintf(ret, len+1, fmt, ap2);
   9.989 +		talloc_set_name_const(ret, ret);
   9.990 +	}
   9.991 +
   9.992 +	return ret;
   9.993 +}
   9.994 +
   9.995 +
   9.996 +/*
   9.997 +  Perform string formatting, and return a pointer to newly allocated
   9.998 +  memory holding the result, inside a memory pool.
   9.999 + */
  9.1000 +char *talloc_asprintf(const void *t, const char *fmt, ...)
  9.1001 +{
  9.1002 +	va_list ap;
  9.1003 +	char *ret;
  9.1004 +
  9.1005 +	va_start(ap, fmt);
  9.1006 +	ret = talloc_vasprintf(t, fmt, ap);
  9.1007 +	va_end(ap);
  9.1008 +	return ret;
  9.1009 +}
  9.1010 +
  9.1011 +
  9.1012 +/**
  9.1013 + * Realloc @p s to append the formatted result of @p fmt and @p ap,
  9.1014 + * and return @p s, which may have moved.  Good for gradually
  9.1015 + * accumulating output into a string buffer.
  9.1016 + **/
  9.1017 +
  9.1018 +static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
  9.1019 +
  9.1020 +static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
  9.1021 +{	
  9.1022 +	struct talloc_chunk *tc;
  9.1023 +	int len, s_len;
  9.1024 +	va_list ap2;
  9.1025 +
  9.1026 +	if (s == NULL) {
  9.1027 +		return talloc_vasprintf(NULL, fmt, ap);
  9.1028 +	}
  9.1029 +
  9.1030 +	tc = talloc_chunk_from_ptr(s);
  9.1031 +
  9.1032 +	VA_COPY(ap2, ap);
  9.1033 +
  9.1034 +	s_len = tc->size - 1;
  9.1035 +	len = vsnprintf(NULL, 0, fmt, ap2);
  9.1036 +
  9.1037 +	s = talloc_realloc(NULL, s, char, s_len + len+1);
  9.1038 +	if (!s) return NULL;
  9.1039 +
  9.1040 +	VA_COPY(ap2, ap);
  9.1041 +
  9.1042 +	vsnprintf(s+s_len, len+1, fmt, ap2);
  9.1043 +	talloc_set_name_const(s, s);
  9.1044 +
  9.1045 +	return s;
  9.1046 +}
  9.1047 +
  9.1048 +/*
  9.1049 +  Realloc @p s to append the formatted result of @p fmt and return @p
  9.1050 +  s, which may have moved.  Good for gradually accumulating output
  9.1051 +  into a string buffer.
  9.1052 + */
  9.1053 +char *talloc_asprintf_append(char *s, const char *fmt, ...)
  9.1054 +{
  9.1055 +	va_list ap;
  9.1056 +
  9.1057 +	va_start(ap, fmt);
  9.1058 +	s = talloc_vasprintf_append(s, fmt, ap);
  9.1059 +	va_end(ap);
  9.1060 +	return s;
  9.1061 +}
  9.1062 +
  9.1063 +/*
  9.1064 +  alloc an array, checking for integer overflow in the array size
  9.1065 +*/
  9.1066 +void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
  9.1067 +{
  9.1068 +	if (count >= MAX_TALLOC_SIZE/el_size) {
  9.1069 +		return NULL;
  9.1070 +	}
  9.1071 +	return talloc_named_const(ctx, el_size * count, name);
  9.1072 +}
  9.1073 +
  9.1074 +/*
  9.1075 +  alloc an zero array, checking for integer overflow in the array size
  9.1076 +*/
  9.1077 +void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
  9.1078 +{
  9.1079 +	if (count >= MAX_TALLOC_SIZE/el_size) {
  9.1080 +		return NULL;
  9.1081 +	}
  9.1082 +	return _talloc_zero(ctx, el_size * count, name);
  9.1083 +}
  9.1084 +
  9.1085 +
  9.1086 +/*
  9.1087 +  realloc an array, checking for integer overflow in the array size
  9.1088 +*/
  9.1089 +void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
  9.1090 +{
  9.1091 +	if (count >= MAX_TALLOC_SIZE/el_size) {
  9.1092 +		return NULL;
  9.1093 +	}
  9.1094 +	return _talloc_realloc(ctx, ptr, el_size * count, name);
  9.1095 +}
  9.1096 +
  9.1097 +/*
  9.1098 +  a function version of talloc_realloc(), so it can be passed as a function pointer
  9.1099 +  to libraries that want a realloc function (a realloc function encapsulates
  9.1100 +  all the basic capabilities of an allocation library, which is why this is useful)
  9.1101 +*/
  9.1102 +void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
  9.1103 +{
  9.1104 +	return _talloc_realloc(context, ptr, size, NULL);
  9.1105 +}
  9.1106 +
  9.1107 +
  9.1108 +static void talloc_autofree(void)
  9.1109 +{
  9.1110 +	talloc_free(cleanup_context);
  9.1111 +	cleanup_context = NULL;
  9.1112 +}
  9.1113 +
  9.1114 +/*
  9.1115 +  return a context which will be auto-freed on exit
  9.1116 +  this is useful for reducing the noise in leak reports
  9.1117 +*/
  9.1118 +void *talloc_autofree_context(void)
  9.1119 +{
  9.1120 +	if (cleanup_context == NULL) {
  9.1121 +		cleanup_context = talloc_named_const(NULL, 0, "autofree_context");
  9.1122 +		atexit(talloc_autofree);
  9.1123 +	}
  9.1124 +	return cleanup_context;
  9.1125 +}
  9.1126 +
  9.1127 +size_t talloc_get_size(const void *context)
  9.1128 +{
  9.1129 +	struct talloc_chunk *tc;
  9.1130 +
  9.1131 +	if (context == NULL)
  9.1132 +		return 0;
  9.1133 +
  9.1134 +	tc = talloc_chunk_from_ptr(context);
  9.1135 +
  9.1136 +	return tc->size;
  9.1137 +}
  9.1138 +
  9.1139 +talloc_fail_handler *talloc_set_fail_handler(talloc_fail_handler *handler,
  9.1140 +					     void *data)
  9.1141 +{
  9.1142 +	talloc_fail_handler *old = malloc_fail_handler;
  9.1143 +	malloc_fail_handler = handler;
  9.1144 +	malloc_fail_data = data;
  9.1145 +	return old;
  9.1146 +}

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/tools/xenstore/talloc.h	Tue Jun 07 12:43:58 2005 +0000
    10.3 @@ -0,0 +1,134 @@
    10.4 +#ifndef _TALLOC_H_
    10.5 +#define _TALLOC_H_
    10.6 +/* 
    10.7 +   Unix SMB/CIFS implementation.
    10.8 +   Samba temporary memory allocation functions
    10.9 +
   10.10 +   Copyright (C) Andrew Tridgell 2004-2005
   10.11 +   
   10.12 +   This program is free software; you can redistribute it and/or modify
   10.13 +   it under the terms of the GNU General Public License as published by
   10.14 +   the Free Software Foundation; either version 2 of the License, or
   10.15 +   (at your option) any later version.
   10.16 +   
   10.17 +   This program is distributed in the hope that it will be useful,
   10.18 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.19 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.20 +   GNU General Public License for more details.
   10.21 +   
   10.22 +   You should have received a copy of the GNU General Public License
   10.23 +   along with this program; if not, write to the Free Software
   10.24 +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   10.25 +*/
   10.26 +
   10.27 +/* this is only needed for compatibility with the old talloc */
   10.28 +typedef void TALLOC_CTX;
   10.29 +
   10.30 +/*
   10.31 +  this uses a little trick to allow __LINE__ to be stringified
   10.32 +*/
   10.33 +#define _STRING_LINE_(s)    #s
   10.34 +#define _STRING_LINE2_(s)   _STRING_LINE_(s)
   10.35 +#define __LINESTR__       _STRING_LINE2_(__LINE__)
   10.36 +#define __location__ __FILE__ ":" __LINESTR__
   10.37 +
   10.38 +#ifndef TALLOC_DEPRECATED
   10.39 +#define TALLOC_DEPRECATED 0
   10.40 +#endif
   10.41 +
   10.42 +/* useful macros for creating type checked pointers */
   10.43 +#define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
   10.44 +#define talloc_size(ctx, size) talloc_named_const(ctx, size, __location__)
   10.45 +
   10.46 +#define talloc_new(ctx) talloc_named_const(ctx, 0, "talloc_new: " __location__)
   10.47 +
   10.48 +#define talloc_zero(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
   10.49 +#define talloc_zero_size(ctx, size) _talloc_zero(ctx, size, __location__)
   10.50 +
   10.51 +#define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
   10.52 +#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
   10.53 +#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
   10.54 +
   10.55 +#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
   10.56 +#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
   10.57 +
   10.58 +#define talloc_memdup(t, p, size) _talloc_memdup(t, p, size, __location__)
   10.59 +
   10.60 +#define malloc_p(type) (type *)malloc(sizeof(type))
   10.61 +#define malloc_array_p(type, count) (type *)realloc_array(NULL, sizeof(type), count)
   10.62 +#define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count)
   10.63 +
   10.64 +#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__)
   10.65 +#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__)
   10.66 +#define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__)
   10.67 +
   10.68 +#define talloc_set_type(ptr, type) talloc_set_name_const(ptr, #type)
   10.69 +#define talloc_get_type(ptr, type) (type *)talloc_check_name(ptr, #type)
   10.70 +
   10.71 +
   10.72 +#if TALLOC_DEPRECATED
   10.73 +#define talloc_zero_p(ctx, type) talloc_zero(ctx, type)
   10.74 +#define talloc_p(ctx, type) talloc(ctx, type)
   10.75 +#define talloc_array_p(ctx, type, count) talloc_array(ctx, type, count)
   10.76 +#define talloc_realloc_p(ctx, p, type, count) talloc_realloc(ctx, p, type, count)
   10.77 +#define talloc_destroy(ctx) talloc_free(ctx)
   10.78 +#endif
   10.79 +
   10.80 +#ifndef PRINTF_ATTRIBUTE
   10.81 +#if (__GNUC__ >= 3)
   10.82 +/** Use gcc attribute to check printf fns.  a1 is the 1-based index of
   10.83 + * the parameter containing the format, and a2 the index of the first
   10.84 + * argument. Note that some gcc 2.x versions don't handle this
   10.85 + * properly **/
   10.86 +#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
   10.87 +#else
   10.88 +#define PRINTF_ATTRIBUTE(a1, a2)
   10.89 +#endif
   10.90 +#endif
   10.91 +
   10.92 +
   10.93 +/* The following definitions come from talloc.c  */
   10.94 +void *_talloc(const void *context, size_t size);
   10.95 +void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
   10.96 +void talloc_increase_ref_count(const void *ptr);
   10.97 +void *talloc_reference(const void *context, const void *ptr);
   10.98 +int talloc_unlink(const void *context, void *ptr);
   10.99 +void talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
  10.100 +void talloc_set_name_const(const void *ptr, const char *name);
  10.101 +void *talloc_named(const void *context, size_t size, 
  10.102 +		   const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
  10.103 +void *talloc_named_const(const void *context, size_t size, const char *name);
  10.104 +const char *talloc_get_name(const void *ptr);
  10.105 +void *talloc_check_name(const void *ptr, const char *name);
  10.106 +void talloc_report_depth(const void *ptr, FILE *f, int depth);
  10.107 +void *talloc_parent(const void *ptr);
  10.108 +void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
  10.109 +int talloc_free(void *ptr);
  10.110 +void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
  10.111 +void *talloc_steal(const void *new_ctx, const void *ptr);
  10.112 +off_t talloc_total_size(const void *ptr);
  10.113 +off_t talloc_total_blocks(const void *ptr);
  10.114 +void talloc_report_full(const void *ptr, FILE *f);
  10.115 +void talloc_report(const void *ptr, FILE *f);
  10.116 +void talloc_enable_null_tracking(void);
  10.117 +void talloc_enable_leak_report(void);
  10.118 +void talloc_enable_leak_report_full(void);
  10.119 +void *_talloc_zero(const void *ctx, size_t size, const char *name);
  10.120 +void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
  10.121 +char *talloc_strdup(const void *t, const char *p);
  10.122 +char *talloc_strndup(const void *t, const char *p, size_t n);
  10.123 +char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
  10.124 +char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
  10.125 +char *talloc_asprintf_append(char *s,
  10.126 +			     const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
  10.127 +void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name);
  10.128 +void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name);
  10.129 +void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
  10.130 +void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
  10.131 +void *talloc_autofree_context(void);
  10.132 +size_t talloc_get_size(const void *ctx);
  10.133 +
  10.134 +typedef int talloc_fail_handler(void *);
  10.135 +talloc_fail_handler *talloc_set_fail_handler(talloc_fail_handler *, void *);
  10.136 +#endif
  10.137 +

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/tools/xenstore/talloc_guide.txt	Tue Jun 07 12:43:58 2005 +0000
    11.3 @@ -0,0 +1,569 @@
    11.4 +Using talloc in Samba4
    11.5 +----------------------
    11.6 +
    11.7 +Andrew Tridgell
    11.8 +September 2004
    11.9 +
   11.10 +The most current version of this document is available at
   11.11 +   http://samba.org/ftp/unpacked/samba4/source/lib/talloc/talloc_guide.txt
   11.12 +
   11.13 +If you are used to talloc from Samba3 then please read this carefully,
   11.14 +as talloc has changed a lot.
   11.15 +
   11.16 +The new talloc is a hierarchical, reference counted memory pool system
   11.17 +with destructors. Quite a mounthful really, but not too bad once you
   11.18 +get used to it.
   11.19 +
   11.20 +Perhaps the biggest change from Samba3 is that there is no distinction
   11.21 +between a "talloc context" and a "talloc pointer". Any pointer
   11.22 +returned from talloc() is itself a valid talloc context. This means
   11.23 +you can do this:
   11.24 +
   11.25 +  struct foo *X = talloc(mem_ctx, struct foo);
   11.26 +  X->name = talloc_strdup(X, "foo");
   11.27 +
   11.28 +and the pointer X->name would be a "child" of the talloc context "X"
   11.29 +which is itself a child of mem_ctx. So if you do talloc_free(mem_ctx)
   11.30 +then it is all destroyed, whereas if you do talloc_free(X) then just X
   11.31 +and X->name are destroyed, and if you do talloc_free(X->name) then
   11.32 +just the name element of X is destroyed.
   11.33 +
   11.34 +If you think about this, then what this effectively gives you is an
   11.35 +n-ary tree, where you can free any part of the tree with
   11.36 +talloc_free().
   11.37 +
   11.38 +If you find this confusing, then I suggest you run the testsuite to
   11.39 +watch talloc in action. You may also like to add your own tests to
   11.40 +testsuite.c to clarify how some particular situation is handled.
   11.41 +
   11.42 +
   11.43 +Performance
   11.44 +-----------
   11.45 +
   11.46 +All the additional features of talloc() over malloc() do come at a
   11.47 +price. We have a simple performance test in Samba4 that measures
   11.48 +talloc() versus malloc() performance, and it seems that talloc() is
   11.49 +about 10% slower than malloc() on my x86 Debian Linux box. For Samba,
   11.50 +the great reduction in code complexity that we get by using talloc
   11.51 +makes this worthwhile, especially as the total overhead of
   11.52 +talloc/malloc in Samba is already quite small.
   11.53 +
   11.54 +
   11.55 +talloc API
   11.56 +----------
   11.57 +
   11.58 +The following is a complete guide to the talloc API. Read it all at
   11.59 +least twice.
   11.60 +
   11.61 +
   11.62 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   11.63 +(type *)talloc(const void *context, type);
   11.64 +
   11.65 +The talloc() macro is the core of the talloc library. It takes a
   11.66 +memory context and a type, and returns a pointer to a new area of
   11.67 +memory of the given type.
   11.68 +
   11.69 +The returned pointer is itself a talloc context, so you can use it as
   11.70 +the context argument to more calls to talloc if you wish.
   11.71 +
   11.72 +The returned pointer is a "child" of the supplied context. This means
   11.73 +that if you talloc_free() the context then the new child disappears as
   11.74 +well. Alternatively you can free just the child.
   11.75 +
   11.76 +The context argument to talloc() can be NULL, in which case a new top
   11.77 +level context is created. 
   11.78 +
   11.79 +
   11.80 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   11.81 +void *talloc_size(const void *context, size_t size);
   11.82 +
   11.83 +The function talloc_size() should be used when you don't have a
   11.84 +convenient type to pass to talloc(). Unlike talloc(), it is not type
   11.85 +safe (as it returns a void *), so you are on your own for type checking.
   11.86 +
   11.87 +
   11.88 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   11.89 +int talloc_free(void *ptr);
   11.90 +
   11.91 +The talloc_free() function frees a piece of talloc memory, and all its
   11.92 +children. You can call talloc_free() on any pointer returned by
   11.93 +talloc().
   11.94 +
   11.95 +The return value of talloc_free() indicates success or failure, with 0
   11.96 +returned for success and -1 for failure. The only possible failure
   11.97 +condition is if the pointer had a destructor attached to it and the
   11.98 +destructor returned -1. See talloc_set_destructor() for details on
   11.99 +destructors.
  11.100 +
  11.101 +If this pointer has an additional parent when talloc_free() is called
  11.102 +then the memory is not actually released, but instead the most
  11.103 +recently established parent is destroyed. See talloc_reference() for
  11.104 +details on establishing additional parents.
  11.105 +
  11.106 +For more control on which parent is removed, see talloc_unlink()
  11.107 +
  11.108 +talloc_free() operates recursively on its children.
  11.109 +
  11.110 +
  11.111 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.112 +int talloc_free_children(void *ptr);
  11.113 +
  11.114 +The talloc_free_children() walks along the list of all children of a
  11.115 +talloc context and talloc_free()s only the children, not the context
  11.116 +itself.
  11.117 +
  11.118 +
  11.119 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.120 +void *talloc_reference(const void *context, const void *ptr);
  11.121 +
  11.122 +The talloc_reference() function makes "context" an additional parent
  11.123 +of "ptr".
  11.124 +
  11.125 +The return value of talloc_reference() is always the original pointer
  11.126 +"ptr", unless talloc ran out of memory in creating the reference in
  11.127 +which case it will return NULL (each additional reference consumes
  11.128 +around 48 bytes of memory on intel x86 platforms).
  11.129 +
  11.130 +If "ptr" is NULL, then the function is a no-op, and simply returns NULL.
  11.131 +
  11.132 +After creating a reference you can free it in one of the following
  11.133 +ways:
  11.134 +
  11.135 +  - you can talloc_free() any parent of the original pointer. That
  11.136 +    will reduce the number of parents of this pointer by 1, and will
  11.137 +    cause this pointer to be freed if it runs out of parents.
  11.138 +
  11.139 +  - you can talloc_free() the pointer itself. That will destroy the
  11.140 +    most recently established parent to the pointer and leave the
  11.141 +    pointer as a child of its current parent.
  11.142 +
  11.143 +For more control on which parent to remove, see talloc_unlink()
  11.144 +
  11.145 +
  11.146 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.147 +int talloc_unlink(const void *context, const void *ptr);
  11.148 +
  11.149 +The talloc_unlink() function removes a specific parent from ptr. The
  11.150 +context passed must either be a context used in talloc_reference()
  11.151 +with this pointer, or must be a direct parent of ptr. 
  11.152 +
  11.153 +Note that if the parent has already been removed using talloc_free()
  11.154 +then this function will fail and will return -1.  Likewise, if "ptr"
  11.155 +is NULL, then the function will make no modifications and return -1.
  11.156 +
  11.157 +Usually you can just use talloc_free() instead of talloc_unlink(), but
  11.158 +sometimes it is useful to have the additional control on which parent
  11.159 +is removed.
  11.160 +
  11.161 +
  11.162 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.163 +void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
  11.164 +
  11.165 +The function talloc_set_destructor() sets the "destructor" for the
  11.166 +pointer "ptr". A destructor is a function that is called when the
  11.167 +memory used by a pointer is about to be released. The destructor
  11.168 +receives the pointer as an argument, and should return 0 for success
  11.169 +and -1 for failure.
  11.170 +
  11.171 +The destructor can do anything it wants to, including freeing other
  11.172 +pieces of memory. A common use for destructors is to clean up
  11.173 +operating system resources (such as open file descriptors) contained
  11.174 +in the structure the destructor is placed on.
  11.175 +
  11.176 +You can only place one destructor on a pointer. If you need more than
  11.177 +one destructor then you can create a zero-length child of the pointer
  11.178 +and place an additional destructor on that.
  11.179 +
  11.180 +To remove a destructor call talloc_set_destructor() with NULL for the
  11.181 +destructor.
  11.182 +
  11.183 +If your destructor attempts to talloc_free() the pointer that it is
  11.184 +the destructor for then talloc_free() will return -1 and the free will
  11.185 +be ignored. This would be a pointless operation anyway, as the
  11.186 +destructor is only called when the memory is just about to go away.
  11.187 +
  11.188 +
  11.189 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.190 +void talloc_increase_ref_count(const void *ptr);
  11.191 +
  11.192 +The talloc_increase_ref_count(ptr) function is exactly equivalent to:
  11.193 +
  11.194 +  talloc_reference(NULL, ptr);
  11.195 +
  11.196 +You can use either syntax, depending on which you think is clearer in
  11.197 +your code.
  11.198 +
  11.199 +
  11.200 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.201 +void talloc_set_name(const void *ptr, const char *fmt, ...);
  11.202 +
  11.203 +Each talloc pointer has a "name". The name is used principally for
  11.204 +debugging purposes, although it is also possible to set and get the
  11.205 +name on a pointer in as a way of "marking" pointers in your code.
  11.206 +
  11.207 +The main use for names on pointer is for "talloc reports". See
  11.208 +talloc_report() and talloc_report_full() for details. Also see
  11.209 +talloc_enable_leak_report() and talloc_enable_leak_report_full().
  11.210 +
  11.211 +The talloc_set_name() function allocates memory as a child of the
  11.212 +pointer. It is logically equivalent to:
  11.213 +  talloc_set_name_const(ptr, talloc_asprintf(ptr, fmt, ...));
  11.214 +
  11.215 +Note that multiple calls to talloc_set_name() will allocate more
  11.216 +memory without releasing the name. All of the memory is released when
  11.217 +the ptr is freed using talloc_free().
  11.218 +
  11.219 +
  11.220 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.221 +void talloc_set_name_const(const void *ptr, const char *name);
  11.222 +
  11.223 +The function talloc_set_name_const() is just like talloc_set_name(),
  11.224 +but it takes a string constant, and is much faster. It is extensively
  11.225 +used by the "auto naming" macros, such as talloc_p().
  11.226 +
  11.227 +This function does not allocate any memory. It just copies the
  11.228 +supplied pointer into the internal representation of the talloc
  11.229 +ptr. This means you must not pass a name pointer to memory that will
  11.230 +disappear before the ptr is freed with talloc_free().
  11.231 +
  11.232 +
  11.233 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.234 +void *talloc_named(const void *context, size_t size, const char *fmt, ...);
  11.235 +
  11.236 +The talloc_named() function creates a named talloc pointer. It is
  11.237 +equivalent to:
  11.238 +
  11.239 +   ptr = talloc_size(context, size);
  11.240 +   talloc_set_name(ptr, fmt, ....);
  11.241 +
  11.242 +
  11.243 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.244 +void *talloc_named_const(const void *context, size_t size, const char *name);
  11.245 +
  11.246 +This is equivalent to:
  11.247 +
  11.248 +   ptr = talloc_size(context, size);
  11.249 +   talloc_set_name_const(ptr, name);
  11.250 +
  11.251 +
  11.252 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.253 +const char *talloc_get_name(const void *ptr);
  11.254 +
  11.255 +This returns the current name for the given talloc pointer. See
  11.256 +talloc_set_name() for details.
  11.257 +
  11.258 +
  11.259 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.260 +void *talloc_init(const char *fmt, ...);
  11.261 +
  11.262 +This function creates a zero length named talloc context as a top
  11.263 +level context. It is equivalent to:
  11.264 +
  11.265 +  talloc_named(NULL, 0, fmt, ...);
  11.266 +
  11.267 +
  11.268 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.269 +void *talloc_new(void *ctx);
  11.270 +
  11.271 +This is a utility macro that creates a new memory context hanging
  11.272 +off an exiting context, automatically naming it "talloc_new: __location__"
  11.273 +where __location__ is the source line it is called from. It is
  11.274 +particularly useful for creating a new temporary working context.
  11.275 +
  11.276 +
  11.277 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.278 +(type *)talloc_realloc(const void *context, void *ptr, type, count);
  11.279 +
  11.280 +The talloc_realloc() macro changes the size of a talloc
  11.281 +pointer. The "count" argument is the number of elements of type "type"
  11.282 +that you want the resulting pointer to hold. 
  11.283 +
  11.284 +talloc_realloc() has the following equivalences:
  11.285 +
  11.286 +  talloc_realloc(context, NULL, type, 1) ==> talloc(context, type);
  11.287 +  talloc_realloc(context, NULL, type, N) ==> talloc_array(context, type, N);
  11.288 +  talloc_realloc(context, ptr, type, 0)  ==> talloc_free(ptr);
  11.289 +
  11.290 +The "context" argument is only used if "ptr" is not NULL, otherwise it
  11.291 +is ignored.
  11.292 +
  11.293 +talloc_realloc() returns the new pointer, or NULL on failure. The call
  11.294 +will fail either due to a lack of memory, or because the pointer has
  11.295 +more than one parent (see talloc_reference()).
  11.296 +
  11.297 +
  11.298 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.299 +void *talloc_realloc_size(const void *context, void *ptr, size_t size);
  11.300 +
  11.301 +the talloc_realloc_size() function is useful when the type is not 
  11.302 +known so the typesafe talloc_realloc() cannot be used.
  11.303 +
  11.304 +
  11.305 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.306 +void *talloc_steal(const void *new_ctx, const void *ptr);
  11.307 +
  11.308 +The talloc_steal() function changes the parent context of a talloc
  11.309 +pointer. It is typically used when the context that the pointer is
  11.310 +currently a child of is going to be freed and you wish to keep the
  11.311 +memory for a longer time. 
  11.312 +
  11.313 +The talloc_steal() function returns the pointer that you pass it. It
  11.314 +does not have any failure modes.
  11.315 +
  11.316 +NOTE: It is possible to produce loops in the parent/child relationship
  11.317 +if you are not careful with talloc_steal(). No guarantees are provided
  11.318 +as to your sanity or the safety of your data if you do this.
  11.319 +
  11.320 +talloc_steal (new_ctx, NULL) will return NULL with no sideeffects.
  11.321 +
  11.322 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.323 +off_t talloc_total_size(const void *ptr);
  11.324 +
  11.325 +The talloc_total_size() function returns the total size in bytes used
  11.326 +by this pointer and all child pointers. Mostly useful for debugging.
  11.327 +
  11.328 +Passing NULL is allowed, but it will only give a meaningful result if
  11.329 +talloc_enable_leak_report() or talloc_enable_leak_report_full() has
  11.330 +been called.
  11.331 +
  11.332 +
  11.333 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.334 +off_t talloc_total_blocks(const void *ptr);
  11.335 +
  11.336 +The talloc_total_blocks() function returns the total memory block
  11.337 +count used by this pointer and all child pointers. Mostly useful for
  11.338 +debugging.
  11.339 +
  11.340 +Passing NULL is allowed, but it will only give a meaningful result if
  11.341 +talloc_enable_leak_report() or talloc_enable_leak_report_full() has
  11.342 +been called.
  11.343 +
  11.344 +
  11.345 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.346 +void talloc_report(const void *ptr, FILE *f);
  11.347 +
  11.348 +The talloc_report() function prints a summary report of all memory
  11.349 +used by ptr. One line of report is printed for each immediate child of
  11.350 +ptr, showing the total memory and number of blocks used by that child.
  11.351 +
  11.352 +You can pass NULL for the pointer, in which case a report is printed
  11.353 +for the top level memory context, but only if
  11.354 +talloc_enable_leak_report() or talloc_enable_leak_report_full() has
  11.355 +been called.
  11.356 +
  11.357 +
  11.358 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.359 +void talloc_report_full(const void *ptr, FILE *f);
  11.360 +
  11.361 +This provides a more detailed report than talloc_report(). It will
  11.362 +recursively print the ensire tree of memory referenced by the
  11.363 +pointer. References in the tree are shown by giving the name of the
  11.364 +pointer that is referenced.
  11.365 +
  11.366 +You can pass NULL for the pointer, in which case a report is printed
  11.367 +for the top level memory context, but only if
  11.368 +talloc_enable_leak_report() or talloc_enable_leak_report_full() has
  11.369 +been called.
  11.370 +
  11.371 +
  11.372 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.373 +void talloc_enable_leak_report(void);
  11.374 +
  11.375 +This enables calling of talloc_report(NULL, stderr) when the program
  11.376 +exits. In Samba4 this is enabled by using the --leak-report command
  11.377 +line option.
  11.378 +
  11.379 +For it to be useful, this function must be called before any other
  11.380 +talloc function as it establishes a "null context" that acts as the
  11.381 +top of the tree. If you don't call this function first then passing
  11.382 +NULL to talloc_report() or talloc_report_full() won't give you the
  11.383 +full tree printout.
  11.384 +
  11.385 +Here is a typical talloc report:
  11.386 +
  11.387 +talloc report on 'null_context' (total 267 bytes in 15 blocks)
  11.388 +        libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
  11.389 +        libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
  11.390 +        iconv(UTF8,CP850)              contains     42 bytes in   2 blocks
  11.391 +        libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
  11.392 +        iconv(CP850,UTF8)              contains     42 bytes in   2 blocks
  11.393 +        iconv(UTF8,UTF-16LE)           contains     45 bytes in   2 blocks
  11.394 +        iconv(UTF-16LE,UTF8)           contains     45 bytes in   2 blocks
  11.395 +
  11.396 +
  11.397 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.398 +void talloc_enable_leak_report_full(void);
  11.399 +
  11.400 +This enables calling of talloc_report_full(NULL, stderr) when the
  11.401 +program exits. In Samba4 this is enabled by using the
  11.402 +--leak-report-full command line option.
  11.403 +
  11.404 +For it to be useful, this function must be called before any other
  11.405 +talloc function as it establishes a "null context" that acts as the
  11.406 +top of the tree. If you don't call this function first then passing
  11.407 +NULL to talloc_report() or talloc_report_full() won't give you the
  11.408 +full tree printout.
  11.409 +
  11.410 +Here is a typical full report:
  11.411 +
  11.412 +full talloc report on 'root' (total 18 bytes in 8 blocks)
  11.413 +    p1                             contains     18 bytes in   7 blocks (ref 0)
  11.414 +        r1                             contains     13 bytes in   2 blocks (ref 0)
  11.415 +            reference to: p2
  11.416 +        p2                             contains      1 bytes in   1 blocks (ref 1)
  11.417 +        x3                             contains      1 bytes in   1 blocks (ref 0)
  11.418 +        x2                             contains      1 bytes in   1 blocks (ref 0)
  11.419 +        x1                             contains      1 bytes in   1 blocks (ref 0)
  11.420 +
  11.421 +
  11.422 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.423 +void talloc_enable_null_tracking(void);
  11.424 +
  11.425 +This enables tracking of the NULL memory context without enabling leak
  11.426 +reporting on exit. Useful for when you want to do your own leak
  11.427 +reporting call via talloc_report_null_full();
  11.428 +
  11.429 +
  11.430 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.431 +(type *)talloc_zero(const void *ctx, type);
  11.432 +
  11.433 +The talloc_zero() macro is equivalent to:
  11.434 +
  11.435 +  ptr = talloc(ctx, type);
  11.436 +  if (ptr) memset(ptr, 0, sizeof(type));
  11.437 +
  11.438 +
  11.439 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.440 +void *talloc_zero_size(const void *ctx, size_t size)
  11.441 +
  11.442 +The talloc_zero_size() function is useful when you don't have a known type
  11.443 +
  11.444 +
  11.445 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.446 +void *talloc_memdup(const void *ctx, const void *p, size_t size);
  11.447 +
  11.448 +The talloc_memdup() function is equivalent to:
  11.449 +
  11.450 +  ptr = talloc_size(ctx, size);
  11.451 +  if (ptr) memcpy(ptr, p, size);
  11.452 +
  11.453 +
  11.454 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.455 +char *talloc_strdup(const void *ctx, const char *p);
  11.456 +
  11.457 +The talloc_strdup() function is equivalent to:
  11.458 +
  11.459 +  ptr = talloc_size(ctx, strlen(p)+1);
  11.460 +  if (ptr) memcpy(ptr, p, strlen(p)+1);
  11.461 +
  11.462 +This functions sets the name of the new pointer to the passed
  11.463 +string. This is equivalent to:
  11.464 +   talloc_set_name_const(ptr, ptr)
  11.465 +
  11.466 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.467 +char *talloc_strndup(const void *t, const char *p, size_t n);
  11.468 +
  11.469 +The talloc_strndup() function is the talloc equivalent of the C
  11.470 +library function strndup()
  11.471 +
  11.472 +This functions sets the name of the new pointer to the passed
  11.473 +string. This is equivalent to:
  11.474 +   talloc_set_name_const(ptr, ptr)
  11.475 +
  11.476 +
  11.477 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.478 +char *talloc_vasprintf(const void *t, const char *fmt, va_list ap);
  11.479 +
  11.480 +The talloc_vasprintf() function is the talloc equivalent of the C
  11.481 +library function vasprintf()
  11.482 +
  11.483 +
  11.484 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.485 +char *talloc_asprintf(const void *t, const char *fmt, ...);
  11.486 +
  11.487 +The talloc_asprintf() function is the talloc equivalent of the C
  11.488 +library function asprintf()
  11.489 +
  11.490 +This functions sets the name of the new pointer to the passed
  11.491 +string. This is equivalent to:
  11.492 +   talloc_set_name_const(ptr, ptr)
  11.493 +
  11.494 +
  11.495 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.496 +char *talloc_asprintf_append(char *s, const char *fmt, ...);
  11.497 +
  11.498 +The talloc_asprintf_append() function appends the given formatted 
  11.499 +string to the given string. 
  11.500 +
  11.501 +
  11.502 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.503 +(type *)talloc_array(const void *ctx, type, uint_t count);
  11.504 +
  11.505 +The talloc_array() macro is equivalent to:
  11.506 +
  11.507 +  (type *)talloc_size(ctx, sizeof(type) * count);
  11.508 +
  11.509 +except that it provides integer overflow protection for the multiply,
  11.510 +returning NULL if the multiply overflows.
  11.511 +
  11.512 +
  11.513 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.514 +void *talloc_array_size(const void *ctx, size_t size, uint_t count);
  11.515 +
  11.516 +The talloc_array_size() function is useful when the type is not
  11.517 +known. It operates in the same way as talloc_array(), but takes a size
  11.518 +instead of a type.
  11.519 +
  11.520 +
  11.521 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.522 +void *talloc_realloc_fn(const void *ctx, void *ptr, size_t size);
  11.523 +
  11.524 +This is a non-macro version of talloc_realloc(), which is useful 
  11.525 +as libraries sometimes want a ralloc function pointer. A realloc()
  11.526 +implementation encapsulates the functionality of malloc(), free() and
  11.527 +realloc() in one call, which is why it is useful to be able to pass
  11.528 +around a single function pointer.
  11.529 +
  11.530 +
  11.531 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.532 +void *talloc_autofree_context(void);
  11.533 +
  11.534 +This is a handy utility function that returns a talloc context
  11.535 +which will be automatically freed on program exit. This can be used
  11.536 +to reduce the noise in memory leak reports.
  11.537 +
  11.538 +
  11.539 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.540 +void *talloc_check_name(const void *ptr, const char *name);
  11.541 +
  11.542 +This function checks if a pointer has the specified name. If it does
  11.543 +then the pointer is returned. It it doesn't then NULL is returned.
  11.544 +
  11.545 +
  11.546 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.547 +(type *)talloc_get_type(const void *ptr, type);
  11.548 +
  11.549 +This macro allows you to do type checking on talloc pointers. It is
  11.550 +particularly useful for void* private pointers. It is equivalent to
  11.551 +this:
  11.552 +
  11.553 +   (type *)talloc_check_name(ptr, #type)
  11.554 +
  11.555 +
  11.556 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.557 +talloc_set_type(const void *ptr, type);
  11.558 +
  11.559 +This macro allows you to force the name of a pointer to be a
  11.560 +particular type. This can be used in conjunction with
  11.561 +talloc_get_type() to do type checking on void* pointers.
  11.562 +
  11.563 +It is equivalent to this:
  11.564 +   talloc_set_name_const(ptr, #type)
  11.565 +
  11.566 +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  11.567 +talloc_get_size(const void *ctx);
  11.568 +
  11.569 +This function lets you know the amount of memory alloced so far by
  11.570 +this context. It does NOT account for subcontext memory.
  11.571 +This can be used to calculate the size of an array.
  11.572 +

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/tools/xenstore/testsuite/01simple.sh	Tue Jun 07 12:43:58 2005 +0000
    12.3 @@ -0,0 +1,4 @@
    12.4 +#! /bin/sh
    12.5 +
    12.6 +# Create an entry, read it.
    12.7 +[ "`echo -e 'write /test create contents\nread /test' | ./xs_test 2>&1`" = "contents" ]

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/tools/xenstore/testsuite/02directory.sh	Tue Jun 07 12:43:58 2005 +0000
    13.3 @@ -0,0 +1,31 @@
    13.4 +#! /bin/sh
    13.5 +
    13.6 +# Root directory has nothing in it.
    13.7 +[ "`echo -e 'dir /' | ./xs_test 2>&1`" = "" ]
    13.8 +
    13.9 +# Create a file.
   13.10 +[ "`echo -e 'write /test create contents' | ./xs_test 2>&1`" = "" ]
   13.11 +
   13.12 +# Directory shows it.
   13.13 +[ "`echo -e 'dir /' | ./xs_test 2>&1`" = "test" ]
   13.14 +
   13.15 +# Make a new directory.
   13.16 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "" ]
   13.17 +
   13.18 +# Check it's there.
   13.19 +DIR="`echo -e 'dir /' | ./xs_test 2>&1`"
   13.20 +[ "$DIR" = "test
   13.21 +dir" ] || [ "$DIR" = "dir
   13.22 +test" ]
   13.23 +
   13.24 +# Check it's empty.
   13.25 +[ "`echo -e 'dir /dir' | ./xs_test 2>&1`" = "" ]
   13.26 +
   13.27 +# Create a file, check it exists.
   13.28 +[ "`echo -e 'write /dir/test2 create contents2' | ./xs_test 2>&1`" = "" ]
   13.29 +[ "`echo -e 'dir /dir' | ./xs_test 2>&1`" = "test2" ]
   13.30 +[ "`echo -e 'read /dir/test2' | ./xs_test 2>&1`" = "contents2" ]
   13.31 +
   13.32 +# Creating dir over the top should fail.
   13.33 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "FATAL: mkdir: File exists" ]
   13.34 +[ "`echo -e 'mkdir /dir/test2' | ./xs_test 2>&1`" = "FATAL: mkdir: File exists" ]

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/tools/xenstore/testsuite/03write.sh	Tue Jun 07 12:43:58 2005 +0000
    14.3 @@ -0,0 +1,17 @@
    14.4 +#! /bin/sh
    14.5 +
    14.6 +# Write without create fails.
    14.7 +[ "`echo -e 'write /test none contents' | ./xs_test 2>&1`" = "FATAL: write: No such file or directory" ]
    14.8 +
    14.9 +# Exclusive write succeeds
   14.10 +[ "`echo -e 'write /test excl contents' | ./xs_test 2>&1`" = "" ]
   14.11 +[ "`echo -e 'read /test' | ./xs_test 2>&1`" = "contents" ]
   14.12 +
   14.13 +# Exclusive write fails to overwrite.
   14.14 +[ "`echo -e 'write /test excl contents' | ./xs_test 2>&1`" = "FATAL: write: File exists" ]
   14.15 +
   14.16 +# Non-exclusive overwrite succeeds.
   14.17 +[ "`echo -e 'write /test none contents2' | ./xs_test 2>&1`" = "" ]
   14.18 +[ "`echo -e 'read /test' | ./xs_test 2>&1`" = "contents2" ]
   14.19 +[ "`echo -e 'write /test create contents3' | ./xs_test 2>&1`" = "" ]
   14.20 +[ "`echo -e 'read /test' | ./xs_test 2>&1`" = "contents3" ]

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/tools/xenstore/testsuite/04rm.sh	Tue Jun 07 12:43:58 2005 +0000
    15.3 @@ -0,0 +1,18 @@
    15.4 +#! /bin/sh
    15.5 +
    15.6 +# Remove non-existant fails.
    15.7 +[ "`echo -e 'rm /test' | ./xs_test 2>&1`" = "FATAL: rm: No such file or directory" ]
    15.8 +[ "`echo -e 'rm /dir/test' | ./xs_test 2>&1`" = "FATAL: rm: No such file or directory" ]
    15.9 +
   15.10 +# Create file and remove it
   15.11 +[ "`echo -e 'write /test excl contents' | ./xs_test 2>&1`" = "" ]
   15.12 +[ "`echo -e 'rm /test' | ./xs_test 2>&1`" = "" ]
   15.13 +
   15.14 +# Create directory and remove it.
   15.15 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "" ]
   15.16 +[ "`echo -e 'rm /dir' | ./xs_test 2>&1`" = "" ]
   15.17 +
   15.18 +# Create directory, create file, remove all.
   15.19 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "" ]
   15.20 +[ "`echo -e 'write /dir/test excl contents' | ./xs_test 2>&1`" = "" ]
   15.21 +[ "`echo -e 'rm /dir' | ./xs_test 2>&1`" = "" ]

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/tools/xenstore/testsuite/05filepermissions.sh	Tue Jun 07 12:43:58 2005 +0000
    16.3 @@ -0,0 +1,49 @@
    16.4 +#! /bin/sh
    16.5 +
    16.6 +# Fail to get perms on non-existent file.
    16.7 +[ "`echo -e 'getperm /test' | ./xs_test 2>&1`" = "FATAL: getperm: No such file or directory" ]
    16.8 +[ "`echo -e 'getperm /dir/test' | ./xs_test 2>&1`" = "FATAL: getperm: No such file or directory" ]
    16.9 +
   16.10 +# Create file: we own it, noone has access.
   16.11 +[ "`echo -e 'write /test excl contents' | ./xs_test 2>&1`" = "" ]
   16.12 +[ "`echo -e 'getperm /test' | ./xs_test 2>&1`" = "0 NONE" ]
   16.13 +[ "`echo -e 'setid 1\ngetperm /test' | ./xs_test 2>&1`" = "FATAL: getperm: Permission denied" ]
   16.14 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   16.15 +[ "`echo -e 'setid 1\nwrite /test none contents2' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   16.16 +
   16.17 +# Grant everyone read access to file.
   16.18 +[ "`echo -e 'setperm /test 0 READ' | ./xs_test 2>&1`" = "" ]
   16.19 +[ "`echo -e 'setid 1\ngetperm /test' | ./xs_test 2>&1`" = "0 READ" ]
   16.20 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "contents" ]
   16.21 +[ "`echo -e 'setid 1\nwrite /test none contents2' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   16.22 +
   16.23 +# Grant everyone write access to file.
   16.24 +[ "`echo -e 'setperm /test 0 WRITE' | ./xs_test 2>&1`" = "" ]
   16.25 +[ "`echo -e 'setid 1\ngetperm /test' | ./xs_test 2>&1`" = "FATAL: getperm: Permission denied" ]
   16.26 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   16.27 +[ "`echo -e 'setid 1\nwrite /test none contents2' | ./xs_test 2>&1`" = "" ]
   16.28 +[ "`echo -e 'read /test' | ./xs_test 2>&1`" = "contents2" ]
   16.29 +
   16.30 +# Grant everyone both read and write access.
   16.31 +[ "`echo -e 'setperm /test 0 READ/WRITE' | ./xs_test 2>&1`" = "" ]
   16.32 +[ "`echo -e 'setid 1\ngetperm /test' | ./xs_test 2>&1`" = "0 READ/WRITE" ]
   16.33 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "contents2" ]
   16.34 +[ "`echo -e 'setid 1\nwrite /test none contents3' | ./xs_test 2>&1`" = "" ]
   16.35 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "contents3" ]
   16.36 +
   16.37 +# Change so that user 1 owns it, noone else can do anything.
   16.38 +[ "`echo -e 'setperm /test 1 NONE' | ./xs_test 2>&1`" = "" ]
   16.39 +[ "`echo -e 'setid 1\ngetperm /test' | ./xs_test 2>&1`" = "1 NONE" ]
   16.40 +[ "`echo -e 'setid 1\nread /test' | ./xs_test 2>&1`" = "contents3" ]
   16.41 +[ "`echo -e 'setid 1\nwrite /test none contents4' | ./xs_test 2>&1`" = "" ]
   16.42 +
   16.43 +# User 2 can do nothing.
   16.44 +[ "`echo -e 'setid 2\nsetperm /test 2 NONE' | ./xs_test 2>&1`" = "FATAL: setperm: Permission denied" ]
   16.45 +[ "`echo -e 'setid 2\ngetperm /test' | ./xs_test 2>&1`" = "FATAL: getperm: Permission denied" ]
   16.46 +[ "`echo -e 'setid 2\nread /test' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   16.47 +[ "`echo -e 'setid 2\nwrite /test none contents4' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   16.48 +
   16.49 +# Tools can always access things.
   16.50 +[ "`echo -e 'getperm /test' | ./xs_test 2>&1`" = "1 NONE" ]
   16.51 +[ "`echo -e 'read /test' | ./xs_test 2>&1`" = "contents4" ]
   16.52 +[ "`echo -e 'write /test none contents5' | ./xs_test 2>&1`" = "" ]

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/tools/xenstore/testsuite/06dirpermissions.sh	Tue Jun 07 12:43:58 2005 +0000
    17.3 @@ -0,0 +1,61 @@
    17.4 +#! /bin/sh
    17.5 +
    17.6 +# Root directory: owned by tool, everyone has read access.
    17.7 +[ "`echo -e 'getperm /' | ./xs_test 2>&1`" = "0 READ" ]
    17.8 +
    17.9 +# Create directory: we own it, noone has access.
   17.10 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "" ]
   17.11 +[ "`echo -e 'getperm /dir' | ./xs_test 2>&1`" = "0 NONE" ]
   17.12 +[ "`echo -e 'setid 1\ndir /dir' | ./xs_test 2>&1`" = "FATAL: dir: Permission denied" ]
   17.13 +[ "`echo -e 'setid 1\nread /dir/test create contents2' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   17.14 +[ "`echo -e 'setid 1\nwrite /dir/test create contents2' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.15 +
   17.16 +# Grant everyone read access to directoy.
   17.17 +[ "`echo -e 'setperm /dir 0 READ' | ./xs_test 2>&1`" = "" ]
   17.18 +[ "`echo -e 'setid 1\ngetperm /dir' | ./xs_test 2>&1`" = "0 READ" ]
   17.19 +[ "`echo -e 'setid 1\ndir /dir' | ./xs_test 2>&1`" = "" ]
   17.20 +[ "`echo -e 'setid 1\nwrite /dir/test create contents2' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.21 +
   17.22 +# Grant everyone write access to directory.
   17.23 +[ "`echo -e 'setperm /dir 0 WRITE' | ./xs_test 2>&1`" = "" ]
   17.24 +[ "`echo -e 'setid 1\ngetperm /dir' | ./xs_test 2>&1`" = "FATAL: getperm: Permission denied" ]
   17.25 +[ "`echo -e 'setid 1\ndir /dir' | ./xs_test 2>&1`" = "FATAL: dir: Permission denied" ]
   17.26 +[ "`echo -e 'setid 1\nwrite /dir/test create contents' | ./xs_test 2>&1`" = "" ]
   17.27 +[ "`echo -e 'read /dir/test' | ./xs_test 2>&1`" = "contents" ]
   17.28 +
   17.29 +# Grant everyone both read and write access.
   17.30 +[ "`echo -e 'setperm /dir 0 READ/WRITE' | ./xs_test 2>&1`" = "" ]
   17.31 +[ "`echo -e 'setid 1\ngetperm /dir' | ./xs_test 2>&1`" = "0 READ/WRITE" ]
   17.32 +[ "`echo -e 'setid 1\ndir /dir' | ./xs_test 2>&1`" = "test" ]
   17.33 +[ "`echo -e 'setid 1\nwrite /dir/test2 create contents' | ./xs_test 2>&1`" = "" ]
   17.34 +[ "`echo -e 'setid 1\nread /dir/test2' | ./xs_test 2>&1`" = "contents" ]
   17.35 +
   17.36 +# Change so that user 1 owns it, noone else can do anything.
   17.37 +[ "`echo -e 'setperm /dir 1 NONE' | ./xs_test 2>&1`" = "" ]
   17.38 +[ "`echo -e 'setid 1\ngetperm /dir' | ./xs_test 2>&1`" = "1 NONE" ]
   17.39 +[ "`echo -e 'setid 1\ndir /dir' | ./xs_test 2>&1 | sort`" = "test
   17.40 +test2" ]
   17.41 +[ "`echo -e 'setid 1\nwrite /dir/test3 create contents' | ./xs_test 2>&1`" = "" ]
   17.42 +
   17.43 +# User 2 can do nothing.  Can't even tell if file exists.
   17.44 +[ "`echo -e 'setid 2\nsetperm /dir 2 NONE' | ./xs_test 2>&1`" = "FATAL: setperm: Permission denied" ]
   17.45 +[ "`echo -e 'setid 2\ngetperm /dir' | ./xs_test 2>&1`" = "FATAL: getperm: Permission denied" ]
   17.46 +[ "`echo -e 'setid 2\ndir /dir' | ./xs_test 2>&1`" = "FATAL: dir: Permission denied" ]
   17.47 +[ "`echo -e 'setid 2\nread /dir/test' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   17.48 +[ "`echo -e 'setid 2\nread /dir/test2' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   17.49 +[ "`echo -e 'setid 2\nread /dir/test3' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   17.50 +[ "`echo -e 'setid 2\nread /dir/test4' | ./xs_test 2>&1`" = "FATAL: read: Permission denied" ]
   17.51 +[ "`echo -e 'setid 2\nwrite /dir/test none contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.52 +[ "`echo -e 'setid 2\nwrite /dir/test create contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.53 +[ "`echo -e 'setid 2\nwrite /dir/test excl contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.54 +[ "`echo -e 'setid 2\nwrite /dir/test4 none contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.55 +[ "`echo -e 'setid 2\nwrite /dir/test4 create contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.56 +[ "`echo -e 'setid 2\nwrite /dir/test4 excl contents' | ./xs_test 2>&1`" = "FATAL: write: Permission denied" ]
   17.57 +
   17.58 +# Tools can always access things.
   17.59 +[ "`echo -e 'getperm /dir' | ./xs_test 2>&1`" = "1 NONE" ]
   17.60 +[ "`echo -e 'dir /dir' | ./xs_test 2>&1 | sort`" = "test
   17.61 +test2
   17.62 +test3" ]
   17.63 +[ "`echo -e 'write /dir/test4 create contents' | ./xs_test 2>&1`" = "" ]
   17.64 +

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/tools/xenstore/testsuite/07watch.sh	Tue Jun 07 12:43:58 2005 +0000
    18.3 @@ -0,0 +1,32 @@
    18.4 +#! /bin/sh
    18.5 +
    18.6 +# Watch something, write to it, check watch has fired.
    18.7 +[ "`echo -e 'write /test create contents' | ./xs_test 2>&1`" = "" ]
    18.8 +
    18.9 +[ "`echo -e '1 watch /test 100\n2 write /test create contents2\n1 waitwatch\n1 ackwatch' | ./xs_test 2>&1`" = "1:/test" ]
   18.10 +
   18.11 +# Check that reads don't set it off.
   18.12 +[ "`echo -e '1 watch /test 100\n2 read /test\n1 waitwatch' | ./xs_test 2>&1`" = "2:contents2
   18.13 +1:waitwatch timeout" ]
   18.14 +
   18.15 +# mkdir, setperm and rm should (also /tests watching dirs)
   18.16 +[ "`echo -e 'mkdir /dir' | ./xs_test 2>&1`" = "" ]
   18.17 +[ "`echo -e '1 watch /dir 100\n2 mkdir /dir/newdir\n1 waitwatch\n1 ackwatch\n2 setperm /dir/newdir 0 READ\n1 waitwatch\n1 ackwatch\n2 rm /dir/newdir\n1 waitwatch\n1 ackwatch' | ./xs_test 2>&1`" = "1:/dir/newdir
   18.18 +1:/dir/newdir
   18.19 +1:/dir/newdir" ]
   18.20 +
   18.21 +# ignore watches while doing commands, should work.
   18.22 +[ "`echo -e 'watch /dir 100\nwrite /dir/test create contents\nread /dir/test\nwaitwatch\nackwatch' | ./xs_test 2>&1`" = "contents
   18.23 +/dir/test" ]
   18.24 +
   18.25 +# watch priority /test.
   18.26 +[ "`echo -e '1 watch /dir 1\n3 watch /dir 3\n2 watch /dir 2\nwrite /dir/test create contents\n3 waitwatch\n3 ackwatch\n2 waitwatch\n2 ackwatch\n1 waitwatch\n1 ackwatch' | ./xs_test 2>&1`" = "3:/dir/test
   18.27 +2:/dir/test
   18.28 +1:/dir/test" ]
   18.29 +
   18.30 +# If one dies (without acking), the other should still get ack.
   18.31 +[ "`echo -e '1 watch /dir 0\n2 watch /dir 1\nwrite /dir/test create contents\n2 waitwatch\n2 close\n1 waitwatch\n1 ackwatch' | ./xs_test 2>&1`" = "2:/dir/test
   18.32 +1:/dir/test" ]
   18.33 +
   18.34 +# If one dies (without reading at all), the other should still get ack.
   18.35 +[ "`echo -e '1 watch /dir 0\n2 watch /dir 1\nwrite /dir/test create contents\n2 close\n1 waitwatch\n1 ackwatch' | ./xs_test 2>&1`" = "1:/dir/test" ]

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/tools/xenstore/testsuite/08transaction.sh	Tue Jun 07 12:43:58 2005 +0000
    19.3 @@ -0,0 +1,54 @@
    19.4 +#! /bin/sh
    19.5 +# Test transactions.
    19.6 +
    19.7 +# Simple transaction: create a file inside transaction.
    19.8 +[ "`echo -e '1 start /
    19.9 +1 write /entry1 create contents
   19.10 +2 dir /
   19.11 +1 dir /
   19.12 +1 commit
   19.13 +2 read /entry1' | ./xs_test`" = "1:entry1
   19.14 +2:contents" ]
   19.15 +echo rm /entry1 | ./xs_test
   19.16 +
   19.17 +# Create a file and abort transaction.
   19.18 +[ "`echo -e '1 start /
   19.19 +1 write /entry1 create contents
   19.20 +2 dir /
   19.21 +1 dir /
   19.22 +1 abort
   19.23 +2 dir /' | ./xs_test`" = "1:entry1" ]
   19.24 +
   19.25 +echo write /entry1 create contents | ./xs_test
   19.26 +# Delete in transaction, commit
   19.27 +[ "`echo -e '1 start /
   19.28 +1 rm /entry1
   19.29 +2 dir /
   19.30 +1 dir /
   19.31 +1 commit
   19.32 +2 dir /' | ./xs_test`" = "2:entry1" ]
   19.33 +
   19.34 +# Delete in transaction, abort.
   19.35 +echo write /entry1 create contents | ./xs_test
   19.36 +[ "`echo -e '1 start /
   19.37 +1 rm /entry1
   19.38 +2 dir /
   19.39 +1 dir /
   19.40 +1 abort
   19.41 +2 dir /' | ./xs_test`" = "2:entry1
   19.42 +2:entry1" ]
   19.43 +
   19.44 +# Transactions can take as long as the want...
   19.45 +[ "`echo -e 'start /
   19.46 +sleep 1
   19.47 +rm /entry1
   19.48 +commit
   19.49 +dir /' | ./xs_test`" = "" ]
   19.50 +
   19.51 +# ... as long as noone is waiting.
   19.52 +[ "`echo -e '1 start /
   19.53 +2 mkdir /dir
   19.54 +1 mkdir /dir
   19.55 +1 dir /
   19.56 +1 commit' | ./xs_test 2>&1`" = "1:dir
   19.57 +FATAL: 1: commit: Connection timed out" ]

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/tools/xenstore/testsuite/09domain.sh	Tue Jun 07 12:43:58 2005 +0000
    20.3 @@ -0,0 +1,15 @@
    20.4 +#! /bin/sh
    20.5 +# Test domain communication.
    20.6 +
    20.7 +# Create a domain, write an entry.
    20.8 +[ "`echo -e 'introduce 1 100 7 /my/home
    20.9 +1 write /entry1 create contents
   20.10 +dir /' | ./xs_test 2>&1`" = "handle is 1
   20.11 +entry1" ]
   20.12 +
   20.13 +# Release that domain.
   20.14 +[ "`echo -e 'release 1' | ./xs_test`" = "" ]
   20.15 +
   20.16 +# Introduce and release by same connection.
   20.17 +[ "`echo -e 'introduce 1 100 7 /my/home
   20.18 +release 1' | ./xs_test 2>&1`" = "handle is 1" ]

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/tools/xenstore/testsuite/test.sh	Tue Jun 07 12:43:58 2005 +0000
    21.3 @@ -0,0 +1,44 @@
    21.4 +#! /bin/sh
    21.5 +
    21.6 +set -e
    21.7 +set -m
    21.8 +
    21.9 +run_test()
   21.10 +{
   21.11 +    rm -rf $XENSTORED_ROOTDIR
   21.12 +    mkdir $XENSTORED_ROOTDIR
   21.13 +# Weird failures with this.
   21.14 +    if type valgrind >/dev/null 2>&1; then
   21.15 +	valgrind -q --logfile-fd=3 ./xenstored_test --output-pid --no-fork 3>testsuite/tmp/vgout > /tmp/pid &
   21.16 +	while [ ! -s /tmp/pid ]; do sleep 0; done
   21.17 +	PID=`cat /tmp/pid`
   21.18 +	rm /tmp/pid
   21.19 +    else
   21.20 +	PID=`./xenstored_test --output-pid`
   21.21 +    fi
   21.22 +    if sh -e $2 $1; then
   21.23 +	if [ -s testsuite/tmp/vgout ]; then
   21.24 +	    kill $PID
   21.25 +	    echo VALGRIND errors:
   21.26 +	    cat testsuite/tmp/vgout
   21.27 +	    return 1
   21.28 +	fi
   21.29 +	echo shutdown | ./xs_test
   21.30 +	return 0
   21.31 +    else
   21.32 +	# In case daemon is wedged.
   21.33 +	kill $PID
   21.34 +	sleep 1
   21.35 +	return 1
   21.36 +    fi
   21.37 +}
   21.38 +
   21.39 +for f in testsuite/[0-9]*.sh; do
   21.40 +    if run_test $f; then
   21.41 +	echo Test $f passed...
   21.42 +    else
   21.43 +	echo Test $f failed, running verbosely...
   21.44 +	run_test $f -x
   21.45 +	exit 1
   21.46 +    fi
   21.47 +done

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/tools/xenstore/utils.c	Tue Jun 07 12:43:58 2005 +0000
    22.3 @@ -0,0 +1,143 @@
    22.4 +#define _GNU_SOURCE
    22.5 +#include <stdio.h>
    22.6 +#include <stdarg.h>
    22.7 +#include <stdlib.h>
    22.8 +#include <string.h>
    22.9 +#include <errno.h>
   22.10 +#include <unistd.h>
   22.11 +#include <fcntl.h>
   22.12 +#include <sys/types.h>
   22.13 +#include <signal.h>
   22.14 +
   22.15 +#include "utils.h"
   22.16 +
   22.17 +void xprintf(const char *fmt, ...)
   22.18 +{
   22.19 +        static FILE *out = NULL;
   22.20 +        va_list args;
   22.21 +        if (!out)
   22.22 +                out = fopen("/dev/console", "w");
   22.23 +	if (!out)
   22.24 +		out = stderr;
   22.25 +
   22.26 +        va_start(args, fmt);
   22.27 +        vfprintf(out, fmt, args);
   22.28 +        va_end(args);
   22.29 +        fflush(out);
   22.30 +}
   22.31 +
   22.32 +void barf(const char *fmt, ...)
   22.33 +{
   22.34 +	char *str;
   22.35 +	va_list arglist;
   22.36 +
   22.37 +	xprintf("FATAL: ");
   22.38 +
   22.39 +	va_start(arglist, fmt);
   22.40 +	vasprintf(&str, fmt, arglist);
   22.41 +	va_end(arglist);
   22.42 +
   22.43 +	xprintf("%s\n", str);
   22.44 +	free(str);
   22.45 +	exit(1);
   22.46 +}
   22.47 +
   22.48 +void barf_perror(const char *fmt, ...)
   22.49 +{
   22.50 +	char *str;
   22.51 +	int err = errno;
   22.52 +	va_list arglist;
   22.53 +
   22.54 +	xprintf("FATAL: ");
   22.55 +
   22.56 +	va_start(arglist, fmt);
   22.57 +	vasprintf(&str, fmt, arglist);
   22.58 +	va_end(arglist);
   22.59 +
   22.60 +	xprintf("%s: %s\n", str, strerror(err));
   22.61 +	free(str);
   22.62 +	exit(1);
   22.63 +}
   22.64 +
   22.65 +void *_realloc_array(void *ptr, size_t size, size_t num)
   22.66 +{
   22.67 +        if (num >= SIZE_MAX/size)
   22.68 +                return NULL;
   22.69 +        return realloc_nofail(ptr, size * num);
   22.70 +}
   22.71 +
   22.72 +void *realloc_nofail(void *ptr, size_t size)
   22.73 +{
   22.74 +        ptr = realloc(ptr, size);
   22.75 +	if (ptr)
   22.76 +		return ptr;
   22.77 +	barf("realloc of %zu failed", size);
   22.78 +}
   22.79 +
   22.80 +void *malloc_nofail(size_t size)
   22.81 +{
   22.82 +	void *ptr = malloc(size);
   22.83 +	if (ptr)
   22.84 +		return ptr;
   22.85 +	barf("malloc of %zu failed", size);
   22.86 +}
   22.87 +
   22.88 +/* Stevens. */
   22.89 +void daemonize(void)
   22.90 +{
   22.91 +	pid_t pid;
   22.92 +
   22.93 +	/* Separate from our parent via fork, so init inherits us. */
   22.94 +	if ((pid = fork()) < 0)
   22.95 +		barf_perror("Failed to fork daemon");
   22.96 +	if (pid != 0)
   22.97 +		exit(0);
   22.98 +
   22.99 +	close(STDIN_FILENO);
  22.100 +	close(STDOUT_FILENO);
  22.101 +	close(STDERR_FILENO);
  22.102 +
  22.103 +	/* Session leader so ^C doesn't whack us. */
  22.104 +	setsid();
  22.105 +	/* Move off any mount points we might be in. */
  22.106 +	chdir("/");
  22.107 +	/* Discard our parent's old-fashioned umask prejudices. */
  22.108 +	umask(0);
  22.109 +}
  22.110 +
  22.111 +
  22.112 +/* This version adds one byte (for nul term) */
  22.113 +void *grab_file(const char *filename, unsigned long *size)
  22.114 +{
  22.115 +	unsigned int max = 16384;
  22.116 +	int ret, fd;
  22.117 +	void *buffer;
  22.118 +
  22.119 +	if (streq(filename, "-"))
  22.120 +		fd = dup(STDIN_FILENO);
  22.121 +	else
  22.122 +		fd = open(filename, O_RDONLY, 0);
  22.123 +
  22.124 +	if (fd < 0)
  22.125 +		return NULL;
  22.126 +
  22.127 +	buffer = malloc(max+1);
  22.128 +	*size = 0;
  22.129 +	while ((ret = read(fd, buffer + *size, max - *size)) > 0) {
  22.130 +		*size += ret;
  22.131 +		if (*size == max)
  22.132 +			buffer = realloc(buffer, max *= 2 + 1);
  22.133 +	}
  22.134 +	if (ret < 0) {
  22.135 +		free(buffer);
  22.136 +		buffer = NULL;
  22.137 +	} else
  22.138 +		((char *)buffer)[*size] = '\0';
  22.139 +	close(fd);
  22.140 +	return buffer;
  22.141 +}
  22.142 +
  22.143 +void release_file(void *data, unsigned long size __attribute__((unused)))
  22.144 +{
  22.145 +	free(data);
  22.146 +}

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/tools/xenstore/utils.h	Tue Jun 07 12:43:58 2005 +0000
    23.3 @@ -0,0 +1,61 @@
    23.4 +#ifndef _UTILS_H
    23.5 +#define _UTILS_H
    23.6 +#include <stdbool.h>
    23.7 +#include <string.h>
    23.8 +#include <stdint.h>
    23.9 +
   23.10 +/* Is A == B ? */
   23.11 +#define streq(a,b) (strcmp((a),(b)) == 0)
   23.12 +
   23.13 +/* Does A start with B ? */
   23.14 +#define strstarts(a,b) (strncmp((a),(b),strlen(b)) == 0)
   23.15 +
   23.16 +/* Does A end in B ? */
   23.17 +static inline bool strends(const char *a, const char *b)
   23.18 +{
   23.19 +	if (strlen(a) < strlen(b))
   23.20 +		return false;
   23.21 +
   23.22 +	return streq(a + strlen(a) - strlen(b), b);
   23.23 +}
   23.24 +
   23.25 +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
   23.26 +
   23.27 +#define ___stringify(x)	#x
   23.28 +#define __stringify(x)		___stringify(x)
   23.29 +
   23.30 +/* Convenient wrappers for malloc and realloc.  Use them. */
   23.31 +#define new(type) ((type *)malloc_nofail(sizeof(type)))
   23.32 +#define new_array(type, num) realloc_array((type *)0, (num))
   23.33 +#define realloc_array(ptr, num) ((__typeof__(ptr))_realloc_array((ptr), sizeof((*ptr)), (num)))
   23.34 +
   23.35 +void *malloc_nofail(size_t size);
   23.36 +void *realloc_nofail(void *ptr, size_t size);
   23.37 +void *_realloc_array(void *ptr, size_t size, size_t num);
   23.38 +
   23.39 +void barf(const char *fmt, ...) __attribute__((noreturn));
   23.40 +void barf_perror(const char *fmt, ...) __attribute__((noreturn));
   23.41 +
   23.42 +/* This version adds one byte (for nul term) */
   23.43 +void *grab_file(const char *filename, unsigned long *size);
   23.44 +void release_file(void *data, unsigned long size);
   23.45 +
   23.46 +/* For writing daemons, based on Stevens. */
   23.47 +void daemonize(void);
   23.48 +
   23.49 +/* Signal handling: returns fd to listen on. */
   23.50 +int signal_to_fd(int signal);
   23.51 +void close_signal(int fd);
   23.52 +
   23.53 +void xprintf(const char *fmt, ...);
   23.54 +
   23.55 +#define eprintf(_fmt, _args...) xprintf("[ERR] %s" _fmt, __FUNCTION__, ##_args)
   23.56 +#define iprintf(_fmt, _args...) xprintf("[INF] %s" _fmt, __FUNCTION__, ##_args)
   23.57 +
   23.58 +#ifdef DEBUG
   23.59 +#define dprintf(_fmt, _args...) xprintf("[DBG] %s" _fmt, __FUNCTION__, ##_args)
   23.60 +#else
   23.61 +#define dprintf(_fmt, _args...) ((void)0)
   23.62 +#endif
   23.63 +
   23.64 +#endif /* _UTILS_H */

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/tools/xenstore/xenstored.h	Tue Jun 07 12:43:58 2005 +0000
    24.3 @@ -0,0 +1,81 @@
    24.4 +/* 
    24.5 +    Simple prototyle Xen Store Daemon providing simple tree-like database.
    24.6 +    Copyright (C) 2005 Rusty Russell IBM Corporation
    24.7 +
    24.8 +    This program is free software; you can redistribute it and/or modify
    24.9 +    it under the terms of the GNU General Public License as published by
   24.10 +    the Free Software Foundation; either version 2 of the License, or
   24.11 +    (at your option) any later version.
   24.12 +
   24.13 +    This program is distributed in the hope that it will be useful,
   24.14 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   24.15 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   24.16 +    GNU General Public License for more details.
   24.17 +
   24.18 +    You should have received a copy of the GNU General Public License
   24.19 +    along with this program; if not, write to the Free Software
   24.20 +    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   24.21 +*/
   24.22 +#ifndef _XENSTORED_H
   24.23 +#define _XENSTORED_H
   24.24 +
   24.25 +enum xsd_sockmsg_type
   24.26 +{
   24.27 +	XS_DEBUG,
   24.28 +	XS_SHUTDOWN,
   24.29 +	XS_DIRECTORY,
   24.30 +	XS_READ,
   24.31 +	XS_GET_PERMS,
   24.32 +	XS_WATCH,
   24.33 +	XS_WATCH_ACK,
   24.34 +	XS_UNWATCH,
   24.35 +	XS_TRANSACTION_START,
   24.36 +	XS_TRANSACTION_END,
   24.37 +	XS_OP_READ_ONLY = XS_TRANSACTION_END,
   24.38 +	XS_INTRODUCE,
   24.39 +	XS_RELEASE,
   24.40 +	XS_GETDOMAINPATH,
   24.41 +	XS_WRITE,
   24.42 +	XS_MKDIR,
   24.43 +	XS_RM,
   24.44 +	XS_SET_PERMS,
   24.45 +	XS_WATCH_EVENT,
   24.46 +	XS_ERROR,
   24.47 +};
   24.48 +
   24.49 +#define XS_WRITE_NONE "NONE"
   24.50 +#define XS_WRITE_CREATE "CREATE"
   24.51 +#define XS_WRITE_CREATE_EXCL "CREATE|EXCL"
   24.52 +
   24.53 +/* We hand errors as strings, for portability. */
   24.54 +struct xsd_errors
   24.55 +{
   24.56 +	int errnum;
   24.57 +	const char *errstring;
   24.58 +};
   24.59 +#define XSD_ERROR(x) { x, #x }
   24.60 +static struct xsd_errors xsd_errors[] __attribute__((unused)) = {
   24.61 +	XSD_ERROR(EINVAL),
   24.62 +	XSD_ERROR(EACCES),
   24.63 +	XSD_ERROR(EEXIST),
   24.64 +	XSD_ERROR(EISDIR),
   24.65 +	XSD_ERROR(ENOENT),
   24.66 +	XSD_ERROR(ENOMEM),
   24.67 +	XSD_ERROR(ENOSPC),
   24.68 +	XSD_ERROR(EIO),
   24.69 +	XSD_ERROR(ENOTEMPTY),
   24.70 +	XSD_ERROR(ENOSYS),
   24.71 +	XSD_ERROR(EROFS),
   24.72 +	XSD_ERROR(EBUSY),
   24.73 +	XSD_ERROR(ETIMEDOUT),
   24.74 +	XSD_ERROR(EISCONN),
   24.75 +};
   24.76 +struct xsd_sockmsg
   24.77 +{
   24.78 +	u32 type;
   24.79 +	u32 len; 		/* Length of data following this. */
   24.80 +
   24.81 +	/* Generally followed by nul-terminated string(s). */
   24.82 +};
   24.83 +
   24.84 +#endif /* _XENSTORED_H */

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/tools/xenstore/xenstored_core.c	Tue Jun 07 12:43:58 2005 +0000
    25.3 @@ -0,0 +1,1354 @@
    25.4 +/* 
    25.5 +    Simple prototype Xen Store Daemon providing simple tree-like database.
    25.6 +    Copyright (C) 2005 Rusty Russell IBM Corporation
    25.7 +
    25.8 +    This program is free software; you can redistribute it and/or modify
    25.9 +    it under the terms of the GNU General Public License as published by
   25.10 +    the Free Software Foundation; either version 2 of the License, or
   25.11 +    (at your option) any later version.
   25.12 +
   25.13 +    This program is distributed in the hope that it will be useful,
   25.14 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   25.15 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   25.16 +    GNU General Public License for more details.
   25.17 +
   25.18 +    You should have received a copy of the GNU General Public License
   25.19 +    along with this program; if not, write to the Free Software
   25.20 +    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   25.21 +*/
   25.22 +
   25.23 +#include <sys/types.h>
   25.24 +#include <sys/stat.h>
   25.25 +#include <sys/socket.h>
   25.26 +#include <sys/select.h>
   25.27 +#include <sys/un.h>
   25.28 +#include <sys/time.h>
   25.29 +#include <time.h>
   25.30 +#include <unistd.h>
   25.31 +#include <fcntl.h>
   25.32 +#include <stdbool.h>
   25.33 +#include <stdio.h>
   25.34 +#include <stdarg.h>
   25.35 +#include <stdlib.h>
   25.36 +#include <syslog.h>
   25.37 +#include <string.h>
   25.38 +#include <errno.h>
   25.39 +#include <dirent.h>
   25.40 +#include <getopt.h>
   25.41 +#include <signal.h>
   25.42 +#include <assert.h>
   25.43 +#include <setjmp.h>
   25.44 +
   25.45 +//#define DEBUG
   25.46 +#include "utils.h"
   25.47 +#include "list.h"
   25.48 +#include "talloc.h"
   25.49 +#include "xs_lib.h"
   25.50 +#include "xenstored.h"
   25.51 +#include "xenstored_core.h"
   25.52 +#include "xenstored_watch.h"
   25.53 +#include "xenstored_transaction.h"
   25.54 +#include "xenstored_domain.h"
   25.55 +
   25.56 +static bool verbose;
   25.57 +static LIST_HEAD(connections);
   25.58 +
   25.59 +#ifdef TESTING
   25.60 +static bool failtest = false;
   25.61 +
   25.62 +/* We override talloc's malloc. */
   25.63 +void *test_malloc(size_t size)
   25.64 +{
   25.65 +	/* 1 in 20 means only about 50% of connections establish. */
   25.66 +	if (failtest && (random() % 32) == 0)
   25.67 +		return NULL;
   25.68 +	return malloc(size);
   25.69 +}
   25.70 +
   25.71 +static void stop_failtest(int signum __attribute__((unused)))
   25.72 +{
   25.73 +	failtest = false;
   25.74 +}
   25.75 +
   25.76 +/* Need these before we #define away write_all/mkdir in testing.h */
   25.77 +bool test_write_all(int fd, void *contents, unsigned int len);
   25.78 +bool test_write_all(int fd, void *contents, unsigned int len)
   25.79 +{
   25.80 +	if (failtest && (random() % 8) == 0) {
   25.81 +		if (len)
   25.82 +			len = random() % len;
   25.83 +		write(fd, contents, len);
   25.84 +		errno = ENOSPC;
   25.85 +		return false;
   25.86 +	}
   25.87 +	return write_all(fd, contents, len);
   25.88 +}
   25.89 +
   25.90 +int test_mkdir(const char *dir, int perms);
   25.91 +int test_mkdir(const char *dir, int perms)
   25.92 +{
   25.93 +	if (failtest && (random() % 8) == 0) {
   25.94 +		errno = ENOSPC;
   25.95 +		return -1;
   25.96 +	}
   25.97 +	return mkdir(dir, perms);
   25.98 +}
   25.99 +#endif /* TESTING */
  25.100 +
  25.101 +#include "xenstored_test.h"
  25.102 +
  25.103 +/* FIXME: Ideally, this should never be called.  Some can be eliminated. */
  25.104 +/* Something is horribly wrong: shutdown immediately. */
  25.105 +void __attribute__((noreturn)) corrupt(struct connection *conn,
  25.106 +				       const char *fmt, ...)
  25.107 +{
  25.108 +	va_list arglist;
  25.109 +	char *str;
  25.110 +	int saved_errno = errno;
  25.111 +
  25.112 +	va_start(arglist, fmt);
  25.113 +	str = talloc_vasprintf(NULL, fmt, arglist);
  25.114 +	va_end(arglist);
  25.115 +
  25.116 +	eprintf("xenstored corruption: connection id %i: err %s: %s",
  25.117 +		conn ? (int)conn->id : -1, strerror(saved_errno), str);
  25.118 +#ifdef TESTING
  25.119 +	/* Allow them to attach debugger. */
  25.120 +	sleep(30);
  25.121 +#endif
  25.122 +	syslog(LOG_DAEMON,
  25.123 +	       "xenstored corruption: connection id %i: err %s: %s",
  25.124 +	       conn ? (int)conn->id : -1, strerror(saved_errno), str);
  25.125 +	_exit(2);
  25.126 +}
  25.127 +
  25.128 +static bool write_message(struct connection *conn)
  25.129 +{
  25.130 +	int ret;
  25.131 +	struct buffered_data *out = conn->out;
  25.132 +
  25.133 +	if (out->inhdr) {
  25.134 +		if (verbose)
  25.135 +			xprintf("Writing msg %i out to %p\n",
  25.136 +				out->hdr.msg.type, conn);
  25.137 +		ret = conn->write(conn, out->hdr.raw + out->used,
  25.138 +				  sizeof(out->hdr) - out->used);
  25.139 +		if (ret < 0)
  25.140 +			return false;
  25.141 +
  25.142 +		out->used += ret;
  25.143 +		if (out->used < sizeof(out->hdr))
  25.144 +			return true;
  25.145 +
  25.146 +		out->inhdr = false;
  25.147 +		out->used = 0;
  25.148 +
  25.149 +		/* Second write might block if non-zero. */
  25.150 +		if (out->hdr.msg.len)
  25.151 +			return true;
  25.152 +	}
  25.153 +
  25.154 +	if (verbose)
  25.155 +		xprintf("Writing data len %i out to %p\n",
  25.156 +			out->hdr.msg.len, conn);
  25.157 +	ret = conn->write(conn, out->buffer + out->used,
  25.158 +			  out->hdr.msg.len - out->used);
  25.159 +
  25.160 +	if (ret < 0)
  25.161 +		return false;
  25.162 +
  25.163 +	out->used += ret;
  25.164 +	if (out->used != out->hdr.msg.len)
  25.165 +		return true;
  25.166 +
  25.167 +	conn->out = NULL;
  25.168 +
  25.169 +	/* If this was an event, we wait for ack, otherwise we're done. */
  25.170 +	if (!is_watch_event(conn, out))
  25.171 +		talloc_free(out);
  25.172 +
  25.173 +	queue_next_event(conn);
  25.174 +	return true;
  25.175 +}
  25.176 +
  25.177 +static int destroy_conn(void *_conn)
  25.178 +{
  25.179 +	struct connection *conn = _conn;
  25.180 +
  25.181 +	/* Flush outgoing if possible, but don't block. */
  25.182 +	if (!conn->domain) {
  25.183 +		fd_set set;
  25.184 +		struct timeval none;
  25.185 +
  25.186 +		FD_ZERO(&set);
  25.187 +		FD_SET(conn->fd, &set);
  25.188 +		none.tv_sec = none.tv_usec = 0;
  25.189 +
  25.190 +		while (conn->out
  25.191 +		       && select(conn->fd+1, NULL, &set, NULL, &none) == 1)
  25.192 +			if (!write_message(conn))
  25.193 +				break;
  25.194 +		close(conn->fd);
  25.195 +	}
  25.196 +	list_del(&conn->list);
  25.197 +	return 0;
  25.198 +}
  25.199 +
  25.200 +static int initialize_set(fd_set *inset, fd_set *outset, int sock, int ro_sock,
  25.201 +			  int event_fd)
  25.202 +{
  25.203 +	struct connection *i;
  25.204 +	int max;
  25.205 +
  25.206 +	FD_ZERO(inset);
  25.207 +	FD_ZERO(outset);
  25.208 +	FD_SET(sock, inset);
  25.209 +	max = sock;
  25.210 +	FD_SET(ro_sock, inset);
  25.211 +	if (ro_sock > max)
  25.212 +		max = ro_sock;
  25.213 +	FD_SET(event_fd, inset);
  25.214 +	if (event_fd > max)
  25.215 +		max = event_fd;
  25.216 +	list_for_each_entry(i, &connections, list) {
  25.217 +		if (i->domain)
  25.218 +			continue;
  25.219 +		if (!i->blocked)
  25.220 +			FD_SET(i->fd, inset);
  25.221 +		if (i->out)
  25.222 +			FD_SET(i->fd, outset);
  25.223 +		if (i->fd > max)
  25.224 +			max = i->fd;
  25.225 +	}
  25.226 +	return max;
  25.227 +}
  25.228 +
  25.229 +/* Read everything from a talloc_open'ed fd. */
  25.230 +static void *read_all(int *fd, unsigned int *size)
  25.231 +{
  25.232 +	unsigned int max = 4;
  25.233 +	int ret;
  25.234 +	void *buffer = talloc_size(fd, max);
  25.235 +
  25.236 +	*size = 0;
  25.237 +	while ((ret = read(*fd, buffer + *size, max - *size)) > 0) {
  25.238 +		*size += ret;
  25.239 +		if (*size == max)
  25.240 +			buffer = talloc_realloc_size(fd, buffer, max *= 2);
  25.241 +	}
  25.242 +	if (ret < 0)
  25.243 +		return NULL;
  25.244 +	return buffer;
  25.245 +}
  25.246 +
  25.247 +static int destroy_fd(void *_fd)
  25.248 +{
  25.249 +	int *fd = _fd;
  25.250 +	close(*fd);
  25.251 +	return 0;
  25.252 +}
  25.253 +
  25.254 +/* Return a pointer to an fd, self-closing and attached to this pathname. */
  25.255 +static int *talloc_open(const char *pathname, int flags, int mode)
  25.256 +{
  25.257 +	int *fd;
  25.258 +
  25.259 +	fd = talloc(pathname, int);
  25.260 +	*fd = open(pathname, flags, mode);
  25.261 +	if (*fd < 0) {
  25.262 +		int saved_errno = errno;
  25.263 +		talloc_free(fd);
  25.264 +		errno = saved_errno;
  25.265 +		return NULL;
  25.266 +	}
  25.267 +	talloc_set_destructor(fd, destroy_fd);
  25.268 +	return fd;
  25.269 +}
  25.270 +
  25.271 +/* Is child a subnode of parent, or equal? */
  25.272 +bool is_child(const char *child, const char *parent)
  25.273 +{
  25.274 +	unsigned int len = strlen(parent);
  25.275 +
  25.276 +	/* / should really be "" for this algorithm to work, but that's a
  25.277 +	 * usability nightmare. */
  25.278 +	if (streq(parent, "/"))
  25.279 +		return true;
  25.280 +
  25.281 +	if (strncmp(child, parent, len) != 0)
  25.282 +		return false;
  25.283 +
  25.284 +	return child[len] == '/' || child[len] == '\0';
  25.285 +}
  25.286 +
  25.287 +/* Answer never ends in /. */
  25.288 +char *node_dir_outside_transaction(const char *node)
  25.289 +{
  25.290 +	if (streq(node, "/"))
  25.291 +		return talloc_strdup(node, xs_daemon_store());
  25.292 +	return talloc_asprintf(node, "%s%s", xs_daemon_store(), node);
  25.293 +}
  25.294 +
  25.295 +static char *node_dir(struct transaction *trans, const char *node)
  25.296 +{
  25.297 +	if (!trans || !within_transaction(trans, node))
  25.298 +		return node_dir_outside_transaction(node);
  25.299 +	return node_dir_inside_transaction(trans, node);
  25.300 +}
  25.301 +
  25.302 +static char *node_datafile(struct transaction *trans, const char *node)
  25.303 +{
  25.304 +	return talloc_asprintf(node, "%s/.data", node_dir(trans, node));
  25.305 +}
  25.306 +
  25.307 +static char *node_permfile(struct transaction *trans, const char *node)
  25.308 +{
  25.309 +	return talloc_asprintf(node, "%s/.perms", node_dir(trans, node));
  25.310 +}
  25.311 +
  25.312 +struct buffered_data *new_buffer(void *ctx)
  25.313 +{
  25.314 +	struct buffered_data *data;
  25.315 +
  25.316 +	data = talloc(ctx, struct buffered_data);
  25.317 +	data->inhdr = true;
  25.318 +	data->used = 0;
  25.319 +	data->buffer = NULL;
  25.320 +
  25.321 +	return data;
  25.322 +}
  25.323 +
  25.324 +/* Return length of string (including nul) at this offset. */
  25.325 +unsigned int get_string(const struct buffered_data *data, unsigned int offset)
  25.326 +{
  25.327 +	const char *nul;
  25.328 +
  25.329 +	if (offset >= data->used)
  25.330 +		return 0;
  25.331 +
  25.332 +	nul = memchr(data->buffer + offset, 0, data->used - offset);
  25.333 +	if (!nul)
  25.334 +		return 0;
  25.335 +
  25.336 +	return nul - (data->buffer + offset) + 1;
  25.337 +}
  25.338 +
  25.339 +/* Break input into vectors, return the number, fill in up to num of them. */
  25.340 +unsigned int get_strings(struct buffered_data *data,
  25.341 +			 char *vec[], unsigned int num)
  25.342 +{
  25.343 +	unsigned int off, i, len;
  25.344 +
  25.345 +	off = i = 0;
  25.346 +	while ((len = get_string(data, off)) != 0) {
  25.347 +		if (i < num)
  25.348 +			vec[i] = data->buffer + off;
  25.349 +		i++;
  25.350 +		off += len;
  25.351 +	}
  25.352 +	return i;
  25.353 +}
  25.354 +
  25.355 +/* Returns "false", meaning "connection is not blocked". */
  25.356 +bool send_reply(struct connection *conn, enum xsd_sockmsg_type type,
  25.357 +		const void *data, unsigned int len)
  25.358 +{
  25.359 +	struct buffered_data *bdata;
  25.360 +
  25.361 +	/* When data gets freed, we want list entry is destroyed (so
  25.362 +	 * list entry is a child). */
  25.363 +	bdata = new_buffer(conn);
  25.364 +	bdata->buffer = talloc_array(bdata, char, len);
  25.365 +
  25.366 +	bdata->hdr.msg.type = type;
  25.367 +	bdata->hdr.msg.len = len;
  25.368 +	memcpy(bdata->buffer, data, len);
  25.369 +
  25.370 +	/* There might be an event going out now.  Queue behind it. */
  25.371 +	if (conn->out) {
  25.372 +		assert(conn->out->hdr.msg.type == XS_WATCH_EVENT);
  25.373 +		assert(!conn->waiting_reply);
  25.374 +		conn->waiting_reply = bdata;
  25.375 +	} else
  25.376 +		conn->out = bdata;
  25.377 +	return false;
  25.378 +}
  25.379 +
  25.380 +/* Some routines (write, mkdir, etc) just need a non-error return */
  25.381 +bool send_ack(struct connection *conn, enum xsd_sockmsg_type type)
  25.382 +{
  25.383 +	return send_reply(conn, type, "OK", sizeof("OK"));
  25.384 +}
  25.385 +
  25.386 +bool send_error(struct connection *conn, int error)
  25.387 +{
  25.388 +	unsigned int i;
  25.389 +
  25.390 +	for (i = 0; error != xsd_errors[i].errnum; i++)
  25.391 +		if (i == ARRAY_SIZE(xsd_errors) - 1)
  25.392 +			corrupt(conn, "Unknown error %i (%s)", error,
  25.393 +				strerror(error));
  25.394 +
  25.395 +	return send_reply(conn, XS_ERROR, xsd_errors[i].errstring,
  25.396 +			  strlen(xsd_errors[i].errstring) + 1);
  25.397 +}
  25.398 +
  25.399 +static bool valid_chars(const char *node)
  25.400 +{
  25.401 +	/* Nodes can have lots of crap. */
  25.402 +	return (strspn(node, 
  25.403 +		       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  25.404 +		       "abcdefghijklmnopqrstuvwxyz"
  25.405 +		       "0123456789-/_@") == strlen(node));
  25.406 +}
  25.407 +
  25.408 +static bool is_valid_nodename(const char *node)
  25.409 +{
  25.410 +	/* Must start in /. */
  25.411 +	if (!strstarts(node, "/"))
  25.412 +		return false;
  25.413 +
  25.414 +	/* Cannot end in / (unless it's just "/"). */
  25.415 +	if (strends(node, "/") && !streq(node, "/"))
  25.416 +		return false;
  25.417 +
  25.418 +	/* No double //. */
  25.419 +	if (strstr(node, "//"))
  25.420 +		return false;
  25.421 +
  25.422 +	return valid_chars(node);
  25.423 +}
  25.424 +
  25.425 +/* We expect one arg in the input: return NULL otherwise. */
  25.426 +static const char *onearg(struct buffered_data *in)
  25.427 +{
  25.428 +	if (get_string(in, 0) != in->used)
  25.429 +		return NULL;
  25.430 +	return in->buffer;
  25.431 +}
  25.432 +
  25.433 +/* If it fails, returns NULL and sets errno. */
  25.434 +static struct xs_permissions *get_perms(struct transaction *transaction,
  25.435 +					const char *node, unsigned int *num)
  25.436 +{
  25.437 +	unsigned int size;
  25.438 +	char *strings;
  25.439 +	struct xs_permissions *ret;
  25.440 +	int *fd;
  25.441 +
  25.442 +	fd = talloc_open(node_permfile(transaction, node), O_RDONLY, 0);
  25.443 +	if (!fd)
  25.444 +		return NULL;
  25.445 +	strings = read_all(fd, &size);
  25.446 +	if (!strings)
  25.447 +		return NULL;
  25.448 +
  25.449 +	*num = count_strings(strings, size);
  25.450 +	ret = talloc_array(node, struct xs_permissions, *num);
  25.451 +	if (!strings_to_perms(ret, *num, strings))
  25.452 +		corrupt(NULL, "Permissions corrupt for %s", node);
  25.453 +
  25.454 +	return ret;
  25.455 +}
  25.456 +
  25.457 +static char *perms_to_strings(const char *node,
  25.458 +			      struct xs_permissions *perms, unsigned int num,
  25.459 +			      unsigned int *len)
  25.460 +{
  25.461 +	unsigned int i;
  25.462 +	char *strings = NULL;
  25.463 +	char buffer[MAX_STRLEN(domid_t) + 1];
  25.464 +
  25.465 +	for (*len = 0, i = 0; i < num; i++) {
  25.466 +		if (!perm_to_string(&perms[i], buffer))
  25.467 +			return NULL;
  25.468 +
  25.469 +		strings = talloc_realloc(node, strings, char,
  25.470 +					 *len + strlen(buffer) + 1);
  25.471 +		strcpy(strings + *len, buffer);
  25.472 +		*len += strlen(buffer) + 1;
  25.473 +	}
  25.474 +	return strings;
  25.475 +}
  25.476 +
  25.477 +/* Destroy this, and its children, and its children's children. */
  25.478 +int destroy_path(void *path)
  25.479 +{
  25.480 +	DIR *dir;
  25.481 +	struct dirent *dirent;
  25.482 +
  25.483 +	dir = opendir(path);
  25.484 +	if (!dir) {
  25.485 +		if (unlink(path) == 0 || errno == ENOENT)
  25.486 +			return 0;
  25.487 +		corrupt(NULL, "Destroying path %s", path);
  25.488 +	}
  25.489 +
  25.490 +	while ((dirent = readdir(dir)) != NULL) {
  25.491 +		char fullpath[strlen(path) + 1 + strlen(dirent->d_name) + 1];
  25.492 +		sprintf(fullpath, "%s/%s", (char *)path, dirent->d_name);
  25.493 +		if (!streq(dirent->d_name,".") && !streq(dirent->d_name,".."))
  25.494 +			destroy_path(fullpath);
  25.495 +	}
  25.496 +	closedir(dir);
  25.497 +	if (rmdir(path) != 0)
  25.498 +		corrupt(NULL, "Destroying directory %s", path);
  25.499 +	return 0;
  25.500 +}
  25.501 +
  25.502 +/* Create a self-destructing temporary file */
  25.503 +static char *tempfile(const char *path, void *contents, unsigned int len)
  25.504 +{
  25.505 +	int *fd;
  25.506 +	char *tmppath = talloc_asprintf(path, "%s.tmp", path);
  25.507 +
  25.508 +	fd = talloc_open(tmppath, O_WRONLY|O_CREAT|O_EXCL, 0640);
  25.509 +	if (!fd)
  25.510 +		return NULL;
  25.511 +	talloc_set_destructor(tmppath, destroy_path);
  25.512 +	if (!write_all(*fd, contents, len))
  25.513 +		return NULL;
  25.514 +
  25.515 +	return tmppath;
  25.516 +}
  25.517 +
  25.518 +/* We assume rename() doesn't fail on moves in same dir. */
  25.519 +static void commit_tempfile(const char *path)
  25.520 +{
  25.521 +	char realname[strlen(path) + 1];
  25.522 +	unsigned int len = strrchr(path, '.') - path;
  25.523 +
  25.524 +	memcpy(realname, path, len);
  25.525 +	realname[len] = '\0';
  25.526 +	if (rename(path, realname) != 0)
  25.527 +		corrupt(NULL, "Committing %s", realname);
  25.528 +	talloc_set_destructor(path, NULL);
  25.529 +}
  25.530 +
  25.531 +static bool set_perms(struct transaction *transaction,
  25.532 +		      const char *node,
  25.533 +		      struct xs_permissions *perms, unsigned int num)
  25.534 +{
  25.535 +	unsigned int len;
  25.536 +	char *permpath, *strings;
  25.537 +
  25.538 +	strings = perms_to_strings(node, perms, num, &len);
  25.539 +	if (!strings)
  25.540 +		return false;
  25.541 +
  25.542 +	/* Create then move. */
  25.543 +	permpath = tempfile(node_permfile(transaction, node), strings, len);
  25.544 +	if (!permpath)
  25.545 +		return false;
  25.546 +
  25.547 +	commit_tempfile(permpath);
  25.548 +	return true;
  25.549 +}
  25.550 +
  25.551 +static char *get_parent(const char *node)
  25.552 +{
  25.553 +	char *slash = strrchr(node + 1, '/');
  25.554 +	if (!slash)
  25.555 +		return talloc_strdup(node, "/");
  25.556 +	return talloc_asprintf(node, "%.*s", slash - node, node);
  25.557 +}
  25.558 +
  25.559 +static enum xs_perm_type perm_for_id(domid_t id,
  25.560 +				     struct xs_permissions *perms,
  25.561 +				     unsigned int num)
  25.562 +{
  25.563 +	unsigned int i;
  25.564 +
  25.565 +	/* Owners and tools get it all... */
  25.566 +	if (!id || perms[0].id == id)
  25.567 +		return XS_PERM_READ|XS_PERM_WRITE|XS_PERM_CREATE|XS_PERM_OWNER;
  25.568 +
  25.569 +	for (i = 1; i < num; i++)
  25.570 +		if (perms[i].id == id)
  25.571 +			return perms[i].perms;
  25.572 +
  25.573 +	return perms[0].perms;
  25.574 +}
  25.575 +
  25.576 +/* We have a weird permissions system.  You can allow someone into a
  25.577 + * specific node without allowing it in the parents.  If it's going to
  25.578 + * fail, however, we don't want the errno to indicate any information
  25.579 + * about the node. */
  25.580 +static int check_with_parents(struct connection *conn, const char *node,
  25.581 +			      int errnum)
  25.582 +{
  25.583 +	struct xs_permissions *perms;
  25.584 +	unsigned int num;
  25.585 +
  25.586 +	/* We always tell them about memory failures. */
  25.587 +	if (errnum == ENOMEM)
  25.588 +		return errnum;
  25.589 +
  25.590 +	do {
  25.591 +		node = get_parent(node);
  25.592 +		perms = get_perms(conn->transaction, node, &num);
  25.593 +		if (perms)
  25.594 +			break;
  25.595 +	} while (!streq(node, "/"));
  25.596 +
  25.597 +	/* No permission at root?  We're in trouble. */
  25.598 +	if (!perms)
  25.599 +		corrupt(conn, "No permissions file at root");
  25.600 +
  25.601 +	if (!(perm_for_id(conn->id, perms, num) & XS_PERM_READ))
  25.602 +		return EACCES;
  25.603 +
  25.604 +	return errnum;
  25.605 +}
  25.606 +
  25.607 +bool check_node_perms(struct connection *conn, const char *node,
  25.608 +		      enum xs_perm_type perm)
  25.609 +{
  25.610 +	struct xs_permissions *perms;
  25.611 +	unsigned int num;
  25.612 +
  25.613 +	if (!node) {
  25.614 +		errno = EINVAL;
  25.615 +		return false;
  25.616 +	}
  25.617 +
  25.618 +	if (!node || !is_valid_nodename(node)) {
  25.619 +		errno = EINVAL;
  25.620 +		return false;
  25.621 +	}
  25.622 +
  25.623 +	if (!conn->write && (perm & XS_PERM_WRITE)) {
  25.624 +		errno = EROFS;
  25.625 +		return false;
  25.626 +	}
  25.627 +
  25.628 +	perms = get_perms(conn->transaction, node, &num);
  25.629 +	/* No permissions.  If we want to create it and
  25.630 +	 * it doesn't exist, check parent directory. */
  25.631 +	if (!perms && errno == ENOENT && (perm & XS_PERM_CREATE)) {
  25.632 +		char *parent = get_parent(node);
  25.633 +		if (!parent)
  25.634 +			return false;
  25.635 +
  25.636 +		perms = get_perms(conn->transaction, parent, &num);
  25.637 +	}
  25.638 +	if (!perms) {
  25.639 +		errno = check_with_parents(conn, node, errno);
  25.640 +		return false;
  25.641 +	}
  25.642 +
  25.643 +	if (perm_for_id(conn->id, perms, num) & perm)
  25.644 +		return true;
  25.645 +
  25.646 +	errno = check_with_parents(conn, node, EACCES);
  25.647 +	return false;
  25.648 +}
  25.649 +
  25.650 +static bool send_directory(struct connection *conn, const char *node)
  25.651 +{
  25.652 +	char *path, *reply = talloc_strdup(node, "");
  25.653 +	unsigned int reply_len = 0;
  25.654 +	DIR *dir;
  25.655 +	struct dirent *dirent;
  25.656 +
  25.657 +	if (!check_node_perms(conn, node, XS_PERM_READ))
  25.658 +		return send_error(conn, errno);
  25.659 +
  25.660 +	path = node_dir(conn->transaction, node);
  25.661 +	dir = opendir(path);
  25.662 +	if (!dir)
  25.663 +		return send_error(conn, errno);
  25.664 +
  25.665 +	while ((dirent = readdir(dir)) != NULL) {
  25.666 +		int len = strlen(dirent->d_name) + 1;
  25.667 +
  25.668 +		if (!valid_chars(dirent->d_name))
  25.669 +			continue;
  25.670 +
  25.671 +		reply = talloc_realloc(path, reply, char, reply_len + len);
  25.672 +		strcpy(reply + reply_len, dirent->d_name);
  25.673 +		reply_len += len;
  25.674 +	}
  25.675 +	closedir(dir);
  25.676 +
  25.677 +	return send_reply(conn, XS_DIRECTORY, reply, reply_len);
  25.678 +}
  25.679 +
  25.680 +static bool do_read(struct connection *conn, const char *node)
  25.681 +{
  25.682 +	char *value;
  25.683 +	unsigned int size;
  25.684 +	int *fd;
  25.685 +
  25.686 +	if (!check_node_perms(conn, node, XS_PERM_READ))
  25.687 +		return send_error(conn, errno);
  25.688 +
  25.689 +	fd = talloc_open(node_datafile(conn->transaction, node), O_RDONLY, 0);
  25.690 +	if (!fd) {
  25.691 +		/* Data file doesn't exist?  We call that a directory */
  25.692 +		if (errno == ENOENT)
  25.693 +			errno = EISDIR;
  25.694 +		return send_error(conn, errno);
  25.695 +	}
  25.696 +
  25.697 +	value = read_all(fd, &size);
  25.698 +	if (!value)
  25.699 +		return send_error(conn, errno);
  25.700 +
  25.701 +	return send_reply(conn, XS_READ, value, size);
  25.702 +}
  25.703 +
  25.704 +/* Create a new directory.  Optionally put data in it (if data != NULL) */
  25.705 +static bool new_directory(struct connection *conn,
  25.706 +			  const char *node, void *data, unsigned int datalen)
  25.707 +{
  25.708 +	struct xs_permissions perms;
  25.709 +	char *permstr;
  25.710 +	unsigned int len;
  25.711 +	int *fd;
  25.712 +	char *dir = node_dir(conn->transaction, node);
  25.713 +
  25.714 +	if (mkdir(dir, 0750) != 0)
  25.715 +		return false;
  25.716 +
  25.717 +	/* Set destructor so we clean up if neccesary. */
  25.718 +	talloc_set_destructor(dir, destroy_path);
  25.719 +
  25.720 +	/* Default permisisons: we own it, noone else has permission. */
  25.721 +	perms.id = conn->id;
  25.722 +	perms.perms = XS_PERM_NONE;
  25.723 +
  25.724 +	permstr = perms_to_strings(dir, &perms, 1, &len);
  25.725 +	fd = talloc_open(node_permfile(conn->transaction, node),
  25.726 +			 O_WRONLY|O_CREAT|O_EXCL, 0640);
  25.727 +	if (!fd || !write_all(*fd, permstr, len))
  25.728 +		return false;
  25.729 +
  25.730 +	if (data) {
  25.731 +		char *datapath = node_datafile(conn->transaction, node);
  25.732 +
  25.733 +		fd = talloc_open(datapath, O_WRONLY|O_CREAT|O_EXCL, 0640);
  25.734 +		if (!fd || !write_all(*fd, data, datalen))
  25.735 +			return false;
  25.736 +	}
  25.737 +
  25.738 +	/* Finished! */
  25.739 +	talloc_set_destructor(dir, NULL);
  25.740 +	return true;
  25.741 +}
  25.742 +
  25.743 +/* path, flags, data... */
  25.744 +static bool do_write(struct connection *conn, struct buffered_data *in)
  25.745 +{
  25.746 +	unsigned int offset, datalen;
  25.747 +	char *vec[2];
  25.748 +	char *node, *tmppath;
  25.749 +	enum xs_perm_type mode;
  25.750 +	struct stat st;
  25.751 +
  25.752 +	/* Extra "strings" can be created by binary data. */
  25.753 +	if (get_strings(in, vec, ARRAY_SIZE(vec)) < ARRAY_SIZE(vec))
  25.754 +		return send_error(conn, EINVAL);
  25.755 +
  25.756 +	node = vec[0];
  25.757 +	if (!within_transaction(conn->transaction, node))
  25.758 +		return send_error(conn, EROFS);
  25.759 +
  25.760 +	if (transaction_block(conn, node))
  25.761 +		return true;
  25.762 +
  25.763 +	offset = strlen(vec[0]) + strlen(vec[1]) + 2;
  25.764 +	datalen = in->used - offset;
  25.765 +
  25.766 +	if (streq(vec[1], XS_WRITE_NONE))
  25.767 +		mode = XS_PERM_WRITE;
  25.768 +	else if (streq(vec[1], XS_WRITE_CREATE))
  25.769 +		mode = XS_PERM_WRITE|XS_PERM_CREATE;
  25.770 +	else if (streq(vec[1], XS_WRITE_CREATE_EXCL))
  25.771 +		mode = XS_PERM_WRITE|XS_PERM_CREATE;
  25.772 +	else
  25.773 +		return send_error(conn, EINVAL);
  25.774 +
  25.775 +	if (!check_node_perms(conn, node, mode))
  25.776 +		return send_error(conn, errno);
  25.777 +
  25.778 +	if (lstat(node_dir(conn->transaction, node), &st) != 0) {
  25.779 +		/* Does not exist... */
  25.780 +		if (errno != ENOENT)
  25.781 +			return send_error(conn, errno);
  25.782 +
  25.783 +		/* Not going to create it? */
  25.784 +		if (!(mode & XS_PERM_CREATE))
  25.785 +			return send_error(conn, ENOENT);
  25.786 +
  25.787 +		if (!new_directory(conn, node, in->buffer + offset, datalen))
  25.788 +			return send_error(conn, errno);
  25.789 +	} else {
  25.790 +		/* Exists... */
  25.791 +		if (streq(vec[1], XS_WRITE_CREATE_EXCL))
  25.792 +			return send_error(conn, EEXIST);
  25.793 +
  25.794 +		tmppath = tempfile(node_datafile(conn->transaction, node),
  25.795 +				   in->buffer + offset, datalen);
  25.796 +		if (!tmppath)
  25.797 +			return send_error(conn, errno);
  25.798 +
  25.799 +		commit_tempfile(tmppath);
  25.800 +	}
  25.801 +
  25.802 +	add_change_node(conn->transaction, node);
  25.803 +	send_ack(conn, XS_WRITE);
  25.804 +	fire_watches(conn->transaction, node);
  25.805 +	return false;
  25.806 +}
  25.807 +
  25.808 +static bool do_mkdir(struct connection *conn, const char *node)
  25.809 +{
  25.810 +	if (!check_node_perms(conn, node, XS_PERM_WRITE|XS_PERM_CREATE))
  25.811 +		return send_error(conn, errno);
  25.812 +
  25.813 +	if (!within_transaction(conn->transaction, node))
  25.814 +		return send_error(conn, EROFS);
  25.815 +
  25.816 +	if (transaction_block(conn, node))
  25.817 +		return true;
  25.818 +
  25.819 +	if (!new_directory(conn, node, NULL, 0))
  25.820 +		return send_error(conn, errno);
  25.821 +
  25.822 +	add_change_node(conn->transaction, node);
  25.823 +	send_ack(conn, XS_MKDIR);
  25.824 +	fire_watches(conn->transaction, node);
  25.825 +	return false;
  25.826 +}
  25.827 +
  25.828 +static bool do_rm(struct connection *conn, const char *node)
  25.829 +{
  25.830 +	char *tmppath, *path;
  25.831 +
  25.832 +	if (!check_node_perms(conn, node, XS_PERM_WRITE))
  25.833 +		return send_error(conn, errno);
  25.834 +
  25.835 +	if (!within_transaction(conn->transaction, node))
  25.836 +		return send_error(conn, EROFS);
  25.837 +
  25.838 +	if (transaction_block(conn, node))
  25.839 +		return true;
  25.840 +
  25.841 +	if (streq(node, "/"))
  25.842 +		return send_error(conn, EINVAL);
  25.843 +
  25.844 +	/* We move the directory to temporary name, destructor cleans up. */
  25.845 +	path = node_dir(conn->transaction, node);
  25.846 +	tmppath = talloc_asprintf(node, "%s.tmp", path);
  25.847 +	talloc_set_destructor(tmppath, destroy_path);
  25.848 +
  25.849 +	if (rename(path, tmppath) != 0)
  25.850 +		return send_error(conn, errno);
  25.851 +
  25.852 +	add_change_node(conn->transaction, node);
  25.853 +	send_ack(conn, XS_RM);
  25.854 +	fire_watches(conn->transaction, node);
  25.855 +	return false;
  25.856 +}
  25.857 +
  25.858 +static bool do_get_perms(struct connection *conn, const char *node)
  25.859 +{
  25.860 +	struct xs_permissions *perms;
  25.861 +	char *strings;
  25.862 +	unsigned int len, num;
  25.863 +
  25.864 +	if (!check_node_perms(conn, node, XS_PERM_READ))
  25.865 +		return send_error(conn, errno);
  25.866 +
  25.867 +	perms = get_perms(conn->transaction, node, &num);
  25.868 +	if (!perms)
  25.869 +		return send_error(conn, errno);
  25.870 +
  25.871 +	strings = perms_to_strings(node, perms, num, &len);
  25.872 +	if (!strings)
  25.873 +		return send_error(conn, errno);
  25.874 +
  25.875 +	return send_reply(conn, XS_GET_PERMS, strings, len);
  25.876 +}
  25.877 +
  25.878 +static bool do_set_perms(struct connection *conn, struct buffered_data *in)
  25.879 +{
  25.880 +	unsigned int num;
  25.881 +	char *node;
  25.882 +	struct xs_permissions *perms;
  25.883 +
  25.884 +	num = count_strings(in->buffer, in->used);
  25.885 +	if (num < 2)
  25.886 +		return send_error(conn, EINVAL);
  25.887 +
  25.888 +	/* First arg is node name. */
  25.889 +	node = in->buffer;
  25.890 +	in->buffer += strlen(in->buffer) + 1;
  25.891 +	num--;
  25.892 +
  25.893 +	if (!within_transaction(conn->transaction, node))
  25.894 +		return send_error(conn, EROFS);
  25.895 +
  25.896 +	if (transaction_block(conn, node))
  25.897 +		return true;
  25.898 +
  25.899 +	/* We must own node to do this (tools can do this too). */
  25.900 +	if (!check_node_perms(conn, node, XS_PERM_WRITE|XS_PERM_OWNER))
  25.901 +		return send_error(conn, errno);
  25.902 +
  25.903 +	perms = talloc_array(node, struct xs_permissions, num);
  25.904 +	if (!strings_to_perms(perms, num, in->buffer))
  25.905 +		return send_error(conn, errno);
  25.906 +
  25.907 +	if (!set_perms(conn->transaction, node, perms, num))
  25.908 +		return send_error(conn, errno);
  25.909 +	add_change_node(conn->transaction, node);
  25.910 +	send_ack(conn, XS_SET_PERMS);
  25.911 +	fire_watches(conn->transaction, node);
  25.912 +	return false;
  25.913 +}
  25.914 +
  25.915 +/* Process "in" for conn: "in" will vanish after this conversation, so
  25.916 + * we can talloc off it for temporary variables.  May free "conn".
  25.917 + * Returns true if can't complete due to block.
  25.918 + */
  25.919 +static bool process_message(struct connection *conn, struct buffered_data *in)
  25.920 +{
  25.921 +	switch (in->hdr.msg.type) {
  25.922 +	case XS_DIRECTORY:
  25.923 +		return send_directory(conn, onearg(in));
  25.924 +
  25.925 +	case XS_READ:
  25.926 +		return do_read(conn, onearg(in));
  25.927 +
  25.928 +	case XS_WRITE:
  25.929 +		return do_write(conn, in);
  25.930 +
  25.931 +	case XS_MKDIR:
  25.932 +		return do_mkdir(conn, onearg(in));
  25.933 +
  25.934 +	case XS_RM:
  25.935 +		return do_rm(conn, onearg(in));
  25.936 +
  25.937 +	case XS_GET_PERMS:
  25.938 +		return do_get_perms(conn, onearg(in));
  25.939 +
  25.940 +	case XS_SET_PERMS:
  25.941 +		return do_set_perms(conn, in);
  25.942 +
  25.943 +	case XS_SHUTDOWN:
  25.944 +		send_ack(conn, XS_SHUTDOWN);
  25.945 +		/* Everything hangs off auto-free context, freed at exit. */
  25.946 +		exit(0);
  25.947 +
  25.948 +#ifdef TESTING
  25.949 +	case XS_DEBUG: {
  25.950 +		/* For testing, we allow them to set id. */
  25.951 +		if (streq(in->buffer, "setid")) {
  25.952 +			conn->id = atoi(in->buffer + get_string(in, 0));
  25.953 +			send_ack(conn, XS_DEBUG);
  25.954 +		} else if (streq(in->buffer, "failtest")) {
  25.955 +			if (get_string(in, 0) < in->used)
  25.956 +				srandom(atoi(in->buffer + get_string(in, 0)));
  25.957 +			send_ack(conn, XS_DEBUG);
  25.958 +			failtest = true;
  25.959 +		}
  25.960 +		return false;
  25.961 +	}
  25.962 +#endif /* TESTING */
  25.963 +
  25.964 +	case XS_WATCH:
  25.965 +		return do_watch(conn, in);
  25.966 +
  25.967 +	case XS_WATCH_ACK:
  25.968 +		return do_watch_ack(conn);
  25.969 +
  25.970 +	case XS_UNWATCH:
  25.971 +		return do_unwatch(conn, onearg(in));
  25.972 +
  25.973 +	case XS_TRANSACTION_START:
  25.974 +		return do_transaction_start(conn, onearg(in));
  25.975 +
  25.976 +	case XS_TRANSACTION_END:
  25.977 +		return do_transaction_end(conn, onearg(in));
  25.978 +
  25.979 +	case XS_INTRODUCE:
  25.980 +		return do_introduce(conn, in);
  25.981 +
  25.982 +	case XS_RELEASE:
  25.983 +		return do_release(conn, onearg(in));
  25.984 +
  25.985 +	case XS_GETDOMAINPATH:
  25.986 +		return do_get_domain_path(conn, onearg(in));
  25.987 +
  25.988 +	case XS_WATCH_EVENT:
  25.989 +	default:
  25.990 +		eprintf("Client unknown operation %i", in->hdr.msg.type);
  25.991 +		send_error(conn, ENOSYS);
  25.992 +		return false;
  25.993 +	}
  25.994 +}
  25.995 +
  25.996 +static int out_of_mem(void *data)
  25.997 +{
  25.998 +	longjmp(*(jmp_buf *)data, 1);
  25.999 +}
 25.1000 +
 25.1001 +static void consider_message(struct connection *conn)
 25.1002 +{
 25.1003 +	struct buffered_data *in = NULL;
 25.1004 +	enum xsd_sockmsg_type type = conn->in->hdr.msg.type;
 25.1005 +	jmp_buf talloc_fail;
 25.1006 +
 25.1007 +	/* For simplicity, we kill the connection on OOM. */
 25.1008 +	talloc_set_fail_handler(out_of_mem, &talloc_fail);
 25.1009 +	if (setjmp(talloc_fail)) {
 25.1010 +		talloc_free(conn);
 25.1011 +		goto end;
 25.1012 +	}
 25.1013 +
 25.1014 +	if (verbose)
 25.1015 +		xprintf("Got message %i len %i from %p\n",
 25.1016 +			type, conn->in->hdr.msg.len, conn);
 25.1017 +
 25.1018 +	/* We might get a command while waiting for an ack: this means
 25.1019 +	 * the other end discarded it: we will re-transmit. */
 25.1020 +	if (type != XS_WATCH_ACK)
 25.1021 +		reset_watch_event(conn);
 25.1022 +
 25.1023 +	/* Careful: process_message may free connection.  We detach
 25.1024 +	 * "in" beforehand and allocate the new buffer to avoid
 25.1025 +	 * touching conn after process_message.
 25.1026 +	 */
 25.1027 +	in = talloc_steal(talloc_autofree_context(), conn->in);
 25.1028 +	conn->in = new_buffer(conn);
 25.1029 +	if (process_message(conn, in)) {
 25.1030 +		/* Blocked by transaction: queue for re-xmit. */
 25.1031 +		talloc_free(conn->in);
 25.1032 +		conn->in = in;
 25.1033 +		in = NULL;
 25.1034 +	}
 25.1035 +
 25.1036 +end:
 25.1037 +	talloc_free(in);
 25.1038 +	talloc_set_fail_handler(NULL, NULL);
 25.1039 +	if (talloc_total_blocks(NULL)
 25.1040 +	    != talloc_total_blocks(talloc_autofree_context()) + 1)
 25.1041 +		talloc_report_full(NULL, stderr);
 25.1042 +}
 25.1043 +
 25.1044 +/* Errors in reading or allocating here mean we get out of sync, so we
 25.1045 + * drop the whole client connection. */
 25.1046 +void handle_input(struct connection *conn)
 25.1047 +{
 25.1048 +	int bytes;
 25.1049 +	struct buffered_data *in;
 25.1050 +
 25.1051 +	assert(!conn->blocked);
 25.1052 +	in = conn->in;
 25.1053 +
 25.1054 +	/* Not finished header yet? */
 25.1055 +	if (in->inhdr) {
 25.1056 +		bytes = conn->read(conn, in->hdr.raw + in->used,
 25.1057 +				   sizeof(in->hdr) - in->used);
 25.1058 +		if (bytes <= 0)
 25.1059 +			goto bad_client;
 25.1060 +		in->used += bytes;
 25.1061 +		if (in->used != sizeof(in->hdr))
 25.1062 +			return;
 25.1063 +
 25.1064 +		if (in->hdr.msg.len > PATH_MAX) {
 25.1065 +			syslog(LOG_DAEMON, "Client tried to feed us %i",
 25.1066 +			       in->hdr.msg.len);
 25.1067 +			goto bad_client;
 25.1068 +		}
 25.1069 +
 25.1070 +		in->buffer = talloc_array(in, char, in->hdr.msg.len);
 25.1071 +		if (!in->buffer)
 25.1072 +			goto bad_client;
 25.1073 +		in->used = 0;
 25.1074 +		in->inhdr = false;
 25.1075 +		return;
 25.1076 +	}
 25.1077 +
 25.1078 +	bytes = conn->read(conn, in->buffer + in->used,
 25.1079 +			   in->hdr.msg.len - in->used);
 25.1080 +	if (bytes < 0)
 25.1081 +		goto bad_client;
 25.1082 +
 25.1083 +	in->used += bytes;
 25.1084 +	if (in->used != in->hdr.msg.len)
 25.1085 +		return;
 25.1086 +
 25.1087 +	consider_message(conn);
 25.1088 +	return;
 25.1089 +
 25.1090 +bad_client:
 25.1091 +	/* Kill it. */
 25.1092 +	talloc_free(conn);
 25.1093 +}
 25.1094 +
 25.1095 +void handle_output(struct connection *conn)
 25.1096 +{
 25.1097 +	if (!write_message(conn))
 25.1098 +		talloc_free(conn);
 25.1099 +}
 25.1100 +
 25.1101 +/* If a transaction has ended, see if we can unblock any connections. */
 25.1102 +static void unblock_connections(void)
 25.1103 +{
 25.1104 +	struct connection *i, *tmp;
 25.1105 +
 25.1106 +	list_for_each_entry_safe(i, tmp, &connections, list) {
 25.1107 +		if (!i->blocked)
 25.1108 +			continue;
 25.1109 +
 25.1110 +		if (!transaction_covering_node(i->blocked)) {
 25.1111 +			talloc_free(i->blocked);
 25.1112 +			i->blocked = NULL;
 25.1113 +			consider_message(i);
 25.1114 +		}
 25.1115 +	}
 25.1116 +
 25.1117 +	/* To balance bias, move first entry to end. */
 25.1118 +	if (!list_empty(&connections)) {
 25.1119 +		i = list_top(&connections, struct connection, list);
 25.1120 +		list_del(&i->list);
 25.1121 +		list_add_tail(&i->list, &connections);
 25.1122 +	}
 25.1123 +}
 25.1124 +
 25.1125 +struct connection *new_connection(connwritefn_t *write, connreadfn_t *read)
 25.1126 +{
 25.1127 +	struct connection *new;
 25.1128 +	jmp_buf talloc_fail;
 25.1129 +
 25.1130 +	new = talloc(talloc_autofree_context(), struct connection);
 25.1131 +	if (!new)
 25.1132 +		return NULL;
 25.1133 +
 25.1134 +	new->blocked = false;
 25.1135 +	new->out = new->waiting_reply = NULL;
 25.1136 +	new->event = NULL;
 25.1137 +	new->fd = -1;
 25.1138 +	new->id = 0;
 25.1139 +	new->domain = NULL;
 25.1140 +	new->transaction = NULL;
 25.1141 +	new->write = write;
 25.1142 +	new->read = read;
 25.1143 +
 25.1144 +	talloc_set_fail_handler(out_of_mem, &talloc_fail);
 25.1145 +	if (setjmp(talloc_fail)) {
 25.1146 +		talloc_free(new);
 25.1147 +		return NULL;
 25.1148 +	}
 25.1149 +	new->in = new_buffer(new);
 25.1150 +	talloc_set_fail_handler(NULL, NULL);
 25.1151 +
 25.1152 +	list_add_tail(&new->list, &connections);
 25.1153 +	talloc_set_destructor(new, destroy_conn);
 25.1154 +	return new;
 25.1155 +}
 25.1156 +
 25.1157 +static int writefd(struct connection *conn, const void *data, unsigned int len)
 25.1158 +{
 25.1159 +	return write(conn->fd, data, len);
 25.1160 +}
 25.1161 +
 25.1162 +static int readfd(struct connection *conn, void *data, unsigned int len)
 25.1163 +{
 25.1164 +	return read(conn->fd, data, len);
 25.1165 +}
 25.1166 +
 25.1167 +static void accept_connection(int sock, bool canwrite)
 25.1168 +{
 25.1169 +	int fd;
 25.1170 +	struct connection *conn;
 25.1171 +
 25.1172 +	fd = accept(sock, NULL, NULL);
 25.1173 +	if (fd < 0)
 25.1174 +		return;
 25.1175 +
 25.1176 +	conn = new_connection(canwrite ? writefd : NULL, readfd);
 25.1177 +	if (conn)
 25.1178 +		conn->fd = fd;
 25.1179 +	else
 25.1180 +		close(fd);
 25.1181 +}
 25.1182 +
 25.1183 +/* Calc timespan from now to absolute time. */
 25.1184 +static void time_relative_to_now(struct timeval *tv)
 25.1185 +{
 25.1186 +	struct timeval now;
 25.1187 +
 25.1188 +	gettimeofday(&now, NULL);
 25.1189 +	if (timercmp(&now, tv, >))
 25.1190 +		timerclear(tv);
 25.1191 +	else {
 25.1192 +		tv->tv_sec -= now.tv_sec;
 25.1193 +		if (now.tv_usec > tv->tv_usec) {
 25.1194 +			tv->tv_sec--;
 25.1195 +			tv->tv_usec += 1000000;
 25.1196 +		}
 25.1197 +		tv->tv_usec -= now.tv_usec;
 25.1198 +	}
 25.1199 +}
 25.1200 +
 25.1201 +static struct option options[] = { { "no-fork", 0, NULL, 'N' },
 25.1202 +				   { "verbose", 0, NULL, 'V' },
 25.1203 +				   { "output-pid", 0, NULL, 'P' },
 25.1204 +				   { NULL, 0, NULL, 0 } };
 25.1205 +
 25.1206 +int main(int argc, char *argv[])
 25.1207 +{
 25.1208 +	int opt, *sock, *ro_sock, event_fd, max, tmpout;
 25.1209 +	struct sockaddr_un addr;
 25.1210 +	fd_set inset, outset;
 25.1211 +	bool dofork = true;
 25.1212 +	bool outputpid = false;
 25.1213 +
 25.1214 +	while ((opt = getopt_long(argc, argv, "DV", options, NULL)) != -1) {
 25.1215 +		switch (opt) {
 25.1216 +		case 'N':
 25.1217 +			dofork = false;
 25.1218 +			break;
 25.1219 +		case 'V':
 25.1220 +			verbose = true;
 25.1221 +			break;
 25.1222 +		case 'P':
 25.1223 +			outputpid = true;
 25.1224 +			break;
 25.1225 +		}
 25.1226 +	}
 25.1227 +	if (optind != argc)
 25.1228 +		barf("%s: No arguments desired", argv[0]);
 25.1229 +
 25.1230 +	talloc_enable_leak_report_full();
 25.1231 +
 25.1232 +	/* Create sockets for them to listen to. */
 25.1233 +	sock = talloc(talloc_autofree_context(), int);
 25.1234 +	*sock = socket(PF_UNIX, SOCK_STREAM, 0);
 25.1235 +	if (*sock < 0)
 25.1236 +		barf_perror("Could not create socket");
 25.1237 +	ro_sock = talloc(talloc_autofree_context(), int);
 25.1238 +	*ro_sock = socket(PF_UNIX, SOCK_STREAM, 0);
 25.1239 +	if (*ro_sock < 0)
 25.1240 +		barf_perror("Could not create socket");
 25.1241 +	talloc_set_destructor(sock, destroy_fd);
 25.1242 +	talloc_set_destructor(ro_sock, destroy_fd);
 25.1243 +
 25.1244 +	/* Don't kill us with SIGPIPE. */
 25.1245 +	signal(SIGPIPE, SIG_IGN);
 25.1246 +
 25.1247 +	/* FIXME: Be more sophisticated, don't mug running daemon. */
 25.1248 +	unlink(xs_daemon_socket());
 25.1249 +	unlink(xs_daemon_socket_ro());
 25.1250 +
 25.1251 +	addr.sun_family = AF_UNIX;
 25.1252 +	strcpy(addr.sun_path, xs_daemon_socket());
 25.1253 +	if (bind(*sock, (struct sockaddr *)&addr, sizeof(addr)) != 0)
 25.1254 +		barf_perror("Could not bind socket to %s", xs_daemon_socket());
 25.1255 +	strcpy(addr.sun_path, xs_daemon_socket_ro());
 25.1256 +	if (bind(*ro_sock, (struct sockaddr *)&addr, sizeof(addr)) != 0)
 25.1257 +		barf_perror("Could not bind socket to %s",
 25.1258 +			    xs_daemon_socket_ro());
 25.1259 +	if (chmod(xs_daemon_socket(), 0600) != 0
 25.1260 +	    || chmod(xs_daemon_socket_ro(), 0660) != 0)
 25.1261 +		barf_perror("Could not chmod sockets");
 25.1262 +
 25.1263 +	if (listen(*sock, 1) != 0
 25.1264 +	    || listen(*ro_sock, 1) != 0)
 25.1265 +		barf_perror("Could not listen on sockets");
 25.1266 +
 25.1267 +	/* If we're the first, create .perms file for root. */
 25.1268 +	if (mkdir(xs_daemon_store(), 0750) == 0) {
 25.1269 +		struct xs_permissions perms;
 25.1270 +		char *root = talloc_strdup(talloc_autofree_context(), "/");
 25.1271 +
 25.1272 +		perms.id = 0;
 25.1273 +		perms.perms = XS_PERM_READ;
 25.1274 +		if (!set_perms(NULL, root, &perms, 1))
 25.1275 +			barf_perror("Could not create permissions in root");
 25.1276 +		talloc_free(root);
 25.1277 +		mkdir(xs_daemon_transactions(), 0750);
 25.1278 +	} else if (errno != EEXIST)
 25.1279 +		barf_perror("Could not create root %s", xs_daemon_store());
 25.1280 +
 25.1281 +	/* Listen to hypervisor. */
 25.1282 +	event_fd = domain_init();
 25.1283 +
 25.1284 +	/* Debugging: daemonize() closes standard fds, so dup here. */
 25.1285 +	tmpout = dup(STDOUT_FILENO);
 25.1286 +	if (dofork) {
 25.1287 +		openlog("xenstored", 0, LOG_DAEMON);
 25.1288 +		daemonize();
 25.1289 +	}
 25.1290 +
 25.1291 +	if (outputpid) {
 25.1292 +		char buffer[20];
 25.1293 +		sprintf(buffer, "%i\n", getpid());
 25.1294 +		write(tmpout, buffer, strlen(buffer));
 25.1295 +	}
 25.1296 +	close(tmpout);
 25.1297 +
 25.1298 +#ifdef TESTING
 25.1299 +	signal(SIGUSR1, stop_failtest);
 25.1300 +#endif
 25.1301 +
 25.1302 +	/* Get ready to listen to the tools. */
 25.1303 +	max = initialize_set(&inset, &outset, *sock, *ro_sock, event_fd);
 25.1304 +
 25.1305 +	/* Main loop. */
 25.1306 +	for (;;) {
 25.1307 +		struct connection *i;
 25.1308 +		struct timeval *tvp = NULL, tv;
 25.1309 +
 25.1310 +		timerclear(&tv);
 25.1311 +		shortest_transaction_timeout(&tv);
 25.1312 +		if (timerisset(&tv)) {
 25.1313 +			time_relative_to_now(&tv);
 25.1314 +			tvp = &tv;
 25.1315 +		}
 25.1316 +
 25.1317 +		if (select(max+1, &inset, &outset, NULL, tvp) < 0) {
 25.1318 +			if (errno == EINTR)
 25.1319 +				continue;
 25.1320 +			barf_perror("Select failed");
 25.1321 +		}
 25.1322 +
 25.1323 +		if (FD_ISSET(*sock, &inset))
 25.1324 +			accept_connection(*sock, true);
 25.1325 +
 25.1326 +		if (FD_ISSET(*ro_sock, &inset))
 25.1327 +			accept_connection(*ro_sock, false);
 25.1328 +
 25.1329 +		if (FD_ISSET(event_fd, &inset))
 25.1330 +			handle_event(event_fd);
 25.1331 +
 25.1332 +		list_for_each_entry(i, &connections, list) {
 25.1333 +			if (i->domain)
 25.1334 +				continue;
 25.1335 +
 25.1336 +			/* Operations can delete themselves or others
 25.1337 +			 * (xs_release): list is not safe after input,
 25.1338 +			 * so break. */
 25.1339 +			if (FD_ISSET(i->fd, &inset)) {
 25.1340 +				handle_input(i);
 25.1341 +				break;
 25.1342 +			}
 25.1343 +			if (FD_ISSET(i->fd, &outset)) {
 25.1344 +				handle_output(i);
 25.1345 +				break;
 25.1346 +			}
 25.1347 +		}
 25.1348 +
 25.1349 +		if (tvp)
 25.1350 +			check_transaction_timeout();
 25.1351 +
 25.1352 +		/* If transactions ended, we might be able to do more work. */
 25.1353 +		unblock_connections();
 25.1354 +
 25.1355 +		max = initialize_set(&inset, &outset, *sock,*ro_sock,event_fd);
 25.1356 +	}
 25.1357 +}