1.1 --- a/.hgignore	Mon Mar 06 09:09:18 2006 -0700
     1.2 +++ b/.hgignore	Mon Mar 06 10:21:35 2006 -0700
     1.3 @@ -166,6 +166,7 @@
     1.4  ^tools/xenstore/xenstore-read$
     1.5  ^tools/xenstore/xenstore-rm$
     1.6  ^tools/xenstore/xenstore-write$
     1.7 +^tools/xenstore/xenstore-control$
     1.8  ^tools/xenstore/xenstore-ls$
     1.9  ^tools/xenstore/xenstored$
    1.10  ^tools/xenstore/xenstored_test$

     2.1 --- a/docs/src/interface.tex	Mon Mar 06 09:09:18 2006 -0700
     2.2 +++ b/docs/src/interface.tex	Mon Mar 06 10:21:35 2006 -0700
     2.3 @@ -1059,6 +1059,21 @@ This path contains:
     2.4        \item[domain] the name of the frontend
     2.5        \end{description}
     2.6      \end{description}
     2.7 +
     2.8 +  \item[vtpm/] a directory containin vtpm backends
     2.9 +    \begin{description}
    2.10 +    \item[$<$domid$>$/] a directory containing vtpm's for domid
    2.11 +      \begin{description}
    2.12 +      \item[$<$vtpm number$>$/] a directory for each vtpm
    2.13 +      \item[frontend-id] the domain id of the frontend
    2.14 +      \item[frontend] the path to the frontend
    2.15 +      \item[instance] the instance of the virtual TPM that is used
    2.16 +      \item[pref{\textunderscore}instance] the instance number as given in the VM configuration file;
    2.17 +           may be different from {\bf instance}
    2.18 +      \item[domain] the name of the domain of the frontend
    2.19 +      \end{description}
    2.20 +    \end{description}
    2.21 +
    2.22    \end{description}
    2.23  
    2.24    \item[device/] a directory containing the frontend devices for the
    2.25 @@ -1094,6 +1109,18 @@ This path contains:
    2.26  	  \item[event-channel] the event channel used for the two ring queues 
    2.27  	  \end{description}
    2.28  	\end{description}
    2.29 +
    2.30 +      \item[vtpm/] a directory containing the vtpm frontend device for the
    2.31 +        domain
    2.32 +        \begin{description}
    2.33 +        \item[$<$id$>$] a directory for vtpm id frontend device for the domain
    2.34 +          \begin{description}
    2.35 +	  \item[backend-id] the backend domain id
    2.36 +          \item[backend] a path to the backend's store entry
    2.37 +          \item[ring-ref] the grant table reference for the tx/rx ring
    2.38 +          \item[event-channel] the event channel used for the ring
    2.39 +          \end{description}
    2.40 +        \end{description}
    2.41  	
    2.42        \item[device-misc/] miscellanous information for devices 
    2.43  	\begin{description}
    2.44 @@ -1450,6 +1477,76 @@ The fields are as follows:
    2.45    value of {\tt first\_sect}.
    2.46  \end{description}
    2.47  
    2.48 +\section{Virtual TPM}
    2.49 +
    2.50 +Virtual TPM (VTPM) support provides TPM functionality to each virtual
    2.51 +machine that requests this functionality in its configuration file.
    2.52 +The interface enables domains to access therr own private TPM like it
    2.53 +was a hardware TPM built into the machine.
    2.54 +
    2.55 +The virtual TPM interface is implemented as a split driver,
    2.56 +similar to the network and block interfaces described above.
    2.57 +The user domain hosting the frontend exports a character device /dev/tpm0
    2.58 +to user-level applications for communicating with the virtual TPM.
    2.59 +This is the same device interface that is also offered if a hardware TPM
    2.60 +is available in the system. The backend provides a single interface
    2.61 +/dev/vtpm where the virtual TPM is waiting for commands from all domains
    2.62 +that have located their backend in a given domain.
    2.63 +
    2.64 +\subsection{Data Transfer}
    2.65 +
    2.66 +A single shared memory ring is used between the frontend and backend
    2.67 +drivers. TPM requests and responses are sent in pages where a pointer
    2.68 +to those pages and other information is placed into the ring such that
    2.69 +the backend can map the pages into its memory space using the grant
    2.70 +table mechanism.
    2.71 +
    2.72 +The backend driver has been implemented to only accept well-formed
    2.73 +TPM requests. To meet this requirement, the length inidicator in the
    2.74 +TPM request must correctly indicate the length of the request.
    2.75 +Otherwise an error message is automatically sent back by the device driver.
    2.76 +
    2.77 +The virtual TPM implementation listenes for TPM request on /dev/vtpm. Since
    2.78 +it must be able to apply the TPM request packet to the virtual TPM instance
    2.79 +associated with the virtual machine, a 4-byte virtual TPM instance
    2.80 +identifier is prepended to each packet by the backend driver (in network
    2.81 +byte order) for internal routing of the request.
    2.82 +
    2.83 +\subsection{Virtual TPM ring interface}
    2.84 +
    2.85 +The TPM protocol is a strict request/response protocol and therefore
    2.86 +only one ring is used to send requests from the frontend to the backend
    2.87 +and responses on the reverse path.
    2.88 +
    2.89 +The request/response structure is defined as follows:
    2.90 +
    2.91 +\scriptsize
    2.92 +\begin{verbatim}
    2.93 +typedef struct {
    2.94 +    unsigned long addr;     /* Machine address of packet.     */
    2.95 +    grant_ref_t ref;        /* grant table access reference.  */
    2.96 +    uint16_t unused;        /* unused                         */
    2.97 +    uint16_t size;          /* Packet size in bytes.          */
    2.98 +} tpmif_tx_request_t;
    2.99 +\end{verbatim}
   2.100 +\normalsize
   2.101 +
   2.102 +The fields are as follows:
   2.103 +
   2.104 +\begin{description}
   2.105 +\item[addr] The machine address of the page asscoiated with the TPM
   2.106 +            request/response; a request/response may span multiple
   2.107 +            pages
   2.108 +\item[ref]  The grant table reference associated with the address.
   2.109 +\item[size] The size of the remaining packet; up to
   2.110 +            PAGE{\textunderscore}SIZE bytes can be found in the
   2.111 +            page referenced by 'addr'
   2.112 +\end{description}
   2.113 +
   2.114 +The frontend initially allocates several pages whose addresses
   2.115 +are stored in the ring. Only these pages are used for exchange of
   2.116 +requests and responses.
   2.117 +
   2.118  
   2.119  \chapter{Further Information}
   2.120  

     3.1 --- a/install.sh	Mon Mar 06 09:09:18 2006 -0700
     3.2 +++ b/install.sh	Mon Mar 06 10:21:35 2006 -0700
     3.3 @@ -22,20 +22,30 @@ if ! [ -d $dst ]; then
     3.4    exit 1
     3.5  fi
     3.6  
     3.7 +tmp="`mktemp -d`"
     3.8 +
     3.9  echo "Installing Xen from '$src' to '$dst'..."
    3.10 -(cd $src; tar -cf - --exclude etc/init.d --exclude etc/hotplug --exclude etc/udev * ) | tar -C $dst -xf -
    3.11 -cp -fdRL $src/etc/init.d/* $dst/etc/init.d/
    3.12 -echo "All done."
    3.13 +(cd $src; tar -cf - * ) | tar -C "$tmp" -xf -
    3.14  
    3.15  [ -x "$(which udevinfo)" ] && \
    3.16    UDEV_VERSION=$(udevinfo -V | sed -e 's/^[^0-9]* \([0-9]\{1,\}\)[^0-9]\{0,\}/\1/')
    3.17  
    3.18  if [ -n "$UDEV_VERSION" ] && [ $UDEV_VERSION -ge 059 ]; then
    3.19 -  cp -f $src/etc/udev/rules.d/*.rules $dst/etc/udev/rules.d/
    3.20 +  echo " - installing for udev-based system"
    3.21 +  rm -rf "$tmp/etc/hotplug"
    3.22  else
    3.23 -  cp -f $src/etc/hotplug/*.agent $dst/etc/hotplug/
    3.24 +  echo " - installing for hotplug-based system"
    3.25 +  rm -rf "$tmp/etc/udev"
    3.26  fi
    3.27  
    3.28 +echo " - modifying permissions"
    3.29 +chmod -R a+rX "$tmp"
    3.30 +
    3.31 +(cd $tmp; tar -cf - *) | tar --no-same-owner -C "$dst" -xf -
    3.32 +rm -rf "$tmp"
    3.33 +
    3.34 +echo "All done."
    3.35 +
    3.36  echo "Checking to see whether prerequisite tools are installed..."
    3.37  cd $src/../check
    3.38  ./chk install

     4.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/io_apic-xen.c	Mon Mar 06 09:09:18 2006 -0700
     4.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/io_apic-xen.c	Mon Mar 06 10:21:35 2006 -0700
     4.3 @@ -61,8 +61,8 @@ static inline unsigned int xen_io_apic_r
     4.4  	int ret;
     4.5  
     4.6  	op.cmd = PHYSDEVOP_APIC_READ;
     4.7 -	op.u.apic_op.apic = mp_ioapics[apic].mpc_apicid;
     4.8 -	op.u.apic_op.offset = reg;
     4.9 +	op.u.apic_op.apic_physbase = mp_ioapics[apic].mpc_apicaddr;
    4.10 +	op.u.apic_op.reg = reg;
    4.11  	ret = HYPERVISOR_physdev_op(&op);
    4.12  	if (ret)
    4.13  		return ret;
    4.14 @@ -74,8 +74,8 @@ static inline void xen_io_apic_write(uns
    4.15  	physdev_op_t op;
    4.16  
    4.17  	op.cmd = PHYSDEVOP_APIC_WRITE;
    4.18 -	op.u.apic_op.apic = mp_ioapics[apic].mpc_apicid;
    4.19 -	op.u.apic_op.offset = reg;
    4.20 +	op.u.apic_op.apic_physbase = mp_ioapics[apic].mpc_apicaddr;
    4.21 +	op.u.apic_op.reg = reg;
    4.22  	op.u.apic_op.value = value;
    4.23  	HYPERVISOR_physdev_op(&op);
    4.24  }

     5.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/io_apic-xen.c	Mon Mar 06 09:09:18 2006 -0700
     5.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/io_apic-xen.c	Mon Mar 06 10:21:35 2006 -0700
     5.3 @@ -108,8 +108,8 @@ static inline unsigned int xen_io_apic_r
     5.4  	int ret;
     5.5  
     5.6  	op.cmd = PHYSDEVOP_APIC_READ;
     5.7 -	op.u.apic_op.apic = mp_ioapics[apic].mpc_apicid;
     5.8 -	op.u.apic_op.offset = reg;
     5.9 +	op.u.apic_op.apic_physbase = mp_ioapics[apic].mpc_apicaddr;
    5.10 +	op.u.apic_op.reg = reg;
    5.11  	ret = HYPERVISOR_physdev_op(&op);
    5.12  	if (ret)
    5.13  		return ret;
    5.14 @@ -121,8 +121,8 @@ static inline void xen_io_apic_write(uns
    5.15  	physdev_op_t op;
    5.16  
    5.17  	op.cmd = PHYSDEVOP_APIC_WRITE;
    5.18 -	op.u.apic_op.apic = mp_ioapics[apic].mpc_apicid;
    5.19 -	op.u.apic_op.offset = reg;
    5.20 +	op.u.apic_op.apic_physbase = mp_ioapics[apic].mpc_apicaddr;
    5.21 +	op.u.apic_op.reg = reg;
    5.22  	op.u.apic_op.value = value;
    5.23  	HYPERVISOR_physdev_op(&op);
    5.24  }

     6.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Mon Mar 06 09:09:18 2006 -0700
     6.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Mon Mar 06 10:21:35 2006 -0700
     6.3 @@ -82,6 +82,8 @@
     6.4  extern unsigned long start_pfn;
     6.5  extern struct edid_info edid_info;
     6.6  
     6.7 +extern void machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c);
     6.8 +
     6.9  shared_info_t *HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page;
    6.10  EXPORT_SYMBOL(HYPERVISOR_shared_info);
    6.11  
    6.12 @@ -1405,6 +1407,8 @@ void __cpuinit identify_cpu(struct cpuin
    6.13  	select_idle_routine(c);
    6.14  	detect_ht(c); 
    6.15  
    6.16 +	machine_specific_modify_cpu_capabilities(c);
    6.17 +
    6.18  	/*
    6.19  	 * On SMP, boot_cpu_data holds the common feature set between
    6.20  	 * all CPUs; so make sure that we indicate which features are

     7.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/x8664_ksyms-xen.c	Mon Mar 06 09:09:18 2006 -0700
     7.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/x8664_ksyms-xen.c	Mon Mar 06 10:21:35 2006 -0700
     7.3 @@ -32,8 +32,6 @@
     7.4  #include <asm/tlbflush.h>
     7.5  #include <asm/kdebug.h>
     7.6  
     7.7 -extern spinlock_t rtc_lock;
     7.8 -
     7.9  #ifdef CONFIG_SMP
    7.10  extern void __write_lock_failed(rwlock_t *rw);
    7.11  extern void __read_lock_failed(rwlock_t *rw);
    7.12 @@ -42,9 +40,6 @@ extern void __read_lock_failed(rwlock_t 
    7.13  /* platform dependent support */
    7.14  EXPORT_SYMBOL(boot_cpu_data);
    7.15  //EXPORT_SYMBOL(dump_fpu);
    7.16 -EXPORT_SYMBOL(__ioremap);
    7.17 -EXPORT_SYMBOL(ioremap_nocache);
    7.18 -EXPORT_SYMBOL(iounmap);
    7.19  EXPORT_SYMBOL(kernel_thread);
    7.20  EXPORT_SYMBOL(pm_idle);
    7.21  EXPORT_SYMBOL(pm_power_off);
    7.22 @@ -102,8 +97,6 @@ EXPORT_SYMBOL(screen_info);
    7.23  
    7.24  EXPORT_SYMBOL(get_wchan);
    7.25  
    7.26 -EXPORT_SYMBOL(rtc_lock);
    7.27 -
    7.28  #ifdef CONFIG_X86_LOCAL_APIC
    7.29  EXPORT_SYMBOL_GPL(set_nmi_callback);
    7.30  EXPORT_SYMBOL_GPL(unset_nmi_callback);
    7.31 @@ -166,7 +159,5 @@ EXPORT_SYMBOL(__supported_pte_mask);
    7.32  EXPORT_SYMBOL(flush_tlb_page);
    7.33  #endif
    7.34  
    7.35 -EXPORT_SYMBOL(cpu_khz);
    7.36 -
    7.37  EXPORT_SYMBOL(load_gs_index);
    7.38  

     8.1 --- a/linux-2.6-xen-sparse/drivers/xen/char/mem.c	Mon Mar 06 09:09:18 2006 -0700
     8.2 +++ b/linux-2.6-xen-sparse/drivers/xen/char/mem.c	Mon Mar 06 10:21:35 2006 -0700
     8.3 @@ -43,49 +43,85 @@ static inline int uncached_access(struct
     8.4  static ssize_t read_mem(struct file * file, char __user * buf,
     8.5  			size_t count, loff_t *ppos)
     8.6  {
     8.7 -	unsigned long i, p = *ppos;
     8.8 -	ssize_t read = -EFAULT;
     8.9 +	unsigned long p = *ppos, ignored;
    8.10 +	ssize_t read = 0, sz;
    8.11  	void __iomem *v;
    8.12  
    8.13 -	if ((v = ioremap(p, count)) == NULL) {
    8.14 +	while (count > 0) {
    8.15  		/*
    8.16 -		 * Some programs (e.g., dmidecode) groove off into weird RAM
    8.17 -		 * areas where no table scan possibly exist (because Xen will
    8.18 -		 * have stomped on them!). These programs get rather upset if
    8.19 -                 * we let them know that Xen failed their access, so we fake
    8.20 -                 * out a read of all zeroes. :-)
    8.21 +		 * Handle first page in case it's not aligned
    8.22  		 */
    8.23 -		for (i = 0; i < count; i++)
    8.24 -			if (put_user(0, buf+i))
    8.25 +		if (-p & (PAGE_SIZE - 1))
    8.26 +			sz = -p & (PAGE_SIZE - 1);
    8.27 +		else
    8.28 +			sz = PAGE_SIZE;
    8.29 +
    8.30 +		sz = min_t(unsigned long, sz, count);
    8.31 +
    8.32 +		if ((v = ioremap(p, sz)) == NULL) {
    8.33 +			/*
    8.34 +			 * Some programs (e.g., dmidecode) groove off into weird RAM
    8.35 +			 * areas where no tables can possibly exist (because Xen will
    8.36 +			 * have stomped on them!). These programs get rather upset if
    8.37 +			 * we let them know that Xen failed their access, so we fake
    8.38 +			 * out a read of all zeroes. :-)
    8.39 +			 */
    8.40 +			if (clear_user(buf, count))
    8.41  				return -EFAULT;
    8.42 -		return count;
    8.43 +			read += count;
    8.44 +			break;
    8.45 +		}
    8.46 +
    8.47 +		ignored = copy_to_user(buf, v, sz);
    8.48 +		iounmap(v);
    8.49 +		if (ignored)
    8.50 +			return -EFAULT;
    8.51 +		buf += sz;
    8.52 +		p += sz;
    8.53 +		count -= sz;
    8.54 +		read += sz;
    8.55  	}
    8.56 -	if (copy_to_user(buf, v, count))
    8.57 -		goto out;
    8.58  
    8.59 -	read = count;
    8.60  	*ppos += read;
    8.61 -out:
    8.62 -	iounmap(v);
    8.63  	return read;
    8.64  }
    8.65  
    8.66  static ssize_t write_mem(struct file * file, const char __user * buf, 
    8.67  			 size_t count, loff_t *ppos)
    8.68  {
    8.69 -	unsigned long p = *ppos;
    8.70 -	ssize_t written = -EFAULT;
    8.71 +	unsigned long p = *ppos, ignored;
    8.72 +	ssize_t written = 0, sz;
    8.73  	void __iomem *v;
    8.74  
    8.75 -	if ((v = ioremap(p, count)) == NULL)
    8.76 -		return -EFAULT;
    8.77 -	if (copy_from_user(v, buf, count))
    8.78 -		goto out;
    8.79 +	while (count > 0) {
    8.80 +		/*
    8.81 +		 * Handle first page in case it's not aligned
    8.82 +		 */
    8.83 +		if (-p & (PAGE_SIZE - 1))
    8.84 +			sz = -p & (PAGE_SIZE - 1);
    8.85 +		else
    8.86 +			sz = PAGE_SIZE;
    8.87 +
    8.88 +		sz = min_t(unsigned long, sz, count);
    8.89 +
    8.90 +		if ((v = ioremap(p, sz)) == NULL)
    8.91 +			break;
    8.92  
    8.93 -	written = count;
    8.94 +		ignored = copy_from_user(v, buf, sz);
    8.95 +		iounmap(v);
    8.96 +		if (ignored) {
    8.97 +			written += sz - ignored;
    8.98 +			if (written)
    8.99 +				break;
   8.100 +			return -EFAULT;
   8.101 +		}
   8.102 +		buf += sz;
   8.103 +		p += sz;
   8.104 +		count -= sz;
   8.105 +		written += sz;
   8.106 +	}
   8.107 +
   8.108  	*ppos += written;
   8.109 -out:
   8.110 -	iounmap(v);
   8.111  	return written;
   8.112  }
   8.113  

     9.1 --- a/linux-2.6-xen-sparse/drivers/xen/core/gnttab.c	Mon Mar 06 09:09:18 2006 -0700
     9.2 +++ b/linux-2.6-xen-sparse/drivers/xen/core/gnttab.c	Mon Mar 06 10:21:35 2006 -0700
     9.3 @@ -35,7 +35,6 @@
     9.4  #include <xen/interface/xen.h>
     9.5  #include <asm/fixmap.h>
     9.6  #include <asm/uaccess.h>
     9.7 -#include <xen/public/privcmd.h>
     9.8  #include <xen/gnttab.h>
     9.9  #include <asm/synch_bitops.h>
    9.10  

    10.1 --- a/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c	Mon Mar 06 09:09:18 2006 -0700
    10.2 +++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c	Mon Mar 06 10:21:35 2006 -0700
    10.3 @@ -19,8 +19,7 @@ int num_frontends = 0;
    10.4  
    10.5  LIST_HEAD(tpmif_list);
    10.6  
    10.7 -tpmif_t *
    10.8 -alloc_tpmif(domid_t domid, long int instance)
    10.9 +static tpmif_t *alloc_tpmif(domid_t domid, long int instance)
   10.10  {
   10.11  	struct page *page;
   10.12  	tpmif_t *tpmif;
   10.13 @@ -45,16 +44,14 @@ alloc_tpmif(domid_t domid, long int inst
   10.14  	return tpmif;
   10.15  }
   10.16  
   10.17 -void
   10.18 -free_tpmif(tpmif_t * tpmif)
   10.19 +static void free_tpmif(tpmif_t * tpmif)
   10.20  {
   10.21  	num_frontends--;
   10.22  	list_del(&tpmif->tpmif_list);
   10.23  	kmem_cache_free(tpmif_cachep, tpmif);
   10.24  }
   10.25  
   10.26 -tpmif_t *
   10.27 -tpmif_find(domid_t domid, long int instance)
   10.28 +tpmif_t *tpmif_find(domid_t domid, long int instance)
   10.29  {
   10.30  	tpmif_t *tpmif;
   10.31  
   10.32 @@ -72,8 +69,7 @@ tpmif_find(domid_t domid, long int insta
   10.33  	return alloc_tpmif(domid, instance);
   10.34  }
   10.35  
   10.36 -static int
   10.37 -map_frontend_page(tpmif_t *tpmif, unsigned long shared_page)
   10.38 +static int map_frontend_page(tpmif_t *tpmif, unsigned long shared_page)
   10.39  {
   10.40  	int ret;
   10.41  	struct gnttab_map_grant_ref op = {
   10.42 @@ -99,8 +95,7 @@ map_frontend_page(tpmif_t *tpmif, unsign
   10.43  	return 0;
   10.44  }
   10.45  
   10.46 -static void
   10.47 -unmap_frontend_page(tpmif_t *tpmif)
   10.48 +static void unmap_frontend_page(tpmif_t *tpmif)
   10.49  {
   10.50  	struct gnttab_unmap_grant_ref op;
   10.51  	int ret;
   10.52 @@ -115,14 +110,14 @@ unmap_frontend_page(tpmif_t *tpmif)
   10.53  	BUG_ON(ret);
   10.54  }
   10.55  
   10.56 -int
   10.57 -tpmif_map(tpmif_t *tpmif, unsigned long shared_page, unsigned int evtchn)
   10.58 +int tpmif_map(tpmif_t *tpmif, unsigned long shared_page, unsigned int evtchn)
   10.59  {
   10.60  	int err;
   10.61  	evtchn_op_t op = {
   10.62  		.cmd = EVTCHNOP_bind_interdomain,
   10.63  		.u.bind_interdomain.remote_dom = tpmif->domid,
   10.64 -		.u.bind_interdomain.remote_port = evtchn };
   10.65 +		.u.bind_interdomain.remote_port = evtchn,
   10.66 +        };
   10.67  
   10.68          if (tpmif->irq) {
   10.69                  return 0;
   10.70 @@ -156,8 +151,7 @@ tpmif_map(tpmif_t *tpmif, unsigned long 
   10.71  	return 0;
   10.72  }
   10.73  
   10.74 -static void
   10.75 -__tpmif_disconnect_complete(void *arg)
   10.76 +static void __tpmif_disconnect_complete(void *arg)
   10.77  {
   10.78  	tpmif_t *tpmif = (tpmif_t *) arg;
   10.79  
   10.80 @@ -172,22 +166,19 @@ static void
   10.81  	free_tpmif(tpmif);
   10.82  }
   10.83  
   10.84 -void
   10.85 -tpmif_disconnect_complete(tpmif_t * tpmif)
   10.86 +void tpmif_disconnect_complete(tpmif_t * tpmif)
   10.87  {
   10.88  	INIT_WORK(&tpmif->work, __tpmif_disconnect_complete, (void *)tpmif);
   10.89  	schedule_work(&tpmif->work);
   10.90  }
   10.91  
   10.92 -void __init
   10.93 -tpmif_interface_init(void)
   10.94 +void __init tpmif_interface_init(void)
   10.95  {
   10.96  	tpmif_cachep = kmem_cache_create("tpmif_cache", sizeof (tpmif_t),
   10.97  					 0, 0, NULL, NULL);
   10.98  }
   10.99  
  10.100 -void __init
  10.101 -tpmif_interface_exit(void)
  10.102 +void __init tpmif_interface_exit(void)
  10.103  {
  10.104  	kmem_cache_destroy(tpmif_cachep);
  10.105  }

    11.1 --- a/linux-2.6-xen-sparse/drivers/xen/tpmback/tpmback.c	Mon Mar 06 09:09:18 2006 -0700
    11.2 +++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/tpmback.c	Mon Mar 06 10:21:35 2006 -0700
    11.3 @@ -22,17 +22,23 @@
    11.4  #include <xen/xenbus.h>
    11.5  #include <xen/interface/grant_table.h>
    11.6  
    11.7 -
    11.8  /* local data structures */
    11.9  struct data_exchange {
   11.10  	struct list_head pending_pak;
   11.11  	struct list_head current_pak;
   11.12  	unsigned int copied_so_far;
   11.13  	u8 has_opener;
   11.14 -	rwlock_t pak_lock;  // protects all of the previous fields
   11.15 +	rwlock_t pak_lock;	// protects all of the previous fields
   11.16  	wait_queue_head_t wait_queue;
   11.17  };
   11.18  
   11.19 +struct vtpm_resp_hdr {
   11.20 +	uint32_t instance_no;
   11.21 +	uint16_t tag_no;
   11.22 +	uint32_t len_no;
   11.23 +	uint32_t ordinal_no;
   11.24 +} __attribute__ ((packed));
   11.25 +
   11.26  struct packet {
   11.27  	struct list_head next;
   11.28  	unsigned int data_len;
   11.29 @@ -50,36 +56,43 @@ enum {
   11.30  	PACKET_FLAG_CHECK_RESPONSESTATUS = 2,
   11.31  };
   11.32  
   11.33 +/* local variables */
   11.34  static struct data_exchange dataex;
   11.35  
   11.36  /* local function prototypes */
   11.37 -static int vtpm_queue_packet(struct packet *pak);
   11.38  static int _packet_write(struct packet *pak,
   11.39 -                         const char *data, size_t size,
   11.40 -                         int userbuffer);
   11.41 +			 const char *data, size_t size, int userbuffer);
   11.42  static void processing_timeout(unsigned long ptr);
   11.43 -static int  packet_read_shmem(struct packet *pak,
   11.44 -                              tpmif_t *tpmif,
   11.45 -                              u32 offset,
   11.46 -                              char *buffer,
   11.47 -                              int isuserbuffer,
   11.48 -                              u32 left);
   11.49 -
   11.50 +static int packet_read_shmem(struct packet *pak,
   11.51 +			     tpmif_t * tpmif,
   11.52 +			     u32 offset,
   11.53 +			     char *buffer, int isuserbuffer, u32 left);
   11.54 +static int vtpm_queue_packet(struct packet *pak);
   11.55  
   11.56  #define MIN(x,y)  (x) < (y) ? (x) : (y)
   11.57  
   11.58 -
   11.59  /***************************************************************
   11.60 - Buffer copying
   11.61 + Buffer copying fo user and kernel space buffes.
   11.62  ***************************************************************/
   11.63 -static inline int
   11.64 -copy_from_buffer(void *to,
   11.65 -                 const void *from,
   11.66 -                 unsigned long size,
   11.67 -                 int userbuffer)
   11.68 +static inline int copy_from_buffer(void *to,
   11.69 +				   const void *from, unsigned long size,
   11.70 +				   int isuserbuffer)
   11.71  {
   11.72 -	if (userbuffer) {
   11.73 -		if (copy_from_user(to, from, size))
   11.74 +	if (isuserbuffer) {
   11.75 +		if (copy_from_user(to, (void __user *)from, size))
   11.76 +			return -EFAULT;
   11.77 +	} else {
   11.78 +		memcpy(to, from, size);
   11.79 +	}
   11.80 +	return 0;
   11.81 +}
   11.82 +
   11.83 +static inline int copy_to_buffer(void *to,
   11.84 +				 const void *from, unsigned long size,
   11.85 +				 int isuserbuffer)
   11.86 +{
   11.87 +	if (isuserbuffer) {
   11.88 +		if (copy_to_user((void __user *)to, from, size))
   11.89  			return -EFAULT;
   11.90  	} else {
   11.91  		memcpy(to, from, size);
   11.92 @@ -91,17 +104,19 @@ copy_from_buffer(void *to,
   11.93   Packet-related functions
   11.94  ***************************************************************/
   11.95  
   11.96 -static struct packet *
   11.97 -packet_find_instance(struct list_head *head, u32 tpm_instance)
   11.98 +static struct packet *packet_find_instance(struct list_head *head,
   11.99 +					   u32 tpm_instance)
  11.100  {
  11.101  	struct packet *pak;
  11.102  	struct list_head *p;
  11.103 +
  11.104  	/*
  11.105  	 * traverse the list of packets and return the first
  11.106  	 * one with the given instance number
  11.107  	 */
  11.108  	list_for_each(p, head) {
  11.109  		pak = list_entry(p, struct packet, next);
  11.110 +
  11.111  		if (pak->tpm_instance == tpm_instance) {
  11.112  			return pak;
  11.113  		}
  11.114 @@ -109,17 +124,18 @@ packet_find_instance(struct list_head *h
  11.115  	return NULL;
  11.116  }
  11.117  
  11.118 -static struct packet *
  11.119 -packet_find_packet(struct list_head *head, void *packet)
  11.120 +static struct packet *packet_find_packet(struct list_head *head, void *packet)
  11.121  {
  11.122  	struct packet *pak;
  11.123  	struct list_head *p;
  11.124 +
  11.125  	/*
  11.126  	 * traverse the list of packets and return the first
  11.127  	 * one with the given instance number
  11.128  	 */
  11.129  	list_for_each(p, head) {
  11.130  		pak = list_entry(p, struct packet, next);
  11.131 +
  11.132  		if (pak == packet) {
  11.133  			return pak;
  11.134  		}
  11.135 @@ -127,22 +143,20 @@ packet_find_packet(struct list_head *hea
  11.136  	return NULL;
  11.137  }
  11.138  
  11.139 -static struct packet *
  11.140 -packet_alloc(tpmif_t *tpmif, u32 size, u8 req_tag, u8 flags)
  11.141 +static struct packet *packet_alloc(tpmif_t * tpmif,
  11.142 +				   u32 size, u8 req_tag, u8 flags)
  11.143  {
  11.144  	struct packet *pak = NULL;
  11.145 -	pak = kmalloc(sizeof(struct packet),
  11.146 -                      GFP_KERNEL);
  11.147 +	pak = kzalloc(sizeof (struct packet), GFP_KERNEL);
  11.148  	if (NULL != pak) {
  11.149 -		memset(pak, 0x0, sizeof(*pak));
  11.150  		if (tpmif) {
  11.151  			pak->tpmif = tpmif;
  11.152  			pak->tpm_instance = tpmif->tpm_instance;
  11.153  		}
  11.154 -		pak->data_len  = size;
  11.155 -		pak->req_tag   = req_tag;
  11.156 +		pak->data_len = size;
  11.157 +		pak->req_tag = req_tag;
  11.158  		pak->last_read = 0;
  11.159 -		pak->flags     = flags;
  11.160 +		pak->flags = flags;
  11.161  
  11.162  		/*
  11.163  		 * cannot do tpmif_get(tpmif); bad things happen
  11.164 @@ -155,16 +169,16 @@ packet_alloc(tpmif_t *tpmif, u32 size, u
  11.165  	return pak;
  11.166  }
  11.167  
  11.168 -static void inline
  11.169 -packet_reset(struct packet *pak)
  11.170 +static void inline packet_reset(struct packet *pak)
  11.171  {
  11.172  	pak->last_read = 0;
  11.173  }
  11.174  
  11.175 -static void inline
  11.176 -packet_free(struct packet *pak)
  11.177 +static void packet_free(struct packet *pak)
  11.178  {
  11.179 -	del_singleshot_timer_sync(&pak->processing_timer);
  11.180 +	if (timer_pending(&pak->processing_timer)) {
  11.181 +		BUG();
  11.182 +	}
  11.183  	kfree(pak->data_buffer);
  11.184  	/*
  11.185  	 * cannot do tpmif_put(pak->tpmif); bad things happen
  11.186 @@ -173,13 +187,13 @@ packet_free(struct packet *pak)
  11.187  	kfree(pak);
  11.188  }
  11.189  
  11.190 -static int
  11.191 -packet_set(struct packet *pak,
  11.192 -           const unsigned char *buffer, u32 size)
  11.193 +static int packet_set(struct packet *pak,
  11.194 +		      const unsigned char *buffer, u32 size)
  11.195  {
  11.196  	int rc = 0;
  11.197  	unsigned char *buf = kmalloc(size, GFP_KERNEL);
  11.198 -	if (NULL != buf) {
  11.199 +
  11.200 +	if (buf) {
  11.201  		pak->data_buffer = buf;
  11.202  		memcpy(buf, buffer, size);
  11.203  		pak->data_len = size;
  11.204 @@ -189,27 +203,21 @@ packet_set(struct packet *pak,
  11.205  	return rc;
  11.206  }
  11.207  
  11.208 -
  11.209  /*
  11.210   * Write data to the shared memory and send it to the FE.
  11.211   */
  11.212 -static int
  11.213 -packet_write(struct packet *pak,
  11.214 -             const char *data, size_t size,
  11.215 -             int userbuffer)
  11.216 +static int packet_write(struct packet *pak,
  11.217 +			const char *data, size_t size, int isuserbuffer)
  11.218  {
  11.219  	int rc = 0;
  11.220  
  11.221 -	DPRINTK("Supposed to send %d bytes to front-end!\n",
  11.222 -	        size);
  11.223 -
  11.224 -	if (0 != (pak->flags & PACKET_FLAG_CHECK_RESPONSESTATUS)) {
  11.225 +	if ((pak->flags & PACKET_FLAG_CHECK_RESPONSESTATUS)) {
  11.226  #ifdef CONFIG_XEN_TPMDEV_CLOSE_IF_VTPM_FAILS
  11.227  		u32 res;
  11.228 +
  11.229  		if (copy_from_buffer(&res,
  11.230 -		                     &data[2+4],
  11.231 -		                     sizeof(res),
  11.232 -		                     userbuffer)) {
  11.233 +				     &data[2 + 4], sizeof (res),
  11.234 +				     isuserbuffer)) {
  11.235  			return -EFAULT;
  11.236  		}
  11.237  
  11.238 @@ -230,17 +238,14 @@ packet_write(struct packet *pak,
  11.239  		/* Don't send a respone to this packet. Just acknowledge it. */
  11.240  		rc = size;
  11.241  	} else {
  11.242 -		rc = _packet_write(pak, data, size, userbuffer);
  11.243 +		rc = _packet_write(pak, data, size, isuserbuffer);
  11.244  	}
  11.245  
  11.246  	return rc;
  11.247  }
  11.248  
  11.249 -
  11.250 -static int
  11.251 -_packet_write(struct packet *pak,
  11.252 -              const char *data, size_t size,
  11.253 -              int userbuffer)
  11.254 +int _packet_write(struct packet *pak,
  11.255 +		  const char *data, size_t size, int isuserbuffer)
  11.256  {
  11.257  	/*
  11.258  	 * Write into the shared memory pages directly
  11.259 @@ -254,7 +259,7 @@ static int
  11.260  
  11.261  	if (tpmif == NULL) {
  11.262  		return -EFAULT;
  11.263 -        }
  11.264 +	}
  11.265  
  11.266  	if (tpmif->status == DISCONNECTED) {
  11.267  		return size;
  11.268 @@ -273,16 +278,13 @@ static int
  11.269  			return 0;
  11.270  		}
  11.271  
  11.272 -		map_op.host_addr  = MMAP_VADDR(tpmif, i);
  11.273 -		map_op.flags      = GNTMAP_host_map;
  11.274 -		map_op.ref        = tx->ref;
  11.275 -		map_op.dom        = tpmif->domid;
  11.276 +		map_op.host_addr = MMAP_VADDR(tpmif, i);
  11.277 +		map_op.flags = GNTMAP_host_map;
  11.278 +		map_op.ref = tx->ref;
  11.279 +		map_op.dom = tpmif->domid;
  11.280  
  11.281 -		if(unlikely(
  11.282 -		    HYPERVISOR_grant_table_op(
  11.283 -		        GNTTABOP_map_grant_ref,
  11.284 -		        &map_op,
  11.285 -		        1))) {
  11.286 +		if (unlikely(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
  11.287 +						       &map_op, 1))) {
  11.288  			BUG();
  11.289  		}
  11.290  
  11.291 @@ -292,28 +294,27 @@ static int
  11.292  			DPRINTK(" Grant table operation failure !\n");
  11.293  			return 0;
  11.294  		}
  11.295 -		set_phys_to_machine(__pa(MMAP_VADDR(tpmif,i)) >> PAGE_SHIFT,
  11.296 -			FOREIGN_FRAME(map_op.dev_bus_addr >> PAGE_SHIFT));
  11.297 +		set_phys_to_machine(__pa(MMAP_VADDR(tpmif, i)) >> PAGE_SHIFT,
  11.298 +				    FOREIGN_FRAME(map_op.
  11.299 +						  dev_bus_addr >> PAGE_SHIFT));
  11.300  
  11.301  		tocopy = MIN(size - offset, PAGE_SIZE);
  11.302  
  11.303 -		if (copy_from_buffer((void *)(MMAP_VADDR(tpmif,i)|
  11.304 -		                     (tx->addr & ~PAGE_MASK)),
  11.305 -		                     &data[offset],
  11.306 -		                     tocopy,
  11.307 -		                     userbuffer)) {
  11.308 +		if (copy_from_buffer((void *)(MMAP_VADDR(tpmif, i) |
  11.309 +					      (tx->addr & ~PAGE_MASK)),
  11.310 +				     &data[offset], tocopy, isuserbuffer)) {
  11.311  			tpmif_put(tpmif);
  11.312  			return -EFAULT;
  11.313  		}
  11.314  		tx->size = tocopy;
  11.315  
  11.316 -		unmap_op.host_addr    = MMAP_VADDR(tpmif, i);
  11.317 -		unmap_op.handle       = handle;
  11.318 +		unmap_op.host_addr = MMAP_VADDR(tpmif, i);
  11.319 +		unmap_op.handle = handle;
  11.320  		unmap_op.dev_bus_addr = 0;
  11.321  
  11.322 -		if(unlikely(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,
  11.323 -		                                      &unmap_op,
  11.324 -		                                      1))) {
  11.325 +		if (unlikely
  11.326 +		    (HYPERVISOR_grant_table_op
  11.327 +		     (GNTTABOP_unmap_grant_ref, &unmap_op, 1))) {
  11.328  			BUG();
  11.329  		}
  11.330  
  11.331 @@ -322,8 +323,7 @@ static int
  11.332  	}
  11.333  
  11.334  	rc = offset;
  11.335 -	DPRINTK("Notifying frontend via irq %d\n",
  11.336 -	        tpmif->irq);
  11.337 +	DPRINTK("Notifying frontend via irq %d\n", tpmif->irq);
  11.338  	notify_remote_via_irq(tpmif->irq);
  11.339  
  11.340  	return rc;
  11.341 @@ -334,26 +334,19 @@ static int
  11.342   * provided buffer. Advance the read_last indicator which tells
  11.343   * how many bytes have already been read.
  11.344   */
  11.345 -static int
  11.346 -packet_read(struct packet *pak, size_t numbytes,
  11.347 -            char *buffer, size_t buffersize,
  11.348 -            int userbuffer)
  11.349 +static int packet_read(struct packet *pak, size_t numbytes,
  11.350 +		       char *buffer, size_t buffersize, int isuserbuffer)
  11.351  {
  11.352  	tpmif_t *tpmif = pak->tpmif;
  11.353 +
  11.354  	/*
  11.355 -	 * I am supposed to read 'numbytes' of data from the
  11.356 -	 * buffer.
  11.357 -	 * The first 4 bytes that are read are the instance number in
  11.358 -	 * network byte order, after that comes the data from the
  11.359 -	 * shared memory buffer.
  11.360 +	 * Read 'numbytes' of data from the buffer. The first 4
  11.361 +	 * bytes are the instance number in network byte order,
  11.362 +	 * after that come the data from the shared memory buffer.
  11.363  	 */
  11.364  	u32 to_copy;
  11.365  	u32 offset = 0;
  11.366  	u32 room_left = buffersize;
  11.367 -	/*
  11.368 -	 * Ensure that we see the request when we copy it.
  11.369 -	 */
  11.370 -	mb();
  11.371  
  11.372  	if (pak->last_read < 4) {
  11.373  		/*
  11.374 @@ -361,18 +354,13 @@ packet_read(struct packet *pak, size_t n
  11.375  		 */
  11.376  		u32 instance_no = htonl(pak->tpm_instance);
  11.377  		u32 last_read = pak->last_read;
  11.378 +
  11.379  		to_copy = MIN(4 - last_read, numbytes);
  11.380  
  11.381 -		if (userbuffer) {
  11.382 -			if (copy_to_user(&buffer[0],
  11.383 -			                 &(((u8 *)&instance_no)[last_read]),
  11.384 -			                 to_copy)) {
  11.385 -				return -EFAULT;
  11.386 -			}
  11.387 -		} else {
  11.388 -			memcpy(&buffer[0],
  11.389 -			       &(((u8 *)&instance_no)[last_read]),
  11.390 -			       to_copy);
  11.391 +		if (copy_to_buffer(&buffer[0],
  11.392 +				   &(((u8 *) & instance_no)[last_read]),
  11.393 +				   to_copy, isuserbuffer)) {
  11.394 +			return -EFAULT;
  11.395  		}
  11.396  
  11.397  		pak->last_read += to_copy;
  11.398 @@ -388,39 +376,30 @@ packet_read(struct packet *pak, size_t n
  11.399  		if (pak->data_buffer) {
  11.400  			u32 to_copy = MIN(pak->data_len - offset, room_left);
  11.401  			u32 last_read = pak->last_read - 4;
  11.402 -			if (userbuffer) {
  11.403 -				if (copy_to_user(&buffer[offset],
  11.404 -				                 &pak->data_buffer[last_read],
  11.405 -				                 to_copy)) {
  11.406 -					return -EFAULT;
  11.407 -				}
  11.408 -			} else {
  11.409 -				memcpy(&buffer[offset],
  11.410 -				       &pak->data_buffer[last_read],
  11.411 -				       to_copy);
  11.412 +
  11.413 +			if (copy_to_buffer(&buffer[offset],
  11.414 +					   &pak->data_buffer[last_read],
  11.415 +					   to_copy, isuserbuffer)) {
  11.416 +				return -EFAULT;
  11.417  			}
  11.418  			pak->last_read += to_copy;
  11.419  			offset += to_copy;
  11.420  		} else {
  11.421  			offset = packet_read_shmem(pak,
  11.422 -			                           tpmif,
  11.423 -			                           offset,
  11.424 -			                           buffer,
  11.425 -			                           userbuffer,
  11.426 -			                           room_left);
  11.427 +						   tpmif,
  11.428 +						   offset,
  11.429 +						   buffer,
  11.430 +						   isuserbuffer, room_left);
  11.431  		}
  11.432  	}
  11.433  	return offset;
  11.434  }
  11.435  
  11.436 -
  11.437 -static int
  11.438 -packet_read_shmem(struct packet *pak,
  11.439 -                  tpmif_t *tpmif,
  11.440 -                  u32 offset,
  11.441 -                  char *buffer,
  11.442 -                  int isuserbuffer,
  11.443 -                  u32 room_left) {
  11.444 +static int packet_read_shmem(struct packet *pak,
  11.445 +			     tpmif_t * tpmif,
  11.446 +			     u32 offset, char *buffer, int isuserbuffer,
  11.447 +			     u32 room_left)
  11.448 +{
  11.449  	u32 last_read = pak->last_read - 4;
  11.450  	u32 i = (last_read / PAGE_SIZE);
  11.451  	u32 pg_offset = last_read & (PAGE_SIZE - 1);
  11.452 @@ -428,6 +407,7 @@ packet_read_shmem(struct packet *pak,
  11.453  	grant_handle_t handle;
  11.454  
  11.455  	tpmif_tx_request_t *tx;
  11.456 +
  11.457  	tx = &tpmif->tx->ring[0].req;
  11.458  	/*
  11.459  	 * Start copying data at the page with index 'index'
  11.460 @@ -443,13 +423,12 @@ packet_read_shmem(struct packet *pak,
  11.461  		tx = &tpmif->tx->ring[i].req;
  11.462  
  11.463  		map_op.host_addr = MMAP_VADDR(tpmif, i);
  11.464 -		map_op.flags     = GNTMAP_host_map;
  11.465 -		map_op.ref       = tx->ref;
  11.466 -		map_op.dom       = tpmif->domid;
  11.467 +		map_op.flags = GNTMAP_host_map;
  11.468 +		map_op.ref = tx->ref;
  11.469 +		map_op.dom = tpmif->domid;
  11.470  
  11.471 -		if(unlikely(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
  11.472 -		                                      &map_op,
  11.473 -		                                      1))) {
  11.474 +		if (unlikely(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
  11.475 +						       &map_op, 1))) {
  11.476  			BUG();
  11.477  		}
  11.478  
  11.479 @@ -462,41 +441,33 @@ packet_read_shmem(struct packet *pak,
  11.480  
  11.481  		if (to_copy > tx->size) {
  11.482  			/*
  11.483 -			 * This is the case when the user wants to read more
  11.484 -			 * than what we have. So we just give him what we
  11.485 -			 * have.
  11.486 +			 * User requests more than what's available
  11.487  			 */
  11.488  			to_copy = MIN(tx->size, to_copy);
  11.489  		}
  11.490  
  11.491  		DPRINTK("Copying from mapped memory at %08lx\n",
  11.492 -		        (unsigned long)(MMAP_VADDR(tpmif,i) |
  11.493 -			(tx->addr & ~PAGE_MASK)));
  11.494 +			(unsigned long)(MMAP_VADDR(tpmif, i) |
  11.495 +					(tx->addr & ~PAGE_MASK)));
  11.496  
  11.497 -		src = (void *)(MMAP_VADDR(tpmif,i) | ((tx->addr & ~PAGE_MASK) + pg_offset));
  11.498 -		if (isuserbuffer) {
  11.499 -			if (copy_to_user(&buffer[offset],
  11.500 -			                 src,
  11.501 -			                 to_copy)) {
  11.502 -				return -EFAULT;
  11.503 -			}
  11.504 -		} else {
  11.505 -			memcpy(&buffer[offset],
  11.506 -			       src,
  11.507 -			       to_copy);
  11.508 +		src = (void *)(MMAP_VADDR(tpmif, i) |
  11.509 +			       ((tx->addr & ~PAGE_MASK) + pg_offset));
  11.510 +		if (copy_to_buffer(&buffer[offset],
  11.511 +				   src, to_copy, isuserbuffer)) {
  11.512 +			return -EFAULT;
  11.513  		}
  11.514  
  11.515 +		DPRINTK("Data from TPM-FE of domain %d are %d %d %d %d\n",
  11.516 +			tpmif->domid, buffer[offset], buffer[offset + 1],
  11.517 +			buffer[offset + 2], buffer[offset + 3]);
  11.518  
  11.519 -		DPRINTK("Data from TPM-FE of domain %d are %d %d %d %d\n",
  11.520 -		        tpmif->domid, buffer[offset], buffer[offset+1],buffer[offset+2],buffer[offset+3]);
  11.521 -
  11.522 -		unmap_op.host_addr    = MMAP_VADDR(tpmif, i);
  11.523 -		unmap_op.handle       = handle;
  11.524 +		unmap_op.host_addr = MMAP_VADDR(tpmif, i);
  11.525 +		unmap_op.handle = handle;
  11.526  		unmap_op.dev_bus_addr = 0;
  11.527  
  11.528 -		if(unlikely(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,
  11.529 -		                                      &unmap_op,
  11.530 -		                                      1))) {
  11.531 +		if (unlikely
  11.532 +		    (HYPERVISOR_grant_table_op
  11.533 +		     (GNTTABOP_unmap_grant_ref, &unmap_op, 1))) {
  11.534  			BUG();
  11.535  		}
  11.536  
  11.537 @@ -507,7 +478,7 @@ packet_read_shmem(struct packet *pak,
  11.538  
  11.539  		to_copy = MIN(PAGE_SIZE, room_left);
  11.540  		i++;
  11.541 -	} /* while (to_copy > 0) */
  11.542 +	}			/* while (to_copy > 0) */
  11.543  	/*
  11.544  	 * Adjust the last_read pointer
  11.545  	 */
  11.546 @@ -515,13 +486,11 @@ packet_read_shmem(struct packet *pak,
  11.547  	return offset;
  11.548  }
  11.549  
  11.550 -
  11.551  /* ============================================================
  11.552   * The file layer for reading data from this device
  11.553   * ============================================================
  11.554   */
  11.555 -static int
  11.556 -vtpm_op_open(struct inode *inode, struct file *f)
  11.557 +static int vtpm_op_open(struct inode *inode, struct file *f)
  11.558  {
  11.559  	int rc = 0;
  11.560  	unsigned long flags;
  11.561 @@ -536,9 +505,8 @@ vtpm_op_open(struct inode *inode, struct
  11.562  	return rc;
  11.563  }
  11.564  
  11.565 -static ssize_t
  11.566 -vtpm_op_read(struct file *file,
  11.567 -	     char __user * data, size_t size, loff_t * offset)
  11.568 +static ssize_t vtpm_op_read(struct file *file,
  11.569 +			    char __user * data, size_t size, loff_t * offset)
  11.570  {
  11.571  	int ret_size = -ENODATA;
  11.572  	struct packet *pak = NULL;
  11.573 @@ -549,7 +517,7 @@ vtpm_op_read(struct file *file,
  11.574  	if (list_empty(&dataex.pending_pak)) {
  11.575  		write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.576  		wait_event_interruptible(dataex.wait_queue,
  11.577 -		                         !list_empty(&dataex.pending_pak));
  11.578 +					 !list_empty(&dataex.pending_pak));
  11.579  		write_lock_irqsave(&dataex.pak_lock, flags);
  11.580  	}
  11.581  
  11.582 @@ -561,7 +529,7 @@ vtpm_op_read(struct file *file,
  11.583  
  11.584  		DPRINTK("size given by app: %d, available: %d\n", size, left);
  11.585  
  11.586 -		ret_size = MIN(size,left);
  11.587 +		ret_size = MIN(size, left);
  11.588  
  11.589  		ret_size = packet_read(pak, ret_size, data, size, 1);
  11.590  		if (ret_size < 0) {
  11.591 @@ -574,7 +542,8 @@ vtpm_op_read(struct file *file,
  11.592  				DPRINTK("All data from this packet given to app.\n");
  11.593  				/* All data given to app */
  11.594  
  11.595 -				del_singleshot_timer_sync(&pak->processing_timer);
  11.596 +				del_singleshot_timer_sync(&pak->
  11.597 +							  processing_timer);
  11.598  				list_del(&pak->next);
  11.599  				list_add_tail(&pak->next, &dataex.current_pak);
  11.600  				/*
  11.601 @@ -582,7 +551,7 @@ vtpm_op_read(struct file *file,
  11.602  				 * the more time we give the TPM to process the request.
  11.603  				 */
  11.604  				mod_timer(&pak->processing_timer,
  11.605 -				          jiffies + (num_frontends * 60 * HZ));
  11.606 +					  jiffies + (num_frontends * 60 * HZ));
  11.607  				dataex.copied_so_far = 0;
  11.608  			}
  11.609  		}
  11.610 @@ -597,16 +566,15 @@ vtpm_op_read(struct file *file,
  11.611  /*
  11.612   * Write operation - only works after a previous read operation!
  11.613   */
  11.614 -static ssize_t
  11.615 -vtpm_op_write(struct file *file, const char __user * data, size_t size,
  11.616 -	      loff_t * offset)
  11.617 +static ssize_t vtpm_op_write(struct file *file,
  11.618 +			     const char __user * data, size_t size,
  11.619 +			     loff_t * offset)
  11.620  {
  11.621  	struct packet *pak;
  11.622  	int rc = 0;
  11.623  	unsigned int off = 4;
  11.624  	unsigned long flags;
  11.625 -	u32 instance_no = 0;
  11.626 -	u32 len_no = 0;
  11.627 +	struct vtpm_resp_hdr vrh;
  11.628  
  11.629  	/*
  11.630  	 * Minimum required packet size is:
  11.631 @@ -616,45 +584,38 @@ vtpm_op_write(struct file *file, const c
  11.632  	 * 4 bytes for the ordinal
  11.633  	 * sum: 14 bytes
  11.634  	 */
  11.635 -	if ( size < off + 10 ) {
  11.636 +	if (size < sizeof (vrh))
  11.637  		return -EFAULT;
  11.638 -	}
  11.639 +
  11.640 +	if (copy_from_user(&vrh, data, sizeof (vrh)))
  11.641 +		return -EFAULT;
  11.642  
  11.643 -	if (copy_from_user(&instance_no,
  11.644 -	                   (void __user *)&data[0],
  11.645 -	                   4)) {
  11.646 +	/* malformed packet? */
  11.647 +	if ((off + ntohl(vrh.len_no)) != size)
  11.648 +		return -EFAULT;
  11.649 +
  11.650 +	write_lock_irqsave(&dataex.pak_lock, flags);
  11.651 +	pak = packet_find_instance(&dataex.current_pak,
  11.652 +				   ntohl(vrh.instance_no));
  11.653 +
  11.654 +	if (pak == NULL) {
  11.655 +		write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.656 +		printk(KERN_ALERT "No associated packet! (inst=%d)\n",
  11.657 +		       ntohl(vrh.instance_no));
  11.658  		return -EFAULT;
  11.659  	}
  11.660  
  11.661 -	if (copy_from_user(&len_no,
  11.662 -	                   (void __user *)&data[off+2],
  11.663 -	                   4) ||
  11.664 -	    (off + ntohl(len_no) != size)) {
  11.665 -		return -EFAULT;
  11.666 -	}
  11.667 -
  11.668 -	write_lock_irqsave(&dataex.pak_lock, flags);
  11.669 -	pak = packet_find_instance(&dataex.current_pak, ntohl(instance_no));
  11.670 -
  11.671 -	if (pak == NULL) {
  11.672 -		write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.673 -		printk(KERN_ALERT "No associated packet!\n");
  11.674 -		return -EFAULT;
  11.675 -	} else {
  11.676 -		del_singleshot_timer_sync(&pak->processing_timer);
  11.677 -		list_del(&pak->next);
  11.678 -	}
  11.679 +	del_singleshot_timer_sync(&pak->processing_timer);
  11.680 +	list_del(&pak->next);
  11.681  
  11.682  	write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.683  
  11.684  	/*
  11.685 -	 * The first 'offset' bytes must be the instance number.
  11.686 -	 * I will just pull that from the packet.
  11.687 +	 * The first 'offset' bytes must be the instance number - skip them.
  11.688  	 */
  11.689  	size -= off;
  11.690 -	data = &data[off];
  11.691  
  11.692 -	rc = packet_write(pak, data, size, 1);
  11.693 +	rc = packet_write(pak, &data[off], size, 1);
  11.694  
  11.695  	if (rc > 0) {
  11.696  		/* I neglected the first 4 bytes */
  11.697 @@ -664,10 +625,10 @@ vtpm_op_write(struct file *file, const c
  11.698  	return rc;
  11.699  }
  11.700  
  11.701 -static int
  11.702 -vtpm_op_release(struct inode *inode, struct file *file)
  11.703 +static int vtpm_op_release(struct inode *inode, struct file *file)
  11.704  {
  11.705  	unsigned long flags;
  11.706 +
  11.707  	vtpm_release_packets(NULL, 1);
  11.708  	write_lock_irqsave(&dataex.pak_lock, flags);
  11.709  	dataex.has_opener = 0;
  11.710 @@ -675,10 +636,11 @@ vtpm_op_release(struct inode *inode, str
  11.711  	return 0;
  11.712  }
  11.713  
  11.714 -static unsigned int
  11.715 -vtpm_op_poll(struct file *file, struct poll_table_struct *pts)
  11.716 +static unsigned int vtpm_op_poll(struct file *file,
  11.717 +				 struct poll_table_struct *pts)
  11.718  {
  11.719  	unsigned int flags = POLLOUT | POLLWRNORM;
  11.720 +
  11.721  	poll_wait(file, &dataex.wait_queue, pts);
  11.722  	if (!list_empty(&dataex.pending_pak)) {
  11.723  		flags |= POLLIN | POLLRDNORM;
  11.724 @@ -696,54 +658,47 @@ static struct file_operations vtpm_ops =
  11.725  	.poll = vtpm_op_poll,
  11.726  };
  11.727  
  11.728 -static struct miscdevice ibmvtpms_miscdevice = {
  11.729 +static struct miscdevice vtpms_miscdevice = {
  11.730  	.minor = 225,
  11.731  	.name = "vtpm",
  11.732  	.fops = &vtpm_ops,
  11.733  };
  11.734  
  11.735 -
  11.736  /***************************************************************
  11.737   Virtual TPM functions and data stuctures
  11.738  ***************************************************************/
  11.739  
  11.740  static u8 create_cmd[] = {
  11.741 -        1,193,		/* 0: TPM_TAG_RQU_COMMAMD */
  11.742 -        0,0,0,19,	/* 2: length */
  11.743 -        0,0,0,0x1,	/* 6: VTPM_ORD_OPEN */
  11.744 -        0,		/* 10: VTPM type */
  11.745 -        0,0,0,0,	/* 11: domain id */
  11.746 -        0,0,0,0		/* 15: instance id */
  11.747 +	1, 193,			/* 0: TPM_TAG_RQU_COMMAMD */
  11.748 +	0, 0, 0, 19,		/* 2: length */
  11.749 +	0, 0, 0, 0x1,		/* 6: VTPM_ORD_OPEN */
  11.750 +	0,			/* 10: VTPM type */
  11.751 +	0, 0, 0, 0,		/* 11: domain id */
  11.752 +	0, 0, 0, 0		/* 15: instance id */
  11.753  };
  11.754  
  11.755 -static u8 destroy_cmd[] = {
  11.756 -        1,193,		/* 0: TPM_TAG_RQU_COMMAMD */
  11.757 -        0,0,0,14,	/* 2: length */
  11.758 -        0,0,0,0x2,	/* 6: VTPM_ORD_CLOSE */
  11.759 -        0,0,0,0		/* 10: instance id */
  11.760 -};
  11.761 -
  11.762 -int tpmif_vtpm_open(tpmif_t *tpmif, domid_t domid, u32 instance)
  11.763 +int tpmif_vtpm_open(tpmif_t * tpmif, domid_t domid, u32 instance)
  11.764  {
  11.765  	int rc = 0;
  11.766  	struct packet *pak;
  11.767  
  11.768  	pak = packet_alloc(tpmif,
  11.769 -	                   sizeof(create_cmd),
  11.770 -	                   create_cmd[0],
  11.771 -	                   PACKET_FLAG_DISCARD_RESPONSE|
  11.772 -	                   PACKET_FLAG_CHECK_RESPONSESTATUS);
  11.773 +			   sizeof (create_cmd),
  11.774 +			   create_cmd[1],
  11.775 +			   PACKET_FLAG_DISCARD_RESPONSE |
  11.776 +			   PACKET_FLAG_CHECK_RESPONSESTATUS);
  11.777  	if (pak) {
  11.778 -		u8 buf[sizeof(create_cmd)];
  11.779 -		u32 domid_no = htonl((u32)domid);
  11.780 +		u8 buf[sizeof (create_cmd)];
  11.781 +		u32 domid_no = htonl((u32) domid);
  11.782  		u32 instance_no = htonl(instance);
  11.783 -		memcpy(buf, create_cmd, sizeof(create_cmd));
  11.784 +
  11.785 +		memcpy(buf, create_cmd, sizeof (create_cmd));
  11.786  
  11.787 -		memcpy(&buf[11], &domid_no, sizeof(u32));
  11.788 -		memcpy(&buf[15], &instance_no, sizeof(u32));
  11.789 +		memcpy(&buf[11], &domid_no, sizeof (u32));
  11.790 +		memcpy(&buf[15], &instance_no, sizeof (u32));
  11.791  
  11.792  		/* copy the buffer into the packet */
  11.793 -		rc = packet_set(pak, buf, sizeof(buf));
  11.794 +		rc = packet_set(pak, buf, sizeof (buf));
  11.795  
  11.796  		if (rc == 0) {
  11.797  			pak->tpm_instance = 0;
  11.798 @@ -759,23 +714,30 @@ int tpmif_vtpm_open(tpmif_t *tpmif, domi
  11.799  	return rc;
  11.800  }
  11.801  
  11.802 +static u8 destroy_cmd[] = {
  11.803 +	1, 193,			/* 0: TPM_TAG_RQU_COMMAMD */
  11.804 +	0, 0, 0, 14,		/* 2: length */
  11.805 +	0, 0, 0, 0x2,		/* 6: VTPM_ORD_CLOSE */
  11.806 +	0, 0, 0, 0		/* 10: instance id */
  11.807 +};
  11.808 +
  11.809  int tpmif_vtpm_close(u32 instid)
  11.810  {
  11.811  	int rc = 0;
  11.812  	struct packet *pak;
  11.813  
  11.814  	pak = packet_alloc(NULL,
  11.815 -	                   sizeof(create_cmd),
  11.816 -	                   create_cmd[0],
  11.817 -	                   PACKET_FLAG_DISCARD_RESPONSE);
  11.818 +			   sizeof (destroy_cmd),
  11.819 +			   destroy_cmd[1], PACKET_FLAG_DISCARD_RESPONSE);
  11.820  	if (pak) {
  11.821 -		u8 buf[sizeof(destroy_cmd)];
  11.822 +		u8 buf[sizeof (destroy_cmd)];
  11.823  		u32 instid_no = htonl(instid);
  11.824 -		memcpy(buf, destroy_cmd, sizeof(destroy_cmd));
  11.825 -		memcpy(&buf[10], &instid_no, sizeof(u32));
  11.826 +
  11.827 +		memcpy(buf, destroy_cmd, sizeof (destroy_cmd));
  11.828 +		memcpy(&buf[10], &instid_no, sizeof (u32));
  11.829  
  11.830  		/* copy the buffer into the packet */
  11.831 -		rc = packet_set(pak, buf, sizeof(buf));
  11.832 +		rc = packet_set(pak, buf, sizeof (buf));
  11.833  
  11.834  		if (rc == 0) {
  11.835  			pak->tpm_instance = 0;
  11.836 @@ -791,23 +753,22 @@ int tpmif_vtpm_close(u32 instid)
  11.837  	return rc;
  11.838  }
  11.839  
  11.840 -
  11.841  /***************************************************************
  11.842   Utility functions
  11.843  ***************************************************************/
  11.844  
  11.845 -static int
  11.846 -tpm_send_fail_message(struct packet *pak, u8 req_tag)
  11.847 +static int tpm_send_fail_message(struct packet *pak, u8 req_tag)
  11.848  {
  11.849  	int rc;
  11.850  	static const unsigned char tpm_error_message_fail[] = {
  11.851  		0x00, 0x00,
  11.852  		0x00, 0x00, 0x00, 0x0a,
  11.853 -		0x00, 0x00, 0x00, 0x09 /* TPM_FAIL */
  11.854 +		0x00, 0x00, 0x00, 0x09	/* TPM_FAIL */
  11.855  	};
  11.856 -	unsigned char buffer[sizeof(tpm_error_message_fail)];
  11.857 +	unsigned char buffer[sizeof (tpm_error_message_fail)];
  11.858  
  11.859 -	memcpy(buffer, tpm_error_message_fail, sizeof(tpm_error_message_fail));
  11.860 +	memcpy(buffer, tpm_error_message_fail,
  11.861 +	       sizeof (tpm_error_message_fail));
  11.862  	/*
  11.863  	 * Insert the right response tag depending on the given tag
  11.864  	 * All response tags are '+3' to the request tag.
  11.865 @@ -817,23 +778,24 @@ tpm_send_fail_message(struct packet *pak
  11.866  	/*
  11.867  	 * Write the data to shared memory and notify the front-end
  11.868  	 */
  11.869 -	rc = packet_write(pak, buffer, sizeof(buffer), 0);
  11.870 +	rc = packet_write(pak, buffer, sizeof (buffer), 0);
  11.871  
  11.872  	return rc;
  11.873  }
  11.874  
  11.875 -
  11.876 -static void
  11.877 -_vtpm_release_packets(struct list_head *head, tpmif_t *tpmif,
  11.878 -                      int send_msgs)
  11.879 +static void _vtpm_release_packets(struct list_head *head,
  11.880 +				  tpmif_t * tpmif, int send_msgs)
  11.881  {
  11.882  	struct packet *pak;
  11.883 -	struct list_head *pos, *tmp;
  11.884 +	struct list_head *pos,
  11.885 +	         *tmp;
  11.886  
  11.887  	list_for_each_safe(pos, tmp, head) {
  11.888  		pak = list_entry(pos, struct packet, next);
  11.889 +
  11.890  		if (tpmif == NULL || pak->tpmif == tpmif) {
  11.891  			int can_send = 0;
  11.892 +
  11.893  			del_singleshot_timer_sync(&pak->processing_timer);
  11.894  			list_del(&pak->next);
  11.895  
  11.896 @@ -849,9 +811,7 @@ static void
  11.897  	}
  11.898  }
  11.899  
  11.900 -
  11.901 -int
  11.902 -vtpm_release_packets(tpmif_t *tpmif, int send_msgs)
  11.903 +int vtpm_release_packets(tpmif_t * tpmif, int send_msgs)
  11.904  {
  11.905  	unsigned long flags;
  11.906  
  11.907 @@ -860,23 +820,22 @@ vtpm_release_packets(tpmif_t *tpmif, int
  11.908  	_vtpm_release_packets(&dataex.pending_pak, tpmif, send_msgs);
  11.909  	_vtpm_release_packets(&dataex.current_pak, tpmif, send_msgs);
  11.910  
  11.911 -	write_unlock_irqrestore(&dataex.pak_lock,
  11.912 -	                        flags);
  11.913 +	write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.914  	return 0;
  11.915  }
  11.916  
  11.917 -
  11.918  static int vtpm_queue_packet(struct packet *pak)
  11.919  {
  11.920  	int rc = 0;
  11.921 +
  11.922  	if (dataex.has_opener) {
  11.923  		unsigned long flags;
  11.924 +
  11.925  		write_lock_irqsave(&dataex.pak_lock, flags);
  11.926  		list_add_tail(&pak->next, &dataex.pending_pak);
  11.927  		/* give the TPM some time to pick up the request */
  11.928  		mod_timer(&pak->processing_timer, jiffies + (30 * HZ));
  11.929 -		write_unlock_irqrestore(&dataex.pak_lock,
  11.930 -		                        flags);
  11.931 +		write_unlock_irqrestore(&dataex.pak_lock, flags);
  11.932  
  11.933  		wake_up_interruptible(&dataex.wait_queue);
  11.934  	} else {
  11.935 @@ -885,24 +844,22 @@ static int vtpm_queue_packet(struct pack
  11.936  	return rc;
  11.937  }
  11.938  
  11.939 -
  11.940 -static int vtpm_receive(tpmif_t *tpmif, u32 size)
  11.941 +static int vtpm_receive(tpmif_t * tpmif, u32 size)
  11.942  {
  11.943  	int rc = 0;
  11.944  	unsigned char buffer[10];
  11.945  	__be32 *native_size;
  11.946 +	struct packet *pak = packet_alloc(tpmif, size, 0, 0);
  11.947  
  11.948 -	struct packet *pak = packet_alloc(tpmif, size, buffer[4], 0);
  11.949 -	if (NULL == pak) {
  11.950 +	if (!pak)
  11.951  		return -ENOMEM;
  11.952 -	}
  11.953  	/*
  11.954  	 * Read 10 bytes from the received buffer to test its
  11.955  	 * content for validity.
  11.956  	 */
  11.957 -	if (sizeof(buffer) != packet_read(pak,
  11.958 -	                                  sizeof(buffer), buffer,
  11.959 -	                                  sizeof(buffer), 0)) {
  11.960 +	if (sizeof (buffer) != packet_read(pak,
  11.961 +					   sizeof (buffer), buffer,
  11.962 +					   sizeof (buffer), 0)) {
  11.963  		goto failexit;
  11.964  	}
  11.965  	/*
  11.966 @@ -911,7 +868,7 @@ static int vtpm_receive(tpmif_t *tpmif, 
  11.967  	 */
  11.968  	packet_reset(pak);
  11.969  
  11.970 -	native_size = (__force __be32 *)(&buffer[4+2]);
  11.971 +	native_size = (__force __be32 *) (&buffer[4 + 2]);
  11.972  	/*
  11.973  	 * Verify that the size of the packet is correct
  11.974  	 * as indicated and that there's actually someone reading packets.
  11.975 @@ -920,26 +877,24 @@ static int vtpm_receive(tpmif_t *tpmif, 
  11.976  	 */
  11.977  	if (size < 10 ||
  11.978  	    be32_to_cpu(*native_size) != size ||
  11.979 -	    0 == dataex.has_opener ||
  11.980 -	    tpmif->status != CONNECTED) {
  11.981 -	    	rc = -EINVAL;
  11.982 -	    	goto failexit;
  11.983 +	    0 == dataex.has_opener || tpmif->status != CONNECTED) {
  11.984 +		rc = -EINVAL;
  11.985 +		goto failexit;
  11.986  	} else {
  11.987 -		if ((rc = vtpm_queue_packet(pak)) < 0) {
  11.988 +		rc = vtpm_queue_packet(pak);
  11.989 +		if (rc < 0)
  11.990  			goto failexit;
  11.991 -		}
  11.992  	}
  11.993  	return 0;
  11.994  
  11.995 -failexit:
  11.996 +      failexit:
  11.997  	if (pak) {
  11.998 -		tpm_send_fail_message(pak, buffer[4+1]);
  11.999 +		tpm_send_fail_message(pak, buffer[4 + 1]);
 11.1000  		packet_free(pak);
 11.1001  	}
 11.1002  	return rc;
 11.1003  }
 11.1004  
 11.1005 -
 11.1006  /*
 11.1007   * Timeout function that gets invoked when a packet has not been processed
 11.1008   * during the timeout period.
 11.1009 @@ -951,44 +906,42 @@ static void processing_timeout(unsigned 
 11.1010  {
 11.1011  	struct packet *pak = (struct packet *)ptr;
 11.1012  	unsigned long flags;
 11.1013 +
 11.1014  	write_lock_irqsave(&dataex.pak_lock, flags);
 11.1015  	/*
 11.1016  	 * The packet needs to be searched whether it
 11.1017  	 * is still on the list.
 11.1018  	 */
 11.1019  	if (pak == packet_find_packet(&dataex.pending_pak, pak) ||
 11.1020 -	    pak == packet_find_packet(&dataex.current_pak, pak) ) {
 11.1021 +	    pak == packet_find_packet(&dataex.current_pak, pak)) {
 11.1022  		list_del(&pak->next);
 11.1023 -		tpm_send_fail_message(pak, pak->req_tag);
 11.1024 +		if ((pak->flags & PACKET_FLAG_DISCARD_RESPONSE) == 0) {
 11.1025 +			tpm_send_fail_message(pak, pak->req_tag);
 11.1026 +		}
 11.1027  		packet_free(pak);
 11.1028  	}
 11.1029  
 11.1030  	write_unlock_irqrestore(&dataex.pak_lock, flags);
 11.1031  }
 11.1032  
 11.1033 -
 11.1034 -
 11.1035  static void tpm_tx_action(unsigned long unused);
 11.1036  static DECLARE_TASKLET(tpm_tx_tasklet, tpm_tx_action, 0);
 11.1037  
 11.1038  static struct list_head tpm_schedule_list;
 11.1039  static spinlock_t tpm_schedule_list_lock;
 11.1040  
 11.1041 -static inline void
 11.1042 -maybe_schedule_tx_action(void)
 11.1043 +static inline void maybe_schedule_tx_action(void)
 11.1044  {
 11.1045  	smp_mb();
 11.1046  	tasklet_schedule(&tpm_tx_tasklet);
 11.1047  }
 11.1048  
 11.1049 -static inline int
 11.1050 -__on_tpm_schedule_list(tpmif_t * tpmif)
 11.1051 +static inline int __on_tpm_schedule_list(tpmif_t * tpmif)
 11.1052  {
 11.1053  	return tpmif->list.next != NULL;
 11.1054  }
 11.1055  
 11.1056 -static void
 11.1057 -remove_from_tpm_schedule_list(tpmif_t * tpmif)
 11.1058 +static void remove_from_tpm_schedule_list(tpmif_t * tpmif)
 11.1059  {
 11.1060  	spin_lock_irq(&tpm_schedule_list_lock);
 11.1061  	if (likely(__on_tpm_schedule_list(tpmif))) {
 11.1062 @@ -999,8 +952,7 @@ remove_from_tpm_schedule_list(tpmif_t * 
 11.1063  	spin_unlock_irq(&tpm_schedule_list_lock);
 11.1064  }
 11.1065  
 11.1066 -static void
 11.1067 -add_to_tpm_schedule_list_tail(tpmif_t * tpmif)
 11.1068 +static void add_to_tpm_schedule_list_tail(tpmif_t * tpmif)
 11.1069  {
 11.1070  	if (__on_tpm_schedule_list(tpmif))
 11.1071  		return;
 11.1072 @@ -1013,22 +965,18 @@ add_to_tpm_schedule_list_tail(tpmif_t * 
 11.1073  	spin_unlock_irq(&tpm_schedule_list_lock);
 11.1074  }
 11.1075  
 11.1076 -void
 11.1077 -tpmif_schedule_work(tpmif_t * tpmif)
 11.1078 +void tpmif_schedule_work(tpmif_t * tpmif)
 11.1079  {
 11.1080  	add_to_tpm_schedule_list_tail(tpmif);
 11.1081  	maybe_schedule_tx_action();
 11.1082  }
 11.1083  
 11.1084 -void
 11.1085 -tpmif_deschedule_work(tpmif_t * tpmif)
 11.1086 +void tpmif_deschedule_work(tpmif_t * tpmif)
 11.1087  {
 11.1088  	remove_from_tpm_schedule_list(tpmif);
 11.1089  }
 11.1090  
 11.1091 -
 11.1092 -static void
 11.1093 -tpm_tx_action(unsigned long unused)
 11.1094 +static void tpm_tx_action(unsigned long unused)
 11.1095  {
 11.1096  	struct list_head *ent;
 11.1097  	tpmif_t *tpmif;
 11.1098 @@ -1042,10 +990,6 @@ tpm_tx_action(unsigned long unused)
 11.1099  		tpmif = list_entry(ent, tpmif_t, list);
 11.1100  		tpmif_get(tpmif);
 11.1101  		remove_from_tpm_schedule_list(tpmif);
 11.1102 -		/*
 11.1103 -		 * Ensure that we see the request when we read from it.
 11.1104 -		 */
 11.1105 -		mb();
 11.1106  
 11.1107  		tx = &tpmif->tx->ring[0].req;
 11.1108  
 11.1109 @@ -1056,22 +1000,22 @@ tpm_tx_action(unsigned long unused)
 11.1110  	}
 11.1111  }
 11.1112  
 11.1113 -irqreturn_t
 11.1114 -tpmif_be_int(int irq, void *dev_id, struct pt_regs *regs)
 11.1115 +irqreturn_t tpmif_be_int(int irq, void *dev_id, struct pt_regs *regs)
 11.1116  {
 11.1117 -	tpmif_t *tpmif = dev_id;
 11.1118 +	tpmif_t *tpmif = (tpmif_t *) dev_id;
 11.1119 +
 11.1120  	add_to_tpm_schedule_list_tail(tpmif);
 11.1121  	maybe_schedule_tx_action();
 11.1122  	return IRQ_HANDLED;
 11.1123  }
 11.1124  
 11.1125 -static int __init
 11.1126 -tpmback_init(void)
 11.1127 +static int __init tpmback_init(void)
 11.1128  {
 11.1129  	int rc;
 11.1130  
 11.1131 -	if ((rc = misc_register(&ibmvtpms_miscdevice)) != 0) {
 11.1132 -		printk(KERN_ALERT "Could not register misc device for TPM BE.\n");
 11.1133 +	if ((rc = misc_register(&vtpms_miscdevice)) != 0) {
 11.1134 +		printk(KERN_ALERT
 11.1135 +		       "Could not register misc device for TPM BE.\n");
 11.1136  		return rc;
 11.1137  	}
 11.1138  
 11.1139 @@ -1094,13 +1038,11 @@ tpmback_init(void)
 11.1140  
 11.1141  module_init(tpmback_init);
 11.1142  
 11.1143 -static void __exit
 11.1144 -tpmback_exit(void)
 11.1145 +static void __exit tpmback_exit(void)
 11.1146  {
 11.1147 -
 11.1148  	tpmif_xenbus_exit();
 11.1149  	tpmif_interface_exit();
 11.1150 -	misc_deregister(&ibmvtpms_miscdevice);
 11.1151 +	misc_deregister(&vtpms_miscdevice);
 11.1152  }
 11.1153  
 11.1154  module_exit(tpmback_exit);

    12.1 --- a/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c	Mon Mar 06 09:09:18 2006 -0700
    12.2 +++ b/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c	Mon Mar 06 10:21:35 2006 -0700
    12.3 @@ -602,7 +602,6 @@ tpm_xmit(struct tpm_private *tp,
    12.4  
    12.5  		tx = &tp->tx->ring[i].req;
    12.6  
    12.7 -		tx->id = i;
    12.8  		tx->addr = virt_to_machine(txb->data);
    12.9  		tx->size = txb->len;
   12.10  

    13.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_client.c	Mon Mar 06 09:09:18 2006 -0700
    13.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_client.c	Mon Mar 06 10:21:35 2006 -0700
    13.3 @@ -95,18 +95,25 @@ int xenbus_switch_state(struct xenbus_de
    13.4  	 */
    13.5  
    13.6  	int current_state;
    13.7 +	int err;
    13.8  
    13.9 -	int err = xenbus_scanf(xbt, dev->nodename, "state", "%d",
   13.10 +	if (state == dev->state)
   13.11 +		return 0;
   13.12 +
   13.13 +	err = xenbus_scanf(xbt, dev->nodename, "state", "%d",
   13.14  			       &current_state);
   13.15 -	if ((err == 1 && (XenbusState)current_state == state) ||
   13.16 -	    err == -ENOENT)
   13.17 +	if (err != 1)
   13.18  		return 0;
   13.19  
   13.20  	err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
   13.21  	if (err) {
   13.22 -		xenbus_dev_fatal(dev, err, "writing new state");
   13.23 +		if (state != XenbusStateClosing) /* Avoid looping */
   13.24 +			xenbus_dev_fatal(dev, err, "writing new state");
   13.25  		return err;
   13.26  	}
   13.27 +
   13.28 +	dev->state = state;
   13.29 +
   13.30  	return 0;
   13.31  }
   13.32  EXPORT_SYMBOL(xenbus_switch_state);
   13.33 @@ -138,7 +145,6 @@ void _dev_error(struct xenbus_device *de
   13.34  	ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
   13.35  
   13.36  	BUG_ON(len + ret > PRINTF_BUFFER_SIZE-1);
   13.37 -	dev->has_error = 1;
   13.38  
   13.39  	dev_err(&dev->dev, "%s\n", printf_buffer);
   13.40  

    14.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_comms.c	Mon Mar 06 09:09:18 2006 -0700
    14.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_comms.c	Mon Mar 06 10:21:35 2006 -0700
    14.3 @@ -89,14 +89,18 @@ int xb_write(const void *data, unsigned 
    14.4  {
    14.5  	struct xenstore_domain_interface *intf = xenstore_domain_interface();
    14.6  	XENSTORE_RING_IDX cons, prod;
    14.7 +	int rc;
    14.8  
    14.9  	while (len != 0) {
   14.10  		void *dst;
   14.11  		unsigned int avail;
   14.12  
   14.13 -		wait_event_interruptible(xb_waitq,
   14.14 -					 (intf->req_prod - intf->req_cons) !=
   14.15 -					 XENSTORE_RING_SIZE);
   14.16 +		rc = wait_event_interruptible(
   14.17 +			xb_waitq,
   14.18 +			(intf->req_prod - intf->req_cons) !=
   14.19 +			XENSTORE_RING_SIZE);
   14.20 +		if (rc < 0)
   14.21 +			return rc;
   14.22  
   14.23  		/* Read indexes, then verify. */
   14.24  		cons = intf->req_cons;
   14.25 @@ -130,13 +134,17 @@ int xb_read(void *data, unsigned len)
   14.26  {
   14.27  	struct xenstore_domain_interface *intf = xenstore_domain_interface();
   14.28  	XENSTORE_RING_IDX cons, prod;
   14.29 +	int rc;
   14.30  
   14.31  	while (len != 0) {
   14.32  		unsigned int avail;
   14.33  		const char *src;
   14.34  
   14.35 -		wait_event_interruptible(xb_waitq,
   14.36 -					 intf->rsp_cons != intf->rsp_prod);
   14.37 +		rc = wait_event_interruptible(
   14.38 +			xb_waitq,
   14.39 +			intf->rsp_cons != intf->rsp_prod);
   14.40 +		if (rc < 0)
   14.41 +			return rc;
   14.42  
   14.43  		/* Read indexes, then verify. */
   14.44  		cons = intf->rsp_cons;

    15.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Mon Mar 06 09:09:18 2006 -0700
    15.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Mon Mar 06 10:21:35 2006 -0700
    15.3 @@ -45,9 +45,7 @@
    15.4  #include <asm/hypervisor.h>
    15.5  #include <xen/xenbus.h>
    15.6  #include <xen/xen_proc.h>
    15.7 -#include <xen/balloon.h>
    15.8  #include <xen/evtchn.h>
    15.9 -#include <xen/public/evtchn.h>
   15.10  
   15.11  #include "xenbus_comms.h"
   15.12  
   15.13 @@ -886,9 +884,33 @@ void unregister_xenstore_notifier(struct
   15.14  EXPORT_SYMBOL(unregister_xenstore_notifier);
   15.15  
   15.16  
   15.17 +static int all_devices_ready_(struct device *dev, void *data)
   15.18 +{
   15.19 +	struct xenbus_device *xendev = to_xenbus_device(dev);
   15.20 +	int *result = data;
   15.21 +
   15.22 +	if (xendev->state != XenbusStateConnected) {
   15.23 +		result = 0;
   15.24 +		return 1;
   15.25 +	}
   15.26 +
   15.27 +	return 0;
   15.28 +}
   15.29 +
   15.30 +
   15.31 +static int all_devices_ready(void)
   15.32 +{
   15.33 +	int ready = 1;
   15.34 +	bus_for_each_dev(&xenbus_frontend.bus, NULL, &ready,
   15.35 +			 all_devices_ready_);
   15.36 +	return ready;
   15.37 +}
   15.38 +
   15.39  
   15.40  void xenbus_probe(void *unused)
   15.41  {
   15.42 +	int i;
   15.43 +
   15.44  	BUG_ON((xenstored_ready <= 0));
   15.45  
   15.46  	/* Enumerate devices in xenstore. */
   15.47 @@ -901,12 +923,50 @@ void xenbus_probe(void *unused)
   15.48  
   15.49  	/* Notify others that xenstore is up */
   15.50  	notifier_call_chain(&xenstore_chain, 0, NULL);
   15.51 +
   15.52 +	/* On a 10 second timeout, waiting for all devices currently
   15.53 +	   configured.  We need to do this to guarantee that the filesystems
   15.54 +	   and / or network devices needed for boot are available, before we
   15.55 +	   can allow the boot to proceed.
   15.56 +
   15.57 +	   A possible improvement here would be to have the tools add a
   15.58 +	   per-device flag to the store entry, indicating whether it is needed
   15.59 +	   at boot time.  This would allow people who knew what they were
   15.60 +	   doing to accelerate their boot slightly, but of course needs tools
   15.61 +	   or manual intervention to set up those flags correctly.
   15.62 +	 */
   15.63 +	for (i = 0; i < 10 * HZ; i++) {
   15.64 +		if (all_devices_ready())
   15.65 +			return;
   15.66 +
   15.67 +		set_current_state(TASK_INTERRUPTIBLE);
   15.68 +		schedule_timeout(1);
   15.69 +	}
   15.70 +
   15.71 +	printk(KERN_WARNING
   15.72 +	       "XENBUS: Timeout connecting to devices!\n");
   15.73  }
   15.74  
   15.75  
   15.76 +static struct file_operations xsd_kva_fops;
   15.77  static struct proc_dir_entry *xsd_kva_intf;
   15.78  static struct proc_dir_entry *xsd_port_intf;
   15.79  
   15.80 +static int xsd_kva_mmap(struct file *file, struct vm_area_struct *vma)
   15.81 +{
   15.82 +	size_t size = vma->vm_end - vma->vm_start;
   15.83 +
   15.84 +	if ((size > PAGE_SIZE) || (vma->vm_pgoff != 0))
   15.85 +		return -EINVAL;
   15.86 +
   15.87 +	vma->vm_pgoff = mfn_to_pfn(xen_start_info->store_mfn);
   15.88 +
   15.89 +	if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
   15.90 +			    size, vma->vm_page_prot))
   15.91 +		return -EAGAIN;
   15.92 +
   15.93 +	return 0;
   15.94 +}
   15.95  
   15.96  static int xsd_kva_read(char *page, char **start, off_t off,
   15.97                          int count, int *eof, void *data)
   15.98 @@ -980,9 +1040,14 @@ static int __init xenbus_probe_init(void
   15.99  		xen_start_info->store_evtchn = op.u.alloc_unbound.port;
  15.100  
  15.101  		/* And finally publish the above info in /proc/xen */
  15.102 -		if((xsd_kva_intf = create_xen_proc_entry("xsd_kva", 0400)))
  15.103 +		if ((xsd_kva_intf = create_xen_proc_entry("xsd_kva", 0400))) {
  15.104 +			memcpy(&xsd_kva_fops, xsd_kva_intf->proc_fops,
  15.105 +			       sizeof(xsd_kva_fops));
  15.106 +			xsd_kva_fops.mmap = xsd_kva_mmap;
  15.107 +			xsd_kva_intf->proc_fops = &xsd_kva_fops;
  15.108  			xsd_kva_intf->read_proc = xsd_kva_read;
  15.109 -		if((xsd_port_intf = create_xen_proc_entry("xsd_port", 0400)))
  15.110 +		}
  15.111 +		if ((xsd_port_intf = create_xen_proc_entry("xsd_port", 0400)))
  15.112  			xsd_port_intf->read_proc = xsd_port_read;
  15.113  	}
  15.114  

    16.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c	Mon Mar 06 09:09:18 2006 -0700
    16.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c	Mon Mar 06 10:21:35 2006 -0700
    16.3 @@ -123,8 +123,9 @@ static void *read_reply(enum xsd_sockmsg
    16.4  
    16.5  	while (list_empty(&xs_state.reply_list)) {
    16.6  		spin_unlock(&xs_state.reply_lock);
    16.7 -		wait_event_interruptible(xs_state.reply_waitq,
    16.8 -					 !list_empty(&xs_state.reply_list));
    16.9 +		/* XXX FIXME: Avoid synchronous wait for response here. */
   16.10 +		wait_event(xs_state.reply_waitq,
   16.11 +			   !list_empty(&xs_state.reply_list));
   16.12  		spin_lock(&xs_state.reply_lock);
   16.13  	}
   16.14  
   16.15 @@ -685,6 +686,9 @@ static int xenwatch_thread(void *unused)
   16.16  		wait_event_interruptible(watch_events_waitq,
   16.17  					 !list_empty(&watch_events));
   16.18  
   16.19 +		if (kthread_should_stop())
   16.20 +			break;
   16.21 +
   16.22  		down(&xenwatch_mutex);
   16.23  
   16.24  		spin_lock(&watch_events_lock);
   16.25 @@ -705,6 +709,8 @@ static int xenwatch_thread(void *unused)
   16.26  
   16.27  		up(&xenwatch_mutex);
   16.28  	}
   16.29 +
   16.30 +	return 0;
   16.31  }
   16.32  
   16.33  static int process_msg(void)
   16.34 @@ -778,7 +784,11 @@ static int xenbus_thread(void *unused)
   16.35  		if (err)
   16.36  			printk(KERN_WARNING "XENBUS error %d while reading "
   16.37  			       "message\n", err);
   16.38 +		if (kthread_should_stop())
   16.39 +			break;
   16.40  	}
   16.41 +
   16.42 +	return 0;
   16.43  }
   16.44  
   16.45  int xs_init(void)

    17.1 --- a/linux-2.6-xen-sparse/include/asm-i386/mach-xen/setup_arch_post.h	Mon Mar 06 09:09:18 2006 -0700
    17.2 +++ b/linux-2.6-xen-sparse/include/asm-i386/mach-xen/setup_arch_post.h	Mon Mar 06 10:21:35 2006 -0700
    17.3 @@ -16,7 +16,7 @@ static char * __init machine_specific_me
    17.4  	return "Xen";
    17.5  }
    17.6  
    17.7 -void __init machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
    17.8 +void __devinit machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
    17.9  {
   17.10  	clear_bit(X86_FEATURE_VME, c->x86_capability);
   17.11  	clear_bit(X86_FEATURE_DE, c->x86_capability);

    18.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/setup_arch_post.h	Mon Mar 06 09:09:18 2006 -0700
    18.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/setup_arch_post.h	Mon Mar 06 10:21:35 2006 -0700
    18.3 @@ -1,28 +1,12 @@
    18.4  /**
    18.5 - * machine_specific_memory_setup - Hook for machine specific memory setup.
    18.6 + * machine_specific_* - Hooks for machine specific setup.
    18.7   *
    18.8   * Description:
    18.9   *	This is included late in kernel/setup.c so that it can make
   18.10   *	use of all of the static functions.
   18.11   **/
   18.12  
   18.13 -static char * __init machine_specific_memory_setup(void)
   18.14 -{
   18.15 -	char *who;
   18.16 -	unsigned long start_pfn, max_pfn;
   18.17 -
   18.18 -	who = "Xen";
   18.19 -
   18.20 -	start_pfn = 0;
   18.21 -	max_pfn = xen_start_info->nr_pages;
   18.22 -
   18.23 -	e820.nr_map = 0;
   18.24 -	add_memory_region(PFN_PHYS(start_pfn), PFN_PHYS(max_pfn) - PFN_PHYS(start_pfn), E820_RAM);
   18.25 -
   18.26 -	return who;
   18.27 -}
   18.28 -
   18.29 -void __init machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
   18.30 +void __cpuinit machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
   18.31  {
   18.32  	clear_bit(X86_FEATURE_VME, c->x86_capability);
   18.33  	clear_bit(X86_FEATURE_DE, c->x86_capability);

    19.1 --- a/linux-2.6-xen-sparse/include/xen/public/xenstored.h	Mon Mar 06 09:09:18 2006 -0700
    19.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.3 @@ -1,89 +0,0 @@
    19.4 -/*
    19.5 - * Simple prototyle Xen Store Daemon providing simple tree-like database.
    19.6 - * Copyright (C) 2005 Rusty Russell IBM Corporation
    19.7 - *
    19.8 - * This file may be distributed separately from the Linux kernel, or
    19.9 - * incorporated into other software packages, subject to the following license:
   19.10 - * 
   19.11 - * Permission is hereby granted, free of charge, to any person obtaining a copy
   19.12 - * of this source file (the "Software"), to deal in the Software without
   19.13 - * restriction, including without limitation the rights to use, copy, modify,
   19.14 - * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   19.15 - * and to permit persons to whom the Software is furnished to do so, subject to
   19.16 - * the following conditions:
   19.17 - * 
   19.18 - * The above copyright notice and this permission notice shall be included in
   19.19 - * all copies or substantial portions of the Software.
   19.20 - * 
   19.21 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   19.22 - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   19.23 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   19.24 - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   19.25 - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   19.26 - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   19.27 - * IN THE SOFTWARE.
   19.28 - */
   19.29 -
   19.30 -#ifndef _XENSTORED_H
   19.31 -#define _XENSTORED_H
   19.32 -
   19.33 -enum xsd_sockmsg_type
   19.34 -{
   19.35 -	XS_DEBUG,
   19.36 -	XS_SHUTDOWN,
   19.37 -	XS_DIRECTORY,
   19.38 -	XS_READ,
   19.39 -	XS_GET_PERMS,
   19.40 -	XS_WATCH,
   19.41 -	XS_WATCH_ACK,
   19.42 -	XS_UNWATCH,
   19.43 -	XS_TRANSACTION_START,
   19.44 -	XS_TRANSACTION_END,
   19.45 -	XS_OP_READ_ONLY = XS_TRANSACTION_END,
   19.46 -	XS_INTRODUCE,
   19.47 -	XS_RELEASE,
   19.48 -	XS_GET_DOMAIN_PATH,
   19.49 -	XS_WRITE,
   19.50 -	XS_MKDIR,
   19.51 -	XS_RM,
   19.52 -	XS_SET_PERMS,
   19.53 -	XS_WATCH_EVENT,
   19.54 -	XS_ERROR,
   19.55 -};
   19.56 -
   19.57 -#define XS_WRITE_NONE "NONE"
   19.58 -#define XS_WRITE_CREATE "CREATE"
   19.59 -#define XS_WRITE_CREATE_EXCL "CREATE|EXCL"
   19.60 -
   19.61 -/* We hand errors as strings, for portability. */
   19.62 -struct xsd_errors
   19.63 -{
   19.64 -	int errnum;
   19.65 -	const char *errstring;
   19.66 -};
   19.67 -#define XSD_ERROR(x) { x, #x }
   19.68 -static struct xsd_errors xsd_errors[] __attribute__((unused)) = {
   19.69 -	XSD_ERROR(EINVAL),
   19.70 -	XSD_ERROR(EACCES),
   19.71 -	XSD_ERROR(EEXIST),
   19.72 -	XSD_ERROR(EISDIR),
   19.73 -	XSD_ERROR(ENOENT),
   19.74 -	XSD_ERROR(ENOMEM),
   19.75 -	XSD_ERROR(ENOSPC),
   19.76 -	XSD_ERROR(EIO),
   19.77 -	XSD_ERROR(ENOTEMPTY),
   19.78 -	XSD_ERROR(ENOSYS),
   19.79 -	XSD_ERROR(EROFS),
   19.80 -	XSD_ERROR(EBUSY),
   19.81 -	XSD_ERROR(EAGAIN),
   19.82 -	XSD_ERROR(EISCONN),
   19.83 -};
   19.84 -struct xsd_sockmsg
   19.85 -{
   19.86 -	u32 type;
   19.87 -	u32 len; 		/* Length of data following this. */
   19.88 -
   19.89 -	/* Generally followed by nul-terminated string(s). */
   19.90 -};
   19.91 -
   19.92 -#endif /* _XENSTORED_H */

    20.1 --- a/linux-2.6-xen-sparse/include/xen/xenbus.h	Mon Mar 06 09:09:18 2006 -0700
    20.2 +++ b/linux-2.6-xen-sparse/include/xen/xenbus.h	Mon Mar 06 10:21:35 2006 -0700
    20.3 @@ -63,7 +63,7 @@ struct xenbus_device {
    20.4  	int otherend_id;
    20.5  	struct xenbus_watch otherend_watch;
    20.6  	struct device dev;
    20.7 -	int has_error;
    20.8 +	XenbusState state;
    20.9  	void *data;
   20.10  };
   20.11  

    21.1 --- a/tools/debugger/gdb/gdb-6.2.1-xen-sparse/gdb/gdbserver/linux-xen-low.c	Mon Mar 06 09:09:18 2006 -0700
    21.2 +++ b/tools/debugger/gdb/gdb-6.2.1-xen-sparse/gdb/gdbserver/linux-xen-low.c	Mon Mar 06 10:21:35 2006 -0700
    21.3 @@ -41,8 +41,6 @@
    21.4  
    21.5  #define TRACE_ENTER /* printf("enter %s\n", __FUNCTION__) */
    21.6  
    21.7 -long (*myptrace)(int xc_handle, enum __ptrace_request, uint32_t, long, long);
    21.8 -int (*myxcwait)(int xc_handle, int domain, int *status, int options) ;
    21.9  static int xc_handle;
   21.10  
   21.11  static inline int
   21.12 @@ -170,7 +168,7 @@ linux_attach (int domid)
   21.13      add_thread (0, new_process);
   21.14      new_process->stop_expected = 0;
   21.15  
   21.16 -    if (myptrace (xc_handle, PTRACE_ATTACH, domid, 0, 0) != 0) {
   21.17 +    if (xc_ptrace (xc_handle, PTRACE_ATTACH, domid, 0, isfile) != 0) {
   21.18  	fprintf (stderr, "Cannot attach to domain %d: %s (%d)\n", domid,
   21.19  		 strerror (errno), errno);
   21.20  	fflush (stderr);
   21.21 @@ -188,7 +186,7 @@ linux_kill_one_process (struct inferior_
   21.22  {
   21.23    struct thread_info *thread = (struct thread_info *) entry;
   21.24    struct process_info *process = get_thread_process (thread);
   21.25 -  myptrace (xc_handle, PTRACE_KILL, pid_of (process), 0, 0);
   21.26 +  xc_ptrace (xc_handle, PTRACE_KILL, pid_of (process), 0, 0);
   21.27  }
   21.28  
   21.29  
   21.30 @@ -202,7 +200,7 @@ static void
   21.31  linux_detach_one_process (struct inferior_list_entry *entry)
   21.32  {
   21.33  
   21.34 -  myptrace (xc_handle, PTRACE_DETACH, current_domid, 0, 0);
   21.35 +  xc_ptrace (xc_handle, PTRACE_DETACH, current_domid, 0, 0);
   21.36  }
   21.37  
   21.38  
   21.39 @@ -228,7 +226,7 @@ static unsigned char
   21.40  linux_wait (char *status)
   21.41  {
   21.42    int w;
   21.43 -  if (myxcwait(xc_handle, current_domid, &w, 0))
   21.44 +  if (xc_waitdomain(xc_handle, current_domid, &w, 0))
   21.45        return -1;
   21.46    
   21.47    linux_set_inferior();
   21.48 @@ -250,7 +248,7 @@ linux_resume (struct thread_resume *resu
   21.49    for_each_inferior(&all_threads, regcache_invalidate_one);
   21.50    if (debug_threads)
   21.51      fprintf(stderr, "step: %d\n", step);
   21.52 -  myptrace (xc_handle, step ? PTRACE_SINGLESTEP : PTRACE_CONT, 
   21.53 +  xc_ptrace (xc_handle, step ? PTRACE_SINGLESTEP : PTRACE_CONT, 
   21.54  	    resume_info->thread, 0, 0);
   21.55  
   21.56  }
   21.57 @@ -275,7 +273,7 @@ regsets_fetch_inferior_registers ()
   21.58  	}
   21.59  
   21.60        buf = malloc (regset->size);
   21.61 -      res = myptrace (xc_handle, regset->get_request, 
   21.62 +      res = xc_ptrace (xc_handle, regset->get_request, 
   21.63  		      curvcpuid(),
   21.64  		      0, (PTRACE_XFER_TYPE)buf);
   21.65        if (res < 0)
   21.66 @@ -329,7 +327,7 @@ regsets_store_inferior_registers ()
   21.67  
   21.68        buf = malloc (regset->size);
   21.69        regset->fill_function (buf);
   21.70 -      res = myptrace (xc_handle, regset->set_request, curvcpuid(), 0, (PTRACE_XFER_TYPE)buf);
   21.71 +      res = xc_ptrace (xc_handle, regset->set_request, curvcpuid(), 0, (PTRACE_XFER_TYPE)buf);
   21.72        if (res < 0)
   21.73  	{
   21.74  	  if (errno == EIO)
   21.75 @@ -407,7 +405,7 @@ linux_read_memory (CORE_ADDR memaddr, ch
   21.76    for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
   21.77      {
   21.78        errno = 0;
   21.79 -      buffer[i] = myptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(), (PTRACE_ARG3_TYPE) addr, 0);
   21.80 +      buffer[i] = xc_ptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(), (PTRACE_ARG3_TYPE) addr, 0);
   21.81        if (errno)
   21.82  	return errno;
   21.83      }
   21.84 @@ -440,13 +438,13 @@ linux_write_memory (CORE_ADDR memaddr, c
   21.85  
   21.86    /* Fill start and end extra bytes of buffer with existing memory data.  */
   21.87  
   21.88 -  buffer[0] = myptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(),
   21.89 +  buffer[0] = xc_ptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(),
   21.90  		      (PTRACE_ARG3_TYPE) addr, 0);
   21.91  
   21.92    if (count > 1)
   21.93      {
   21.94        buffer[count - 1]
   21.95 -	= myptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(),
   21.96 +	= xc_ptrace (xc_handle, PTRACE_PEEKTEXT, curvcpuid(),
   21.97  		  (PTRACE_ARG3_TYPE) (addr + (count - 1)
   21.98  				      * sizeof (PTRACE_XFER_TYPE)),
   21.99  		  0);
  21.100 @@ -460,7 +458,7 @@ linux_write_memory (CORE_ADDR memaddr, c
  21.101    for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
  21.102      {
  21.103        errno = 0;
  21.104 -      myptrace (xc_handle, PTRACE_POKETEXT, curvcpuid(), 
  21.105 +      xc_ptrace (xc_handle, PTRACE_POKETEXT, curvcpuid(), 
  21.106  		(PTRACE_ARG3_TYPE) addr, buffer[i]);
  21.107        if (errno)
  21.108  	return errno;
  21.109 @@ -561,13 +559,6 @@ initialize_low (void)
  21.110  		       the_low_target.breakpoint_len);
  21.111    init_registers ();
  21.112    linux_init_signals ();
  21.113 -  if (isfile) {
  21.114 -      myptrace = xc_ptrace_core;
  21.115 -      myxcwait = xc_waitdomain_core;
  21.116 -  } else {
  21.117 -      myptrace = xc_ptrace;
  21.118 -      myxcwait = xc_waitdomain;
  21.119 -  }
  21.120    using_threads = thread_db_init ();
  21.121  
  21.122  }

    22.1 --- a/tools/debugger/gdb/gdbbuild	Mon Mar 06 09:09:18 2006 -0700
    22.2 +++ b/tools/debugger/gdb/gdbbuild	Mon Mar 06 10:21:35 2006 -0700
    22.3 @@ -1,7 +1,9 @@
    22.4  #!/bin/sh
    22.5  
    22.6 +[ "$GDB_MIRROR" ] || GDB_MIRROR="ftp://ftp.gnu.org/gnu/gdb/"
    22.7 +
    22.8  rm -rf gdb-6.2.1 gdb-6.2.1-linux-i386-xen
    22.9 -[ -a gdb-6.2.1.tar.bz2 ] || wget -c ftp://ftp.gnu.org/gnu/gdb/gdb-6.2.1.tar.bz2
   22.10 +[ -a gdb-6.2.1.tar.bz2 ] || wget -c "$GDB_MIRROR/gdb-6.2.1.tar.bz2"
   22.11  tar xjf gdb-6.2.1.tar.bz2
   22.12  
   22.13  cd gdb-6.2.1-xen-sparse
   22.14 @@ -12,8 +14,10 @@ mkdir gdb-6.2.1-linux-i386-xen
   22.15  cd gdb-6.2.1-linux-i386-xen
   22.16  ../gdb-6.2.1/configure
   22.17  
   22.18 -# some people don't have gmake
   22.19 -if which gmake ; then
   22.20 +# Use $MAKE if set, else use gmake if present, otherwise use make
   22.21 +if [ "$MAKE" ]; then
   22.22 +    $MAKE
   22.23 +elif which gmake ; then
   22.24      gmake -j4
   22.25  else
   22.26      make -j4

    23.1 --- a/tools/examples/block	Mon Mar 06 09:09:18 2006 -0700
    23.2 +++ b/tools/examples/block	Mon Mar 06 10:21:35 2006 -0700
    23.3 @@ -129,7 +129,14 @@ check_sharing()
    23.4  same_vm()
    23.5  {
    23.6    local otherdom="$1"
    23.7 -  local othervm=$(xenstore-read "/local/domain/$otherdom/vm")
    23.8 +  # Note that othervm can be MISSING here, because Xend will be racing with
    23.9 +  # the hotplug scripts -- the entries in /local/domain can be removed by
   23.10 +  # Xend before the hotplug scripts have removed the entry in
   23.11 +  # /local/domain/0/backend/.  In this case, we want to pretend that the
   23.12 +  # VM is the same as FRONTEND_UUID, because that way the 'sharing' will be
   23.13 +  # allowed.
   23.14 +  local othervm=$(xenstore_read_default "/local/domain/$otherdom/vm"         \
   23.15 +                  "$FRONTEND_UUID")
   23.16  
   23.17    [ "$FRONTEND_UUID" == "$othervm" ]
   23.18  }
   23.19 @@ -314,7 +321,28 @@ mount it read-write in a guest domain."
   23.20                fi
   23.21              fi
   23.22  
   23.23 -            f=$(readlink -f "$f")
   23.24 +            # Canonicalise the filename for the comparison.
   23.25 +
   23.26 +            # I have seen this readlink fails because the filename given by
   23.27 +            # losetup is only the basename.  This cannot happen when the loop
   23.28 +            # device is set up through this script, because file is
   23.29 +            # canonicalised above, but it may happen when loop devices are set
   23.30 +            # up some other way.  This readlink may also conceivably fail if
   23.31 +            # the file backing this loop device has been removed.
   23.32 +
   23.33 +            # For maximum safety, in the case that $f does not resolve, we
   23.34 +            # assume that $file and $f are in the same directory.
   23.35 +
   23.36 +            # If you create a loopback filesystem, remove it and continue to
   23.37 +            # run on it, and then create another file with the same name, then
   23.38 +            # this check will block that -- don't do that.
   23.39 +
   23.40 +            # If you create loop devices through some other mechanism, use
   23.41 +            # relative filenames, and then use the same filename through this
   23.42 +            # script, then this check will block that -- don't do that either.
   23.43 +
   23.44 +            f=$(readlink -f "$f" || echo $(dirname "$file")/$(basename "$f"))
   23.45 +
   23.46  
   23.47              if [ "$f" == "$file" ]
   23.48              then

    24.1 --- a/tools/examples/xen-hotplug-cleanup	Mon Mar 06 09:09:18 2006 -0700
    24.2 +++ b/tools/examples/xen-hotplug-cleanup	Mon Mar 06 10:21:35 2006 -0700
    24.3 @@ -12,10 +12,11 @@ dir=$(dirname "$0")
    24.4  claim_lock "block"
    24.5  
    24.6  # remove device frontend store entries
    24.7 -xenstore-rm -t $(xenstore-read "$XENBUS_PATH/frontend") || true
    24.8 +xenstore-rm -t \
    24.9 +  $(xenstore-read "$XENBUS_PATH/frontend" 2>/dev/null) 2>/dev/null || true
   24.10  
   24.11  # remove device backend store entries
   24.12 -xenstore-rm -t "$XENBUS_PATH"       || true
   24.13 -xenstore-rm -t "error/$XENBUS_PATH" || true
   24.14 +xenstore-rm -t "$XENBUS_PATH"        2>/dev/null || true
   24.15 +xenstore-rm -t "error/$XENBUS_PATH"  2>/dev/null || true
   24.16  
   24.17  release_lock "block"

    25.1 --- a/tools/firmware/hvmloader/Makefile	Mon Mar 06 09:09:18 2006 -0700
    25.2 +++ b/tools/firmware/hvmloader/Makefile	Mon Mar 06 10:21:35 2006 -0700
    25.3 @@ -18,6 +18,9 @@
    25.4  # Place - Suite 330, Boston, MA 02111-1307 USA.
    25.5  #
    25.6  
    25.7 +# External CFLAGS can do more harm than good.
    25.8 +CFLAGS :=
    25.9 +
   25.10  XEN_ROOT = ../../..
   25.11  include $(XEN_ROOT)/Config.mk
   25.12  

    26.1 --- a/tools/firmware/vmxassist/Makefile	Mon Mar 06 09:09:18 2006 -0700
    26.2 +++ b/tools/firmware/vmxassist/Makefile	Mon Mar 06 10:21:35 2006 -0700
    26.3 @@ -18,6 +18,9 @@
    26.4  # Place - Suite 330, Boston, MA 02111-1307 USA.
    26.5  #
    26.6  
    26.7 +# External CFLAGS can do more harm than good.
    26.8 +CFLAGS :=
    26.9 +
   26.10  XEN_ROOT = ../../..
   26.11  include $(XEN_ROOT)/Config.mk
   26.12  

    27.1 --- a/tools/firmware/vmxassist/setup.c	Mon Mar 06 09:09:18 2006 -0700
    27.2 +++ b/tools/firmware/vmxassist/setup.c	Mon Mar 06 10:21:35 2006 -0700
    27.3 @@ -123,6 +123,8 @@ setup_paging(void)
    27.4  void
    27.5  setup_gdt(void)
    27.6  {
    27.7 +	unsigned long long addr = (unsigned long long) &tss;
    27.8 +
    27.9  	/* setup task state segment */
   27.10  	memset(&tss, 0, sizeof(tss));
   27.11  	tss.ss0 = DATA_SELECTOR;
   27.12 @@ -130,8 +132,7 @@ setup_gdt(void)
   27.13  	tss.iomap_base = offsetof(struct tss, iomap);
   27.14  
   27.15  	/* initialize gdt's tss selector */
   27.16 -	unsigned long long addr = (unsigned long long) &tss;
   27.17 -        gdt[TSS_SELECTOR / sizeof(gdt[0])] |=
   27.18 +	gdt[TSS_SELECTOR / sizeof(gdt[0])] |=
   27.19  		((addr & 0xFF000000) << (56-24)) |
   27.20  		((addr & 0x00FF0000) << (32-16)) |
   27.21  		((addr & 0x0000FFFF) << (16)) |

    28.1 --- a/tools/ioemu/audio/audio.c	Mon Mar 06 09:09:18 2006 -0700
    28.2 +++ b/tools/ioemu/audio/audio.c	Mon Mar 06 10:21:35 2006 -0700
    28.3 @@ -713,7 +713,7 @@ int AUD_calc_elapsed (SWVoice *sw)
    28.4      delta = now - sw->old_ticks;
    28.5      bytes = (delta * sw->bytes_per_second) / ticks_per_sec;
    28.6      if (delta < 0) {
    28.7 -        dolog ("whoops delta(<0)=%lld\n", delta);
    28.8 +        dolog ("whoops delta(<0)=%"PRId64"\n", delta);
    28.9          return 0;
   28.10      }
   28.11  

    29.1 --- a/tools/ioemu/hw/i8254.c	Mon Mar 06 09:09:18 2006 -0700
    29.2 +++ b/tools/ioemu/hw/i8254.c	Mon Mar 06 10:21:35 2006 -0700
    29.3 @@ -249,7 +249,7 @@ void pit_reset_hvm_vectors()
    29.4      req->u.data |= (irq << 16);
    29.5      req->u.data |= (hvm_channel << 24);
    29.6      req->u.data |= ((s->rw_mode) << 26);
    29.7 -    fprintf(logfile, "HVM_PIT:pass info 0x%llx to HV!\n", req->u.data);
    29.8 +    fprintf(logfile, "HVM_PIT:pass info 0x%"PRIx64" to HV!\n", req->u.data);
    29.9  }
   29.10  
   29.11  static inline void pit_load_count(PITChannelState *s, int val)

    30.1 --- a/tools/ioemu/monitor.c	Mon Mar 06 09:09:18 2006 -0700
    30.2 +++ b/tools/ioemu/monitor.c	Mon Mar 06 10:21:35 2006 -0700
    30.3 @@ -676,19 +676,19 @@ static void monitor_handle_command(const
    30.4              break;
    30.5          case '-':
    30.6              {
    30.7 -                int has_option;
    30.8 +                long has_option;
    30.9                  /* option */
   30.10 -                
   30.11 +
   30.12                  c = *typestr++;
   30.13                  if (c == '\0')
   30.14                      goto bad_type;
   30.15 -                while (isspace(*p)) 
   30.16 +                while (isspace(*p))
   30.17                      p++;
   30.18                  has_option = 0;
   30.19                  if (*p == '-') {
   30.20                      p++;
   30.21                      if (*p != c) {
   30.22 -                        term_printf("%s: unsupported option -%c\n", 
   30.23 +                        term_printf("%s: unsupported option -%c\n",
   30.24                                      cmdname, *p);
   30.25                          goto fail;
   30.26                      }

    31.1 --- a/tools/ioemu/target-i386-dm/helper2.c	Mon Mar 06 09:09:18 2006 -0700
    31.2 +++ b/tools/ioemu/target-i386-dm/helper2.c	Mon Mar 06 10:21:35 2006 -0700
    31.3 @@ -138,11 +138,11 @@ void sp_info()
    31.4          req = &(shared_page->vcpu_iodata[i].vp_ioreq);
    31.5          term_printf("vcpu %d: event port %d\n",
    31.6                      i, shared_page->vcpu_iodata[i].vp_eport);
    31.7 -        term_printf("  req state: %x, pvalid: %x, addr: %llx, "
    31.8 -                    "data: %llx, count: %llx, size: %llx\n",
    31.9 +        term_printf("  req state: %x, pvalid: %x, addr: %"PRIx64", "
   31.10 +                    "data: %"PRIx64", count: %"PRIx64", size: %"PRIx64"\n",
   31.11                      req->state, req->pdata_valid, req->addr,
   31.12                      req->u.data, req->count, req->size);
   31.13 -        term_printf("  IO totally occurred on this vcpu: %llx\n",
   31.14 +        term_printf("  IO totally occurred on this vcpu: %"PRIx64"\n",
   31.15                      req->io_count);
   31.16      }
   31.17  }
   31.18 @@ -158,8 +158,8 @@ static ioreq_t* __cpu_get_ioreq(int vcpu
   31.19          return req;
   31.20  
   31.21      fprintf(logfile, "False I/O request ... in-service already: "
   31.22 -                     "%x, pvalid: %x, port: %llx, "
   31.23 -                     "data: %llx, count: %llx, size: %llx\n",
   31.24 +                     "%x, pvalid: %x, port: %"PRIx64", "
   31.25 +                     "data: %"PRIx64", count: %"PRIx64", size: %"PRIx64"\n",
   31.26                       req->state, req->pdata_valid, req->addr,
   31.27                       req->u.data, req->count, req->size);
   31.28      return NULL;
   31.29 @@ -460,12 +460,6 @@ int main_loop(void)
   31.30          FD_ZERO(&wakeup_rfds);
   31.31          FD_SET(evtchn_fd, &wakeup_rfds);
   31.32  
   31.33 -#if __WORDSIZE == 32
   31.34 -#define ULONGLONG_MAX   0xffffffffffffffffULL
   31.35 -#else
   31.36 -#define ULONGLONG_MAX   ULONG_MAX
   31.37 -#endif
   31.38 -
   31.39          tun_receive_handler(&rfds);
   31.40          if ( FD_ISSET(evtchn_fd, &rfds) ) {
   31.41              cpu_handle_ioreq(env);

    32.1 --- a/tools/ioemu/vl.c	Mon Mar 06 09:09:18 2006 -0700
    32.2 +++ b/tools/ioemu/vl.c	Mon Mar 06 10:21:35 2006 -0700
    32.3 @@ -2672,6 +2672,7 @@ int main(int argc, char **argv)
    32.4      char qemu_dm_logfilename[64];
    32.5      const char *loadvm = NULL;
    32.6      unsigned long nr_pages, extra_pages, ram_pages, *page_array;
    32.7 +    xc_dominfo_t info;
    32.8      extern void *shared_page;
    32.9      extern void *shared_vram;
   32.10  
   32.11 @@ -3132,7 +3133,7 @@ int main(int argc, char **argv)
   32.12  
   32.13      ram_pages = ram_size/PAGE_SIZE;
   32.14  #if defined(__i386__) || defined(__x86_64__)
   32.15 -    vgaram_pages =  (vga_ram_size -1)/PAGE_SIZE + 1;
   32.16 +    vgaram_pages =  (vga_ram_size -1) / PAGE_SIZE + 1;
   32.17      free_pages = vgaram_pages / L1_PAGETABLE_ENTRIES;
   32.18      extra_pages = vgaram_pages + free_pages;
   32.19  #else
   32.20 @@ -3142,7 +3143,6 @@ int main(int argc, char **argv)
   32.21  
   32.22      xc_handle = xc_interface_open();
   32.23  
   32.24 -    xc_dominfo_t info;
   32.25      xc_domain_getinfo(xc_handle, domid, 1, &info);
   32.26  
   32.27      nr_pages = info.nr_pages + extra_pages;

    33.1 --- a/tools/libxc/xc_core.c	Mon Mar 06 09:09:18 2006 -0700
    33.2 +++ b/tools/libxc/xc_core.c	Mon Mar 06 10:21:35 2006 -0700
    33.3 @@ -61,7 +61,7 @@ xc_domain_dumpcore(int xc_handle,
    33.4   
    33.5      nr_pages = info.nr_pages;
    33.6  
    33.7 -    header.xch_magic = 0xF00FEBED; 
    33.8 +    header.xch_magic = XC_CORE_MAGIC;
    33.9      header.xch_nr_vcpus = nr_vcpus;
   33.10      header.xch_nr_pages = nr_pages;
   33.11      header.xch_ctxt_offset = sizeof(struct xc_core_header);
   33.12 @@ -71,8 +71,12 @@ xc_domain_dumpcore(int xc_handle,
   33.13                                           (sizeof(vcpu_guest_context_t) * nr_vcpus) +
   33.14                                           (nr_pages * sizeof(unsigned long)));
   33.15  
   33.16 -    write(dump_fd, &header, sizeof(struct xc_core_header));
   33.17 -    write(dump_fd, &ctxt, sizeof(ctxt[0]) * nr_vcpus);
   33.18 +    if (write(dump_fd, &header, sizeof(struct xc_core_header)) < 0 ||
   33.19 +        write(dump_fd, &ctxt, sizeof(ctxt[0]) * nr_vcpus) < 0)
   33.20 +    {
   33.21 +        PERROR("write failed");
   33.22 +        goto error_out;
   33.23 +    }
   33.24  
   33.25      if ((page_array = malloc(nr_pages * sizeof(unsigned long))) == NULL) {
   33.26          printf("Could not allocate memory\n");
   33.27 @@ -82,7 +86,11 @@ xc_domain_dumpcore(int xc_handle,
   33.28          printf("Could not get the page frame list\n");
   33.29          goto error_out;
   33.30      }
   33.31 -    write(dump_fd, page_array, nr_pages * sizeof(unsigned long));
   33.32 +    if (write(dump_fd, page_array, nr_pages * sizeof(unsigned long)) < 0)
   33.33 +    {
   33.34 +        PERROR("write failed");
   33.35 +        goto error_out;
   33.36 +    }
   33.37      lseek(dump_fd, header.xch_pages_offset, SEEK_SET);
   33.38      for (dump_mem = dump_mem_start, i = 0; i < nr_pages; i++) {
   33.39          copy_from_domain_page(xc_handle, domid, page_array, i, dump_mem);

    34.1 --- a/tools/libxc/xc_ptrace.c	Mon Mar 06 09:09:18 2006 -0700
    34.2 +++ b/tools/libxc/xc_ptrace.c	Mon Mar 06 10:21:35 2006 -0700
    34.3 @@ -7,14 +7,13 @@
    34.4  
    34.5  #include "xc_private.h"
    34.6  #include "xg_private.h"
    34.7 -#include <thread_db.h>
    34.8  #include "xc_ptrace.h"
    34.9  
   34.10 -
   34.11  /* XXX application state */
   34.12  static long                     nr_pages = 0;
   34.13  static unsigned long           *page_array = NULL;
   34.14  static int                      current_domid = -1;
   34.15 +static int                      current_isfile;
   34.16  
   34.17  static cpumap_t                 online_cpumap;
   34.18  static cpumap_t                 regs_valid;
   34.19 @@ -32,7 +31,8 @@ fetch_regs(int xc_handle, int cpu, int *
   34.20  
   34.21      if (online)
   34.22          *online = 0;
   34.23 -    if ( !(regs_valid & (1 << cpu)) ) { 
   34.24 +    if ( !(regs_valid & (1 << cpu)) )
   34.25 +    { 
   34.26          retval = xc_vcpu_getcontext(xc_handle, current_domid, 
   34.27  						cpu, &ctxt[cpu]);
   34.28          if ( retval ) 
   34.29 @@ -50,9 +50,6 @@ fetch_regs(int xc_handle, int cpu, int *
   34.30      return retval;    
   34.31  }
   34.32  
   34.33 -#define FETCH_REGS(cpu) if (fetch_regs(xc_handle, cpu, NULL)) goto error_out;
   34.34 -
   34.35 -
   34.36  static struct thr_ev_handlers {
   34.37      thr_ev_handler_t td_create;
   34.38      thr_ev_handler_t td_death;
   34.39 @@ -95,14 +92,12 @@ get_online_cpumap(int xc_handle, dom0_ge
   34.40      *cpumap = 0;
   34.41      for (i = 0; i <= d->max_vcpu_id; i++) {
   34.42          if ((retval = fetch_regs(xc_handle, i, &online)))
   34.43 -            goto error_out;        
   34.44 +            return retval;
   34.45          if (online)
   34.46              *cpumap |= (1 << i);            
   34.47      }
   34.48      
   34.49      return 0;
   34.50 - error_out:
   34.51 -    return retval;
   34.52  }
   34.53  
   34.54  /* 
   34.55 @@ -118,7 +113,8 @@ online_vcpus_changed(cpumap_t cpumap)
   34.56      int index;
   34.57      
   34.58      while ( (index = ffsll(changed_cpumap)) ) {
   34.59 -        if ( cpumap & (1 << (index - 1)) ) {
   34.60 +        if ( cpumap & (1 << (index - 1)) )
   34.61 +        {
   34.62              if (handlers.td_create) handlers.td_create(index - 1);
   34.63          } else {
   34.64              printf("thread death: %d\n", index - 1);
   34.65 @@ -143,34 +139,32 @@ map_domain_va_pae(
   34.66      uint64_t *l3, *l2, *l1;
   34.67      static void *v;
   34.68  
   34.69 -    FETCH_REGS(cpu);
   34.70 +    if (fetch_regs(xc_handle, cpu, NULL))
   34.71 +        return NULL;
   34.72  
   34.73      l3 = xc_map_foreign_range(
   34.74          xc_handle, current_domid, PAGE_SIZE, PROT_READ, ctxt[cpu].ctrlreg[3] >> PAGE_SHIFT);
   34.75      if ( l3 == NULL )
   34.76 -        goto error_out;
   34.77 +        return NULL;
   34.78  
   34.79      l2p = l3[l3_table_offset_pae(va)] >> PAGE_SHIFT;
   34.80      l2 = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, PROT_READ, l2p);
   34.81      if ( l2 == NULL )
   34.82 -        goto error_out;
   34.83 +        return NULL;
   34.84  
   34.85      l1p = l2[l2_table_offset_pae(va)] >> PAGE_SHIFT;
   34.86      l1 = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, perm, l1p);
   34.87      if ( l1 == NULL )
   34.88 -        goto error_out;
   34.89 +        return NULL;
   34.90  
   34.91      p = l1[l1_table_offset_pae(va)] >> PAGE_SHIFT;
   34.92      if ( v != NULL )
   34.93          munmap(v, PAGE_SIZE);
   34.94      v = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, perm, p);
   34.95      if ( v == NULL )
   34.96 -        goto error_out;
   34.97 +        return NULL;
   34.98  
   34.99      return (void *)((unsigned long)v | (va & (PAGE_SIZE - 1)));
  34.100 -
  34.101 - error_out:
  34.102 -    return NULL;
  34.103  }
  34.104  
  34.105  static void *
  34.106 @@ -215,17 +209,18 @@ map_domain_va(
  34.107          if ( (page_array = malloc(nr_pages * sizeof(unsigned long))) == NULL )
  34.108          {
  34.109              printf("Could not allocate memory\n");
  34.110 -            goto error_out;
  34.111 +            return NULL;
  34.112          }
  34.113          if ( xc_get_pfn_list(xc_handle, current_domid,
  34.114                               page_array, nr_pages) != nr_pages )
  34.115          {
  34.116              printf("Could not get the page frame list\n");
  34.117 -            goto error_out;
  34.118 +            return NULL;
  34.119          }
  34.120      }
  34.121  
  34.122 -    FETCH_REGS(cpu);
  34.123 +    if (fetch_regs(xc_handle, cpu, NULL))
  34.124 +        return NULL;
  34.125  
  34.126      if ( ctxt[cpu].ctrlreg[3] != cr3_phys[cpu] )
  34.127      {
  34.128 @@ -236,10 +231,10 @@ map_domain_va(
  34.129              xc_handle, current_domid, PAGE_SIZE, PROT_READ,
  34.130              cr3_phys[cpu] >> PAGE_SHIFT);
  34.131          if ( cr3_virt[cpu] == NULL )
  34.132 -            goto error_out;
  34.133 +            return NULL;
  34.134      }
  34.135      if ( (pde = cr3_virt[cpu][vtopdi(va)]) == 0 )
  34.136 -        goto error_out;
  34.137 +        return NULL;
  34.138      if ( (ctxt[cpu].flags & VGCF_HVM_GUEST) && paging_enabled(&ctxt[cpu]) )
  34.139          pde = page_array[pde >> PAGE_SHIFT] << PAGE_SHIFT;
  34.140      if ( pde != pde_phys[cpu] )
  34.141 @@ -251,10 +246,10 @@ map_domain_va(
  34.142              xc_handle, current_domid, PAGE_SIZE, PROT_READ,
  34.143              pde_phys[cpu] >> PAGE_SHIFT);
  34.144          if ( pde_virt[cpu] == NULL )
  34.145 -            goto error_out;
  34.146 +            return NULL;
  34.147      }
  34.148      if ( (page = pde_virt[cpu][vtopti(va)]) == 0 )
  34.149 -        goto error_out;
  34.150 +        return NULL;
  34.151      if ( (ctxt[cpu].flags & VGCF_HVM_GUEST) && paging_enabled(&ctxt[cpu]) )
  34.152          page = page_array[page >> PAGE_SHIFT] << PAGE_SHIFT;
  34.153      if ( (page != page_phys[cpu]) || (perm != prev_perm[cpu]) )
  34.154 @@ -268,19 +263,16 @@ map_domain_va(
  34.155          if ( page_virt[cpu] == NULL )
  34.156          {
  34.157              page_phys[cpu] = 0;
  34.158 -            goto error_out;
  34.159 +            return NULL;
  34.160          }
  34.161          prev_perm[cpu] = perm;
  34.162      } 
  34.163  
  34.164      return (void *)(((unsigned long)page_virt[cpu]) | (va & BSD_PAGE_MASK));
  34.165 -
  34.166 - error_out:
  34.167 -    return NULL;
  34.168  }
  34.169  
  34.170 -int 
  34.171 -xc_waitdomain(
  34.172 +static int 
  34.173 +__xc_waitdomain(
  34.174      int xc_handle,
  34.175      int domain,
  34.176      int *status,
  34.177 @@ -335,7 +327,6 @@ xc_ptrace(
  34.178      long edata)
  34.179  {
  34.180      DECLARE_DOM0_OP;
  34.181 -    int             status = 0;
  34.182      struct gdb_regs pt;
  34.183      long            retval = 0;
  34.184      unsigned long  *guest_va;
  34.185 @@ -350,84 +341,83 @@ xc_ptrace(
  34.186      { 
  34.187      case PTRACE_PEEKTEXT:
  34.188      case PTRACE_PEEKDATA:
  34.189 -        guest_va = (unsigned long *)map_domain_va(
  34.190 -            xc_handle, cpu, addr, PROT_READ);
  34.191 +        if (current_isfile)
  34.192 +            guest_va = (unsigned long *)map_domain_va_core(current_domid, 
  34.193 +                                cpu, addr, ctxt);
  34.194 +        else
  34.195 +            guest_va = (unsigned long *)map_domain_va(xc_handle, 
  34.196 +                                cpu, addr, PROT_READ);
  34.197          if ( guest_va == NULL )
  34.198 -        {
  34.199 -            status = EFAULT;
  34.200 -            goto error_out;
  34.201 -        }
  34.202 +            goto out_error;
  34.203          retval = *guest_va;
  34.204          break;
  34.205  
  34.206      case PTRACE_POKETEXT:
  34.207      case PTRACE_POKEDATA:
  34.208          /* XXX assume that all CPUs have the same address space */
  34.209 -        guest_va = (unsigned long *)map_domain_va(
  34.210 -                            xc_handle, cpu, addr, PROT_READ|PROT_WRITE);
  34.211 -        if ( guest_va == NULL ) {
  34.212 -            status = EFAULT;
  34.213 -            goto error_out;
  34.214 -        }
  34.215 +        if (current_isfile)
  34.216 +            guest_va = (unsigned long *)map_domain_va_core(current_domid, 
  34.217 +                                cpu, addr, ctxt);
  34.218 +        else
  34.219 +            guest_va = (unsigned long *)map_domain_va(xc_handle, 
  34.220 +                                cpu, addr, PROT_READ|PROT_WRITE);
  34.221 +        if ( guest_va == NULL ) 
  34.222 +            goto out_error;
  34.223          *guest_va = (unsigned long)data;
  34.224          break;
  34.225  
  34.226      case PTRACE_GETREGS:
  34.227 +        if (!current_isfile && fetch_regs(xc_handle, cpu, NULL)) 
  34.228 +            goto out_error;
  34.229 +        SET_PT_REGS(pt, ctxt[cpu].user_regs); 
  34.230 +        memcpy(data, &pt, sizeof(struct gdb_regs));
  34.231 +        break;
  34.232 +
  34.233      case PTRACE_GETFPREGS:
  34.234      case PTRACE_GETFPXREGS:
  34.235 -        
  34.236 -        FETCH_REGS(cpu);
  34.237 -        if ( request == PTRACE_GETREGS )
  34.238 -        {
  34.239 -            SET_PT_REGS(pt, ctxt[cpu].user_regs); 
  34.240 -            memcpy(data, &pt, sizeof(struct gdb_regs));
  34.241 -        }
  34.242 -        else if (request == PTRACE_GETFPREGS)
  34.243 -        {
  34.244 -            memcpy(data, &ctxt[cpu].fpu_ctxt, sizeof(ctxt[cpu].fpu_ctxt));
  34.245 -        }
  34.246 -        else /*if (request == PTRACE_GETFPXREGS)*/
  34.247 -        {
  34.248 -            memcpy(data, &ctxt[cpu].fpu_ctxt, sizeof(ctxt[cpu].fpu_ctxt));
  34.249 -        }
  34.250 +        if (!current_isfile && fetch_regs(xc_handle, cpu, NULL)) 
  34.251 +                goto out_error;
  34.252 +        memcpy(data, &ctxt[cpu].fpu_ctxt, sizeof(ctxt[cpu].fpu_ctxt));
  34.253          break;
  34.254  
  34.255      case PTRACE_SETREGS:
  34.256 +        if (!current_isfile)
  34.257 +                goto out_unspported; /* XXX not yet supported */
  34.258          SET_XC_REGS(((struct gdb_regs *)data), ctxt[cpu].user_regs);
  34.259 -        retval = xc_vcpu_setcontext(xc_handle, current_domid, cpu, &ctxt[cpu]);
  34.260 -        if (retval)
  34.261 -            goto error_out;
  34.262 +        if ((retval = xc_vcpu_setcontext(xc_handle, current_domid, cpu, 
  34.263 +                                &ctxt[cpu])))
  34.264 +            goto out_error_dom0;
  34.265          break;
  34.266  
  34.267      case PTRACE_SINGLESTEP:
  34.268 +        if (!current_isfile)
  34.269 +              goto out_unspported; /* XXX not yet supported */
  34.270          /*  XXX we can still have problems if the user switches threads
  34.271           *  during single-stepping - but that just seems retarded
  34.272           */
  34.273          ctxt[cpu].user_regs.eflags |= PSL_T; 
  34.274 -        retval = xc_vcpu_setcontext(xc_handle, current_domid, cpu, &ctxt[cpu]);
  34.275 -        if ( retval )
  34.276 -        {
  34.277 -            perror("dom0 op failed");
  34.278 -            goto error_out;
  34.279 -        }
  34.280 +        if ((retval = xc_vcpu_setcontext(xc_handle, current_domid, cpu, 
  34.281 +                                &ctxt[cpu])))
  34.282 +            goto out_error_dom0;
  34.283          /* FALLTHROUGH */
  34.284  
  34.285      case PTRACE_CONT:
  34.286      case PTRACE_DETACH:
  34.287 +        if (!current_isfile)
  34.288 +            goto out_unspported; /* XXX not yet supported */
  34.289          if ( request != PTRACE_SINGLESTEP )
  34.290          {
  34.291              FOREACH_CPU(cpumap, index) {
  34.292                  cpu = index - 1;
  34.293 -                FETCH_REGS(cpu);
  34.294 +                if (fetch_regs(xc_handle, cpu, NULL)) 
  34.295 +                    goto out_error;
  34.296                  /* Clear trace flag */
  34.297 -                if ( ctxt[cpu].user_regs.eflags & PSL_T ) {
  34.298 +                if ( ctxt[cpu].user_regs.eflags & PSL_T ) 
  34.299 +                {
  34.300                      ctxt[cpu].user_regs.eflags &= ~PSL_T;
  34.301 -                    retval = xc_vcpu_setcontext(xc_handle, current_domid, 
  34.302 -                                                cpu, &ctxt[cpu]);
  34.303 -                    if ( retval ) {
  34.304 -                        perror("dom0 op failed");
  34.305 -                        goto error_out;
  34.306 -                    }
  34.307 +                    if ((retval = xc_vcpu_setcontext(xc_handle, current_domid, 
  34.308 +                                                cpu, &ctxt[cpu])))
  34.309 +                        goto out_error_dom0;
  34.310                  }
  34.311              }
  34.312          }
  34.313 @@ -436,31 +426,34 @@ xc_ptrace(
  34.314              op.cmd = DOM0_SETDEBUGGING;
  34.315              op.u.setdebugging.domain = current_domid;
  34.316              op.u.setdebugging.enable = 0;
  34.317 -            retval = do_dom0_op(xc_handle, &op);
  34.318 +            if ((retval = do_dom0_op(xc_handle, &op)))
  34.319 +                goto out_error_dom0;
  34.320          }
  34.321          regs_valid = 0;
  34.322 -        xc_domain_unpause(xc_handle, current_domid > 0 ? current_domid : -current_domid);
  34.323 +        if ((retval = xc_domain_unpause(xc_handle, current_domid > 0 ? 
  34.324 +                                current_domid : -current_domid)))
  34.325 +            goto out_error_dom0;
  34.326          break;
  34.327  
  34.328      case PTRACE_ATTACH:
  34.329          current_domid = domid_tid;
  34.330 +        current_isfile = (int)edata;
  34.331 +        if (current_isfile)
  34.332 +            break;
  34.333          op.cmd = DOM0_GETDOMAININFO;
  34.334          op.u.getdomaininfo.domain = current_domid;
  34.335          retval = do_dom0_op(xc_handle, &op);
  34.336          if ( retval || (op.u.getdomaininfo.domain != current_domid) )
  34.337 -        {
  34.338 -            perror("dom0 op failed");
  34.339 -            goto error_out;
  34.340 -        }
  34.341 +            goto out_error_dom0;
  34.342          if ( op.u.getdomaininfo.flags & DOMFLAGS_PAUSED )
  34.343 -        {
  34.344              printf("domain currently paused\n");
  34.345 -        } else
  34.346 -            retval = xc_domain_pause(xc_handle, current_domid);
  34.347 +        else if ((retval = xc_domain_pause(xc_handle, current_domid)))
  34.348 +            goto out_error_dom0;
  34.349          op.cmd = DOM0_SETDEBUGGING;
  34.350          op.u.setdebugging.domain = current_domid;
  34.351          op.u.setdebugging.enable = 1;
  34.352 -        retval = do_dom0_op(xc_handle, &op);
  34.353 +        if ((retval = do_dom0_op(xc_handle, &op)))
  34.354 +            goto out_error_dom0;
  34.355  
  34.356          if (get_online_cpumap(xc_handle, &op.u.getdomaininfo, &cpumap))
  34.357              printf("get_online_cpumap failed\n");
  34.358 @@ -474,26 +467,40 @@ xc_ptrace(
  34.359      case PTRACE_POKEUSER:
  34.360      case PTRACE_SYSCALL:
  34.361      case PTRACE_KILL:
  34.362 -#ifdef DEBUG
  34.363 -        printf("unsupported xc_ptrace request %s\n", ptrace_names[request]);
  34.364 -#endif
  34.365 -        /* XXX not yet supported */
  34.366 -        status = ENOSYS;
  34.367 -        break;
  34.368 +        goto out_unspported; /* XXX not yet supported */
  34.369  
  34.370      case PTRACE_TRACEME:
  34.371          printf("PTRACE_TRACEME is an invalid request under Xen\n");
  34.372 -        status = EINVAL;
  34.373 -    }
  34.374 -    
  34.375 -    if ( status )
  34.376 -    {
  34.377 -        errno = status;
  34.378 -        retval = -1;
  34.379 +        goto out_error;
  34.380      }
  34.381  
  34.382 - error_out:
  34.383 +    return retval;
  34.384 +
  34.385 + out_error_dom0:
  34.386 +    perror("dom0 op failed");
  34.387 + out_error:
  34.388 +    errno = EINVAL;
  34.389      return retval;
  34.390 +
  34.391 + out_unspported:
  34.392 +#ifdef DEBUG
  34.393 +    printf("unsupported xc_ptrace request %s\n", ptrace_names[request]);
  34.394 +#endif
  34.395 +    errno = ENOSYS;
  34.396 +    return -1;
  34.397 +
  34.398 +}
  34.399 +
  34.400 +int 
  34.401 +xc_waitdomain(
  34.402 +    int xc_handle,
  34.403 +    int domain,
  34.404 +    int *status,
  34.405 +    int options)
  34.406 +{
  34.407 +    if (current_isfile)
  34.408 +        return xc_waitdomain_core(xc_handle, domain, status, options, ctxt);
  34.409 +    return __xc_waitdomain(xc_handle, domain, status, options);
  34.410  }
  34.411  
  34.412  /*

    35.1 --- a/tools/libxc/xc_ptrace.h	Mon Mar 06 09:09:18 2006 -0700
    35.2 +++ b/tools/libxc/xc_ptrace.h	Mon Mar 06 10:21:35 2006 -0700
    35.3 @@ -1,6 +1,8 @@
    35.4  #ifndef XC_PTRACE_
    35.5  #define XC_PTRACE_
    35.6  
    35.7 +#include <thread_db.h>
    35.8 +
    35.9  #ifdef XC_PTRACE_PRIVATE
   35.10  #define X86_CR0_PE              0x00000001 /* Enable Protected Mode    (RW) */
   35.11  #define X86_CR0_PG              0x80000000 /* Paging                   (RW) */
   35.12 @@ -8,33 +10,7 @@
   35.13  #define PDRSHIFT        22
   35.14  #define PSL_T  0x00000100 /* trace enable bit */
   35.15  
   35.16 -char * ptrace_names[] = {
   35.17 -    "PTRACE_TRACEME",
   35.18 -    "PTRACE_PEEKTEXT",
   35.19 -    "PTRACE_PEEKDATA",
   35.20 -    "PTRACE_PEEKUSER",
   35.21 -    "PTRACE_POKETEXT",
   35.22 -    "PTRACE_POKEDATA",
   35.23 -    "PTRACE_POKEUSER",
   35.24 -    "PTRACE_CONT",
   35.25 -    "PTRACE_KILL",
   35.26 -    "PTRACE_SINGLESTEP",
   35.27 -    "PTRACE_INVALID",
   35.28 -    "PTRACE_INVALID",
   35.29 -    "PTRACE_GETREGS",
   35.30 -    "PTRACE_SETREGS",
   35.31 -    "PTRACE_GETFPREGS",
   35.32 -    "PTRACE_SETFPREGS",
   35.33 -    "PTRACE_ATTACH",
   35.34 -    "PTRACE_DETACH",
   35.35 -    "PTRACE_GETFPXREGS",
   35.36 -    "PTRACE_SETFPXREGS",
   35.37 -    "PTRACE_INVALID",
   35.38 -    "PTRACE_INVALID",
   35.39 -    "PTRACE_INVALID",
   35.40 -    "PTRACE_INVALID",
   35.41 -    "PTRACE_SYSCALL",
   35.42 -};
   35.43 +extern const char const * ptrace_names[];
   35.44  
   35.45  struct gdb_regs {
   35.46      long ebx; /* 0 */

    36.1 --- a/tools/libxc/xc_ptrace_core.c	Mon Mar 06 09:09:18 2006 -0700
    36.2 +++ b/tools/libxc/xc_ptrace_core.c	Mon Mar 06 10:21:35 2006 -0700
    36.3 @@ -1,82 +1,11 @@
    36.4 +#define XC_PTRACE_PRIVATE
    36.5 +
    36.6  #include <sys/ptrace.h>
    36.7  #include <sys/wait.h>
    36.8  #include "xc_private.h"
    36.9 +#include "xc_ptrace.h"
   36.10  #include <time.h>
   36.11  
   36.12 -#define BSD_PAGE_MASK (PAGE_SIZE-1)
   36.13 -#define PDRSHIFT        22
   36.14 -#define VCPU            0               /* XXX */
   36.15 -
   36.16 -/*
   36.17 - * long  
   36.18 - * ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);
   36.19 - */
   36.20 -
   36.21 -struct gdb_regs {
   36.22 -    long ebx; /* 0 */
   36.23 -    long ecx; /* 4 */
   36.24 -    long edx; /* 8 */
   36.25 -    long esi; /* 12 */
   36.26 -    long edi; /* 16 */
   36.27 -    long ebp; /* 20 */
   36.28 -    long eax; /* 24 */ 
   36.29 -    int  xds; /* 28 */
   36.30 -    int  xes; /* 32 */
   36.31 -    int  xfs; /* 36 */
   36.32 -    int  xgs; /* 40 */
   36.33 -    long orig_eax; /* 44 */
   36.34 -    long eip;    /* 48 */
   36.35 -    int  xcs;    /* 52 */
   36.36 -    long eflags; /* 56 */
   36.37 -    long esp;    /* 60 */     
   36.38 -    int  xss;    /* 64 */
   36.39 -};
   36.40 -
   36.41 -#define printval(x) printf("%s = %lx\n", #x, (long)x);
   36.42 -#define SET_PT_REGS(pt, xc)                     \
   36.43 -{                                               \
   36.44 -    pt.ebx = xc.ebx;                            \
   36.45 -    pt.ecx = xc.ecx;                            \
   36.46 -    pt.edx = xc.edx;                            \
   36.47 -    pt.esi = xc.esi;                            \
   36.48 -    pt.edi = xc.edi;                            \
   36.49 -    pt.ebp = xc.ebp;                            \
   36.50 -    pt.eax = xc.eax;                            \
   36.51 -    pt.eip = xc.eip;                            \
   36.52 -    pt.xcs = xc.cs;                             \
   36.53 -    pt.eflags = xc.eflags;                      \
   36.54 -    pt.esp = xc.esp;                            \
   36.55 -    pt.xss = xc.ss;                             \
   36.56 -    pt.xes = xc.es;                             \
   36.57 -    pt.xds = xc.ds;                             \
   36.58 -    pt.xfs = xc.fs;                             \
   36.59 -    pt.xgs = xc.gs;                             \
   36.60 -}
   36.61 -
   36.62 -#define SET_XC_REGS(pt, xc)                     \
   36.63 -{                                               \
   36.64 -    xc.ebx = pt->ebx;                           \
   36.65 -    xc.ecx = pt->ecx;                           \
   36.66 -    xc.edx = pt->edx;                           \
   36.67 -    xc.esi = pt->esi;                           \
   36.68 -    xc.edi = pt->edi;                           \
   36.69 -    xc.ebp = pt->ebp;                           \
   36.70 -    xc.eax = pt->eax;                           \
   36.71 -    xc.eip = pt->eip;                           \
   36.72 -    xc.cs = pt->xcs;                            \
   36.73 -    xc.eflags = pt->eflags;                     \
   36.74 -    xc.esp = pt->esp;                           \
   36.75 -    xc.ss = pt->xss;                            \
   36.76 -    xc.es = pt->xes;                            \
   36.77 -    xc.ds = pt->xds;                            \
   36.78 -    xc.fs = pt->xfs;                            \
   36.79 -    xc.gs = pt->xgs;                            \
   36.80 -}
   36.81 -
   36.82 -
   36.83 -#define vtopdi(va) ((va) >> PDRSHIFT)
   36.84 -#define vtopti(va) (((va) >> PAGE_SHIFT) & 0x3ff)
   36.85 -
   36.86  /* XXX application state */
   36.87  
   36.88  static long   nr_pages = 0;
   36.89 @@ -84,7 +13,6 @@ static unsigned long  *p2m_array = NULL;
   36.90  static unsigned long  *m2p_array = NULL;
   36.91  static unsigned long            pages_offset;
   36.92  static unsigned long            cr3[MAX_VIRT_CPUS];
   36.93 -static vcpu_guest_context_t     ctxt[MAX_VIRT_CPUS];
   36.94  
   36.95  /* --------------------- */
   36.96  
   36.97 @@ -92,11 +20,13 @@ static unsigned long
   36.98  map_mtop_offset(unsigned long ma)
   36.99  {
  36.100      return pages_offset + (m2p_array[ma >> PAGE_SHIFT] << PAGE_SHIFT);
  36.101 +    return 0;
  36.102  }
  36.103  
  36.104  
  36.105 -static void *
  36.106 -map_domain_va(unsigned long domfd, int cpu, void * guest_va)
  36.107 +void *
  36.108 +map_domain_va_core(unsigned long domfd, int cpu, void * guest_va,
  36.109 +                        vcpu_guest_context_t *ctxt)
  36.110  {
  36.111      unsigned long pde, page;
  36.112      unsigned long va = (unsigned long)guest_va;
  36.113 @@ -120,12 +50,12 @@ map_domain_va(unsigned long domfd, int c
  36.114          if (v == MAP_FAILED)
  36.115          {
  36.116              perror("mmap failed");
  36.117 -            goto error_out;
  36.118 +            return NULL;
  36.119          }
  36.120          cr3_virt[cpu] = v;
  36.121      } 
  36.122      if ((pde = cr3_virt[cpu][vtopdi(va)]) == 0) /* logical address */
  36.123 -        goto error_out;
  36.124 +        return NULL;
  36.125      if (ctxt[cpu].flags & VGCF_HVM_GUEST)
  36.126          pde = p2m_array[pde >> PAGE_SHIFT] << PAGE_SHIFT;
  36.127      if (pde != pde_phys[cpu]) 
  36.128 @@ -137,11 +67,11 @@ map_domain_va(unsigned long domfd, int c
  36.129              NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE, domfd,
  36.130              map_mtop_offset(pde_phys[cpu]));
  36.131          if (v == MAP_FAILED)
  36.132 -            goto error_out;
  36.133 +            return NULL;
  36.134          pde_virt[cpu] = v;
  36.135      }
  36.136      if ((page = pde_virt[cpu][vtopti(va)]) == 0) /* logical address */
  36.137 -        goto error_out;
  36.138 +        return NULL;
  36.139      if (ctxt[cpu].flags & VGCF_HVM_GUEST)
  36.140          page = p2m_array[page >> PAGE_SHIFT] << PAGE_SHIFT;
  36.141      if (page != page_phys[cpu]) 
  36.142 @@ -152,17 +82,15 @@ map_domain_va(unsigned long domfd, int c
  36.143          v = mmap(
  36.144              NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE, domfd,
  36.145              map_mtop_offset(page_phys[cpu]));
  36.146 -        if (v == MAP_FAILED) {
  36.147 +        if (v == MAP_FAILED)
  36.148 +        {
  36.149              printf("cr3 %lx pde %lx page %lx pti %lx\n", cr3[cpu], pde, page, vtopti(va));
  36.150              page_phys[cpu] = 0;
  36.151 -            goto error_out;
  36.152 +            return NULL;
  36.153          }
  36.154          page_virt[cpu] = v;
  36.155      } 
  36.156      return (void *)(((unsigned long)page_virt[cpu]) | (va & BSD_PAGE_MASK));
  36.157 -
  36.158 - error_out:
  36.159 -    return 0;
  36.160  }
  36.161  
  36.162  int 
  36.163 @@ -170,18 +98,26 @@ xc_waitdomain_core(
  36.164      int xc_handle,
  36.165      int domfd,
  36.166      int *status,
  36.167 -    int options)
  36.168 +    int options,
  36.169 +    vcpu_guest_context_t *ctxt)
  36.170  {
  36.171 -    int retval = -1;
  36.172      int nr_vcpus;
  36.173      int i;
  36.174      xc_core_header_t header;
  36.175  
  36.176 -    if (nr_pages == 0) {
  36.177 +    if (nr_pages == 0)
  36.178 +    {
  36.179  
  36.180          if (read(domfd, &header, sizeof(header)) != sizeof(header))
  36.181              return -1;
  36.182  
  36.183 +        if (header.xch_magic != XC_CORE_MAGIC) {
  36.184 +                printf("Magic number missmatch: 0x%08x (file) != "
  36.185 +                                        " 0x%08x (code)\n", header.xch_magic,
  36.186 +                                        XC_CORE_MAGIC);
  36.187 +                return -1;
  36.188 +        }
  36.189 +
  36.190          nr_pages = header.xch_nr_pages;
  36.191          nr_vcpus = header.xch_nr_vcpus;
  36.192          pages_offset = header.xch_pages_offset;
  36.193 @@ -193,17 +129,19 @@ xc_waitdomain_core(
  36.194          for (i = 0; i < nr_vcpus; i++) {
  36.195              cr3[i] = ctxt[i].ctrlreg[3];
  36.196          }
  36.197 -        if ((p2m_array = malloc(nr_pages * sizeof(unsigned long))) == NULL) {
  36.198 +        if ((p2m_array = malloc(nr_pages * sizeof(unsigned long))) == NULL)
  36.199 +        {
  36.200              printf("Could not allocate p2m_array\n");
  36.201 -            goto error_out;
  36.202 +            return -1;
  36.203          }
  36.204          if (read(domfd, p2m_array, sizeof(unsigned long)*nr_pages) != 
  36.205              sizeof(unsigned long)*nr_pages)
  36.206              return -1;
  36.207  
  36.208 -        if ((m2p_array = malloc((1<<20) * sizeof(unsigned long))) == NULL) {
  36.209 +        if ((m2p_array = malloc((1<<20) * sizeof(unsigned long))) == NULL)
  36.210 +        {
  36.211              printf("Could not allocate m2p array\n");
  36.212 -            goto error_out;
  36.213 +            return -1;
  36.214          }
  36.215          bzero(m2p_array, sizeof(unsigned long)* 1 << 20);
  36.216  
  36.217 @@ -212,89 +150,7 @@ xc_waitdomain_core(
  36.218          }
  36.219  
  36.220      }
  36.221 -    retval = 0;
  36.222 - error_out:
  36.223 -    return retval;
  36.224 -
  36.225 -}
  36.226 -
  36.227 -long
  36.228 -xc_ptrace_core(
  36.229 -    int xc_handle,
  36.230 -    enum __ptrace_request request,
  36.231 -    uint32_t domfd,
  36.232 -    long eaddr,
  36.233 -    long edata)
  36.234 -{
  36.235 -    int             status = 0;
  36.236 -    struct gdb_regs pt;
  36.237 -    long            retval = 0;
  36.238 -    unsigned long  *guest_va;
  36.239 -    int             cpu = VCPU;
  36.240 -    void           *addr = (char *)eaddr;
  36.241 -    void           *data = (char *)edata;
  36.242 -
  36.243 -#if 0
  36.244 -    printf("%20s %d, %p, %p \n", ptrace_names[request], domid, addr, data);
  36.245 -#endif
  36.246 -    switch (request) { 
  36.247 -    case PTRACE_PEEKTEXT:
  36.248 -    case PTRACE_PEEKDATA:
  36.249 -        if ((guest_va = (unsigned long *)map_domain_va(domfd, cpu, addr)) == NULL) {
  36.250 -            status = EFAULT;
  36.251 -            goto error_out;
  36.252 -        }
  36.253 -
  36.254 -        retval = *guest_va;
  36.255 -        break;
  36.256 -    case PTRACE_POKETEXT:
  36.257 -    case PTRACE_POKEDATA:
  36.258 -        if ((guest_va = (unsigned long *)map_domain_va(domfd, cpu, addr)) == NULL) {
  36.259 -            status = EFAULT;
  36.260 -            goto error_out;
  36.261 -        }
  36.262 -        *guest_va = (unsigned long)data;
  36.263 -        break;
  36.264 -    case PTRACE_GETREGS:
  36.265 -    case PTRACE_GETFPREGS:
  36.266 -    case PTRACE_GETFPXREGS:
  36.267 -        if (request == PTRACE_GETREGS) {
  36.268 -            SET_PT_REGS(pt, ctxt[cpu].user_regs); 
  36.269 -            memcpy(data, &pt, sizeof(struct gdb_regs));
  36.270 -        } else if (request == PTRACE_GETFPREGS)
  36.271 -            memcpy(data, &ctxt[cpu].fpu_ctxt, sizeof(ctxt[cpu].fpu_ctxt));
  36.272 -        else /*if (request == PTRACE_GETFPXREGS)*/
  36.273 -            memcpy(data, &ctxt[cpu].fpu_ctxt, sizeof(ctxt[cpu].fpu_ctxt));
  36.274 -        break;
  36.275 -    case PTRACE_ATTACH:
  36.276 -        retval = 0;
  36.277 -        break;
  36.278 -    case PTRACE_SETREGS:
  36.279 -    case PTRACE_SINGLESTEP:
  36.280 -    case PTRACE_CONT:
  36.281 -    case PTRACE_DETACH:
  36.282 -    case PTRACE_SETFPREGS:
  36.283 -    case PTRACE_SETFPXREGS:
  36.284 -    case PTRACE_PEEKUSER:
  36.285 -    case PTRACE_POKEUSER:
  36.286 -    case PTRACE_SYSCALL:
  36.287 -    case PTRACE_KILL:
  36.288 -#ifdef DEBUG
  36.289 -        printf("unsupported xc_ptrace request %s\n", ptrace_names[request]);
  36.290 -#endif
  36.291 -        status = ENOSYS;
  36.292 -        break;
  36.293 -    case PTRACE_TRACEME:
  36.294 -        printf("PTRACE_TRACEME is an invalid request under Xen\n");
  36.295 -        status = EINVAL;
  36.296 -    }
  36.297 -    
  36.298 -    if (status) {
  36.299 -        errno = status;
  36.300 -        retval = -1;
  36.301 -    }
  36.302 - error_out:
  36.303 -    return retval;
  36.304 +    return 0;
  36.305  }
  36.306  
  36.307  /*

    37.1 --- a/tools/libxc/xenctrl.h	Mon Mar 06 09:09:18 2006 -0700
    37.2 +++ b/tools/libxc/xenctrl.h	Mon Mar 06 10:21:35 2006 -0700
    37.3 @@ -92,19 +92,26 @@ typedef struct xc_core_header {
    37.4      unsigned int xch_pages_offset;
    37.5  } xc_core_header_t;
    37.6  
    37.7 +#define XC_CORE_MAGIC 0xF00FEBED
    37.8  
    37.9  long xc_ptrace_core(
   37.10      int xc_handle,
   37.11      enum __ptrace_request request, 
   37.12      uint32_t domid, 
   37.13      long addr, 
   37.14 -    long data);
   37.15 -
   37.16 +    long data,
   37.17 +    vcpu_guest_context_t *ctxt);
   37.18 +void * map_domain_va_core(
   37.19 +    unsigned long domfd, 
   37.20 +    int cpu, 
   37.21 +    void *guest_va,
   37.22 +    vcpu_guest_context_t *ctxt);
   37.23  int xc_waitdomain_core(
   37.24      int xc_handle,
   37.25      int domain, 
   37.26      int *status, 
   37.27 -    int options);
   37.28 +    int options,
   37.29 +    vcpu_guest_context_t *ctxt);
   37.30  
   37.31  /*
   37.32   * DOMAIN MANAGEMENT FUNCTIONS

    38.1 --- a/tools/misc/lomount/lomount.c	Mon Mar 06 09:09:18 2006 -0700
    38.2 +++ b/tools/misc/lomount/lomount.c	Mon Mar 06 10:21:35 2006 -0700
    38.3 @@ -24,16 +24,33 @@
    38.4   * THE SOFTWARE.
    38.5   */
    38.6  
    38.7 +/*
    38.8 + *  Return code:
    38.9 + *
   38.10 + *  bit 7 set:		lomount wrapper failed
   38.11 + *  bit 7 clear:	lomount wrapper ok; mount's return code in low 7 bits
   38.12 + *  0			success
   38.13 + */
   38.14 +
   38.15 +enum
   38.16 +{
   38.17 +	ERR_USAGE = 0x80,	// Incorrect usage
   38.18 +	ERR_PART_PARSE,		// Failed to parse partition table
   38.19 +	ERR_NO_PART,		// No such partition
   38.20 +	ERR_NO_EPART,		// No such extended partition
   38.21 +	ERR_MOUNT		// Other failure of mount command
   38.22 +};
   38.23 +
   38.24  #include <unistd.h>
   38.25  #include <stdio.h>
   38.26  #include <stdlib.h>
   38.27  #include <string.h>
   38.28  #include <strings.h>
   38.29 +#include <sys/wait.h>
   38.30  #include <errno.h>
   38.31  
   38.32  #define BUF 4096
   38.33  
   38.34 -//#define SECSIZE 4096    /* arbitrarilly large (it's probably just 512) */
   38.35  #define SECSIZE 512
   38.36  
   38.37  struct pentry 
   38.38 @@ -50,30 +67,32 @@ struct pentry
   38.39  	unsigned long no_of_sectors_abs;
   38.40  };
   38.41  
   38.42 -char * progname;
   38.43 -
   38.44 -int loadptable(const char *argv, struct pentry parttbl[], struct pentry **exttbl)
   38.45 +int loadptable(const char *diskimage, struct pentry parttbl[], struct pentry **exttbl, int * valid)
   38.46  {
   38.47 -	FILE *fd; 
   38.48 -	int i, valid, total_known_sectors = 0;
   38.49 +	FILE *fd;
   38.50 +	size_t size;
   38.51 +	int fail = 1;
   38.52 +	int i, total_known_sectors = 0;
   38.53  	unsigned char *pi; 
   38.54  	unsigned char data [SECSIZE]; 
   38.55  	unsigned long extent = 0, old_extent = 0, e_count = 1;
   38.56  	struct pentry exttbls[4];
   38.57  
   38.58 -	fd = fopen(argv, "r");
   38.59 +	*valid = 0;
   38.60 +
   38.61 +	fd = fopen(diskimage, "r");
   38.62  	if (fd == NULL)
   38.63  	{
   38.64 -		perror ("lomount"); 
   38.65 -		return 1;
   38.66 +		perror(diskimage);
   38.67 +		goto done;
   38.68  	}
   38.69 -	i = fread (&data, 1, sizeof (data), fd); 
   38.70 -	if (i < SECSIZE)
   38.71 +	size = fread (&data, 1, sizeof(data), fd);
   38.72 +	if (size < (size_t)sizeof(data))
   38.73  	{
   38.74 -		fprintf (stderr, "%s: could not read the entire first sector\n", progname); 
   38.75 -		return 1;
   38.76 +		fprintf(stderr, "Could not read the entire first sector of %s.\n", diskimage);
   38.77 +		goto done;
   38.78  	}
   38.79 -	for (i = 0;i < 4;i++)
   38.80 +	for (i = 0; i < 4; i++)
   38.81  	{
   38.82  		pi = &data [446 + 16 * i];
   38.83  		parttbl [i].bootable = *pi; 
   38.84 @@ -95,7 +114,7 @@ int loadptable(const char *argv, struct 
   38.85  			old_extent = extent;
   38.86  		}
   38.87  	}
   38.88 -	valid = (data [510] == 0x55 && data [511] == 0xaa) ? 1 : 0;
   38.89 +	*valid = (data [510] == 0x55 && data [511] == 0xaa) ? 1 : 0;
   38.90  	for (i = 0; i < 4; i++)
   38.91  	{
   38.92  		total_known_sectors += parttbl[i].no_of_sectors_abs;
   38.93 @@ -105,7 +124,7 @@ int loadptable(const char *argv, struct 
   38.94  #ifdef DEBUG
   38.95  	if (extent != 0)
   38.96  	{
   38.97 -		printf("extended partition detected at offset %d\n", extent);
   38.98 +		printf("extended partition detected at offset %ld\n", extent);
   38.99  	}
  38.100  #endif
  38.101  	while (extent != 0)
  38.102 @@ -113,14 +132,14 @@ int loadptable(const char *argv, struct 
  38.103  /* according to realloc(3) passing NULL as pointer is same as calling malloc() */
  38.104  		exttbl[0] = realloc(exttbl[0], e_count * sizeof(struct pentry));
  38.105  		fseek(fd, extent, SEEK_SET);
  38.106 -		i = fread (&data, 1, sizeof (data), fd); 
  38.107 -		if (i < SECSIZE)
  38.108 +		size = fread (&data, 1, sizeof(data), fd);
  38.109 +		if (size < (size_t)sizeof(data))
  38.110  		{
  38.111 -			fprintf (stderr, "%s: could not read the entire first sector\n", progname); 
  38.112 -			return 1;
  38.113 +			fprintf(stderr, "Could not read extended partition of %s.", diskimage);
  38.114 +			goto done;
  38.115  		}
  38.116  	/* only first 2 entrys are used in extented partition tables */
  38.117 -		for (i = 0;i < 2;i++)
  38.118 +		for (i = 0; i < 2; i++)
  38.119  		{
  38.120  			pi = &data [446 + 16 * i];
  38.121  			exttbls [i].bootable = *pi; 
  38.122 @@ -152,7 +171,7 @@ int loadptable(const char *argv, struct 
  38.123  			/* adjust for start of image instead of start of ext partition */
  38.124  				exttbl[0][e_count-1].start_sector_abs += (extent/SECSIZE);
  38.125  #ifdef DEBUG
  38.126 -				printf("extent %d start_sector_abs %d\n", extent, exttbl[0][e_count-1].start_sector_abs);
  38.127 +				printf("extent %ld start_sector_abs %ld\n", extent, exttbl[0][e_count-1].start_sector_abs);
  38.128  #endif
  38.129  			//else if (parttbl[i].system == 0x5)
  38.130  			}
  38.131 @@ -165,53 +184,71 @@ int loadptable(const char *argv, struct 
  38.132  		}
  38.133  		e_count ++;
  38.134  	}
  38.135 -	//fclose (fd);
  38.136 -	//the above segfaults (?!!!)
  38.137  #ifdef DEBUG
  38.138 -	printf("e_count = %d\n", e_count);
  38.139 +	printf("e_count = %ld\n", e_count);
  38.140  #endif
  38.141 -	return valid;
  38.142 +	fail = 0;
  38.143 +
  38.144 +done:
  38.145 +	if (fd)
  38.146 +		fclose(fd);
  38.147 +	return fail;
  38.148 +}
  38.149 +
  38.150 +void usage()
  38.151 +{
  38.152 +	fprintf(stderr, "You must specify at least -diskimage and -partition.\n");
  38.153 +	fprintf(stderr, "All other arguments are passed through to 'mount'.\n");
  38.154 +	fprintf(stderr, "ex. lomount -t fs-type -diskimage hda.img -partition 1 /mnt\n");
  38.155 +	exit(ERR_USAGE);
  38.156  }
  38.157  
  38.158  int main(int argc, char ** argv)
  38.159  {
  38.160 +	int status;
  38.161  	struct pentry perttbl [4];
  38.162  	struct pentry *exttbl[1], *parttbl;
  38.163 -	char buf[BUF], argv2[BUF], diskimage[BUF];
  38.164 -	int partition = 1, sec, num = 0, pnum = 0, len = BUF, i, f = 0, valid;
  38.165 -	progname = argv[0];
  38.166 +	char buf[BUF], argv2[BUF];
  38.167 +	const char * diskimage = 0;
  38.168 +	int partition = 0, sec, num = 0, pnum = 0, i, valid;
  38.169 +	size_t argv2_len = sizeof(argv2);
  38.170 +	argv2[0] = '\0';
  38.171  	exttbl[0] = NULL;
  38.172 +
  38.173  	for (i = 1; i < argc; i ++)
  38.174  	{
  38.175 -		if (strncmp(argv[i], "-diskimage", BUF)==0)
  38.176 +		if (strcmp(argv[i], "-diskimage")==0)
  38.177  		{
  38.178 -			strncpy(diskimage, argv[i+1], BUF);
  38.179 -			i++; f = 1;
  38.180 +			if (i == argc-1)
  38.181 +				usage();
  38.182 +			i++;
  38.183 +			diskimage = argv[i];
  38.184  		}
  38.185 -		else if (strncmp(argv[i], "-partition", BUF)==0)
  38.186 +		else if (strcmp(argv[i], "-partition")==0)
  38.187  		{
  38.188 -			partition = atoi(argv[i+1]);
  38.189 +			if (i == argc-1)
  38.190 +				usage();
  38.191  			i++;
  38.192 -			if (partition < 1) partition = 1;
  38.193 +			partition = atoi(argv[i]);
  38.194  		}
  38.195  		else
  38.196  		{
  38.197 -			strncat(argv2, argv[i], len);
  38.198 -			strncat(argv2, " ", len-1);
  38.199 -			len -= strlen(argv[i]);
  38.200 -			len--;
  38.201 +			size_t len = strlen(argv[i]);
  38.202 +			if (len >= argv2_len-1)
  38.203 +				usage();
  38.204 +			strcat(argv2, argv[i]);
  38.205 +			strcat(argv2, " ");
  38.206 +			len -= (len+1);
  38.207  		}
  38.208  	}
  38.209 -	if (!f)
  38.210 -	{
  38.211 -		printf("You must specify -diskimage and -partition\n");
  38.212 -		printf("ex. lomount -t fs-type -diskimage hda.img -partition 1 /mnt\n");
  38.213 -		return 0;
  38.214 -	}
  38.215 -	valid = loadptable(diskimage, perttbl, exttbl);
  38.216 +	if (! diskimage || partition < 1)
  38.217 +		usage();
  38.218 +
  38.219 +	if (loadptable(diskimage, perttbl, exttbl, &valid))
  38.220 +		return ERR_PART_PARSE;
  38.221  	if (!valid)
  38.222  	{
  38.223 -		printf("Warning: disk image does not appear to describe a valid partition table.\n");
  38.224 +		fprintf(stderr, "Warning: disk image does not appear to describe a valid partition table.\n");
  38.225  	}
  38.226  	/* NOTE: need to make sure this always rounds down */
  38.227  	//sec = total_known_sectors / sizeof_diskimage;
  38.228 @@ -228,14 +265,14 @@ off by (larger than) a value less than o
  38.229  	{
  38.230  		if (exttbl[0] == NULL)
  38.231  		{
  38.232 -		    printf("No extended partitions were found in %s.\n", diskimage);
  38.233 -		    return 2;
  38.234 +		    fprintf(stderr, "No extended partitions were found in %s.\n", diskimage);
  38.235 +		    return ERR_NO_EPART;
  38.236  		}
  38.237  		parttbl = exttbl[0];
  38.238  		if (parttbl[partition-5].no_of_sectors_abs == 0)
  38.239  		{
  38.240 -			printf("Partition %d was not found in %s.\n", partition, diskimage);
  38.241 -			return 3;
  38.242 +			fprintf(stderr, "Partition %d was not found in %s.\n", partition, diskimage);
  38.243 +			return ERR_NO_PART;
  38.244  		}
  38.245  		partition -= 4;
  38.246  	}
  38.247 @@ -244,8 +281,8 @@ off by (larger than) a value less than o
  38.248  		parttbl = perttbl;
  38.249  		if (parttbl[partition-1].no_of_sectors_abs == 0)
  38.250  		{
  38.251 -			printf("Partition %d was not found in %s.\n", partition, diskimage);
  38.252 -			return 3;
  38.253 +			fprintf(stderr, "Partition %d was not found in %s.\n", partition, diskimage);
  38.254 +			return ERR_NO_PART;
  38.255  		}
  38.256  	}
  38.257  	num = parttbl[partition-1].start_sector_abs;
  38.258 @@ -253,10 +290,14 @@ off by (larger than) a value less than o
  38.259  #ifdef DEBUG
  38.260  	printf("offset = %d\n", pnum);
  38.261  #endif
  38.262 -	snprintf(buf, BUF, "mount -oloop,offset=%d %s %s", pnum, diskimage, argv2);
  38.263 +	snprintf(buf, sizeof(buf), "mount -oloop,offset=%d %s %s", pnum, diskimage, argv2);
  38.264  #ifdef DEBUG
  38.265  	printf("%s\n", buf);
  38.266  #endif
  38.267 -	system(buf);
  38.268 -	return 0;
  38.269 +	status = system(buf);
  38.270 +	if (WIFEXITED(status))
  38.271 +		status = WEXITSTATUS(status);
  38.272 +	else
  38.273 +		status = ERR_MOUNT;
  38.274 +	return status;
  38.275  }

    39.1 --- a/tools/python/xen/xend/XendClient.py	Mon Mar 06 09:09:18 2006 -0700
    39.2 +++ b/tools/python/xen/xend/XendClient.py	Mon Mar 06 10:21:35 2006 -0700
    39.3 @@ -196,8 +196,9 @@ class Xend:
    39.4      def xend_domains(self):
    39.5          return self.xendGet(self.domainurl())
    39.6  
    39.7 -    def xend_list_domains(self):
    39.8 -        return self.xendGet(self.domainurl(), {'detail': '1'})
    39.9 +    def xend_list_domains(self, detail = True):
   39.10 +        return self.xendGet(self.domainurl(),
   39.11 +                            {'detail': detail and '1' or '0'})
   39.12  
   39.13      def xend_domain_vcpuinfo(self, dom):
   39.14          return self.xendGet(self.domainurl(dom), {'op': 'vcpuinfo'})

    40.1 --- a/tools/python/xen/xend/XendDomainInfo.py	Mon Mar 06 09:09:18 2006 -0700
    40.2 +++ b/tools/python/xen/xend/XendDomainInfo.py	Mon Mar 06 10:21:35 2006 -0700
    40.3 @@ -13,7 +13,7 @@
    40.4  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    40.5  #============================================================================
    40.6  # Copyright (C) 2004, 2005 Mike Wray <mike.wray@hp.com>
    40.7 -# Copyright (C) 2005 XenSource Ltd
    40.8 +# Copyright (C) 2005, 2006 XenSource Ltd
    40.9  #============================================================================
   40.10  
   40.11  """Representation of a single domain.
   40.12 @@ -82,7 +82,7 @@ restart_modes = [
   40.13  STATE_DOM_OK       = 1
   40.14  STATE_DOM_SHUTDOWN = 2
   40.15  
   40.16 -SHUTDOWN_TIMEOUT = 30
   40.17 +SHUTDOWN_TIMEOUT = 30.0
   40.18  
   40.19  ZOMBIE_PREFIX = 'Zombie-'
   40.20  
   40.21 @@ -182,7 +182,7 @@ def create(config):
   40.22          vm.initDomain()
   40.23          vm.storeVmDetails()
   40.24          vm.storeDomDetails()
   40.25 -        vm.registerWatch()
   40.26 +        vm.registerWatches()
   40.27          vm.refreshShutdown()
   40.28          return vm
   40.29      except:
   40.30 @@ -238,7 +238,7 @@ def recreate(xeninfo, priv):
   40.31          vm.storeVmDetails()
   40.32          vm.storeDomDetails()
   40.33  
   40.34 -    vm.registerWatch()
   40.35 +    vm.registerWatches()
   40.36      vm.refreshShutdown(xeninfo)
   40.37      return vm
   40.38  
   40.39 @@ -443,7 +443,10 @@ class XendDomainInfo:
   40.40          self.console_mfn = None
   40.41  
   40.42          self.vmWatch = None
   40.43 +        self.shutdownWatch = None
   40.44  
   40.45 +        self.shutdownStartTime = None
   40.46 +        
   40.47          self.state = STATE_DOM_OK
   40.48          self.state_updated = threading.Condition()
   40.49          self.refresh_shutdown_lock = threading.Condition()
   40.50 @@ -648,7 +651,7 @@ class XendDomainInfo:
   40.51  
   40.52          self.introduceDomain()
   40.53          self.storeDomDetails()
   40.54 -        self.registerWatch()
   40.55 +        self.registerWatches()
   40.56          self.refreshShutdown()
   40.57  
   40.58          log.debug("XendDomainInfo.completeRestore done")
   40.59 @@ -711,13 +714,15 @@ class XendDomainInfo:
   40.60  
   40.61      ## public:
   40.62  
   40.63 -    def registerWatch(self):
   40.64 -        """Register a watch on this VM's entries in the store, so that
   40.65 -        when they are changed externally, we keep up to date.  This should
   40.66 -        only be called by {@link #create}, {@link #recreate}, or {@link
   40.67 -        #restore}, once the domain's details have been written, but before the
   40.68 -        new instance is returned."""
   40.69 +    def registerWatches(self):
   40.70 +        """Register a watch on this VM's entries in the store, and the
   40.71 +        domain's control/shutdown node, so that when they are changed
   40.72 +        externally, we keep up to date.  This should only be called by {@link
   40.73 +        #create}, {@link #recreate}, or {@link #restore}, once the domain's
   40.74 +        details have been written, but before the new instance is returned."""
   40.75          self.vmWatch = xswatch(self.vmpath, self.storeChanged)
   40.76 +        self.shutdownWatch = xswatch(self.dompath + '/control/shutdown',
   40.77 +                                     self.handleShutdownWatch)
   40.78  
   40.79  
   40.80      def getDomid(self):
   40.81 @@ -852,20 +857,14 @@ class XendDomainInfo:
   40.82                  # Domain is alive.  If we are shutting it down, then check
   40.83                  # the timeout on that, and destroy it if necessary.
   40.84  
   40.85 -                sst = self.readDom('xend/shutdown_start_time')
   40.86 -                if sst:
   40.87 -                    sst = float(sst)
   40.88 -                    timeout = SHUTDOWN_TIMEOUT - time.time() + sst
   40.89 +                if self.shutdownStartTime:
   40.90 +                    timeout = (SHUTDOWN_TIMEOUT - time.time() +
   40.91 +                               self.shutdownStartTime)
   40.92                      if timeout < 0:
   40.93                          log.info(
   40.94                              "Domain shutdown timeout expired: name=%s id=%s",
   40.95                              self.info['name'], self.domid)
   40.96                          self.destroy()
   40.97 -                    else:
   40.98 -                        log.debug(
   40.99 -                            "Scheduling refreshShutdown on domain %d in %ds.",
  40.100 -                            self.domid, timeout)
  40.101 -                        threading.Timer(timeout, self.refreshShutdown).start()
  40.102          finally:
  40.103              self.refresh_shutdown_lock.release()
  40.104  
  40.105 @@ -873,12 +872,34 @@ class XendDomainInfo:
  40.106              self.maybeRestart(restart_reason)
  40.107  
  40.108  
  40.109 +    def handleShutdownWatch(self, _):
  40.110 +        log.debug('XendDomainInfo.handleShutdownWatch')
  40.111 +        
  40.112 +        reason = self.readDom('control/shutdown')
  40.113 +
  40.114 +        if reason and reason != 'suspend':
  40.115 +            sst = self.readDom('xend/shutdown_start_time')
  40.116 +            now = time.time()
  40.117 +            if sst:
  40.118 +                self.shutdownStartTime = float(sst)
  40.119 +                timeout = float(sst) + SHUTDOWN_TIMEOUT - now
  40.120 +            else:
  40.121 +                self.shutdownStartTime = now
  40.122 +                self.storeDom('xend/shutdown_start_time', now)
  40.123 +                timeout = SHUTDOWN_TIMEOUT
  40.124 +
  40.125 +            log.trace(
  40.126 +                "Scheduling refreshShutdown on domain %d in %ds.",
  40.127 +                self.domid, timeout)
  40.128 +            threading.Timer(timeout, self.refreshShutdown).start()
  40.129 +
  40.130 +        return 1
  40.131 +
  40.132 +
  40.133      def shutdown(self, reason):
  40.134          if not reason in shutdown_reasons.values():
  40.135              raise XendError('Invalid reason: %s' % reason)
  40.136          self.storeDom("control/shutdown", reason)
  40.137 -        if reason != 'suspend':
  40.138 -            self.storeDom('xend/shutdown_start_time', time.time())
  40.139  
  40.140  
  40.141      ## private:
  40.142 @@ -1225,6 +1246,8 @@ class XendDomainInfo:
  40.143          """Cleanup domain resources; release devices.  Idempotent.  Nothrow
  40.144          guarantee."""
  40.145  
  40.146 +        self.unwatchShutdown()
  40.147 +
  40.148          self.release_devices()
  40.149  
  40.150          if self.image:
  40.151 @@ -1276,6 +1299,20 @@ class XendDomainInfo:
  40.152              log.exception("Unwatching VM path failed.")
  40.153  
  40.154  
  40.155 +    def unwatchShutdown(self):
  40.156 +        """Remove the watch on the domain's control/shutdown node, if any.
  40.157 +        Idempotent.  Nothrow guarantee."""
  40.158 +
  40.159 +        try:
  40.160 +            try:
  40.161 +                if self.shutdownWatch:
  40.162 +                    self.shutdownWatch.unwatch()
  40.163 +            finally:
  40.164 +                self.shutdownWatch = None
  40.165 +        except:
  40.166 +            log.exception("Unwatching control/shutdown failed.")
  40.167 +
  40.168 +
  40.169      ## public:
  40.170  
  40.171      def destroy(self):

    41.1 --- a/tools/python/xen/xend/image.py	Mon Mar 06 09:09:18 2006 -0700
    41.2 +++ b/tools/python/xen/xend/image.py	Mon Mar 06 10:21:35 2006 -0700
    41.3 @@ -274,6 +274,10 @@ class HVMImageHandler(ImageHandler):
    41.4                  uname = sxp.child_value(info, 'uname')
    41.5                  typedev = sxp.child_value(info, 'dev')
    41.6                  (_, vbdparam) = string.split(uname, ':', 1)
    41.7 +
    41.8 +                if 'file:' in uname and not os.path.isfile(vbdparam):
    41.9 +                   raise VmError('Disk image does not exist: %s' % vbdparam)
   41.10 +
   41.11                  if 'ioemu:' in typedev:
   41.12                      (emtype, vbddev) = string.split(typedev, ':', 1)
   41.13                  else:

    42.1 --- a/tools/python/xen/xend/server/blkif.py	Mon Mar 06 09:09:18 2006 -0700
    42.2 +++ b/tools/python/xen/xend/server/blkif.py	Mon Mar 06 10:21:35 2006 -0700
    42.3 @@ -42,10 +42,6 @@ class BlkifController(DevController):
    42.4          """@see DevController.getDeviceDetails"""
    42.5  
    42.6          dev = sxp.child_value(config, 'dev')
    42.7 -        if 'ioemu:' in dev:
    42.8 -            return (None,{},{})
    42.9 -
   42.10 -        devid = blkif.blkdev_name_to_number(dev)
   42.11  
   42.12          (typ, params) = string.split(sxp.child_value(config, 'uname'), ':', 1)
   42.13          back = { 'dev'    : dev,
   42.14 @@ -54,7 +50,13 @@ class BlkifController(DevController):
   42.15                   'mode'   : sxp.child_value(config, 'mode', 'r')
   42.16                   }
   42.17  
   42.18 -        front = { 'virtual-device' : "%i" % devid }
   42.19 +        if 'ioemu:' in dev:
   42.20 +            (dummy, dev1) = string.split(dev, ':', 1)
   42.21 +            devid = blkif.blkdev_name_to_number(dev1)
   42.22 +            front = {}
   42.23 +        else:
   42.24 +            devid = blkif.blkdev_name_to_number(dev)
   42.25 +            front = { 'virtual-device' : "%i" % devid }
   42.26  
   42.27          return (devid, back, front)
   42.28  

    43.1 --- a/tools/python/xen/xm/main.py	Mon Mar 06 09:09:18 2006 -0700
    43.2 +++ b/tools/python/xen/xm/main.py	Mon Mar 06 10:21:35 2006 -0700
    43.3 @@ -396,10 +396,8 @@ def xm_vcpu_list(args):
    43.4      if args:
    43.5          dominfo = map(server.xend_domain_vcpuinfo, args)
    43.6      else:
    43.7 -        doms = server.xend_list_domains()
    43.8 -        dominfo = map(
    43.9 -            lambda x: server.xend_domain_vcpuinfo(sxp.child_value(x, 'name')),
   43.10 -            doms)
   43.11 +        doms = server.xend_list_domains(False)
   43.12 +        dominfo = map(server.xend_domain_vcpuinfo, doms)
   43.13  
   43.14      print 'Name                              ID  VCPU  CPU  State  Time(s)  CPU Affinity'
   43.15  

    44.1 --- a/tools/vtpm_manager/manager/dmictl.c	Mon Mar 06 09:09:18 2006 -0700
    44.2 +++ b/tools/vtpm_manager/manager/dmictl.c	Mon Mar 06 10:21:35 2006 -0700
    44.3 @@ -74,7 +74,13 @@ TPM_RESULT close_dmi( VTPM_DMI_RESOURCE 
    44.4  	  
    44.5    close(dmi_res->guest_tx_fh); dmi_res->guest_tx_fh = -1;
    44.6    close(dmi_res->vtpm_tx_fh);  dmi_res->vtpm_tx_fh = -1; 
    44.7 -		
    44.8 +  vtpm_globals->connected_dmis--;
    44.9 +
   44.10 +  if (vtpm_globals->connected_dmis == 0) {
   44.11 +    // No more DMI's connected. Close fifo to prevent a broken pipe.
   44.12 +    close(vtpm_globals->guest_rx_fh);
   44.13 +    vtpm_globals->guest_rx_fh = -1;
   44.14 +  }
   44.15   #ifndef MANUAL_DM_LAUNCH
   44.16    if (dmi_res->dmi_id != VTPM_CTL_DM) {
   44.17      if (dmi_res->dmi_pid != 0) {
   44.18 @@ -118,6 +124,7 @@ TPM_RESULT VTPM_Handle_New_DMI( const bu
   44.19      status = TPM_BAD_PARAMETER;
   44.20      goto abort_egress;
   44.21    } else {
   44.22 +    vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0
   44.23      BSG_UnpackList( param_buf->bytes, 3,
   44.24  		    BSG_TYPE_BYTE, &type,
   44.25  		    BSG_TYPE_UINT32, &domain_id,

    45.1 --- a/tools/vtpm_manager/manager/securestorage.c	Mon Mar 06 09:09:18 2006 -0700
    45.2 +++ b/tools/vtpm_manager/manager/securestorage.c	Mon Mar 06 10:21:35 2006 -0700
    45.3 @@ -307,8 +307,8 @@ TPM_RESULT VTPM_SaveService(void) {
    45.4    TPM_RESULT status=TPM_SUCCESS;
    45.5    int fh, dmis=-1;
    45.6  
    45.7 -  BYTE *flat_boot_key, *flat_dmis, *flat_enc;
    45.8 -  buffer_t clear_flat_global, enc_flat_global;
    45.9 +  BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL;
   45.10 +  buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF;
   45.11    UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap);
   45.12    UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap);
   45.13    struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes};
   45.14 @@ -328,12 +328,9 @@ TPM_RESULT VTPM_SaveService(void) {
   45.15                                                sizeof(UINT32) +// storagekeysize
   45.16                                                storageKeySize, NULL) ); // storage key
   45.17  
   45.18 -  flat_dmis_size = (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0)
   45.19 -                   (sizeof(UINT32) + 2*sizeof(TPM_DIGEST)); // Per DMI info
   45.20  
   45.21    flat_boot_key = (BYTE *) malloc( boot_key_size );
   45.22    flat_enc = (BYTE *) malloc( sizeof(UINT32) );
   45.23 -  flat_dmis = (BYTE *) malloc( flat_dmis_size );
   45.24  
   45.25    boot_key_size = BSG_PackList(flat_boot_key, 1,
   45.26                                 BSG_TPM_SIZE32_DATA, &boot_key_pack);
   45.27 @@ -349,9 +346,13 @@ TPM_RESULT VTPM_SaveService(void) {
   45.28  
   45.29    BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc);
   45.30  
   45.31 -  // Per DMI values to be saved
   45.32 +  // Per DMI values to be saved (if any exit)
   45.33    if (hashtable_count(vtpm_globals->dmi_map) > 0) {
   45.34  
   45.35 +    flat_dmis_size = (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0)
   45.36 +                     (sizeof(UINT32) + 2*sizeof(TPM_DIGEST)); // Per DMI info
   45.37 +    flat_dmis = (BYTE *) malloc( flat_dmis_size );
   45.38 +
   45.39      dmi_itr = hashtable_iterator(vtpm_globals->dmi_map);
   45.40      do {
   45.41        dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr);

    46.1 --- a/tools/vtpm_manager/manager/vtpm_manager.c	Mon Mar 06 09:09:18 2006 -0700
    46.2 +++ b/tools/vtpm_manager/manager/vtpm_manager.c	Mon Mar 06 10:21:35 2006 -0700
    46.3 @@ -754,6 +754,7 @@ TPM_RESULT VTPM_Init_Service() {
    46.4  #ifndef VTPM_MULTI_VM
    46.5    vtpm_globals->vtpm_rx_fh = -1;
    46.6    vtpm_globals->guest_rx_fh = -1;
    46.7 +  vtpm_globals->connected_dmis = 0;
    46.8  #endif
    46.9    if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){
   46.10      status = TPM_FAIL;

    47.1 --- a/tools/vtpm_manager/manager/vtpmpriv.h	Mon Mar 06 09:09:18 2006 -0700
    47.2 +++ b/tools/vtpm_manager/manager/vtpmpriv.h	Mon Mar 06 10:21:35 2006 -0700
    47.3 @@ -98,6 +98,7 @@ typedef struct tdVTPM_GLOBALS {
    47.4  #ifndef VTPM_MULTI_VM
    47.5    int                 vtpm_rx_fh;
    47.6    int                 guest_rx_fh;
    47.7 +  int                 connected_dmis;     // Used to close guest_rx when no dmis are connected
    47.8    
    47.9    pid_t               master_pid;
   47.10  #endif

    48.1 --- a/tools/xenstore/Makefile	Mon Mar 06 09:09:18 2006 -0700
    48.2 +++ b/tools/xenstore/Makefile	Mon Mar 06 10:21:35 2006 -0700
    48.3 @@ -27,21 +27,27 @@ CLIENTS := xenstore-exists xenstore-list
    48.4  CLIENTS += xenstore-write
    48.5  CLIENTS_OBJS := $(patsubst xenstore-%,xenstore_%.o,$(CLIENTS))
    48.6  
    48.7 -all: libxenstore.so xenstored $(CLIENTS) xs_tdb_dump xenstore-ls
    48.8 +all: libxenstore.so xenstored $(CLIENTS) xs_tdb_dump xenstore-control xenstore-ls
    48.9 +
   48.10 +test_interleaved_transactions: test_interleaved_transactions.o
   48.11 +	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -L. -lxenstore -o $@
   48.12  
   48.13  testcode: xs_test xenstored_test xs_random
   48.14  
   48.15 -xenstored: xenstored_core.o xenstored_watch.o xenstored_domain.o xenstored_transaction.o xs_lib.o talloc.o utils.o tdb.o
   48.16 +xenstored: xenstored_core.o xenstored_watch.o xenstored_domain.o xenstored_transaction.o xs_lib.o talloc.o utils.o tdb.o hashtable.o
   48.17  	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -lxenctrl -o $@
   48.18  
   48.19  $(CLIENTS): xenstore-%: xenstore_%.o libxenstore.so
   48.20 -	$(LINK.o) $< $(LOADLIBES) $(LDLIBS) -lxenctrl -L. -lxenstore -o $@
   48.21 +	$(LINK.o) $< $(LOADLIBES) $(LDLIBS) -L. -lxenstore -o $@
   48.22  
   48.23  $(CLIENTS_OBJS): xenstore_%.o: xenstore_client.c
   48.24  	$(COMPILE.c) -DCLIENT_$(*F) -o $@ $<
   48.25  
   48.26 +xenstore-control: xenstore_control.o libxenstore.so
   48.27 +	$(LINK.o) $< $(LOADLIBES) $(LDLIBS) -L. -lxenstore -o $@
   48.28 +
   48.29  xenstore-ls: xsls.o libxenstore.so
   48.30 -	$(LINK.o) $< $(LOADLIBES) $(LDLIBS) -lxenctrl -L. -lxenstore -o $@
   48.31 +	$(LINK.o) $< $(LOADLIBES) $(LDLIBS) -L. -lxenstore -o $@
   48.32  
   48.33  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 tdb.o
   48.34  	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@
   48.35 @@ -77,7 +83,8 @@ libxenstore.so: xs.opic xs_lib.opic
   48.36  clean: testsuite-clean
   48.37  	rm -f *.o *.opic *.so
   48.38  	rm -f xenstored xs_random xs_stress xs_crashme
   48.39 -	rm -f xs_test xenstored_test xs_tdb_dump xenstore-ls $(CLIENTS)
   48.40 +	rm -f xs_test xenstored_test xs_tdb_dump xenstore-control xenstore-ls
   48.41 +	rm -f $(CLIENTS)
   48.42  	$(RM) $(PROG_DEP)
   48.43  
   48.44  print-dir:
   48.45 @@ -129,7 +136,7 @@ TAGS:
   48.46  tarball: clean
   48.47  	cd .. && tar -c -j -v -h -f xenstore.tar.bz2 xenstore/
   48.48  
   48.49 -install: libxenstore.so xenstored xenstore-ls $(CLIENTS)
   48.50 +install: all
   48.51  	$(INSTALL_DIR) -p $(DESTDIR)/var/run/xenstored
   48.52  	$(INSTALL_DIR) -p $(DESTDIR)/var/lib/xenstored
   48.53  	$(INSTALL_DIR) -p $(DESTDIR)/usr/bin
   48.54 @@ -137,6 +144,7 @@ install: libxenstore.so xenstored xensto
   48.55  	$(INSTALL_DIR) -p $(DESTDIR)/usr/include
   48.56  	$(INSTALL_PROG) xenstored $(DESTDIR)/usr/sbin
   48.57  	$(INSTALL_PROG) $(CLIENTS) $(DESTDIR)/usr/bin
   48.58 +	$(INSTALL_PROG) xenstore-control $(DESTDIR)/usr/bin
   48.59  	$(INSTALL_PROG) xenstore-ls $(DESTDIR)/usr/bin
   48.60  	$(INSTALL_DIR) -p $(DESTDIR)/usr/$(LIBDIR)
   48.61  	$(INSTALL_DATA) libxenstore.so $(DESTDIR)/usr/$(LIBDIR)

    49.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    49.2 +++ b/tools/xenstore/hashtable.c	Mon Mar 06 10:21:35 2006 -0700
    49.3 @@ -0,0 +1,276 @@
    49.4 +/* Copyright (C) 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
    49.5 +
    49.6 +#include "hashtable.h"
    49.7 +#include "hashtable_private.h"
    49.8 +#include <stdlib.h>
    49.9 +#include <stdio.h>
   49.10 +#include <string.h>
   49.11 +#include <math.h>
   49.12 +#include <stdint.h>
   49.13 +
   49.14 +/*
   49.15 +Credit for primes table: Aaron Krowne
   49.16 + http://br.endernet.org/~akrowne/
   49.17 + http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
   49.18 +*/
   49.19 +static const unsigned int primes[] = {
   49.20 +53, 97, 193, 389,
   49.21 +769, 1543, 3079, 6151,
   49.22 +12289, 24593, 49157, 98317,
   49.23 +196613, 393241, 786433, 1572869,
   49.24 +3145739, 6291469, 12582917, 25165843,
   49.25 +50331653, 100663319, 201326611, 402653189,
   49.26 +805306457, 1610612741
   49.27 +};
   49.28 +const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]);
   49.29 +const unsigned int max_load_factor = 65; /* percentage */
   49.30 +
   49.31 +/*****************************************************************************/
   49.32 +struct hashtable *
   49.33 +create_hashtable(unsigned int minsize,
   49.34 +                 unsigned int (*hashf) (void*),
   49.35 +                 int (*eqf) (void*,void*))
   49.36 +{
   49.37 +    struct hashtable *h;
   49.38 +    unsigned int pindex, size = primes[0];
   49.39 +    /* Check requested hashtable isn't too large */
   49.40 +    if (minsize > (1u << 30)) return NULL;
   49.41 +    /* Enforce size as prime */
   49.42 +    for (pindex=0; pindex < prime_table_length; pindex++) {
   49.43 +        if (primes[pindex] > minsize) { size = primes[pindex]; break; }
   49.44 +    }
   49.45 +    h = (struct hashtable *)malloc(sizeof(struct hashtable));
   49.46 +    if (NULL == h) return NULL; /*oom*/
   49.47 +    h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
   49.48 +    if (NULL == h->table) { free(h); return NULL; } /*oom*/
   49.49 +    memset(h->table, 0, size * sizeof(struct entry *));
   49.50 +    h->tablelength  = size;
   49.51 +    h->primeindex   = pindex;
   49.52 +    h->entrycount   = 0;
   49.53 +    h->hashfn       = hashf;
   49.54 +    h->eqfn         = eqf;
   49.55 +    h->loadlimit    = (unsigned int)(((uint64_t)size * max_load_factor) / 100);
   49.56 +    return h;
   49.57 +}
   49.58 +
   49.59 +/*****************************************************************************/
   49.60 +unsigned int
   49.61 +hash(struct hashtable *h, void *k)
   49.62 +{
   49.63 +    /* Aim to protect against poor hash functions by adding logic here
   49.64 +     * - logic taken from java 1.4 hashtable source */
   49.65 +    unsigned int i = h->hashfn(k);
   49.66 +    i += ~(i << 9);
   49.67 +    i ^=  ((i >> 14) | (i << 18)); /* >>> */
   49.68 +    i +=  (i << 4);
   49.69 +    i ^=  ((i >> 10) | (i << 22)); /* >>> */
   49.70 +    return i;
   49.71 +}
   49.72 +
   49.73 +/*****************************************************************************/
   49.74 +static int
   49.75 +hashtable_expand(struct hashtable *h)
   49.76 +{
   49.77 +    /* Double the size of the table to accomodate more entries */
   49.78 +    struct entry **newtable;
   49.79 +    struct entry *e;
   49.80 +    struct entry **pE;
   49.81 +    unsigned int newsize, i, index;
   49.82 +    /* Check we're not hitting max capacity */
   49.83 +    if (h->primeindex == (prime_table_length - 1)) return 0;
   49.84 +    newsize = primes[++(h->primeindex)];
   49.85 +
   49.86 +    newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize);
   49.87 +    if (NULL != newtable)
   49.88 +    {
   49.89 +        memset(newtable, 0, newsize * sizeof(struct entry *));
   49.90 +        /* This algorithm is not 'stable'. ie. it reverses the list
   49.91 +         * when it transfers entries between the tables */
   49.92 +        for (i = 0; i < h->tablelength; i++) {
   49.93 +            while (NULL != (e = h->table[i])) {
   49.94 +                h->table[i] = e->next;
   49.95 +                index = indexFor(newsize,e->h);
   49.96 +                e->next = newtable[index];
   49.97 +                newtable[index] = e;
   49.98 +            }
   49.99 +        }
  49.100 +        free(h->table);
  49.101 +        h->table = newtable;
  49.102 +    }
  49.103 +    /* Plan B: realloc instead */
  49.104 +    else 
  49.105 +    {
  49.106 +        newtable = (struct entry **)
  49.107 +                   realloc(h->table, newsize * sizeof(struct entry *));
  49.108 +        if (NULL == newtable) { (h->primeindex)--; return 0; }
  49.109 +        h->table = newtable;
  49.110 +        memset(newtable[h->tablelength], 0, newsize - h->tablelength);
  49.111 +        for (i = 0; i < h->tablelength; i++) {
  49.112 +            for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
  49.113 +                index = indexFor(newsize,e->h);
  49.114 +                if (index == i)
  49.115 +                {
  49.116 +                    pE = &(e->next);
  49.117 +                }
  49.118 +                else
  49.119 +                {
  49.120 +                    *pE = e->next;
  49.121 +                    e->next = newtable[index];
  49.122 +                    newtable[index] = e;
  49.123 +                }
  49.124 +            }
  49.125 +        }
  49.126 +    }
  49.127 +    h->tablelength = newsize;
  49.128 +    h->loadlimit   = (unsigned int)
  49.129 +        (((uint64_t)newsize * max_load_factor) / 100);
  49.130 +    return -1;
  49.131 +}
  49.132 +
  49.133 +/*****************************************************************************/
  49.134 +unsigned int
  49.135 +hashtable_count(struct hashtable *h)
  49.136 +{
  49.137 +    return h->entrycount;
  49.138 +}
  49.139 +
  49.140 +/*****************************************************************************/
  49.141 +int
  49.142 +hashtable_insert(struct hashtable *h, void *k, void *v)
  49.143 +{
  49.144 +    /* This method allows duplicate keys - but they shouldn't be used */
  49.145 +    unsigned int index;
  49.146 +    struct entry *e;
  49.147 +    if (++(h->entrycount) > h->loadlimit)
  49.148 +    {
  49.149 +        /* Ignore the return value. If expand fails, we should
  49.150 +         * still try cramming just this value into the existing table
  49.151 +         * -- we may not have memory for a larger table, but one more
  49.152 +         * element may be ok. Next time we insert, we'll try expanding again.*/
  49.153 +        hashtable_expand(h);
  49.154 +    }
  49.155 +    e = (struct entry *)malloc(sizeof(struct entry));
  49.156 +    if (NULL == e) { --(h->entrycount); return 0; } /*oom*/
  49.157 +    e->h = hash(h,k);
  49.158 +    index = indexFor(h->tablelength,e->h);
  49.159 +    e->k = k;
  49.160 +    e->v = v;
  49.161 +    e->next = h->table[index];
  49.162 +    h->table[index] = e;
  49.163 +    return -1;
  49.164 +}
  49.165 +
  49.166 +/*****************************************************************************/
  49.167 +void * /* returns value associated with key */
  49.168 +hashtable_search(struct hashtable *h, void *k)
  49.169 +{
  49.170 +    struct entry *e;
  49.171 +    unsigned int hashvalue, index;
  49.172 +    hashvalue = hash(h,k);
  49.173 +    index = indexFor(h->tablelength,hashvalue);
  49.174 +    e = h->table[index];
  49.175 +    while (NULL != e)
  49.176 +    {
  49.177 +        /* Check hash value to short circuit heavier comparison */
  49.178 +        if ((hashvalue == e->h) && (h->eqfn(k, e->k))) return e->v;
  49.179 +        e = e->next;
  49.180 +    }
  49.181 +    return NULL;
  49.182 +}
  49.183 +
  49.184 +/*****************************************************************************/
  49.185 +void * /* returns value associated with key */
  49.186 +hashtable_remove(struct hashtable *h, void *k)
  49.187 +{
  49.188 +    /* TODO: consider compacting the table when the load factor drops enough,
  49.189 +     *       or provide a 'compact' method. */
  49.190 +
  49.191 +    struct entry *e;
  49.192 +    struct entry **pE;
  49.193 +    void *v;
  49.194 +    unsigned int hashvalue, index;
  49.195 +
  49.196 +    hashvalue = hash(h,k);
  49.197 +    index = indexFor(h->tablelength,hash(h,k));
  49.198 +    pE = &(h->table[index]);
  49.199 +    e = *pE;
  49.200 +    while (NULL != e)
  49.201 +    {
  49.202 +        /* Check hash value to short circuit heavier comparison */
  49.203 +        if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
  49.204 +        {
  49.205 +            *pE = e->next;
  49.206 +            h->entrycount--;
  49.207 +            v = e->v;
  49.208 +            freekey(e->k);
  49.209 +            free(e);
  49.210 +            return v;
  49.211 +        }
  49.212 +        pE = &(e->next);
  49.213 +        e = e->next;
  49.214 +    }
  49.215 +    return NULL;
  49.216 +}
  49.217 +
  49.218 +/*****************************************************************************/
  49.219 +/* destroy */
  49.220 +void
  49.221 +hashtable_destroy(struct hashtable *h, int free_values)
  49.222 +{
  49.223 +    unsigned int i;
  49.224 +    struct entry *e, *f;
  49.225 +    struct entry **table = h->table;
  49.226 +    if (free_values)
  49.227 +    {
  49.228 +        for (i = 0; i < h->tablelength; i++)
  49.229 +        {
  49.230 +            e = table[i];
  49.231 +            while (NULL != e)
  49.232 +            { f = e; e = e->next; freekey(f->k); free(f->v); free(f); }
  49.233 +        }
  49.234 +    }
  49.235 +    else
  49.236 +    {
  49.237 +        for (i = 0; i < h->tablelength; i++)
  49.238 +        {
  49.239 +            e = table[i];
  49.240 +            while (NULL != e)
  49.241 +            { f = e; e = e->next; freekey(f->k); free(f); }
  49.242 +        }
  49.243 +    }
  49.244 +    free(h->table);
  49.245 +    free(h);
  49.246 +}
  49.247 +
  49.248 +/*
  49.249 + * Copyright (c) 2002, Christopher Clark
  49.250 + * All rights reserved.
  49.251 + * 
  49.252 + * Redistribution and use in source and binary forms, with or without
  49.253 + * modification, are permitted provided that the following conditions
  49.254 + * are met:
  49.255 + * 
  49.256 + * * Redistributions of source code must retain the above copyright
  49.257 + * notice, this list of conditions and the following disclaimer.
  49.258 + * 
  49.259 + * * Redistributions in binary form must reproduce the above copyright
  49.260 + * notice, this list of conditions and the following disclaimer in the
  49.261 + * documentation and/or other materials provided with the distribution.
  49.262 + * 
  49.263 + * * Neither the name of the original author; nor the names of any contributors
  49.264 + * may be used to endorse or promote products derived from this software
  49.265 + * without specific prior written permission.
  49.266 + * 
  49.267 + * 
  49.268 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  49.269 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  49.270 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  49.271 + * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  49.272 + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  49.273 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  49.274 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  49.275 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  49.276 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  49.277 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  49.278 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  49.279 +*/

    50.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    50.2 +++ b/tools/xenstore/hashtable.h	Mon Mar 06 10:21:35 2006 -0700
    50.3 @@ -0,0 +1,199 @@
    50.4 +/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
    50.5 +
    50.6 +#ifndef __HASHTABLE_CWC22_H__
    50.7 +#define __HASHTABLE_CWC22_H__
    50.8 +
    50.9 +struct hashtable;
   50.10 +
   50.11 +/* Example of use:
   50.12 + *
   50.13 + *      struct hashtable  *h;
   50.14 + *      struct some_key   *k;
   50.15 + *      struct some_value *v;
   50.16 + *
   50.17 + *      static unsigned int         hash_from_key_fn( void *k );
   50.18 + *      static int                  keys_equal_fn ( void *key1, void *key2 );
   50.19 + *
   50.20 + *      h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
   50.21 + *      k = (struct some_key *)     malloc(sizeof(struct some_key));
   50.22 + *      v = (struct some_value *)   malloc(sizeof(struct some_value));
   50.23 + *
   50.24 + *      (initialise k and v to suitable values)
   50.25 + * 
   50.26 + *      if (! hashtable_insert(h,k,v) )
   50.27 + *      {     exit(-1);               }
   50.28 + *
   50.29 + *      if (NULL == (found = hashtable_search(h,k) ))
   50.30 + *      {    printf("not found!");                  }
   50.31 + *
   50.32 + *      if (NULL == (found = hashtable_remove(h,k) ))
   50.33 + *      {    printf("Not found\n");                 }
   50.34 + *
   50.35 + */
   50.36 +
   50.37 +/* Macros may be used to define type-safe(r) hashtable access functions, with
   50.38 + * methods specialized to take known key and value types as parameters.
   50.39 + * 
   50.40 + * Example:
   50.41 + *
   50.42 + * Insert this at the start of your file:
   50.43 + *
   50.44 + * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value);
   50.45 + * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value);
   50.46 + * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value);
   50.47 + *
   50.48 + * This defines the functions 'insert_some', 'search_some' and 'remove_some'.
   50.49 + * These operate just like hashtable_insert etc., with the same parameters,
   50.50 + * but their function signatures have 'struct some_key *' rather than
   50.51 + * 'void *', and hence can generate compile time errors if your program is
   50.52 + * supplying incorrect data as a key (and similarly for value).
   50.53 + *
   50.54 + * Note that the hash and key equality functions passed to create_hashtable
   50.55 + * still take 'void *' parameters instead of 'some key *'. This shouldn't be
   50.56 + * a difficult issue as they're only defined and passed once, and the other
   50.57 + * functions will ensure that only valid keys are supplied to them.
   50.58 + *
   50.59 + * The cost for this checking is increased code size and runtime overhead
   50.60 + * - if performance is important, it may be worth switching back to the
   50.61 + * unsafe methods once your program has been debugged with the safe methods.
   50.62 + * This just requires switching to some simple alternative defines - eg:
   50.63 + * #define insert_some hashtable_insert
   50.64 + *
   50.65 + */
   50.66 +
   50.67 +/*****************************************************************************
   50.68 + * create_hashtable
   50.69 +   
   50.70 + * @name                    create_hashtable
   50.71 + * @param   minsize         minimum initial size of hashtable
   50.72 + * @param   hashfunction    function for hashing keys
   50.73 + * @param   key_eq_fn       function for determining key equality
   50.74 + * @return                  newly created hashtable or NULL on failure
   50.75 + */
   50.76 +
   50.77 +struct hashtable *
   50.78 +create_hashtable(unsigned int minsize,
   50.79 +                 unsigned int (*hashfunction) (void*),
   50.80 +                 int (*key_eq_fn) (void*,void*));
   50.81 +
   50.82 +/*****************************************************************************
   50.83 + * hashtable_insert
   50.84 +   
   50.85 + * @name        hashtable_insert
   50.86 + * @param   h   the hashtable to insert into
   50.87 + * @param   k   the key - hashtable claims ownership and will free on removal
   50.88 + * @param   v   the value - does not claim ownership
   50.89 + * @return      non-zero for successful insertion
   50.90 + *
   50.91 + * This function will cause the table to expand if the insertion would take
   50.92 + * the ratio of entries to table size over the maximum load factor.
   50.93 + *
   50.94 + * This function does not check for repeated insertions with a duplicate key.
   50.95 + * The value returned when using a duplicate key is undefined -- when
   50.96 + * the hashtable changes size, the order of retrieval of duplicate key
   50.97 + * entries is reversed.
   50.98 + * If in doubt, remove before insert.
   50.99 + */
  50.100 +
  50.101 +int 
  50.102 +hashtable_insert(struct hashtable *h, void *k, void *v);
  50.103 +
  50.104 +#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \
  50.105 +int fnname (struct hashtable *h, keytype *k, valuetype *v) \
  50.106 +{ \
  50.107 +    return hashtable_insert(h,k,v); \
  50.108 +}
  50.109 +
  50.110 +/*****************************************************************************
  50.111 + * hashtable_search
  50.112 +   
  50.113 + * @name        hashtable_search
  50.114 + * @param   h   the hashtable to search
  50.115 + * @param   k   the key to search for  - does not claim ownership
  50.116 + * @return      the value associated with the key, or NULL if none found
  50.117 + */
  50.118 +
  50.119 +void *
  50.120 +hashtable_search(struct hashtable *h, void *k);
  50.121 +
  50.122 +#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \
  50.123 +valuetype * fnname (struct hashtable *h, keytype *k) \
  50.124 +{ \
  50.125 +    return (valuetype *) (hashtable_search(h,k)); \
  50.126 +}
  50.127 +
  50.128 +/*****************************************************************************
  50.129 + * hashtable_remove
  50.130 +   
  50.131 + * @name        hashtable_remove
  50.132 + * @param   h   the hashtable to remove the item from
  50.133 + * @param   k   the key to search for  - does not claim ownership
  50.134 + * @return      the value associated with the key, or NULL if none found
  50.135 + */
  50.136 +
  50.137 +void * /* returns value */
  50.138 +hashtable_remove(struct hashtable *h, void *k);
  50.139 +
  50.140 +#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \
  50.141 +valuetype * fnname (struct hashtable *h, keytype *k) \
  50.142 +{ \
  50.143 +    return (valuetype *) (hashtable_remove(h,k)); \
  50.144 +}
  50.145 +
  50.146 +
  50.147 +/*****************************************************************************
  50.148 + * hashtable_count
  50.149 +   
  50.150 + * @name        hashtable_count
  50.151 + * @param   h   the hashtable
  50.152 + * @return      the number of items stored in the hashtable
  50.153 + */
  50.154 +unsigned int
  50.155 +hashtable_count(struct hashtable *h);
  50.156 +
  50.157 +
  50.158 +/*****************************************************************************
  50.159 + * hashtable_destroy
  50.160 +   
  50.161 + * @name        hashtable_destroy
  50.162 + * @param   h   the hashtable
  50.163 + * @param       free_values     whether to call 'free' on the remaining values
  50.164 + */
  50.165 +
  50.166 +void
  50.167 +hashtable_destroy(struct hashtable *h, int free_values);
  50.168 +
  50.169 +#endif /* __HASHTABLE_CWC22_H__ */
  50.170 +
  50.171 +/*
  50.172 + * Copyright (c) 2002, Christopher Clark
  50.173 + * All rights reserved.
  50.174 + * 
  50.175 + * Redistribution and use in source and binary forms, with or without
  50.176 + * modification, are permitted provided that the following conditions
  50.177 + * are met:
  50.178 + * 
  50.179 + * * Redistributions of source code must retain the above copyright
  50.180 + * notice, this list of conditions and the following disclaimer.
  50.181 + * 
  50.182 + * * Redistributions in binary form must reproduce the above copyright
  50.183 + * notice, this list of conditions and the following disclaimer in the
  50.184 + * documentation and/or other materials provided with the distribution.
  50.185 + * 
  50.186 + * * Neither the name of the original author; nor the names of any contributors
  50.187 + * may be used to endorse or promote products derived from this software
  50.188 + * without specific prior written permission.
  50.189 + * 
  50.190 + * 
  50.191 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  50.192 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  50.193 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  50.194 + * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  50.195 + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  50.196 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  50.197 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  50.198 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  50.199 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  50.200 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  50.201 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  50.202 +*/

    51.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    51.2 +++ b/tools/xenstore/hashtable_private.h	Mon Mar 06 10:21:35 2006 -0700
    51.3 @@ -0,0 +1,85 @@
    51.4 +/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
    51.5 +
    51.6 +#ifndef __HASHTABLE_PRIVATE_CWC22_H__
    51.7 +#define __HASHTABLE_PRIVATE_CWC22_H__
    51.8 +
    51.9 +#include "hashtable.h"
   51.10 +
   51.11 +/*****************************************************************************/
   51.12 +struct entry
   51.13 +{
   51.14 +    void *k, *v;
   51.15 +    unsigned int h;
   51.16 +    struct entry *next;
   51.17 +};
   51.18 +
   51.19 +struct hashtable {
   51.20 +    unsigned int tablelength;
   51.21 +    struct entry **table;
   51.22 +    unsigned int entrycount;
   51.23 +    unsigned int loadlimit;
   51.24 +    unsigned int primeindex;
   51.25 +    unsigned int (*hashfn) (void *k);
   51.26 +    int (*eqfn) (void *k1, void *k2);
   51.27 +};
   51.28 +
   51.29 +/*****************************************************************************/
   51.30 +unsigned int
   51.31 +hash(struct hashtable *h, void *k);
   51.32 +
   51.33 +/*****************************************************************************/
   51.34 +/* indexFor */
   51.35 +static inline unsigned int
   51.36 +indexFor(unsigned int tablelength, unsigned int hashvalue) {
   51.37 +    return (hashvalue % tablelength);
   51.38 +};
   51.39 +
   51.40 +/* Only works if tablelength == 2^N */
   51.41 +/*static inline unsigned int
   51.42 +indexFor(unsigned int tablelength, unsigned int hashvalue)
   51.43 +{
   51.44 +    return (hashvalue & (tablelength - 1u));
   51.45 +}
   51.46 +*/
   51.47 +
   51.48 +/*****************************************************************************/
   51.49 +#define freekey(X) free(X)
   51.50 +/*define freekey(X) ; */
   51.51 +
   51.52 +
   51.53 +/*****************************************************************************/
   51.54 +
   51.55 +#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/
   51.56 +
   51.57 +/*
   51.58 + * Copyright (c) 2002, Christopher Clark
   51.59 + * All rights reserved.
   51.60 + * 
   51.61 + * Redistribution and use in source and binary forms, with or without
   51.62 + * modification, are permitted provided that the following conditions
   51.63 + * are met:
   51.64 + * 
   51.65 + * * Redistributions of source code must retain the above copyright
   51.66 + * notice, this list of conditions and the following disclaimer.
   51.67 + * 
   51.68 + * * Redistributions in binary form must reproduce the above copyright
   51.69 + * notice, this list of conditions and the following disclaimer in the
   51.70 + * documentation and/or other materials provided with the distribution.
   51.71 + * 
   51.72 + * * Neither the name of the original author; nor the names of any contributors
   51.73 + * may be used to endorse or promote products derived from this software
   51.74 + * without specific prior written permission.
   51.75 + * 
   51.76 + * 
   51.77 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   51.78 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   51.79 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   51.80 + * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
   51.81 + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   51.82 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   51.83 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   51.84 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   51.85 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   51.86 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   51.87 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   51.88 +*/

    52.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    52.2 +++ b/tools/xenstore/xenstore_control.c	Mon Mar 06 10:21:35 2006 -0700
    52.3 @@ -0,0 +1,35 @@
    52.4 +#include <stdio.h>
    52.5 +#include <stdlib.h>
    52.6 +#include <string.h>
    52.7 +
    52.8 +#include "xs.h"
    52.9 +
   52.10 +
   52.11 +int main(int argc, char **argv)
   52.12 +{
   52.13 +  struct xs_handle * xsh;
   52.14 +
   52.15 +  if (argc < 2 ||
   52.16 +      strcmp(argv[1], "check"))
   52.17 +  {
   52.18 +    fprintf(stderr,
   52.19 +            "Usage:\n"
   52.20 +            "\n"
   52.21 +            "       %s check\n"
   52.22 +            "\n", argv[0]);
   52.23 +    return 2;
   52.24 +  }
   52.25 +
   52.26 +  xsh = xs_daemon_open();
   52.27 +
   52.28 +  if (xsh == NULL) {
   52.29 +    fprintf(stderr, "Failed to contact Xenstored.\n");
   52.30 +    return 1;
   52.31 +  }
   52.32 +
   52.33 +  xs_debug_command(xsh, argv[1], NULL, 0);
   52.34 +
   52.35 +  xs_daemon_close(xsh);
   52.36 +
   52.37 +  return 0;
   52.38 +}

    53.1 --- a/tools/xenstore/xenstored_core.c	Mon Mar 06 09:09:18 2006 -0700
    53.2 +++ b/tools/xenstore/xenstored_core.c	Mon Mar 06 10:21:35 2006 -0700
    53.3 @@ -51,15 +51,32 @@
    53.4  #include "xenctrl.h"
    53.5  #include "tdb.h"
    53.6  
    53.7 +#include "hashtable.h"
    53.8 +
    53.9 +
   53.10  extern int eventchn_fd; /* in xenstored_domain.c */
   53.11  
   53.12 -static bool verbose;
   53.13 +static bool verbose = false;
   53.14  LIST_HEAD(connections);
   53.15  static int tracefd = -1;
   53.16 +static bool recovery = true;
   53.17 +static bool remove_local = true;
   53.18  static int reopen_log_pipe[2];
   53.19  static char *tracefile = NULL;
   53.20  static TDB_CONTEXT *tdb_ctx;
   53.21  
   53.22 +static void corrupt(struct connection *conn, const char *fmt, ...);
   53.23 +static void check_store();
   53.24 +
   53.25 +#define log(...)							\
   53.26 +	do {								\
   53.27 +		char *s = talloc_asprintf(NULL, __VA_ARGS__);		\
   53.28 +		trace("%s\n", s);					\
   53.29 +		syslog(LOG_ERR, "%s",  s);				\
   53.30 +		talloc_free(s);						\
   53.31 +	} while (0)
   53.32 +
   53.33 +
   53.34  #ifdef TESTING
   53.35  static bool failtest = false;
   53.36  
   53.37 @@ -104,33 +121,6 @@ int test_mkdir(const char *dir, int perm
   53.38  
   53.39  #include "xenstored_test.h"
   53.40  
   53.41 -/* FIXME: Ideally, this should never be called.  Some can be eliminated. */
   53.42 -/* Something is horribly wrong: shutdown immediately. */
   53.43 -void __attribute__((noreturn)) corrupt(struct connection *conn,
   53.44 -				       const char *fmt, ...)
   53.45 -{
   53.46 -	va_list arglist;
   53.47 -	char *str;
   53.48 -	int saved_errno = errno;
   53.49 -
   53.50 -	va_start(arglist, fmt);
   53.51 -	str = talloc_vasprintf(NULL, fmt, arglist);
   53.52 -	va_end(arglist);
   53.53 -
   53.54 -	trace("xenstored corruption: connection id %i: err %s: %s",
   53.55 -		conn ? (int)conn->id : -1, strerror(saved_errno), str);
   53.56 -	eprintf("xenstored corruption: connection id %i: err %s: %s",
   53.57 -		conn ? (int)conn->id : -1, strerror(saved_errno), str);
   53.58 -#ifdef TESTING
   53.59 -	/* Allow them to attach debugger. */
   53.60 -	sleep(30);
   53.61 -#endif
   53.62 -	syslog(LOG_DAEMON,
   53.63 -	       "xenstored corruption: connection id %i: err %s: %s",
   53.64 -	       conn ? (int)conn->id : -1, strerror(saved_errno), str);
   53.65 -	_exit(2);
   53.66 -}
   53.67 -
   53.68  TDB_CONTEXT *tdb_context(struct connection *conn)
   53.69  {
   53.70  	/* conn = NULL used in manual_node at setup. */
   53.71 @@ -216,8 +206,9 @@ static void trace_io(const struct connec
   53.72  	now = time(NULL);
   53.73  	tm = localtime(&now);
   53.74  
   53.75 -	trace("%s %p %02d:%02d:%02d %s (", prefix, conn,
   53.76 -	      tm->tm_hour, tm->tm_min, tm->tm_sec,
   53.77 +	trace("%s %p %04d%02d%02d %02d:%02d:%02d %s (", prefix, conn,
   53.78 +	      tm->tm_year + 1900, tm->tm_mon + 1,
   53.79 +	      tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
   53.80  	      sockmsg_string(data->hdr.msg.type));
   53.81  	
   53.82  	for (i = 0; i < data->hdr.msg.len; i++)
   53.83 @@ -415,16 +406,19 @@ static struct node *read_node(struct con
   53.84  	TDB_DATA key, data;
   53.85  	uint32_t *p;
   53.86  	struct node *node;
   53.87 +	TDB_CONTEXT * context = tdb_context(conn);
   53.88  
   53.89  	key.dptr = (void *)name;
   53.90  	key.dsize = strlen(name);
   53.91 -	data = tdb_fetch(tdb_context(conn), key);
   53.92 +	data = tdb_fetch(context, key);
   53.93  
   53.94  	if (data.dptr == NULL) {
   53.95 -		if (tdb_error(tdb_context(conn)) == TDB_ERR_NOEXIST)
   53.96 +		if (tdb_error(context) == TDB_ERR_NOEXIST)
   53.97  			errno = ENOENT;
   53.98 -		else
   53.99 +		else {
  53.100 +			log("TDB error on read: %s", tdb_errorstr(context));
  53.101  			errno = EIO;
  53.102 +		}
  53.103  		return NULL;
  53.104  	}
  53.105  
  53.106 @@ -837,8 +831,6 @@ static int destroy_node(void *_node)
  53.107  	return 0;
  53.108  }
  53.109  
  53.110 -/* Be careful: create heirarchy, put entry in existing parent *last*.
  53.111 - * This helps fsck if we die during this. */
  53.112  static struct node *create_node(struct connection *conn, 
  53.113  				const char *name,
  53.114  				void *data, unsigned int datalen)
  53.115 @@ -939,8 +931,9 @@ static void delete_node(struct connectio
  53.116  {
  53.117  	unsigned int i;
  53.118  
  53.119 -	/* Delete self, then delete children.  If something goes wrong,
  53.120 -	 * consistency check will clean up this way. */
  53.121 +	/* Delete self, then delete children.  If we crash, then the worst
  53.122 +	   that can happen is the children will continue to take up space, but
  53.123 +	   will otherwise be unreachable. */
  53.124  	delete_node_single(conn, node);
  53.125  
  53.126  	/* Delete children, too. */
  53.127 @@ -950,18 +943,35 @@ static void delete_node(struct connectio
  53.128  		child = read_node(conn, 
  53.129  				  talloc_asprintf(node, "%s/%s", node->name,
  53.130  						  node->children + i));
  53.131 -		if (!child)
  53.132 -			corrupt(conn, "No child '%s' found", child);
  53.133 -		delete_node(conn, child);
  53.134 +		if (child) {
  53.135 +			delete_node(conn, child);
  53.136 +		}
  53.137 +		else {
  53.138 +			trace("delete_node: No child '%s/%s' found!\n",
  53.139 +			      node->name, node->children + i);
  53.140 +			/* Skip it, we've already deleted the parent. */
  53.141 +		}
  53.142  	}
  53.143  }
  53.144  
  53.145 +
  53.146  /* Delete memory using memmove. */
  53.147  static void memdel(void *mem, unsigned off, unsigned len, unsigned total)
  53.148  {
  53.149  	memmove(mem + off, mem + off + len, total - off - len);
  53.150  }
  53.151  
  53.152 +
  53.153 +static bool remove_child_entry(struct connection *conn, struct node *node,
  53.154 +			       size_t offset)
  53.155 +{
  53.156 +	size_t childlen = strlen(node->children + offset);
  53.157 +	memdel(node->children, offset, childlen + 1, node->childlen);
  53.158 +	node->childlen -= childlen + 1;
  53.159 +	return write_node(conn, node);
  53.160 +}
  53.161 +
  53.162 +
  53.163  static bool delete_child(struct connection *conn,
  53.164  			 struct node *node, const char *childname)
  53.165  {
  53.166 @@ -969,19 +979,19 @@ static bool delete_child(struct connecti
  53.167  
  53.168  	for (i = 0; i < node->childlen; i += strlen(node->children+i) + 1) {
  53.169  		if (streq(node->children+i, childname)) {
  53.170 -			memdel(node->children, i, strlen(childname) + 1,
  53.171 -			       node->childlen);
  53.172 -			node->childlen -= strlen(childname) + 1;
  53.173 -			return write_node(conn, node);
  53.174 +			return remove_child_entry(conn, node, i);
  53.175  		}
  53.176  	}
  53.177  	corrupt(conn, "Can't find child '%s' in %s", childname, node->name);
  53.178 +	return false;
  53.179  }
  53.180  
  53.181  
  53.182  static int _rm(struct connection *conn, struct node *node, const char *name)
  53.183  {
  53.184 -	/* Delete from parent first, then if something explodes fsck cleans. */
  53.185 +	/* Delete from parent first, then if we crash, the worst that can
  53.186 +	   happen is the child will continue to take up space, but will
  53.187 +	   otherwise be unreachable. */
  53.188  	struct node *parent = read_node(conn, get_parent(name));
  53.189  	if (!parent) {
  53.190  		send_error(conn, EINVAL);
  53.191 @@ -1000,10 +1010,12 @@ static int _rm(struct connection *conn, 
  53.192  
  53.193  static void internal_rm(const char *name)
  53.194  {
  53.195 -	char *tname = talloc_strdup(talloc_autofree_context(), name);
  53.196 +	char *tname = talloc_strdup(NULL, name);
  53.197  	struct node *node = read_node(NULL, tname);
  53.198  	if (node)
  53.199  		_rm(NULL, node, tname);
  53.200 +	talloc_free(node);
  53.201 +	talloc_free(tname);
  53.202  }
  53.203  
  53.204  
  53.205 @@ -1149,18 +1161,19 @@ static void process_message(struct conne
  53.206  	case XS_DEBUG:
  53.207  		if (streq(in->buffer, "print"))
  53.208  			xprintf("debug: %s", in->buffer + get_string(in, 0));
  53.209 +		if (streq(in->buffer, "check"))
  53.210 +			check_store();
  53.211  #ifdef TESTING
  53.212  		/* For testing, we allow them to set id. */
  53.213  		if (streq(in->buffer, "setid")) {
  53.214  			conn->id = atoi(in->buffer + get_string(in, 0));
  53.215 -			send_ack(conn, XS_DEBUG);
  53.216  		} else if (streq(in->buffer, "failtest")) {
  53.217  			if (get_string(in, 0) < in->used)
  53.218  				srandom(atoi(in->buffer + get_string(in, 0)));
  53.219 -			send_ack(conn, XS_DEBUG);
  53.220  			failtest = true;
  53.221  		}
  53.222  #endif /* TESTING */
  53.223 +		send_ack(conn, XS_DEBUG);
  53.224  		break;
  53.225  
  53.226  	case XS_WATCH:
  53.227 @@ -1258,7 +1271,7 @@ static void handle_input(struct connecti
  53.228  
  53.229  		if (in->hdr.msg.len > PATH_MAX) {
  53.230  #ifndef TESTING
  53.231 -			syslog(LOG_DAEMON, "Client tried to feed us %i",
  53.232 +			syslog(LOG_ERR, "Client tried to feed us %i",
  53.233  			       in->hdr.msg.len);
  53.234  #endif
  53.235  			goto bad_client;
  53.236 @@ -1425,10 +1438,18 @@ static void setup_structure(void)
  53.237  		   balloon driver will pick up stale entries.  In the case of
  53.238  		   the balloon driver, this can be fatal.
  53.239  		*/
  53.240 -		char *tlocal = talloc_strdup(talloc_autofree_context(),
  53.241 -					     "/local");
  53.242 -		internal_rm("/local");
  53.243 -		create_node(NULL, tlocal, NULL, 0);
  53.244 +		char *tlocal = talloc_strdup(NULL, "/local");
  53.245 +
  53.246 +		check_store();
  53.247 +
  53.248 +		if (remove_local) {
  53.249 +			internal_rm("/local");
  53.250 +			create_node(NULL, tlocal, NULL, 0);
  53.251 +
  53.252 +			check_store();
  53.253 +		}
  53.254 +
  53.255 +		talloc_free(tlocal);
  53.256  	}
  53.257  	else {
  53.258  		tdb_ctx = tdb_open(tdbname, 7919, TDB_FLAGS, O_RDWR|O_CREAT,
  53.259 @@ -1439,11 +1460,197 @@ static void setup_structure(void)
  53.260  		manual_node("/", "tool");
  53.261  		manual_node("/tool", "xenstored");
  53.262  		manual_node("/tool/xenstored", NULL);
  53.263 +
  53.264 +		check_store();
  53.265 +	}
  53.266 +}
  53.267 +
  53.268 +
  53.269 +static unsigned int hash_from_key_fn(void *k)
  53.270 +{
  53.271 +	char *str = k;
  53.272 +        unsigned int hash = 5381;
  53.273 +        char c;
  53.274 +
  53.275 +        while ((c = *str++))
  53.276 +		hash = ((hash << 5) + hash) + (unsigned int)c;
  53.277 +
  53.278 +        return hash;
  53.279 +}
  53.280 +
  53.281 +
  53.282 +static int keys_equal_fn(void *key1, void *key2)
  53.283 +{
  53.284 +	return 0 == strcmp((char *)key1, (char *)key2);
  53.285 +}
  53.286 +
  53.287 +
  53.288 +static char *child_name(const char *s1, const char *s2)
  53.289 +{
  53.290 +	if (strcmp(s1, "/")) {
  53.291 +		return talloc_asprintf(NULL, "%s/%s", s1, s2);
  53.292 +	}
  53.293 +	else {
  53.294 +		return talloc_asprintf(NULL, "/%s", s2);
  53.295 +	}
  53.296 +}
  53.297 +
  53.298 +
  53.299 +static void remember_string(struct hashtable *hash, const char *str)
  53.300 +{
  53.301 +	char *k = malloc(strlen(str) + 1);
  53.302 +	strcpy(k, str);
  53.303 +	hashtable_insert(hash, k, (void *)1);
  53.304 +}
  53.305 +
  53.306 +
  53.307 +/**
  53.308 + * A node has a children field that names the children of the node, separated
  53.309 + * by NULs.  We check whether there are entries in there that are duplicated
  53.310 + * (and if so, delete the second one), and whether there are any that do not
  53.311 + * have a corresponding child node (and if so, delete them).  Each valid child
  53.312 + * is then recursively checked.
  53.313 + *
  53.314 + * No deleting is performed if the recovery flag is cleared (i.e. -R was
  53.315 + * passed on the command line).
  53.316 + *
  53.317 + * As we go, we record each node in the given reachable hashtable.  These
  53.318 + * entries will be used later in clean_store.
  53.319 + */
  53.320 +static void check_store_(const char *name, struct hashtable *reachable)
  53.321 +{
  53.322 +	struct node *node = read_node(NULL, name);
  53.323 +
  53.324 +	if (node) {
  53.325 +		size_t i = 0;
  53.326 +
  53.327 +		struct hashtable * children =
  53.328 +			create_hashtable(16, hash_from_key_fn, keys_equal_fn);
  53.329 +
  53.330 +		remember_string(reachable, name);
  53.331 +
  53.332 +		while (i < node->childlen) {
  53.333 +			size_t childlen = strlen(node->children + i);
  53.334 +			char * childname = child_name(node->name,
  53.335 +						      node->children + i);
  53.336 +			struct node *childnode = read_node(NULL, childname);
  53.337 +			
  53.338 +			if (childnode) {
  53.339 +				if (hashtable_search(children, childname)) {
  53.340 +					log("check_store: '%s' is duplicated!",
  53.341 +					    childname);
  53.342 +
  53.343 +					if (recovery) {
  53.344 +						remove_child_entry(NULL, node,
  53.345 +								   i);
  53.346 +						i -= childlen + 1;
  53.347 +					}
  53.348 +				}
  53.349 +				else {
  53.350 +					remember_string(children, childname);
  53.351 +					check_store_(childname, reachable);
  53.352 +				}
  53.353 +			}
  53.354 +			else {
  53.355 +				log("check_store: No child '%s' found!\n",
  53.356 +				    childname);
  53.357 +
  53.358 +				if (recovery) {
  53.359 +					remove_child_entry(NULL, node, i);
  53.360 +					i -= childlen + 1;
  53.361 +				}
  53.362 +			}
  53.363 +
  53.364 +			talloc_free(childnode);
  53.365 +			talloc_free(childname);
  53.366 +			i += childlen + 1;
  53.367 +		}
  53.368 +
  53.369 +		hashtable_destroy(children, 0 /* Don't free values (they are
  53.370 +						 all (void *)1) */);
  53.371 +		talloc_free(node);
  53.372 +	}
  53.373 +	else {
  53.374 +		/* Impossible, because no database should ever be without the
  53.375 +		   root, and otherwise, we've just checked in our caller
  53.376 +		   (which made a recursive call to get here). */
  53.377 +		   
  53.378 +		log("check_store: No child '%s' found: impossible!", name);
  53.379 +	}
  53.380 +}
  53.381 +
  53.382 +
  53.383 +/**
  53.384 + * Helper to clean_store below.
  53.385 + */
  53.386 +static int clean_store_(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA val,
  53.387 +			void *private)
  53.388 +{
  53.389 +	struct hashtable *reachable = private;
  53.390 +	char * name = talloc_strndup(NULL, key.dptr, key.dsize);
  53.391 +
  53.392 +	if (!hashtable_search(reachable, name)) {
  53.393 +		log("clean_store: '%s' is orphaned!", name);
  53.394 +		if (recovery) {
  53.395 +			tdb_delete(tdb, key);
  53.396 +		}
  53.397  	}
  53.398  
  53.399 -	/* FIXME: Fsck */
  53.400 +	talloc_free(name);
  53.401 +
  53.402 +	return 0;
  53.403 +}
  53.404 +
  53.405 +
  53.406 +/**
  53.407 + * Given the list of reachable nodes, iterate over the whole store, and
  53.408 + * remove any that were not reached.
  53.409 + */
  53.410 +static void clean_store(struct hashtable *reachable)
  53.411 +{
  53.412 +	tdb_traverse(tdb_ctx, &clean_store_, reachable);
  53.413  }
  53.414  
  53.415 +
  53.416 +static void check_store()
  53.417 +{
  53.418 +	char * root = talloc_strdup(NULL, "/");
  53.419 +	struct hashtable * reachable =
  53.420 +		create_hashtable(16, hash_from_key_fn, keys_equal_fn);
  53.421 + 
  53.422 +	log("Checking store ...");
  53.423 +	check_store_(root, reachable);
  53.424 +	clean_store(reachable);
  53.425 +	log("Checking store complete.");
  53.426 +
  53.427 +	hashtable_destroy(reachable, 0 /* Don't free values (they are all
  53.428 +					  (void *)1) */);
  53.429 +	talloc_free(root);
  53.430 +}
  53.431 +
  53.432 +
  53.433 +/* Something is horribly wrong: check the store. */
  53.434 +static void corrupt(struct connection *conn, const char *fmt, ...)
  53.435 +{
  53.436 +	va_list arglist;
  53.437 +	char *str;
  53.438 +	int saved_errno = errno;
  53.439 +
  53.440 +	va_start(arglist, fmt);
  53.441 +	str = talloc_vasprintf(NULL, fmt, arglist);
  53.442 +	va_end(arglist);
  53.443 +
  53.444 +	log("corruption detected by connection %i: err %s: %s",
  53.445 +	    conn ? (int)conn->id : -1, strerror(saved_errno), str);
  53.446 +
  53.447 +#ifdef TESTING
  53.448 +	/* Allow them to attach debugger. */
  53.449 +	sleep(30);
  53.450 +#endif
  53.451 +	check_store();
  53.452 +}
  53.453 +
  53.454 +
  53.455  static void write_pidfile(const char *pidfile)
  53.456  {
  53.457  	char buf[100];
  53.458 @@ -1506,6 +1713,9 @@ static void usage(void)
  53.459  "  --no-fork           to request that the daemon does not fork,\n"
  53.460  "  --output-pid        to request that the pid of the daemon is output,\n"
  53.461  "  --trace-file <file> giving the file for logging, and\n"
  53.462 +"  --no-recovery       to request that no recovery should be attempted when\n"
  53.463 +"                      the store is corrupted (debug only),\n"
  53.464 +"  --preserve-local    to request that /local is preserved on start-up,\n"
  53.465  "  --verbose           to request verbose execution.\n");
  53.466  }
  53.467  
  53.468 @@ -1517,6 +1727,8 @@ static struct option options[] = {
  53.469  	{ "no-fork", 0, NULL, 'N' },
  53.470  	{ "output-pid", 0, NULL, 'P' },
  53.471  	{ "trace-file", 1, NULL, 'T' },
  53.472 +	{ "no-recovery", 0, NULL, 'R' },
  53.473 +	{ "preserve-local", 0, NULL, 'L' },
  53.474  	{ "verbose", 0, NULL, 'V' },
  53.475  	{ NULL, 0, NULL, 0 } };
  53.476  
  53.477 @@ -1532,7 +1744,7 @@ int main(int argc, char *argv[])
  53.478  	bool no_domain_init = false;
  53.479  	const char *pidfile = NULL;
  53.480  
  53.481 -	while ((opt = getopt_long(argc, argv, "DF:HNPT:V", options,
  53.482 +	while ((opt = getopt_long(argc, argv, "DF:HNPT:RLV", options,
  53.483  				  NULL)) != -1) {
  53.484  		switch (opt) {
  53.485  		case 'D':
  53.486 @@ -1550,6 +1762,12 @@ int main(int argc, char *argv[])
  53.487  		case 'P':
  53.488  			outputpid = true;
  53.489  			break;
  53.490 +		case 'R':
  53.491 +			recovery = false;
  53.492 +			break;
  53.493 +		case 'L':
  53.494 +			remove_local = false;
  53.495 +			break;
  53.496  		case 'T':
  53.497  			tracefile = optarg;
  53.498  			break;