1.1 --- a/extras/mini-os/include/events.h	Sun Oct 30 13:52:38 2005 +0100
     1.2 +++ b/extras/mini-os/include/events.h	Sun Oct 30 14:00:35 2005 +0100
     1.3 @@ -47,7 +47,7 @@ static inline int notify_via_evtchn(int 
     1.4  {
     1.5      evtchn_op_t op;
     1.6      op.cmd = EVTCHNOP_send;
     1.7 -    op.u.send.local_port = port;
     1.8 +    op.u.send.port = port;
     1.9      return HYPERVISOR_event_channel_op(&op);
    1.10  }
    1.11  

     2.1 --- a/extras/mini-os/include/hypervisor.h	Sun Oct 30 13:52:38 2005 +0100
     2.2 +++ b/extras/mini-os/include/hypervisor.h	Sun Oct 30 14:00:35 2005 +0100
     2.3 @@ -14,6 +14,7 @@
     2.4  
     2.5  #include <types.h>
     2.6  #include <xen/xen.h>
     2.7 +#include <xen/dom0_ops.h>
     2.8  
     2.9  /*
    2.10   * a placeholder for the start of day information passed up from the hypervisor
    2.11 @@ -37,548 +38,281 @@ void clear_evtchn(u32 port);
    2.12   * Assembler stubs for hyper-calls.
    2.13   */
    2.14  #if defined(__i386__)
    2.15 +/* Taken from Linux */
    2.16 +
    2.17 +#ifndef __HYPERCALL_H__
    2.18 +#define __HYPERCALL_H__
    2.19 +
    2.20 +#include <xen/sched.h>
    2.21 +
    2.22 +#define _hypercall0(type, name)			\
    2.23 +({						\
    2.24 +	long __res;				\
    2.25 +	asm volatile (				\
    2.26 +		TRAP_INSTR			\
    2.27 +		: "=a" (__res)			\
    2.28 +		: "0" (__HYPERVISOR_##name)	\
    2.29 +		: "memory" );			\
    2.30 +	(type)__res;				\
    2.31 +})
    2.32 +
    2.33 +#define _hypercall1(type, name, a1)				\
    2.34 +({								\
    2.35 +	long __res, __ign1;					\
    2.36 +	asm volatile (						\
    2.37 +		TRAP_INSTR					\
    2.38 +		: "=a" (__res), "=b" (__ign1)			\
    2.39 +		: "0" (__HYPERVISOR_##name), "1" ((long)(a1))	\
    2.40 +		: "memory" );					\
    2.41 +	(type)__res;						\
    2.42 +})
    2.43 +
    2.44 +#define _hypercall2(type, name, a1, a2)				\
    2.45 +({								\
    2.46 +	long __res, __ign1, __ign2;				\
    2.47 +	asm volatile (						\
    2.48 +		TRAP_INSTR					\
    2.49 +		: "=a" (__res), "=b" (__ign1), "=c" (__ign2)	\
    2.50 +		: "0" (__HYPERVISOR_##name), "1" ((long)(a1)),	\
    2.51 +		"2" ((long)(a2))				\
    2.52 +		: "memory" );					\
    2.53 +	(type)__res;						\
    2.54 +})
    2.55 +
    2.56 +#define _hypercall3(type, name, a1, a2, a3)			\
    2.57 +({								\
    2.58 +	long __res, __ign1, __ign2, __ign3;			\
    2.59 +	asm volatile (						\
    2.60 +		TRAP_INSTR					\
    2.61 +		: "=a" (__res), "=b" (__ign1), "=c" (__ign2), 	\
    2.62 +		"=d" (__ign3)					\
    2.63 +		: "0" (__HYPERVISOR_##name), "1" ((long)(a1)),	\
    2.64 +		"2" ((long)(a2)), "3" ((long)(a3))		\
    2.65 +		: "memory" );					\
    2.66 +	(type)__res;						\
    2.67 +})
    2.68 +
    2.69 +#define _hypercall4(type, name, a1, a2, a3, a4)			\
    2.70 +({								\
    2.71 +	long __res, __ign1, __ign2, __ign3, __ign4;		\
    2.72 +	asm volatile (						\
    2.73 +		TRAP_INSTR					\
    2.74 +		: "=a" (__res), "=b" (__ign1), "=c" (__ign2),	\
    2.75 +		"=d" (__ign3), "=S" (__ign4)			\
    2.76 +		: "0" (__HYPERVISOR_##name), "1" ((long)(a1)),	\
    2.77 +		"2" ((long)(a2)), "3" ((long)(a3)),		\
    2.78 +		"4" ((long)(a4))				\
    2.79 +		: "memory" );					\
    2.80 +	(type)__res;						\
    2.81 +})
    2.82 +
    2.83 +#define _hypercall5(type, name, a1, a2, a3, a4, a5)		\
    2.84 +({								\
    2.85 +	long __res, __ign1, __ign2, __ign3, __ign4, __ign5;	\
    2.86 +	asm volatile (						\
    2.87 +		TRAP_INSTR					\
    2.88 +		: "=a" (__res), "=b" (__ign1), "=c" (__ign2),	\
    2.89 +		"=d" (__ign3), "=S" (__ign4), "=D" (__ign5)	\
    2.90 +		: "0" (__HYPERVISOR_##name), "1" ((long)(a1)),	\
    2.91 +		"2" ((long)(a2)), "3" ((long)(a3)),		\
    2.92 +		"4" ((long)(a4)), "5" ((long)(a5))		\
    2.93 +		: "memory" );					\
    2.94 +	(type)__res;						\
    2.95 +})
    2.96 +
    2.97  static inline int
    2.98  HYPERVISOR_set_trap_table(
    2.99 -    trap_info_t *table)
   2.100 +	trap_info_t *table)
   2.101  {
   2.102 -    int ret;
   2.103 -    unsigned long ignore;
   2.104 -
   2.105 -    __asm__ __volatile__ (
   2.106 -        TRAP_INSTR
   2.107 -        : "=a" (ret), "=b" (ignore)
   2.108 -	: "0" (__HYPERVISOR_set_trap_table), "1" (table)
   2.109 -	: "memory" );
   2.110 -
   2.111 -    return ret;
   2.112 +	return _hypercall1(int, set_trap_table, table);
   2.113  }
   2.114  
   2.115  static inline int
   2.116  HYPERVISOR_mmu_update(
   2.117 -    mmu_update_t *req, int count, int *success_count, domid_t domid)
   2.118 +	mmu_update_t *req, int count, int *success_count, domid_t domid)
   2.119  {
   2.120 -    int ret;
   2.121 -    unsigned long ign1, ign2, ign3, ign4;
   2.122 -
   2.123 -    __asm__ __volatile__ (
   2.124 -        TRAP_INSTR
   2.125 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4)
   2.126 -	: "0" (__HYPERVISOR_mmu_update), "1" (req), "2" (count),
   2.127 -        "3" (success_count), "4" (domid)
   2.128 -	: "memory" );
   2.129 -
   2.130 -    return ret;
   2.131 +	return _hypercall4(int, mmu_update, req, count, success_count, domid);
   2.132  }
   2.133  
   2.134  static inline int
   2.135  HYPERVISOR_mmuext_op(
   2.136 -    struct mmuext_op *op, int count, int *success_count, domid_t domid)
   2.137 +	struct mmuext_op *op, int count, int *success_count, domid_t domid)
   2.138  {
   2.139 -    int ret;
   2.140 -    unsigned long ign1, ign2, ign3, ign4;
   2.141 -
   2.142 -    __asm__ __volatile__ (
   2.143 -        TRAP_INSTR
   2.144 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4)
   2.145 -	: "0" (__HYPERVISOR_mmuext_op), "1" (op), "2" (count),
   2.146 -        "3" (success_count), "4" (domid)
   2.147 -	: "memory" );
   2.148 -
   2.149 -    return ret;
   2.150 +	return _hypercall4(int, mmuext_op, op, count, success_count, domid);
   2.151  }
   2.152  
   2.153  static inline int
   2.154  HYPERVISOR_set_gdt(
   2.155 -    unsigned long *frame_list, int entries)
   2.156 +	unsigned long *frame_list, int entries)
   2.157  {
   2.158 -    int ret;
   2.159 -    unsigned long ign1, ign2;
   2.160 -
   2.161 -    __asm__ __volatile__ (
   2.162 -        TRAP_INSTR
   2.163 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.164 -	: "0" (__HYPERVISOR_set_gdt), "1" (frame_list), "2" (entries)
   2.165 -	: "memory" );
   2.166 -
   2.167 -
   2.168 -    return ret;
   2.169 +	return _hypercall2(int, set_gdt, frame_list, entries);
   2.170  }
   2.171  
   2.172  static inline int
   2.173  HYPERVISOR_stack_switch(
   2.174 -    unsigned long ss, unsigned long esp)
   2.175 +	unsigned long ss, unsigned long esp)
   2.176  {
   2.177 -    int ret;
   2.178 -    unsigned long ign1, ign2;
   2.179 -
   2.180 -    __asm__ __volatile__ (
   2.181 -        TRAP_INSTR
   2.182 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.183 -	: "0" (__HYPERVISOR_stack_switch), "1" (ss), "2" (esp)
   2.184 -	: "memory" );
   2.185 -
   2.186 -    return ret;
   2.187 +	return _hypercall2(int, stack_switch, ss, esp);
   2.188  }
   2.189  
   2.190  static inline int
   2.191  HYPERVISOR_set_callbacks(
   2.192 -    unsigned long event_selector, unsigned long event_address,
   2.193 -    unsigned long failsafe_selector, unsigned long failsafe_address)
   2.194 +	unsigned long event_selector, unsigned long event_address,
   2.195 +	unsigned long failsafe_selector, unsigned long failsafe_address)
   2.196  {
   2.197 -    int ret;
   2.198 -    unsigned long ign1, ign2, ign3, ign4;
   2.199 -
   2.200 -    __asm__ __volatile__ (
   2.201 -        TRAP_INSTR
   2.202 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4)
   2.203 -	: "0" (__HYPERVISOR_set_callbacks), "1" (event_selector),
   2.204 -	  "2" (event_address), "3" (failsafe_selector), "4" (failsafe_address)
   2.205 -	: "memory" );
   2.206 -
   2.207 -    return ret;
   2.208 +	return _hypercall4(int, set_callbacks,
   2.209 +			   event_selector, event_address,
   2.210 +			   failsafe_selector, failsafe_address);
   2.211  }
   2.212  
   2.213  static inline int
   2.214  HYPERVISOR_fpu_taskswitch(
   2.215 -    int set)
   2.216 -{
   2.217 -    int ret;
   2.218 -    unsigned long ign;
   2.219 -
   2.220 -    __asm__ __volatile__ (
   2.221 -        TRAP_INSTR
   2.222 -        : "=a" (ret), "=b" (ign)
   2.223 -        : "0" (__HYPERVISOR_fpu_taskswitch), "1" (set)
   2.224 -        : "memory" );
   2.225 -
   2.226 -    return ret;
   2.227 -}
   2.228 -
   2.229 -static inline int
   2.230 -HYPERVISOR_yield(
   2.231 -    void)
   2.232 +	int set)
   2.233  {
   2.234 -    int ret;
   2.235 -    unsigned long ign;
   2.236 -
   2.237 -    __asm__ __volatile__ (
   2.238 -        TRAP_INSTR
   2.239 -        : "=a" (ret), "=b" (ign)
   2.240 -	: "0" (__HYPERVISOR_sched_op), "1" (SCHEDOP_yield)
   2.241 -	: "memory", "ecx" );
   2.242 -
   2.243 -    return ret;
   2.244 -}
   2.245 -
   2.246 -static inline int
   2.247 -HYPERVISOR_block(
   2.248 -    void)
   2.249 -{
   2.250 -    int ret;
   2.251 -    unsigned long ign1;
   2.252 -    __asm__ __volatile__ (
   2.253 -        TRAP_INSTR
   2.254 -        : "=a" (ret), "=b" (ign1)
   2.255 -	: "0" (__HYPERVISOR_sched_op), "1" (SCHEDOP_block)
   2.256 -	: "memory", "ecx" );
   2.257 -
   2.258 -    return ret;
   2.259 +	return _hypercall1(int, fpu_taskswitch, set);
   2.260  }
   2.261  
   2.262  static inline int
   2.263 -HYPERVISOR_shutdown(
   2.264 -    void)
   2.265 -{
   2.266 -    int ret;
   2.267 -    unsigned long ign1;
   2.268 -    __asm__ __volatile__ (
   2.269 -        TRAP_INSTR
   2.270 -        : "=a" (ret), "=b" (ign1)
   2.271 -	: "0" (__HYPERVISOR_sched_op),
   2.272 -	  "1" (SCHEDOP_shutdown | (SHUTDOWN_poweroff << SCHEDOP_reasonshift))
   2.273 -        : "memory", "ecx" );
   2.274 -
   2.275 -    return ret;
   2.276 -}
   2.277 -
   2.278 -static inline int
   2.279 -HYPERVISOR_reboot(
   2.280 -    void)
   2.281 +HYPERVISOR_sched_op(
   2.282 +	int cmd, unsigned long arg)
   2.283  {
   2.284 -    int ret;
   2.285 -    unsigned long ign1;
   2.286 -    __asm__ __volatile__ (
   2.287 -        TRAP_INSTR
   2.288 -        : "=a" (ret), "=b" (ign1)
   2.289 -	: "0" (__HYPERVISOR_sched_op),
   2.290 -	  "1" (SCHEDOP_shutdown | (SHUTDOWN_reboot << SCHEDOP_reasonshift))
   2.291 -        : "memory", "ecx" );
   2.292 -
   2.293 -    return ret;
   2.294 -}
   2.295 -
   2.296 -static inline int
   2.297 -HYPERVISOR_suspend(
   2.298 -    unsigned long srec)
   2.299 -{
   2.300 -    int ret;
   2.301 -    unsigned long ign1, ign2;
   2.302 -
   2.303 -    /* NB. On suspend, control software expects a suspend record in %esi. */
   2.304 -    __asm__ __volatile__ (
   2.305 -        TRAP_INSTR
   2.306 -        : "=a" (ret), "=b" (ign1), "=S" (ign2)
   2.307 -	: "0" (__HYPERVISOR_sched_op),
   2.308 -        "b" (SCHEDOP_shutdown | (SHUTDOWN_suspend << SCHEDOP_reasonshift)), 
   2.309 -        "S" (srec) : "memory", "ecx");
   2.310 -
   2.311 -    return ret;
   2.312 -}
   2.313 -
   2.314 -static inline int
   2.315 -HYPERVISOR_crash(
   2.316 -    void)
   2.317 -{
   2.318 -    int ret;
   2.319 -    unsigned long ign1;
   2.320 -    __asm__ __volatile__ (
   2.321 -        TRAP_INSTR
   2.322 -        : "=a" (ret), "=b" (ign1)
   2.323 -	: "0" (__HYPERVISOR_sched_op),
   2.324 -	  "1" (SCHEDOP_shutdown | (SHUTDOWN_crash << SCHEDOP_reasonshift))
   2.325 -        : "memory", "ecx" );
   2.326 -
   2.327 -    return ret;
   2.328 +	return _hypercall2(int, sched_op, cmd, arg);
   2.329  }
   2.330  
   2.331  static inline long
   2.332  HYPERVISOR_set_timer_op(
   2.333 -    u64 timeout)
   2.334 +	u64 timeout)
   2.335  {
   2.336 -    int ret;
   2.337 -    unsigned long timeout_hi = (unsigned long)(timeout>>32);
   2.338 -    unsigned long timeout_lo = (unsigned long)timeout;
   2.339 -    unsigned long ign1, ign2;
   2.340 -
   2.341 -    __asm__ __volatile__ (
   2.342 -        TRAP_INSTR
   2.343 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.344 -	: "0" (__HYPERVISOR_set_timer_op), "b" (timeout_lo), "c" (timeout_hi)
   2.345 -	: "memory");
   2.346 -
   2.347 -    return ret;
   2.348 +	unsigned long timeout_hi = (unsigned long)(timeout>>32);
   2.349 +	unsigned long timeout_lo = (unsigned long)timeout;
   2.350 +	return _hypercall2(long, set_timer_op, timeout_lo, timeout_hi);
   2.351  }
   2.352  
   2.353 -#if 0
   2.354  static inline int
   2.355  HYPERVISOR_dom0_op(
   2.356 -    dom0_op_t *dom0_op)
   2.357 +	dom0_op_t *dom0_op)
   2.358  {
   2.359 -    int ret;
   2.360 -    unsigned long ign1;
   2.361 -
   2.362 -    dom0_op->interface_version = DOM0_INTERFACE_VERSION;
   2.363 -    __asm__ __volatile__ (
   2.364 -        TRAP_INSTR
   2.365 -        : "=a" (ret), "=b" (ign1)
   2.366 -	: "0" (__HYPERVISOR_dom0_op), "1" (dom0_op)
   2.367 -	: "memory");
   2.368 -
   2.369 -    return ret;
   2.370 +	dom0_op->interface_version = DOM0_INTERFACE_VERSION;
   2.371 +	return _hypercall1(int, dom0_op, dom0_op);
   2.372  }
   2.373 -#endif
   2.374  
   2.375  static inline int
   2.376  HYPERVISOR_set_debugreg(
   2.377 -    int reg, unsigned long value)
   2.378 +	int reg, unsigned long value)
   2.379  {
   2.380 -    int ret;
   2.381 -    unsigned long ign1, ign2;
   2.382 -    __asm__ __volatile__ (
   2.383 -        TRAP_INSTR
   2.384 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.385 -	: "0" (__HYPERVISOR_set_debugreg), "1" (reg), "2" (value)
   2.386 -	: "memory" );
   2.387 -
   2.388 -    return ret;
   2.389 +	return _hypercall2(int, set_debugreg, reg, value);
   2.390  }
   2.391  
   2.392  static inline unsigned long
   2.393  HYPERVISOR_get_debugreg(
   2.394 -    int reg)
   2.395 +	int reg)
   2.396  {
   2.397 -    unsigned long ret;
   2.398 -    unsigned long ign;
   2.399 -    __asm__ __volatile__ (
   2.400 -        TRAP_INSTR
   2.401 -        : "=a" (ret), "=b" (ign)
   2.402 -	: "0" (__HYPERVISOR_get_debugreg), "1" (reg)
   2.403 -	: "memory" );
   2.404 -
   2.405 -    return ret;
   2.406 +	return _hypercall1(unsigned long, get_debugreg, reg);
   2.407  }
   2.408  
   2.409  static inline int
   2.410  HYPERVISOR_update_descriptor(
   2.411 -    u64 ma, u64 desc)
   2.412 +	u64 ma, u64 desc)
   2.413  {
   2.414 -    int ret;
   2.415 -    unsigned long ign1, ign2, ign3, ign4;
   2.416 -
   2.417 -    __asm__ __volatile__ (
   2.418 -        TRAP_INSTR
   2.419 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4)
   2.420 -	: "0" (__HYPERVISOR_update_descriptor),
   2.421 -	  "1" ((unsigned long)ma), "2" ((unsigned long)(ma>>32)),
   2.422 -	  "3" ((unsigned long)desc), "4" ((unsigned long)(desc>>32))
   2.423 -	: "memory" );
   2.424 -
   2.425 -    return ret;
   2.426 +	return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32);
   2.427  }
   2.428  
   2.429  static inline int
   2.430 -HYPERVISOR_dom_mem_op(
   2.431 -    unsigned int op, unsigned long *extent_list,
   2.432 -    unsigned long nr_extents, unsigned int extent_order)
   2.433 +HYPERVISOR_memory_op(
   2.434 +	unsigned int cmd, void *arg)
   2.435  {
   2.436 -    int ret;
   2.437 -    unsigned long ign1, ign2, ign3, ign4, ign5;
   2.438 -
   2.439 -    __asm__ __volatile__ (
   2.440 -        TRAP_INSTR
   2.441 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4),
   2.442 -	  "=D" (ign5)
   2.443 -	: "0" (__HYPERVISOR_dom_mem_op), "1" (op), "2" (extent_list),
   2.444 -	  "3" (nr_extents), "4" (extent_order), "5" (DOMID_SELF)
   2.445 -        : "memory" );
   2.446 -
   2.447 -    return ret;
   2.448 +	return _hypercall2(int, memory_op, cmd, arg);
   2.449  }
   2.450  
   2.451  static inline int
   2.452  HYPERVISOR_multicall(
   2.453 -    void *call_list, int nr_calls)
   2.454 +	void *call_list, int nr_calls)
   2.455  {
   2.456 -    int ret;
   2.457 -    unsigned long ign1, ign2;
   2.458 -
   2.459 -    __asm__ __volatile__ (
   2.460 -        TRAP_INSTR
   2.461 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.462 -	: "0" (__HYPERVISOR_multicall), "1" (call_list), "2" (nr_calls)
   2.463 -	: "memory" );
   2.464 -
   2.465 -    return ret;
   2.466 +	return _hypercall2(int, multicall, call_list, nr_calls);
   2.467  }
   2.468  
   2.469  static inline int
   2.470  HYPERVISOR_update_va_mapping(
   2.471 -    unsigned long va, pte_t new_val, unsigned long flags)
   2.472 +	unsigned long va, pte_t new_val, unsigned long flags)
   2.473  {
   2.474 -    int ret;
   2.475 -    unsigned long ign1, ign2, ign3, ign4;
   2.476 -
   2.477 -    __asm__ __volatile__ (
   2.478 -        TRAP_INSTR
   2.479 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3), "=S" (ign4)
   2.480 -	: "0" (__HYPERVISOR_update_va_mapping), 
   2.481 -          "1" (va), "2" ((new_val).pte_low),
   2.482 +	unsigned long pte_hi = 0;
   2.483  #ifdef CONFIG_X86_PAE
   2.484 -	  "3" ((new_val).pte_high),
   2.485 -#else
   2.486 -	  "3" (0),
   2.487 +	pte_hi = new_val.pte_high;
   2.488  #endif
   2.489 -	  "4" (flags)
   2.490 -	: "memory" );
   2.491 -
   2.492 -    return ret;
   2.493 +	return _hypercall4(int, update_va_mapping, va,
   2.494 +			   new_val.pte_low, pte_hi, flags);
   2.495  }
   2.496  
   2.497  static inline int
   2.498  HYPERVISOR_event_channel_op(
   2.499 -    void *op)
   2.500 +	void *op)
   2.501  {
   2.502 -    int ret;
   2.503 -    unsigned long ignore;
   2.504 -    __asm__ __volatile__ (
   2.505 -        TRAP_INSTR
   2.506 -        : "=a" (ret), "=b" (ignore)
   2.507 -	: "0" (__HYPERVISOR_event_channel_op), "1" (op)
   2.508 -	: "memory" );
   2.509 -
   2.510 -    return ret;
   2.511 +	return _hypercall1(int, event_channel_op, op);
   2.512  }
   2.513  
   2.514  static inline int
   2.515  HYPERVISOR_xen_version(
   2.516 -    int cmd, void *arg)
   2.517 +	int cmd, void *arg)
   2.518  {
   2.519 -    int ret;
   2.520 -    unsigned long ignore, ign2;
   2.521 -
   2.522 -    __asm__ __volatile__ (
   2.523 -        TRAP_INSTR
   2.524 -        : "=a" (ret), "=b" (ignore), "=c" (ign2)
   2.525 -	: "0" (__HYPERVISOR_xen_version), "1" (cmd), "2" (arg)
   2.526 -	: "memory" );
   2.527 -
   2.528 -    return ret;
   2.529 +	return _hypercall2(int, xen_version, cmd, arg);
   2.530  }
   2.531  
   2.532  static inline int
   2.533  HYPERVISOR_console_io(
   2.534 -    int cmd, int count, char *str)
   2.535 +	int cmd, int count, char *str)
   2.536  {
   2.537 -    int ret;
   2.538 -    unsigned long ign1, ign2, ign3;
   2.539 -    __asm__ __volatile__ (
   2.540 -        TRAP_INSTR
   2.541 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3)
   2.542 -	: "0" (__HYPERVISOR_console_io), "1" (cmd), "2" (count), "3" (str)
   2.543 -	: "memory" );
   2.544 -
   2.545 -    return ret;
   2.546 +	return _hypercall3(int, console_io, cmd, count, str);
   2.547  }
   2.548  
   2.549  static inline int
   2.550  HYPERVISOR_physdev_op(
   2.551 -    void *physdev_op)
   2.552 +	void *physdev_op)
   2.553  {
   2.554 -    int ret;
   2.555 -    unsigned long ign;
   2.556 -
   2.557 -    __asm__ __volatile__ (
   2.558 -        TRAP_INSTR
   2.559 -        : "=a" (ret), "=b" (ign)
   2.560 -	: "0" (__HYPERVISOR_physdev_op), "1" (physdev_op)
   2.561 -	: "memory" );
   2.562 -
   2.563 -    return ret;
   2.564 +	return _hypercall1(int, physdev_op, physdev_op);
   2.565  }
   2.566  
   2.567  static inline int
   2.568  HYPERVISOR_grant_table_op(
   2.569 -    unsigned int cmd, void *uop, unsigned int count)
   2.570 +	unsigned int cmd, void *uop, unsigned int count)
   2.571  {
   2.572 -    int ret;
   2.573 -    unsigned long ign1, ign2, ign3;
   2.574 -
   2.575 -    __asm__ __volatile__ (
   2.576 -        TRAP_INSTR
   2.577 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3)
   2.578 -	: "0" (__HYPERVISOR_grant_table_op), "1" (cmd), "2" (uop), "3" (count)
   2.579 -	: "memory" );
   2.580 -
   2.581 -    return ret;
   2.582 +	return _hypercall3(int, grant_table_op, cmd, uop, count);
   2.583  }
   2.584  
   2.585  static inline int
   2.586  HYPERVISOR_update_va_mapping_otherdomain(
   2.587 -    unsigned long va, pte_t new_val, unsigned long flags, domid_t domid)
   2.588 +	unsigned long va, pte_t new_val, unsigned long flags, domid_t domid)
   2.589  {
   2.590 -    int ret;
   2.591 -    unsigned long ign1, ign2, ign3, ign4, ign5;
   2.592 -
   2.593 -    __asm__ __volatile__ (
   2.594 -        TRAP_INSTR
   2.595 -        : "=a" (ret), "=b" (ign1), "=c" (ign2), "=d" (ign3),
   2.596 -	  "=S" (ign4), "=D" (ign5)
   2.597 -	: "0" (__HYPERVISOR_update_va_mapping_otherdomain),
   2.598 -          "1" (va), "2" ((new_val).pte_low),
   2.599 +	unsigned long pte_hi = 0;
   2.600  #ifdef CONFIG_X86_PAE
   2.601 -	  "3" ((new_val).pte_high),
   2.602 -#else
   2.603 -	  "3" (0),
   2.604 +	pte_hi = new_val.pte_high;
   2.605  #endif
   2.606 -	  "4" (flags), "5" (domid) :
   2.607 -        "memory" );
   2.608 -    
   2.609 -    return ret;
   2.610 +	return _hypercall5(int, update_va_mapping_otherdomain, va,
   2.611 +			   new_val.pte_low, pte_hi, flags, domid);
   2.612  }
   2.613  
   2.614  static inline int
   2.615  HYPERVISOR_vm_assist(
   2.616 -    unsigned int cmd, unsigned int type)
   2.617 +	unsigned int cmd, unsigned int type)
   2.618  {
   2.619 -    int ret;
   2.620 -    unsigned long ign1, ign2;
   2.621 -
   2.622 -    __asm__ __volatile__ (
   2.623 -        TRAP_INSTR
   2.624 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.625 -	: "0" (__HYPERVISOR_vm_assist), "1" (cmd), "2" (type)
   2.626 -	: "memory" );
   2.627 -
   2.628 -    return ret;
   2.629 -}
   2.630 -
   2.631 -static inline int
   2.632 -HYPERVISOR_boot_vcpu(
   2.633 -    unsigned long vcpu, vcpu_guest_context_t *ctxt)
   2.634 -{
   2.635 -    int ret;
   2.636 -    unsigned long ign1, ign2;
   2.637 -
   2.638 -    __asm__ __volatile__ (
   2.639 -        TRAP_INSTR
   2.640 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.641 -	: "0" (__HYPERVISOR_boot_vcpu), "1" (vcpu), "2" (ctxt)
   2.642 -	: "memory");
   2.643 -
   2.644 -    return ret;
   2.645 +	return _hypercall2(int, vm_assist, cmd, type);
   2.646  }
   2.647  
   2.648  static inline int
   2.649 -HYPERVISOR_vcpu_down(
   2.650 -    int vcpu)
   2.651 +HYPERVISOR_vcpu_op(
   2.652 +	int cmd, int vcpuid, void *extra_args)
   2.653  {
   2.654 -    int ret;
   2.655 -    unsigned long ign1;
   2.656 -    /* Yes, I really do want to clobber edx here: when we resume a
   2.657 -       vcpu after unpickling a multi-processor domain, it returns
   2.658 -       here, but clobbers all of the call clobbered registers. */
   2.659 -    __asm__ __volatile__ (
   2.660 -        TRAP_INSTR
   2.661 -        : "=a" (ret), "=b" (ign1)
   2.662 -	: "0" (__HYPERVISOR_sched_op),
   2.663 -	  "1" (SCHEDOP_vcpu_down | (vcpu << SCHEDOP_vcpushift))
   2.664 -        : "memory", "ecx", "edx" );
   2.665 -
   2.666 -    return ret;
   2.667 +	return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
   2.668  }
   2.669  
   2.670  static inline int
   2.671 -HYPERVISOR_vcpu_up(
   2.672 -    int vcpu)
   2.673 +HYPERVISOR_suspend(
   2.674 +	unsigned long srec)
   2.675  {
   2.676 -    int ret;
   2.677 -    unsigned long ign1;
   2.678 -    __asm__ __volatile__ (
   2.679 -        TRAP_INSTR
   2.680 -        : "=a" (ret), "=b" (ign1)
   2.681 -	: "0" (__HYPERVISOR_sched_op),
   2.682 -	  "1" (SCHEDOP_vcpu_up | (vcpu << SCHEDOP_vcpushift))
   2.683 -        : "memory", "ecx" );
   2.684 -
   2.685 -    return ret;
   2.686 +	return _hypercall3(int, sched_op, SCHEDOP_shutdown,
   2.687 +			   SHUTDOWN_suspend, srec);
   2.688  }
   2.689  
   2.690 -static inline int
   2.691 -HYPERVISOR_vcpu_pickle(
   2.692 -    int vcpu, vcpu_guest_context_t *ctxt)
   2.693 -{
   2.694 -    int ret;
   2.695 -    unsigned long ign1, ign2;
   2.696 -    __asm__ __volatile__ (
   2.697 -        TRAP_INSTR
   2.698 -        : "=a" (ret), "=b" (ign1), "=c" (ign2)
   2.699 -	: "0" (__HYPERVISOR_sched_op),
   2.700 -	  "1" (SCHEDOP_vcpu_pickle | (vcpu << SCHEDOP_vcpushift)),
   2.701 -	  "2" (ctxt)
   2.702 -        : "memory" );
   2.703 -
   2.704 -    return ret;
   2.705 -}
   2.706 +#endif /* __HYPERCALL_H__ */
   2.707  #elif defined(__x86_64__)
   2.708  
   2.709  #define __syscall_clobber "r11","rcx","memory"
   2.710 @@ -792,106 +526,4 @@ HYPERVISOR_set_timer_op(
   2.711  }
   2.712  #endif
   2.713  
   2.714 -
   2.715 -static __inline__ int HYPERVISOR_dom0_op(void *dom0_op)
   2.716 -{
   2.717 -    int ret;
   2.718 -    __asm__ __volatile__ (
   2.719 -        TRAP_INSTR
   2.720 -        : "=a" (ret) : "0" (__HYPERVISOR_dom0_op),
   2.721 -        _a1 (dom0_op) : "memory" );
   2.722 -
   2.723 -    return ret;
   2.724 -}
   2.725 -
   2.726 -static __inline__ int HYPERVISOR_set_debugreg(int reg, unsigned long value)
   2.727 -{
   2.728 -    int ret;
   2.729 -    __asm__ __volatile__ (
   2.730 -        TRAP_INSTR
   2.731 -        : "=a" (ret) : "0" (__HYPERVISOR_set_debugreg),
   2.732 -        _a1 (reg), _a2 (value) : "memory" );
   2.733 -
   2.734 -    return ret;
   2.735 -}
   2.736 -
   2.737 -static __inline__ unsigned long HYPERVISOR_get_debugreg(int reg)
   2.738 -{
   2.739 -    unsigned long ret;
   2.740 -    __asm__ __volatile__ (
   2.741 -        TRAP_INSTR
   2.742 -        : "=a" (ret) : "0" (__HYPERVISOR_get_debugreg),
   2.743 -        _a1 (reg) : "memory" );
   2.744 -
   2.745 -    return ret;
   2.746 -}
   2.747 -
   2.748 -static __inline__ int HYPERVISOR_update_descriptor(
   2.749 -    unsigned long pa, unsigned long word1, unsigned long word2)
   2.750 -{
   2.751 -    int ret;
   2.752 -    __asm__ __volatile__ (
   2.753 -        TRAP_INSTR
   2.754 -        : "=a" (ret) : "0" (__HYPERVISOR_update_descriptor), 
   2.755 -        _a1 (pa), _a2 (word1), _a3 (word2) : "memory" );
   2.756 -
   2.757 -    return ret;
   2.758 -}
   2.759 -
   2.760 -static __inline__ int HYPERVISOR_dom_mem_op(void *dom_mem_op)
   2.761 -{
   2.762 -    int ret;
   2.763 -    __asm__ __volatile__ (
   2.764 -        TRAP_INSTR
   2.765 -        : "=a" (ret) : "0" (__HYPERVISOR_memory_op),
   2.766 -        _a1 (dom_mem_op) : "memory" );
   2.767 -
   2.768 -    return ret;
   2.769 -}
   2.770 -
   2.771 -static __inline__ int HYPERVISOR_multicall(void *call_list, int nr_calls)
   2.772 -{
   2.773 -    int ret;
   2.774 -    __asm__ __volatile__ (
   2.775 -        TRAP_INSTR
   2.776 -        : "=a" (ret) : "0" (__HYPERVISOR_multicall),
   2.777 -        _a1 (call_list), _a2 (nr_calls) : "memory" );
   2.778 -
   2.779 -    return ret;
   2.780 -}
   2.781 -
   2.782 -static __inline__ int HYPERVISOR_update_va_mapping(
   2.783 -    unsigned long page_nr, unsigned long new_val, unsigned long flags)
   2.784 -{
   2.785 -    int ret;
   2.786 -    __asm__ __volatile__ (
   2.787 -        TRAP_INSTR
   2.788 -        : "=a" (ret) : "0" (__HYPERVISOR_update_va_mapping), 
   2.789 -        _a1 (page_nr), _a2 (new_val), _a3 (flags) : "memory" );
   2.790 -
   2.791 -    return ret;
   2.792 -}
   2.793 -
   2.794 -static __inline__ int HYPERVISOR_xen_version(int cmd)
   2.795 -{
   2.796 -    int ret;
   2.797 -    __asm__ __volatile__ (
   2.798 -        TRAP_INSTR
   2.799 -        : "=a" (ret) : "0" (__HYPERVISOR_xen_version), 
   2.800 -        _a1 (cmd) : "memory" );
   2.801 -
   2.802 -    return ret;
   2.803 -}
   2.804 -
   2.805 -static __inline__ int HYPERVISOR_console_io(int cmd, int count, char *str)
   2.806 -{
   2.807 -    int ret;
   2.808 -    __asm__ __volatile__ (
   2.809 -        TRAP_INSTR
   2.810 -        : "=a" (ret) : "0" (__HYPERVISOR_console_io),
   2.811 -        _a1 (cmd), _a2 (count), _a3 (str) : "memory" );
   2.812 -
   2.813 -    return ret;
   2.814 -}
   2.815 -
   2.816  #endif /* __HYPERVISOR_H__ */

     3.1 --- a/extras/mini-os/include/os.h	Sun Oct 30 13:52:38 2005 +0100
     3.2 +++ b/extras/mini-os/include/os.h	Sun Oct 30 14:00:35 2005 +0100
     3.3 @@ -24,7 +24,7 @@
     3.4  #include <xen/xen.h>
     3.5  
     3.6  
     3.7 -#define force_evtchn_callback() ((void)HYPERVISOR_xen_version(0))
     3.8 +#define force_evtchn_callback() ((void)HYPERVISOR_xen_version(0, 0))
     3.9  
    3.10  #define __KERNEL_CS  FLAT_KERNEL_CS
    3.11  #define __KERNEL_DS  FLAT_KERNEL_DS
    3.12 @@ -55,6 +55,8 @@
    3.13  /* Everything below this point is not included by assembler (.S) files. */
    3.14  #ifndef __ASSEMBLY__
    3.15  
    3.16 +extern shared_info_t *HYPERVISOR_shared_info;
    3.17 +
    3.18  void trap_init(void);
    3.19  
    3.20  /* 

     4.1 --- a/extras/mini-os/include/types.h	Sun Oct 30 13:52:38 2005 +0100
     4.2 +++ b/extras/mini-os/include/types.h	Sun Oct 30 14:00:35 2005 +0100
     4.3 @@ -54,7 +54,14 @@ typedef unsigned long       uintptr_t;
     4.4  typedef struct { unsigned long pte; } pte_t;
     4.5  #endif
     4.6  
     4.7 -
     4.8 +typedef  u8 uint8_t;
     4.9 +typedef  s8 int8_t;
    4.10 +typedef u16 uint16_t;
    4.11 +typedef s16 int16_t;
    4.12 +typedef u32 uint32_t;
    4.13 +typedef s32 int32_t;
    4.14 +typedef u64 uint64_t;
    4.15 +typedef s64 int64_t;
    4.16  
    4.17  
    4.18  #define INT_MAX         ((int)(~0U>>1))

     5.1 --- a/extras/mini-os/kernel.c	Sun Oct 30 13:52:38 2005 +0100
     5.2 +++ b/extras/mini-os/kernel.c	Sun Oct 30 14:00:35 2005 +0100
     5.3 @@ -61,7 +61,7 @@ void failsafe_callback(void);
     5.4  
     5.5  extern char shared_info[PAGE_SIZE];
     5.6  
     5.7 -#define __pte(x) ((pte_t) { (0) } )
     5.8 +#define __pte(x) ((pte_t) { (x) } )
     5.9  
    5.10  static shared_info_t *map_shared_info(unsigned long pa)
    5.11  {
    5.12 @@ -150,5 +150,5 @@ void start_kernel(start_info_t *si)
    5.13  void do_exit(void)
    5.14  {
    5.15      printk("do_exit called!\n");
    5.16 -    for ( ;; ) HYPERVISOR_shutdown();
    5.17 +    for ( ;; ) HYPERVISOR_sched_op(SCHEDOP_shutdown, SHUTDOWN_crash);
    5.18  }

     6.1 --- a/extras/mini-os/time.c	Sun Oct 30 13:52:38 2005 +0100
     6.2 +++ b/extras/mini-os/time.c	Sun Oct 30 14:00:35 2005 +0100
     6.3 @@ -208,7 +208,7 @@ void block_domain(u32 millisecs)
     6.4      struct timeval tv;
     6.5      gettimeofday(&tv);
     6.6      HYPERVISOR_set_timer_op(monotonic_clock() + 1000000LL * (s64) millisecs);
     6.7 -    HYPERVISOR_block();
     6.8 +    HYPERVISOR_sched_op(SCHEDOP_block, 0);
     6.9  }
    6.10  
    6.11  

     7.1 --- a/extras/mini-os/xenbus/xenbus_xs.c	Sun Oct 30 13:52:38 2005 +0100
     7.2 +++ b/extras/mini-os/xenbus/xenbus_xs.c	Sun Oct 30 14:00:35 2005 +0100
     7.3 @@ -39,7 +39,7 @@
     7.4  #include <wait.h>
     7.5  #include <sched.h>
     7.6  #include <semaphore.h>
     7.7 -#include "xenstored.h"
     7.8 +#include <xen/io/xs_wire.h>
     7.9  #include "xenbus_comms.h"
    7.10  
    7.11  #define streq(a, b) (strcmp((a), (b)) == 0)
    7.12 @@ -408,7 +408,12 @@ static char *xs_read_watch(char **token)
    7.13  
    7.14  static int xs_acknowledge_watch(const char *token)
    7.15  {
    7.16 +#if 0
    7.17  	return xs_error(xs_single(XS_WATCH_ACK, token, NULL));
    7.18 +#else
    7.19 +	/* XS_WATCH_ACK is no longer available */
    7.20 +	return 0;
    7.21 +#endif
    7.22  }
    7.23  
    7.24  static int xs_unwatch(const char *path, const char *token)

     8.1 --- a/linux-2.6-xen-sparse/arch/ia64/xen/drivers/evtchn_ia64.c	Sun Oct 30 13:52:38 2005 +0100
     8.2 +++ b/linux-2.6-xen-sparse/arch/ia64/xen/drivers/evtchn_ia64.c	Sun Oct 30 14:00:35 2005 +0100
     8.3 @@ -29,7 +29,7 @@ unsigned int bind_virq_to_evtchn(int vir
     8.4      return op.u.bind_virq.port;
     8.5  }
     8.6  
     8.7 -int bind_virq_to_irq(int virq)
     8.8 +int bind_virq_to_irq(int virq, int cpu)
     8.9  {
    8.10  	printk("bind_virq_to_irq called... FIXME??\n");
    8.11  	while(1);
    8.12 @@ -66,7 +66,11 @@ int bind_evtchn_to_irqhandler(unsigned i
    8.13      evtchns[evtchn].handler = handler;
    8.14      evtchns[evtchn].dev_id = dev_id;
    8.15      unmask_evtchn(evtchn);
    8.16 -    return 0;
    8.17 +    //return 0;
    8.18 +    /* On ia64, there's only one irq vector allocated for all event channels,
    8.19 +     * so let's just return evtchn as handle for later communication
    8.20 +     */
    8.21 +    return evtchn;
    8.22  }
    8.23  
    8.24  void unbind_evtchn_from_irqhandler(unsigned int evtchn, void *dev_id)

     9.1 --- a/linux-2.6-xen-sparse/arch/ia64/xen/xenentry.S	Sun Oct 30 13:52:38 2005 +0100
     9.2 +++ b/linux-2.6-xen-sparse/arch/ia64/xen/xenentry.S	Sun Oct 30 14:00:35 2005 +0100
     9.3 @@ -46,8 +46,6 @@ GLOBAL_ENTRY(ia64_switch_to)
     9.4  	.prologue
     9.5  	alloc r16=ar.pfs,1,0,0,0
     9.6  #endif
     9.7 -	.prologue
     9.8 -	alloc r16=ar.pfs,1,0,0,0
     9.9  	DO_SAVE_SWITCH_STACK
    9.10  	.body
    9.11  

    10.1 --- a/linux-2.6-xen-sparse/arch/xen/i386/kernel/entry.S	Sun Oct 30 13:52:38 2005 +0100
    10.2 +++ b/linux-2.6-xen-sparse/arch/xen/i386/kernel/entry.S	Sun Oct 30 14:00:35 2005 +0100
    10.3 @@ -653,7 +653,7 @@ ENTRY(simd_coprocessor_error)
    10.4  ENTRY(device_not_available)
    10.5  	pushl $-1			# mark this as an int
    10.6  	SAVE_ALL
    10.7 -	preempt_stop
    10.8 +	#preempt_stop /* This is already an interrupt gate on Xen. */
    10.9  	call math_state_restore
   10.10  	jmp ret_from_exception
   10.11  

    11.1 --- a/linux-2.6-xen-sparse/arch/xen/i386/kernel/process.c	Sun Oct 30 13:52:38 2005 +0100
    11.2 +++ b/linux-2.6-xen-sparse/arch/xen/i386/kernel/process.c	Sun Oct 30 14:00:35 2005 +0100
    11.3 @@ -483,6 +483,9 @@ struct task_struct fastcall * __switch_t
    11.4  		mcl->args[0] = 1;
    11.5  		mcl++;
    11.6  	}
    11.7 +#if 0 /* lazy fpu sanity check */
    11.8 +	else BUG_ON(!(read_cr0() & 8));
    11.9 +#endif
   11.10  
   11.11  	/*
   11.12  	 * Reload esp0, LDT and the page table pointer:

    12.1 --- a/linux-2.6-xen-sparse/arch/xen/i386/kernel/traps.c	Sun Oct 30 13:52:38 2005 +0100
    12.2 +++ b/linux-2.6-xen-sparse/arch/xen/i386/kernel/traps.c	Sun Oct 30 14:00:35 2005 +0100
    12.3 @@ -648,6 +648,12 @@ fastcall void do_int3(struct pt_regs *re
    12.4  }
    12.5  #endif
    12.6  
    12.7 +static inline void conditional_sti(struct pt_regs *regs)
    12.8 +{
    12.9 +	if ((uint8_t)(regs->xcs >> 16) == 0)
   12.10 +		local_irq_enable();
   12.11 +}
   12.12 +
   12.13  /*
   12.14   * Our handling of the processor debug registers is non-trivial.
   12.15   * We do not clear them on entry and exit from the kernel. Therefore
   12.16 @@ -680,11 +686,9 @@ fastcall void do_debug(struct pt_regs * 
   12.17  	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
   12.18  					SIGTRAP) == NOTIFY_STOP)
   12.19  		return;
   12.20 -#if 0
   12.21 +
   12.22  	/* It's safe to allow irq's after DR6 has been saved */
   12.23 -	if (regs->eflags & X86_EFLAGS_IF)
   12.24 -		local_irq_enable();
   12.25 -#endif
   12.26 +	conditional_sti(regs);
   12.27  
   12.28  	/* Mask out spurious debug traps due to lazy DR7 setting */
   12.29  	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
   12.30 @@ -967,15 +971,18 @@ void __init trap_init_f00f_bug(void)
   12.31  #endif
   12.32  
   12.33  
   12.34 -/* NB. All these are "trap gates" (i.e. events_mask isn't cleared). */
   12.35 +/*
   12.36 + * NB. All these are "trap gates" (i.e. events_mask isn't cleared) except
   12.37 + * for those that specify <dpl>|4 in the second field.
   12.38 + */
   12.39  static trap_info_t trap_table[] = {
   12.40  	{  0, 0, __KERNEL_CS, (unsigned long)divide_error		},
   12.41 -	{  1, 0, __KERNEL_CS, (unsigned long)debug			},
   12.42 -	{  3, 3, __KERNEL_CS, (unsigned long)int3			},
   12.43 +	{  1, 0|4, __KERNEL_CS, (unsigned long)debug			},
   12.44 +	{  3, 3|4, __KERNEL_CS, (unsigned long)int3			},
   12.45  	{  4, 3, __KERNEL_CS, (unsigned long)overflow			},
   12.46  	{  5, 3, __KERNEL_CS, (unsigned long)bounds			},
   12.47  	{  6, 0, __KERNEL_CS, (unsigned long)invalid_op			},
   12.48 -	{  7, 0, __KERNEL_CS, (unsigned long)device_not_available	},
   12.49 +	{  7, 0|4, __KERNEL_CS, (unsigned long)device_not_available	},
   12.50  	{  9, 0, __KERNEL_CS, (unsigned long)coprocessor_segment_overrun },
   12.51  	{ 10, 0, __KERNEL_CS, (unsigned long)invalid_TSS		},
   12.52  	{ 11, 0, __KERNEL_CS, (unsigned long)segment_not_present	},

    13.1 --- a/linux-2.6-xen-sparse/arch/xen/x86_64/kernel/setup.c	Sun Oct 30 13:52:38 2005 +0100
    13.2 +++ b/linux-2.6-xen-sparse/arch/xen/x86_64/kernel/setup.c	Sun Oct 30 14:00:35 2005 +0100
    13.3 @@ -733,6 +733,7 @@ void __init setup_arch(char **cmdline_p)
    13.4  #ifdef CONFIG_XEN
    13.5  	{
    13.6  		int i, j, k, fpp;
    13.7 +		unsigned long va;
    13.8  
    13.9  		/* Make sure we have a large enough P->M table. */
   13.10  		phys_to_machine_mapping = alloc_bootmem(
   13.11 @@ -746,9 +747,21 @@ void __init setup_arch(char **cmdline_p)
   13.12  			__pa(xen_start_info->mfn_list), 
   13.13  			PFN_PHYS(PFN_UP(xen_start_info->nr_pages *
   13.14  					sizeof(unsigned long))));
   13.15 -		make_pages_readonly((void *)xen_start_info->mfn_list,
   13.16 -				    PFN_UP(xen_start_info->nr_pages *
   13.17 -					   sizeof(unsigned long)));
   13.18 +
   13.19 +		/* 'Initial mapping' of old p2m table must be destroyed. */
   13.20 +		for (va = xen_start_info->mfn_list;
   13.21 +		     va < (xen_start_info->mfn_list +
   13.22 +			   (xen_start_info->nr_pages*sizeof(unsigned long)));
   13.23 +		     va += PAGE_SIZE) {
   13.24 +			HYPERVISOR_update_va_mapping(va, __pte_ma(0), 0);
   13.25 +		}
   13.26 +
   13.27 +		/* 'Initial mapping' of initrd must be destroyed. */
   13.28 +		for (va = xen_start_info->mod_start;
   13.29 +		     va < (xen_start_info->mod_start+xen_start_info->mod_len);
   13.30 +		     va += PAGE_SIZE) {
   13.31 +			HYPERVISOR_update_va_mapping(va, __pte_ma(0), 0);
   13.32 +		}
   13.33  
   13.34  		/* 
   13.35  		 * Initialise the list of the frames that specify the list of 

    14.1 --- a/linux-2.6-xen-sparse/arch/xen/x86_64/kernel/xen_entry.S	Sun Oct 30 13:52:38 2005 +0100
    14.2 +++ b/linux-2.6-xen-sparse/arch/xen/x86_64/kernel/xen_entry.S	Sun Oct 30 14:00:35 2005 +0100
    14.3 @@ -5,7 +5,7 @@
    14.4  #define evtchn_upcall_pending		0
    14.5  #define evtchn_upcall_mask		1
    14.6  
    14.7 -#define sizeof_vcpu_shift		3
    14.8 +#define sizeof_vcpu_shift		4
    14.9  
   14.10  #ifdef CONFIG_SMP
   14.11  //#define preempt_disable(reg)	incl threadinfo_preempt_count(reg)

    15.1 --- a/linux-2.6-xen-sparse/drivers/xen/balloon/balloon.c	Sun Oct 30 13:52:38 2005 +0100
    15.2 +++ b/linux-2.6-xen-sparse/drivers/xen/balloon/balloon.c	Sun Oct 30 14:00:35 2005 +0100
    15.3 @@ -191,12 +191,13 @@ static int increase_reservation(unsigned
    15.4  	rc = HYPERVISOR_memory_op(
    15.5  		XENMEM_increase_reservation, &reservation);
    15.6  	if (rc < nr_pages) {
    15.7 +		int ret;
    15.8  		/* We hit the Xen hard limit: reprobe. */
    15.9  		reservation.extent_start = mfn_list;
   15.10  		reservation.nr_extents   = rc;
   15.11 -		BUG_ON(HYPERVISOR_memory_op(
   15.12 -			XENMEM_decrease_reservation,
   15.13 -			&reservation) != rc);
   15.14 +		ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
   15.15 +				&reservation);
   15.16 +		BUG_ON(ret != rc);
   15.17  		hard_limit = current_pages + rc - driver_pages;
   15.18  		goto out;
   15.19  	}
   15.20 @@ -213,11 +214,14 @@ static int increase_reservation(unsigned
   15.21  		xen_machphys_update(mfn_list[i], pfn);
   15.22              
   15.23  		/* Link back into the page tables if not highmem. */
   15.24 -		if (pfn < max_low_pfn)
   15.25 -			BUG_ON(HYPERVISOR_update_va_mapping(
   15.26 +		if (pfn < max_low_pfn) {
   15.27 +			int ret;
   15.28 +			ret = HYPERVISOR_update_va_mapping(
   15.29  				(unsigned long)__va(pfn << PAGE_SHIFT),
   15.30  				pfn_pte_ma(mfn_list[i], PAGE_KERNEL),
   15.31 -				0));
   15.32 +				0);
   15.33 +			BUG_ON(ret);
   15.34 +		}
   15.35  
   15.36  		/* Relinquish the page back to the allocator. */
   15.37  		ClearPageReserved(page);
   15.38 @@ -242,6 +246,7 @@ static int decrease_reservation(unsigned
   15.39  	struct page   *page;
   15.40  	void          *v;
   15.41  	int            need_sleep = 0;
   15.42 +	int ret;
   15.43  	struct xen_memory_reservation reservation = {
   15.44  		.address_bits = 0,
   15.45  		.extent_order = 0,
   15.46 @@ -268,8 +273,9 @@ static int decrease_reservation(unsigned
   15.47  		if (!PageHighMem(page)) {
   15.48  			v = phys_to_virt(pfn << PAGE_SHIFT);
   15.49  			scrub_pages(v, 1);
   15.50 -			BUG_ON(HYPERVISOR_update_va_mapping(
   15.51 -				(unsigned long)v, __pte_ma(0), 0));
   15.52 +			ret = HYPERVISOR_update_va_mapping(
   15.53 +				(unsigned long)v, __pte_ma(0), 0);
   15.54 +			BUG_ON(ret);
   15.55  		}
   15.56  #ifdef CONFIG_XEN_SCRUB_PAGES
   15.57  		else {
   15.58 @@ -295,8 +301,8 @@ static int decrease_reservation(unsigned
   15.59  
   15.60  	reservation.extent_start = mfn_list;
   15.61  	reservation.nr_extents   = nr_pages;
   15.62 -	BUG_ON(HYPERVISOR_memory_op(
   15.63 -		XENMEM_decrease_reservation, &reservation) != nr_pages);
   15.64 +	ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
   15.65 +	BUG_ON(ret != nr_pages);
   15.66  
   15.67  	current_pages -= nr_pages;
   15.68  	totalram_pages = current_pages;
   15.69 @@ -501,6 +507,7 @@ static int dealloc_pte_fn(
   15.70  	pte_t *pte, struct page *pte_page, unsigned long addr, void *data)
   15.71  {
   15.72  	unsigned long mfn = pte_mfn(*pte);
   15.73 +	int ret;
   15.74  	struct xen_memory_reservation reservation = {
   15.75  		.extent_start = &mfn,
   15.76  		.nr_extents   = 1,
   15.77 @@ -510,8 +517,8 @@ static int dealloc_pte_fn(
   15.78  	set_pte_at(&init_mm, addr, pte, __pte_ma(0));
   15.79  	phys_to_machine_mapping[__pa(addr) >> PAGE_SHIFT] =
   15.80  		INVALID_P2M_ENTRY;
   15.81 -	BUG_ON(HYPERVISOR_memory_op(
   15.82 -		XENMEM_decrease_reservation, &reservation) != 1);
   15.83 +	ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
   15.84 +	BUG_ON(ret != 1);
   15.85  	return 0;
   15.86  }
   15.87  
   15.88 @@ -519,6 +526,7 @@ struct page *balloon_alloc_empty_page_ra
   15.89  {
   15.90  	unsigned long vstart, flags;
   15.91  	unsigned int  order = get_order(nr_pages * PAGE_SIZE);
   15.92 +	int ret;
   15.93  
   15.94  	vstart = __get_free_pages(GFP_KERNEL, order);
   15.95  	if (vstart == 0)
   15.96 @@ -527,8 +535,9 @@ struct page *balloon_alloc_empty_page_ra
   15.97  	scrub_pages(vstart, 1 << order);
   15.98  
   15.99  	balloon_lock(flags);
  15.100 -	BUG_ON(generic_page_range(
  15.101 -		&init_mm, vstart, PAGE_SIZE << order, dealloc_pte_fn, NULL));
  15.102 +	ret = generic_page_range(
  15.103 +		&init_mm, vstart, PAGE_SIZE << order, dealloc_pte_fn, NULL);
  15.104 +	BUG_ON(ret);
  15.105  	current_pages -= 1UL << order;
  15.106  	balloon_unlock(flags);
  15.107  

    16.1 --- a/linux-2.6-xen-sparse/drivers/xen/blkback/blkback.c	Sun Oct 30 13:52:38 2005 +0100
    16.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blkback/blkback.c	Sun Oct 30 14:00:35 2005 +0100
    16.3 @@ -108,6 +108,7 @@ static void fast_flush_area(int idx, int
    16.4  	struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
    16.5  	unsigned int i, invcount = 0;
    16.6  	u16 handle;
    16.7 +	int ret;
    16.8  
    16.9  	for (i = 0; i < nr_pages; i++) {
   16.10  		handle = pending_handle(idx, i);
   16.11 @@ -120,8 +121,9 @@ static void fast_flush_area(int idx, int
   16.12  		invcount++;
   16.13  	}
   16.14  
   16.15 -	BUG_ON(HYPERVISOR_grant_table_op(
   16.16 -		GNTTABOP_unmap_grant_ref, unmap, invcount));
   16.17 +	ret = HYPERVISOR_grant_table_op(
   16.18 +		GNTTABOP_unmap_grant_ref, unmap, invcount);
   16.19 +	BUG_ON(ret);
   16.20  }
   16.21  
   16.22  
   16.23 @@ -338,6 +340,7 @@ static void dispatch_rw_block_io(blkif_t
   16.24  	struct bio *bio = NULL, *biolist[BLKIF_MAX_SEGMENTS_PER_REQUEST];
   16.25  	int nbio = 0;
   16.26  	request_queue_t *q;
   16.27 +	int ret;
   16.28  
   16.29  	/* Check that number of segments is sane. */
   16.30  	nseg = req->nr_segments;
   16.31 @@ -367,8 +370,8 @@ static void dispatch_rw_block_io(blkif_t
   16.32  			map[i].flags |= GNTMAP_readonly;
   16.33  	}
   16.34  
   16.35 -	BUG_ON(HYPERVISOR_grant_table_op(
   16.36 -		GNTTABOP_map_grant_ref, map, nseg));
   16.37 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, nseg);
   16.38 +	BUG_ON(ret);
   16.39  
   16.40  	for (i = 0; i < nseg; i++) {
   16.41  		if (unlikely(map[i].handle < 0)) {
   16.42 @@ -493,6 +496,7 @@ static int __init blkif_init(void)
   16.43  {
   16.44  	int i;
   16.45  	struct page *page;
   16.46 +	int ret;
   16.47  
   16.48  	blkif_interface_init();
   16.49  
   16.50 @@ -509,7 +513,8 @@ static int __init blkif_init(void)
   16.51  	spin_lock_init(&blkio_schedule_list_lock);
   16.52  	INIT_LIST_HEAD(&blkio_schedule_list);
   16.53  
   16.54 -	BUG_ON(kernel_thread(blkio_schedule, 0, CLONE_FS | CLONE_FILES) < 0);
   16.55 +	ret = kernel_thread(blkio_schedule, 0, CLONE_FS | CLONE_FILES);
   16.56 +	BUG_ON(ret < 0);
   16.57  
   16.58  	blkif_xenbus_init();
   16.59  

    17.1 --- a/linux-2.6-xen-sparse/drivers/xen/blkback/interface.c	Sun Oct 30 13:52:38 2005 +0100
    17.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blkback/interface.c	Sun Oct 30 14:00:35 2005 +0100
    17.3 @@ -31,6 +31,7 @@ blkif_t *alloc_blkif(domid_t domid)
    17.4  static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
    17.5  {
    17.6  	struct gnttab_map_grant_ref op;
    17.7 +	int ret;
    17.8  
    17.9  	op.host_addr = (unsigned long)blkif->blk_ring_area->addr;
   17.10  	op.flags     = GNTMAP_host_map;
   17.11 @@ -38,8 +39,9 @@ static int map_frontend_page(blkif_t *bl
   17.12  	op.dom       = blkif->domid;
   17.13  
   17.14  	lock_vm_area(blkif->blk_ring_area);
   17.15 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
   17.16 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
   17.17  	unlock_vm_area(blkif->blk_ring_area);
   17.18 +	BUG_ON(ret);
   17.19  
   17.20  	if (op.handle < 0) {
   17.21  		DPRINTK(" Grant table operation failure !\n");
   17.22 @@ -55,14 +57,16 @@ static int map_frontend_page(blkif_t *bl
   17.23  static void unmap_frontend_page(blkif_t *blkif)
   17.24  {
   17.25  	struct gnttab_unmap_grant_ref op;
   17.26 +	int ret;
   17.27  
   17.28  	op.host_addr    = (unsigned long)blkif->blk_ring_area->addr;
   17.29  	op.handle       = blkif->shmem_handle;
   17.30  	op.dev_bus_addr = 0;
   17.31  
   17.32  	lock_vm_area(blkif->blk_ring_area);
   17.33 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1));
   17.34 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
   17.35  	unlock_vm_area(blkif->blk_ring_area);
   17.36 +	BUG_ON(ret);
   17.37  }
   17.38  
   17.39  int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn)

    18.1 --- a/linux-2.6-xen-sparse/drivers/xen/blkfront/blkfront.c	Sun Oct 30 13:52:38 2005 +0100
    18.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blkfront/blkfront.c	Sun Oct 30 14:00:35 2005 +0100
    18.3 @@ -305,6 +305,7 @@ static irqreturn_t blkif_int(int irq, vo
    18.4  
    18.5  	for (i = info->ring.rsp_cons; i != rp; i++) {
    18.6  		unsigned long id;
    18.7 +		int ret;
    18.8  
    18.9  		bret = RING_GET_RESPONSE(&info->ring, i);
   18.10  		id   = bret->id;
   18.11 @@ -321,9 +322,10 @@ static irqreturn_t blkif_int(int irq, vo
   18.12  				DPRINTK("Bad return from blkdev data "
   18.13  					"request: %x\n", bret->status);
   18.14  
   18.15 -			BUG_ON(end_that_request_first(
   18.16 +			ret = end_that_request_first(
   18.17  				req, (bret->status == BLKIF_RSP_OKAY),
   18.18 -				req->hard_nr_sectors));
   18.19 +				req->hard_nr_sectors);
   18.20 +			BUG_ON(ret);
   18.21  			end_that_request_last(req);
   18.22  			break;
   18.23  		default:

    19.1 --- a/linux-2.6-xen-sparse/drivers/xen/blktap/blktap.c	Sun Oct 30 13:52:38 2005 +0100
    19.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blktap/blktap.c	Sun Oct 30 14:00:35 2005 +0100
    19.3 @@ -413,6 +413,7 @@ static void fast_flush_area(int idx, int
    19.4  	unsigned int i, op = 0;
    19.5  	struct grant_handle_pair *handle;
    19.6  	unsigned long ptep;
    19.7 +	int ret;
    19.8  
    19.9  	for ( i = 0; i < nr_pages; i++)
   19.10  	{
   19.11 @@ -440,8 +441,8 @@ static void fast_flush_area(int idx, int
   19.12  		BLKTAP_INVALIDATE_HANDLE(handle);
   19.13  	}
   19.14  
   19.15 -	BUG_ON(HYPERVISOR_grant_table_op(
   19.16 -		GNTTABOP_unmap_grant_ref, unmap, op));
   19.17 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, op);
   19.18 +	BUG_ON(ret);
   19.19  
   19.20  	if (blktap_vma != NULL)
   19.21  		zap_page_range(blktap_vma, 
   19.22 @@ -673,6 +674,7 @@ static void dispatch_rw_block_io(blkif_t
   19.23  	struct gnttab_map_grant_ref map[BLKIF_MAX_SEGMENTS_PER_REQUEST*2];
   19.24  	int op, ret;
   19.25  	unsigned int nseg;
   19.26 +	int retval;
   19.27  
   19.28  	/* Check that number of segments is sane. */
   19.29  	nseg = req->nr_segments;
   19.30 @@ -740,8 +742,8 @@ static void dispatch_rw_block_io(blkif_t
   19.31  		op++;
   19.32  	}
   19.33  
   19.34 -	BUG_ON(HYPERVISOR_grant_table_op(
   19.35 -		GNTTABOP_map_grant_ref, map, op));
   19.36 +	retval = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, op);
   19.37 +	BUG_ON(retval);
   19.38  
   19.39  	op = 0;
   19.40  	for (i = 0; i < (req->nr_segments*2); i += 2) {
   19.41 @@ -877,7 +879,8 @@ static int __init blkif_init(void)
   19.42  	spin_lock_init(&blkio_schedule_list_lock);
   19.43  	INIT_LIST_HEAD(&blkio_schedule_list);
   19.44  
   19.45 -	BUG_ON(kernel_thread(blkio_schedule, 0, CLONE_FS | CLONE_FILES) < 0);
   19.46 +	i = kernel_thread(blkio_schedule, 0, CLONE_FS | CLONE_FILES);
   19.47 +	BUG_ON(i<0);
   19.48  
   19.49  	blkif_xenbus_init();
   19.50  

    20.1 --- a/linux-2.6-xen-sparse/drivers/xen/blktap/interface.c	Sun Oct 30 13:52:38 2005 +0100
    20.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blktap/interface.c	Sun Oct 30 14:00:35 2005 +0100
    20.3 @@ -31,6 +31,7 @@ blkif_t *alloc_blkif(domid_t domid)
    20.4  static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
    20.5  {
    20.6  	struct gnttab_map_grant_ref op;
    20.7 +	int ret;
    20.8  
    20.9  	op.host_addr = (unsigned long)blkif->blk_ring_area->addr;
   20.10  	op.flags     = GNTMAP_host_map;
   20.11 @@ -38,8 +39,9 @@ static int map_frontend_page(blkif_t *bl
   20.12  	op.dom       = blkif->domid;
   20.13  
   20.14  	lock_vm_area(blkif->blk_ring_area);
   20.15 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
   20.16 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
   20.17  	unlock_vm_area(blkif->blk_ring_area);
   20.18 +	BUG_ON(ret);
   20.19  
   20.20  	if (op.handle < 0) {
   20.21  		DPRINTK(" Grant table operation failure !\n");
   20.22 @@ -55,14 +57,16 @@ static int map_frontend_page(blkif_t *bl
   20.23  static void unmap_frontend_page(blkif_t *blkif)
   20.24  {
   20.25  	struct gnttab_unmap_grant_ref op;
   20.26 +	int ret;
   20.27  
   20.28  	op.host_addr    = (unsigned long)blkif->blk_ring_area->addr;
   20.29  	op.handle       = blkif->shmem_handle;
   20.30  	op.dev_bus_addr = 0;
   20.31  
   20.32  	lock_vm_area(blkif->blk_ring_area);
   20.33 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1));
   20.34 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
   20.35  	unlock_vm_area(blkif->blk_ring_area);
   20.36 +	BUG_ON(ret);
   20.37  }
   20.38  
   20.39  int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn)

    21.1 --- a/linux-2.6-xen-sparse/drivers/xen/evtchn/evtchn.c	Sun Oct 30 13:52:38 2005 +0100
    21.2 +++ b/linux-2.6-xen-sparse/drivers/xen/evtchn/evtchn.c	Sun Oct 30 14:00:35 2005 +0100
    21.3 @@ -282,6 +282,7 @@ static int evtchn_ioctl(struct inode *in
    21.4  
    21.5  	case IOCTL_EVTCHN_UNBIND: {
    21.6  		struct ioctl_evtchn_unbind unbind;
    21.7 +		int ret;
    21.8  
    21.9  		rc = -EFAULT;
   21.10  		if (copy_from_user(&unbind, (void *)arg, sizeof(unbind)))
   21.11 @@ -306,7 +307,8 @@ static int evtchn_ioctl(struct inode *in
   21.12  
   21.13  		op.cmd = EVTCHNOP_close;
   21.14  		op.u.close.port = unbind.port;
   21.15 -		BUG_ON(HYPERVISOR_event_channel_op(&op));
   21.16 +		ret = HYPERVISOR_event_channel_op(&op);
   21.17 +		BUG_ON(ret);
   21.18  
   21.19  		rc = 0;
   21.20  		break;
   21.21 @@ -399,6 +401,7 @@ static int evtchn_release(struct inode *
   21.22  
   21.23  	for (i = 0; i < NR_EVENT_CHANNELS; i++)
   21.24  	{
   21.25 +		int ret;
   21.26  		if (port_user[i] != u)
   21.27  			continue;
   21.28  
   21.29 @@ -407,7 +410,8 @@ static int evtchn_release(struct inode *
   21.30  
   21.31  		op.cmd = EVTCHNOP_close;
   21.32  		op.u.close.port = i;
   21.33 -		BUG_ON(HYPERVISOR_event_channel_op(&op));
   21.34 +		ret = HYPERVISOR_event_channel_op(&op);
   21.35 +		BUG_ON(ret);
   21.36  	}
   21.37  
   21.38  	spin_unlock_irq(&port_user_lock);

    22.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/interface.c	Sun Oct 30 13:52:38 2005 +0100
    22.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/interface.c	Sun Oct 30 14:00:35 2005 +0100
    22.3 @@ -115,6 +115,7 @@ static int map_frontend_pages(
    22.4  	netif_t *netif, grant_ref_t tx_ring_ref, grant_ref_t rx_ring_ref)
    22.5  {
    22.6  	struct gnttab_map_grant_ref op;
    22.7 +	int ret;
    22.8  
    22.9  	op.host_addr = (unsigned long)netif->comms_area->addr;
   22.10  	op.flags     = GNTMAP_host_map;
   22.11 @@ -122,8 +123,9 @@ static int map_frontend_pages(
   22.12  	op.dom       = netif->domid;
   22.13      
   22.14  	lock_vm_area(netif->comms_area);
   22.15 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
   22.16 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
   22.17  	unlock_vm_area(netif->comms_area);
   22.18 +	BUG_ON(ret);
   22.19  
   22.20  	if (op.handle < 0) { 
   22.21  		DPRINTK(" Gnttab failure mapping tx_ring_ref!\n");
   22.22 @@ -139,8 +141,9 @@ static int map_frontend_pages(
   22.23  	op.dom       = netif->domid;
   22.24  
   22.25  	lock_vm_area(netif->comms_area);
   22.26 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
   22.27 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
   22.28  	unlock_vm_area(netif->comms_area);
   22.29 +	BUG_ON(ret);
   22.30  
   22.31  	if (op.handle < 0) { 
   22.32  		DPRINTK(" Gnttab failure mapping rx_ring_ref!\n");
   22.33 @@ -156,22 +159,25 @@ static int map_frontend_pages(
   22.34  static void unmap_frontend_pages(netif_t *netif)
   22.35  {
   22.36  	struct gnttab_unmap_grant_ref op;
   22.37 +	int ret;
   22.38  
   22.39  	op.host_addr    = (unsigned long)netif->comms_area->addr;
   22.40  	op.handle       = netif->tx_shmem_handle;
   22.41  	op.dev_bus_addr = 0;
   22.42  
   22.43  	lock_vm_area(netif->comms_area);
   22.44 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1));
   22.45 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
   22.46  	unlock_vm_area(netif->comms_area);
   22.47 +	BUG_ON(ret);
   22.48  
   22.49  	op.host_addr    = (unsigned long)netif->comms_area->addr + PAGE_SIZE;
   22.50  	op.handle       = netif->rx_shmem_handle;
   22.51  	op.dev_bus_addr = 0;
   22.52  
   22.53  	lock_vm_area(netif->comms_area);
   22.54 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1));
   22.55 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
   22.56  	unlock_vm_area(netif->comms_area);
   22.57 +	BUG_ON(ret);
   22.58  }
   22.59  
   22.60  int netif_map(netif_t *netif, unsigned long tx_ring_ref,

    23.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Sun Oct 30 13:52:38 2005 +0100
    23.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Sun Oct 30 14:00:35 2005 +0100
    23.3 @@ -112,9 +112,12 @@ static void free_mfn(unsigned long mfn)
    23.4  	spin_lock_irqsave(&mfn_lock, flags);
    23.5  	if ( alloc_index != MAX_MFN_ALLOC )
    23.6  		mfn_list[alloc_index++] = mfn;
    23.7 -	else
    23.8 -		BUG_ON(HYPERVISOR_memory_op(XENMEM_decrease_reservation,
    23.9 -					    &reservation) != 1);
   23.10 +	else {
   23.11 +		int ret;
   23.12 +		ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
   23.13 +					    &reservation);
   23.14 +		BUG_ON(ret != 1);
   23.15 +	}
   23.16  	spin_unlock_irqrestore(&mfn_lock, flags);
   23.17  }
   23.18  #endif
   23.19 @@ -159,13 +162,15 @@ int netif_be_start_xmit(struct sk_buff *
   23.20  	 */
   23.21  	if (skb_shared(skb) || skb_cloned(skb) || !is_xen_skb(skb)) {
   23.22  		int hlen = skb->data - skb->head;
   23.23 +		int ret;
   23.24  		struct sk_buff *nskb = dev_alloc_skb(hlen + skb->len);
   23.25  		if ( unlikely(nskb == NULL) )
   23.26  			goto drop;
   23.27  		skb_reserve(nskb, hlen);
   23.28  		__skb_put(nskb, skb->len);
   23.29 -		BUG_ON(skb_copy_bits(skb, -hlen, nskb->data - hlen,
   23.30 -				     skb->len + hlen));
   23.31 +		ret = skb_copy_bits(skb, -hlen, nskb->data - hlen,
   23.32 +				     skb->len + hlen);
   23.33 +		BUG_ON(ret);
   23.34  		nskb->dev = skb->dev;
   23.35  		nskb->proto_csum_valid = skb->proto_csum_valid;
   23.36  		dev_kfree_skb(skb);
   23.37 @@ -218,6 +223,7 @@ static void net_rx_action(unsigned long 
   23.38  	struct sk_buff *skb;
   23.39  	u16 notify_list[NETIF_RX_RING_SIZE];
   23.40  	int notify_nr = 0;
   23.41 +	int ret;
   23.42  
   23.43  	skb_queue_head_init(&rxq);
   23.44  
   23.45 @@ -279,7 +285,8 @@ static void net_rx_action(unsigned long 
   23.46  	mcl++;
   23.47  
   23.48  	mcl[-2].args[MULTI_UVMFLAGS_INDEX] = UVMF_TLB_FLUSH|UVMF_ALL;
   23.49 -	BUG_ON(HYPERVISOR_multicall(rx_mcl, mcl - rx_mcl) != 0);
   23.50 +	ret = HYPERVISOR_multicall(rx_mcl, mcl - rx_mcl);
   23.51 +	BUG_ON(ret != 0);
   23.52  
   23.53  	mcl = rx_mcl;
   23.54  	if( HYPERVISOR_grant_table_op(GNTTABOP_transfer, grant_rx_op, 
   23.55 @@ -421,6 +428,7 @@ inline static void net_tx_action_dealloc
   23.56  	u16 pending_idx;
   23.57  	PEND_RING_IDX dc, dp;
   23.58  	netif_t *netif;
   23.59 +	int ret;
   23.60  
   23.61  	dc = dealloc_cons;
   23.62  	dp = dealloc_prod;
   23.63 @@ -436,8 +444,9 @@ inline static void net_tx_action_dealloc
   23.64  		gop->handle       = grant_tx_ref[pending_idx];
   23.65  		gop++;
   23.66  	}
   23.67 -	BUG_ON(HYPERVISOR_grant_table_op(
   23.68 -		GNTTABOP_unmap_grant_ref, tx_unmap_ops, gop - tx_unmap_ops));
   23.69 +	ret = HYPERVISOR_grant_table_op(
   23.70 +		GNTTABOP_unmap_grant_ref, tx_unmap_ops, gop - tx_unmap_ops);
   23.71 +	BUG_ON(ret);
   23.72  
   23.73  	while (dealloc_cons != dp) {
   23.74  		pending_idx = dealloc_ring[MASK_PEND_IDX(dealloc_cons++)];
   23.75 @@ -477,6 +486,7 @@ static void net_tx_action(unsigned long 
   23.76  	NETIF_RING_IDX i;
   23.77  	gnttab_map_grant_ref_t *mop;
   23.78  	unsigned int data_len;
   23.79 +	int ret;
   23.80  
   23.81  	if (dealloc_cons != dealloc_prod)
   23.82  		net_tx_action_dealloc();
   23.83 @@ -599,8 +609,9 @@ static void net_tx_action(unsigned long 
   23.84  	if (mop == tx_map_ops)
   23.85  		return;
   23.86  
   23.87 -	BUG_ON(HYPERVISOR_grant_table_op(
   23.88 -		GNTTABOP_map_grant_ref, tx_map_ops, mop - tx_map_ops));
   23.89 +	ret = HYPERVISOR_grant_table_op(
   23.90 +		GNTTABOP_map_grant_ref, tx_map_ops, mop - tx_map_ops);
   23.91 +	BUG_ON(ret);
   23.92  
   23.93  	mop = tx_map_ops;
   23.94  	while ((skb = __skb_dequeue(&tx_queue)) != NULL) {

    24.1 --- a/linux-2.6-xen-sparse/drivers/xen/privcmd/privcmd.c	Sun Oct 30 13:52:38 2005 +0100
    24.2 +++ b/linux-2.6-xen-sparse/drivers/xen/privcmd/privcmd.c	Sun Oct 30 14:00:35 2005 +0100
    24.3 @@ -25,8 +25,8 @@
    24.4  #include <asm/pgtable.h>
    24.5  #include <asm/uaccess.h>
    24.6  #include <asm/tlb.h>
    24.7 +#include <asm/hypervisor.h>
    24.8  #include <asm-xen/linux-public/privcmd.h>
    24.9 -#include <asm/hypervisor.h>
   24.10  #include <asm-xen/xen-public/xen.h>
   24.11  #include <asm-xen/xen-public/dom0_ops.h>
   24.12  #include <asm-xen/xen_proc.h>

    25.1 --- a/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c	Sun Oct 30 13:52:38 2005 +0100
    25.2 +++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c	Sun Oct 30 14:00:35 2005 +0100
    25.3 @@ -78,6 +78,7 @@ tpmif_find(domid_t domid, long int insta
    25.4  static int
    25.5  map_frontend_page(tpmif_t *tpmif, unsigned long shared_page)
    25.6  {
    25.7 +	int ret;
    25.8  	struct gnttab_map_grant_ref op = {
    25.9  		.host_addr = (unsigned long)tpmif->tx_area->addr,
   25.10  		.flags = GNTMAP_host_map,
   25.11 @@ -86,8 +87,9 @@ map_frontend_page(tpmif_t *tpmif, unsign
   25.12  	};
   25.13  
   25.14  	lock_vm_area(tpmif->tx_area);
   25.15 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
   25.16 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
   25.17  	unlock_vm_area(tpmif->tx_area);
   25.18 +	BUG_ON(ret);
   25.19  
   25.20  	if (op.handle < 0) {
   25.21  		DPRINTK(" Grant table operation failure !\n");
   25.22 @@ -104,14 +106,16 @@ static void
   25.23  unmap_frontend_page(tpmif_t *tpmif)
   25.24  {
   25.25  	struct gnttab_unmap_grant_ref op;
   25.26 +	int ret;
   25.27  
   25.28  	op.host_addr    = (unsigned long)tpmif->tx_area->addr;
   25.29  	op.handle       = tpmif->shmem_handle;
   25.30  	op.dev_bus_addr = 0;
   25.31  
   25.32  	lock_vm_area(tpmif->tx_area);
   25.33 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1));
   25.34 +	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
   25.35  	unlock_vm_area(tpmif->tx_area);
   25.36 +	BUG_ON(ret);
   25.37  }
   25.38  
   25.39  int

    26.1 --- a/linux-2.6-xen-sparse/drivers/xen/util.c	Sun Oct 30 13:52:38 2005 +0100
    26.2 +++ b/linux-2.6-xen-sparse/drivers/xen/util.c	Sun Oct 30 14:00:35 2005 +0100
    26.3 @@ -34,7 +34,9 @@ struct vm_struct *alloc_vm_area(unsigned
    26.4  
    26.5  void free_vm_area(struct vm_struct *area)
    26.6  {
    26.7 -	BUG_ON(remove_vm_area(area->addr) != area);
    26.8 +	struct vm_struct *ret;
    26.9 +	ret = remove_vm_area(area->addr);
   26.10 +	BUG_ON(ret != area);
   26.11  	kfree(area);
   26.12  }
   26.13  

    27.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Sun Oct 30 13:52:38 2005 +0100
    27.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Sun Oct 30 14:00:35 2005 +0100
    27.3 @@ -714,11 +714,7 @@ static int xsd_port_read(char *page, cha
    27.4  
    27.5  static int __init xenbus_probe_init(void)
    27.6  {
    27.7 -	int err = 0;
    27.8 -	/* 
    27.9 -	** Domain0 doesn't have a store_evtchn or store_mfn yet. 
   27.10 -	*/
   27.11 -	int dom0 = (xen_start_info->store_evtchn == 0);
   27.12 +	int err = 0, dom0;
   27.13  
   27.14  	printk("xenbus_probe_init\n");
   27.15  
   27.16 @@ -733,10 +729,16 @@ static int __init xenbus_probe_init(void
   27.17  	device_register(&xenbus_frontend.dev);
   27.18  	device_register(&xenbus_backend.dev);
   27.19  
   27.20 +	/*
   27.21 +	** Domain0 doesn't have a store_evtchn or store_mfn yet.
   27.22 +	*/
   27.23 +	dom0 = (xen_start_info->store_evtchn == 0);
   27.24 +
   27.25  	if (dom0) {
   27.26  
   27.27  		unsigned long page;
   27.28  		evtchn_op_t op = { 0 };
   27.29 +		int ret;
   27.30  
   27.31  
   27.32  		/* Allocate page. */
   27.33 @@ -757,7 +759,8 @@ static int __init xenbus_probe_init(void
   27.34  		op.u.alloc_unbound.dom        = DOMID_SELF;
   27.35  		op.u.alloc_unbound.remote_dom = 0; 
   27.36  
   27.37 -		BUG_ON(HYPERVISOR_event_channel_op(&op)); 
   27.38 +		ret = HYPERVISOR_event_channel_op(&op);
   27.39 +		BUG_ON(ret); 
   27.40  		xen_start_info->store_evtchn = op.u.alloc_unbound.port;
   27.41  
   27.42  		/* And finally publish the above info in /proc/xen */

    28.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c	Sun Oct 30 13:52:38 2005 +0100
    28.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c	Sun Oct 30 14:00:35 2005 +0100
    28.3 @@ -28,6 +28,7 @@
    28.4   * IN THE SOFTWARE.
    28.5   */
    28.6  
    28.7 +#include <linux/unistd.h>
    28.8  #include <linux/errno.h>
    28.9  #include <linux/types.h>
   28.10  #include <linux/uio.h>

    29.1 --- a/tools/examples/Makefile	Sun Oct 30 13:52:38 2005 +0100
    29.2 +++ b/tools/examples/Makefile	Sun Oct 30 14:00:35 2005 +0100
    29.3 @@ -17,6 +17,7 @@ XEN_CONFIGS = xend-config.sxp
    29.4  XEN_CONFIGS += xmexample1 
    29.5  XEN_CONFIGS += xmexample2
    29.6  XEN_CONFIGS += xmexample.vmx
    29.7 +XEN_CONFIGS += xmexample.vti
    29.8  
    29.9  # Xen script dir and scripts to go there.
   29.10  XEN_SCRIPT_DIR = /etc/xen/scripts

    30.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    30.2 +++ b/tools/examples/xmexample.vti	Sun Oct 30 14:00:35 2005 +0100
    30.3 @@ -0,0 +1,100 @@
    30.4 +#  -*- mode: python; -*-
    30.5 +#============================================================================
    30.6 +# Python configuration setup for 'xm create'.
    30.7 +# This script sets the parameters used when a domain is created using 'xm create'.
    30.8 +# You use a separate script for each domain you want to create, or 
    30.9 +# you can set the parameters for the domain on the xm command line.
   30.10 +#============================================================================
   30.11 +
   30.12 +import os, re
   30.13 +arch = os.uname()[4]
   30.14 +arch_libdir = 'lib'
   30.15 +
   30.16 +#----------------------------------------------------------------------------
   30.17 +# Kernel image file.
   30.18 +kernel = "/boot/Flash.fd"
   30.19 +
   30.20 +# The domain build function. VMX domain uses 'vmx'.
   30.21 +builder='vmx'
   30.22 +
   30.23 +# Initial memory allocation (in megabytes) for the new domain.
   30.24 +memory = 256
   30.25 +
   30.26 +# A name for your domain. All domains must have different names.
   30.27 +name = "ExampleVMXDomain"
   30.28 +
   30.29 +# Which CPU to start domain on? 
   30.30 +#cpu = -1   # leave to Xen to pick
   30.31 +
   30.32 +# Optionally define mac and/or bridge for the network interfaces.
   30.33 +# Random MACs are assigned if not given.
   30.34 +#vif = [ 'mac=aa:00:00:00:00:11, bridge=xen-br0' ]
   30.35 +
   30.36 +#----------------------------------------------------------------------------
   30.37 +# Define the disk devices you want the domain to have access to, and
   30.38 +# what you want them accessible as.
   30.39 +# Each disk entry is of the form phy:UNAME,DEV,MODE
   30.40 +# where UNAME is the device, DEV is the device name the domain will see,
   30.41 +# and MODE is r for read-only, w for read-write.
   30.42 +
   30.43 +#disk = [ 'phy:hda1,hda1,r' ]
   30.44 +disk = [ 'file:/var/images/xenia64.img,ioemu:hda,w' ]
   30.45 +
   30.46 +#----------------------------------------------------------------------------
   30.47 +# Set according to whether you want the domain restarted when it exits.
   30.48 +# The default is 'onreboot', which restarts the domain when it shuts down
   30.49 +# with exit code reboot.
   30.50 +# Other values are 'always', and 'never'.
   30.51 +
   30.52 +#restart = 'onreboot'
   30.53 +
   30.54 +#============================================================================
   30.55 +
   30.56 +# New stuff
   30.57 +device_model = '/usr/' + arch_libdir + '/xen/bin/qemu-dm.debug'
   30.58 +
   30.59 +# Advanced users only. Don't touch if you don't know what you're doing
   30.60 +memmap = '/usr/lib/xen/boot/mem-map.sxp'
   30.61 +
   30.62 +#-----------------------------------------------------------------------------
   30.63 +# Disk image for 
   30.64 +#cdrom=
   30.65 +
   30.66 +#-----------------------------------------------------------------------------
   30.67 +# boot on floppy (a), hard disk (c) or CD-ROM (d) 
   30.68 +#boot=[a|c|d]
   30.69 +#-----------------------------------------------------------------------------
   30.70 +#  write to temporary files instead of disk image files
   30.71 +#snapshot=1
   30.72 +
   30.73 +#----------------------------------------------------------------------------
   30.74 +# enable SDL library for graphics, default = 0
   30.75 +sdl=1
   30.76 +
   30.77 +stdvga=1
   30.78 +#----------------------------------------------------------------------------
   30.79 +# enable VNC library for graphics, default = 1
   30.80 +vnc=0
   30.81 +
   30.82 +#----------------------------------------------------------------------------
   30.83 +# enable spawning vncviewer(only valid when vnc=1), default = 1
   30.84 +vncviewer=0
   30.85 +
   30.86 +#----------------------------------------------------------------------------
   30.87 +# no graphics, use serial port
   30.88 +#nographic=0
   30.89 +
   30.90 +
   30.91 +#-----------------------------------------------------------------------------
   30.92 +#   enable audio support
   30.93 +#enable-audio=1
   30.94 +
   30.95 +
   30.96 +#-----------------------------------------------------------------------------
   30.97 +#    set the real time clock to local time [default=0 i.e. set to utc]
   30.98 +#localtime=1
   30.99 +
  30.100 +
  30.101 +#-----------------------------------------------------------------------------
  30.102 +#    start in full screen
  30.103 +#full-screen=1   diff -r 42cab8724273 tools/libxc/xc_ia64_stubs.c

    31.1 --- a/tools/ioemu/hw/ide.c	Sun Oct 30 13:52:38 2005 +0100
    31.2 +++ b/tools/ioemu/hw/ide.c	Sun Oct 30 14:00:35 2005 +0100
    31.3 @@ -22,6 +22,7 @@
    31.4   * THE SOFTWARE.
    31.5   */
    31.6  #include "vl.h"
    31.7 +#include <pthread.h>
    31.8  
    31.9  /* debug IDE devices */
   31.10  //#define DEBUG_IDE
   31.11 @@ -360,6 +361,48 @@ typedef struct PCIIDEState {
   31.12      BMDMAState bmdma[2];
   31.13  } PCIIDEState;
   31.14  
   31.15 +#define DMA_MULTI_THREAD
   31.16 +
   31.17 +#ifdef DMA_MULTI_THREAD
   31.18 +
   31.19 +static int file_pipes[2];
   31.20 +
   31.21 +static void ide_dma_loop(BMDMAState *bm);
   31.22 +static void dma_thread_loop(BMDMAState *bm);
   31.23 +
   31.24 +static void *dma_thread_func(void* opaque)
   31.25 +{
   31.26 +    BMDMAState* req;
   31.27 +
   31.28 +    while (read(file_pipes[0], &req, sizeof(req))) {
   31.29 +        dma_thread_loop(req);
   31.30 +    }
   31.31 +
   31.32 +    return NULL;
   31.33 +}
   31.34 +
   31.35 +static void dma_create_thread()
   31.36 +{
   31.37 +    pthread_t tid;
   31.38 +    int rt;
   31.39 +
   31.40 +    if (pipe(file_pipes) != 0){
   31.41 +        fprintf(stderr, "create pipe failed\n");
   31.42 +        exit(1);
   31.43 +    }
   31.44 +
   31.45 +    if ( (rt = pthread_create(&tid, NULL, dma_thread_func, NULL)) ) {
   31.46 +        fprintf(stderr, "Oops, dma thread creation failed, errno=%d\n", rt);
   31.47 +        exit(1);
   31.48 +    }
   31.49 +
   31.50 +    if ( (rt = pthread_detach(tid)) ) {
   31.51 +        fprintf(stderr, "Oops, dma thread detachment failed, errno=%d\n", rt);
   31.52 +        exit(1);
   31.53 +    }
   31.54 +}
   31.55 +#endif //DMA_MULTI_THREAD
   31.56 +
   31.57  static void ide_dma_start(IDEState *s, IDEDMAFunc *dma_cb);
   31.58  
   31.59  static void padstr(char *str, const char *src, int len)
   31.60 @@ -1978,8 +2021,16 @@ static void ide_map(PCIDevice *pci_dev, 
   31.61  
   31.62  /* XXX: full callback usage to prepare non blocking I/Os support -
   31.63     error handling */
   31.64 +#ifdef DMA_MULTI_THREAD
   31.65  static void ide_dma_loop(BMDMAState *bm)
   31.66  {
   31.67 +    write(file_pipes[1], &bm, sizeof(bm));
   31.68 +}
   31.69 +static void dma_thread_loop(BMDMAState *bm)
   31.70 +#else 
   31.71 +static void ide_dma_loop(BMDMAState *bm)
   31.72 +#endif //DMA_MULTI_THREAD
   31.73 +{
   31.74      struct {
   31.75          uint32_t addr;
   31.76          uint32_t size;
   31.77 @@ -2166,6 +2217,9 @@ void pci_ide_init(PCIBus *bus, BlockDriv
   31.78          d->ide_if[i].pci_dev = (PCIDevice *)d;
   31.79      ide_init2(&d->ide_if[0], 16, hd_table[0], hd_table[1]);
   31.80      ide_init2(&d->ide_if[2], 16, hd_table[2], hd_table[3]);
   31.81 +#ifdef DMA_MULTI_THREAD    
   31.82 +    dma_create_thread();
   31.83 +#endif //DMA_MULTI_THREAD    
   31.84  }
   31.85  
   31.86  /* hd_table must contain 4 block drivers */
   31.87 @@ -2196,6 +2250,9 @@ void pci_piix3_ide_init(PCIBus *bus, Blo
   31.88      ide_init2(&d->ide_if[2], 15, hd_table[2], hd_table[3]);
   31.89      ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);
   31.90      ide_init_ioport(&d->ide_if[2], 0x170, 0x376);
   31.91 +#ifdef DMA_MULTI_THREAD    
   31.92 +    dma_create_thread();
   31.93 +#endif //DMA_MULTI_THREAD    
   31.94  }
   31.95  
   31.96  /***********************************************************/

    32.1 --- a/tools/libxc/xc_elf.h	Sun Oct 30 13:52:38 2005 +0100
    32.2 +++ b/tools/libxc/xc_elf.h	Sun Oct 30 14:00:35 2005 +0100
    32.3 @@ -24,26 +24,26 @@
    32.4   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    32.5   */
    32.6  
    32.7 -typedef u_int8_t	Elf_Byte;
    32.8 +typedef uint8_t		Elf_Byte;
    32.9  
   32.10 -typedef u_int32_t	Elf32_Addr;	/* Unsigned program address */
   32.11 -typedef u_int32_t	Elf32_Off;	/* Unsigned file offset */
   32.12 +typedef uint32_t	Elf32_Addr;	/* Unsigned program address */
   32.13 +typedef uint32_t	Elf32_Off;	/* Unsigned file offset */
   32.14  typedef int32_t		Elf32_Sword;	/* Signed large integer */
   32.15 -typedef u_int32_t	Elf32_Word;	/* Unsigned large integer */
   32.16 -typedef u_int16_t	Elf32_Half;	/* Unsigned medium integer */
   32.17 +typedef uint32_t	Elf32_Word;	/* Unsigned large integer */
   32.18 +typedef uint16_t	Elf32_Half;	/* Unsigned medium integer */
   32.19  
   32.20 -typedef u_int64_t	Elf64_Addr;
   32.21 -typedef u_int64_t	Elf64_Off;
   32.22 +typedef uint64_t	Elf64_Addr;
   32.23 +typedef uint64_t	Elf64_Off;
   32.24  typedef int32_t		Elf64_Shalf;
   32.25  
   32.26  typedef int32_t		Elf64_Sword;
   32.27 -typedef u_int32_t	Elf64_Word;
   32.28 +typedef uint32_t	Elf64_Word;
   32.29  
   32.30  typedef int64_t		Elf64_Sxword;
   32.31 -typedef u_int64_t	Elf64_Xword;
   32.32 +typedef uint64_t	Elf64_Xword;
   32.33  
   32.34 -typedef u_int32_t	Elf64_Half;
   32.35 -typedef u_int16_t	Elf64_Quarter;
   32.36 +typedef uint32_t	Elf64_Half;
   32.37 +typedef uint16_t	Elf64_Quarter;
   32.38  
   32.39  /*
   32.40   * e_ident[] identification indexes 

    33.1 --- a/tools/libxc/xc_ia64_stubs.c	Sun Oct 30 13:52:38 2005 +0100
    33.2 +++ b/tools/libxc/xc_ia64_stubs.c	Sun Oct 30 14:00:35 2005 +0100
    33.3 @@ -1,5 +1,11 @@
    33.4  #include "xg_private.h"
    33.5  #include "xenguest.h"
    33.6 +#include "xc_private.h"
    33.7 +#include "xc_elf.h"
    33.8 +#include <stdlib.h>
    33.9 +#include <zlib.h>
   33.10 +#include "xen/arch-ia64.h"
   33.11 +#include <xen/io/ioreq.h>
   33.12  
   33.13  int xc_linux_save(int xc_handle, int io_fd, uint32_t dom, uint32_t max_iters, 
   33.14                    uint32_t max_factor, uint32_t flags)
   33.15 @@ -16,22 +22,6 @@ int xc_linux_restore(int xc_handle, int 
   33.16      return -1;
   33.17  }
   33.18  
   33.19 -int xc_vmx_build(int xc_handle,
   33.20 -                   uint32_t domid,
   33.21 -                   int memsize,
   33.22 -                   const char *image_name,
   33.23 -                   struct mem_map *mem_mapp,
   33.24 -                   const char *ramdisk_name,
   33.25 -                   const char *cmdline,
   33.26 -                   unsigned int control_evtchn,
   33.27 -                   unsigned int vcpus,
   33.28 -                   unsigned int store_evtchn,
   33.29 -                   unsigned long *store_mfn)
   33.30 -{
   33.31 -    PERROR("xc_vmx_build not implemented\n");
   33.32 -    return -1;
   33.33 -}
   33.34 -
   33.35  int
   33.36  xc_plan9_build(int xc_handle,
   33.37                 uint32_t domid,
   33.38 @@ -43,6 +33,653 @@ xc_plan9_build(int xc_handle,
   33.39      return -1;
   33.40  }
   33.41  
   33.42 +int xc_ia64_get_pfn_list(int xc_handle,
   33.43 +                         uint32_t domid, 
   33.44 +                         unsigned long *pfn_buf, 
   33.45 +                         unsigned int start_page,
   33.46 +                         unsigned int nr_pages)
   33.47 +{
   33.48 +    dom0_op_t op;
   33.49 +    int ret;
   33.50 +    unsigned long max_pfns = ((unsigned long)start_page << 32) | nr_pages;
   33.51 +
   33.52 +    op.cmd = DOM0_GETMEMLIST;
   33.53 +    op.u.getmemlist.domain   = (domid_t)domid;
   33.54 +    op.u.getmemlist.max_pfns = max_pfns;
   33.55 +    op.u.getmemlist.buffer   = pfn_buf;
   33.56 +
   33.57 +    if ( (max_pfns != -1UL)
   33.58 +		&& mlock(pfn_buf, nr_pages * sizeof(unsigned long)) != 0 )
   33.59 +    {
   33.60 +        PERROR("Could not lock pfn list buffer");
   33.61 +        return -1;
   33.62 +    }    
   33.63 +
   33.64 +    ret = do_dom0_op(xc_handle, &op);
   33.65 +
   33.66 +    if (max_pfns != -1UL)
   33.67 +    	(void)munlock(pfn_buf, nr_pages * sizeof(unsigned long));
   33.68 +
   33.69 +    return (ret < 0) ? -1 : op.u.getmemlist.num_pfns;
   33.70 +}
   33.71 +
   33.72 +long xc_get_max_pages(int xc_handle, uint32_t domid)
   33.73 +{
   33.74 +    dom0_op_t op;
   33.75 +    op.cmd = DOM0_GETDOMAININFO;
   33.76 +    op.u.getdomaininfo.domain = (domid_t)domid;
   33.77 +    return (do_dom0_op(xc_handle, &op) < 0) ? 
   33.78 +        -1 : op.u.getdomaininfo.max_pages;
   33.79 +}
   33.80 +
   33.81 +int xc_ia64_copy_to_domain_pages(int xc_handle, uint32_t domid,
   33.82 +        void* src_page, unsigned long dst_pfn, int nr_pages)
   33.83 +{
   33.84 +    // N.B. gva should be page aligned
   33.85 +    
   33.86 +    unsigned long *page_array=NULL;
   33.87 +    int i;
   33.88 +
   33.89 +    if ( (page_array = malloc(nr_pages * sizeof(unsigned long))) == NULL ){
   33.90 +        PERROR("Could not allocate memory");
   33.91 +        goto error_out;
   33.92 +    }
   33.93 +    if ( xc_ia64_get_pfn_list(xc_handle, domid, page_array,
   33.94 +                dst_pfn>>PAGE_SHIFT, nr_pages) != nr_pages ){
   33.95 +        PERROR("Could not get the page frame list");
   33.96 +        goto error_out;
   33.97 +    }
   33.98 +
   33.99 +    for ( i=0; i< nr_pages; i++ ){
  33.100 +	if (xc_copy_to_domain_page(xc_handle, domid, page_array[i],
  33.101 +			src_page + (i << PAGE_SHIFT)))
  33.102 +	    goto error_out;
  33.103 +    }
  33.104 +    free(page_array);
  33.105 +    return 0;
  33.106 +    
  33.107 +error_out:
  33.108 +    if (page_array)
  33.109 +        free(page_array);
  33.110 +    return -1;
  33.111 +}
  33.112 +
  33.113 +
  33.114 +#define HOB_SIGNATURE 0x3436474953424f48 // "HOBSIG64"
  33.115 +#define GFW_HOB_START    ((4UL<<30)-(14UL<<20))    //4G -14M
  33.116 +#define GFW_HOB_SIZE     (1UL<<20)              //1M
  33.117 +#define MEM_G   (1UL << 30) 
  33.118 +#define MEM_M   (1UL << 20) 
  33.119 +
  33.120 +typedef struct {
  33.121 +    unsigned long signature;
  33.122 +    unsigned int  type;
  33.123 +    unsigned int  length;
  33.124 +} HOB_GENERIC_HEADER;
  33.125 +
  33.126 +/*
  33.127 + * INFO HOB is the first data data in one HOB list
  33.128 + * it contains the control information of the HOB list
  33.129 + */
  33.130 +typedef struct { 
  33.131 +    HOB_GENERIC_HEADER  header;
  33.132 +    unsigned long       length;    // current length of hob
  33.133 +    unsigned long       cur_pos;   // current poisiton of hob
  33.134 +    unsigned long       buf_size;  // size of hob buffer
  33.135 +}HOB_INFO;
  33.136 +
  33.137 +typedef struct{
  33.138 +    unsigned long start;
  33.139 +    unsigned long size;
  33.140 +}hob_mem_t;
  33.141 +
  33.142 +typedef enum {
  33.143 +    HOB_TYPE_INFO=0,
  33.144 +    HOB_TYPE_TERMINAL,
  33.145 +    HOB_TYPE_MEM,
  33.146 +    HOB_TYPE_PAL_BUS_GET_FEATURES_DATA,
  33.147 +    HOB_TYPE_PAL_CACHE_SUMMARY,
  33.148 +    HOB_TYPE_PAL_MEM_ATTRIB,
  33.149 +    HOB_TYPE_PAL_CACHE_INFO,
  33.150 +    HOB_TYPE_PAL_CACHE_PROT_INFO,
  33.151 +    HOB_TYPE_PAL_DEBUG_INFO,
  33.152 +    HOB_TYPE_PAL_FIXED_ADDR,
  33.153 +    HOB_TYPE_PAL_FREQ_BASE,
  33.154 +    HOB_TYPE_PAL_FREQ_RATIOS,
  33.155 +    HOB_TYPE_PAL_HALT_INFO,
  33.156 +    HOB_TYPE_PAL_PERF_MON_INFO,
  33.157 +    HOB_TYPE_PAL_PROC_GET_FEATURES,
  33.158 +    HOB_TYPE_PAL_PTCE_INFO,
  33.159 +    HOB_TYPE_PAL_REGISTER_INFO,
  33.160 +    HOB_TYPE_PAL_RSE_INFO,
  33.161 +    HOB_TYPE_PAL_TEST_INFO,
  33.162 +    HOB_TYPE_PAL_VM_SUMMARY,
  33.163 +    HOB_TYPE_PAL_VM_INFO,
  33.164 +    HOB_TYPE_PAL_VM_PAGE_SIZE,
  33.165 +    HOB_TYPE_MAX
  33.166 +}hob_type_t;
  33.167 +
  33.168 +static int hob_init( void  *buffer ,unsigned long buf_size);
  33.169 +static int add_pal_hob(void* hob_buf);
  33.170 +static int add_mem_hob(void* hob_buf, unsigned long dom_mem_size);
  33.171 +static int build_hob (void* hob_buf, unsigned long hob_buf_size,
  33.172 +                  unsigned long dom_mem_size);
  33.173 +static int load_hob(int xc_handle,uint32_t dom, void *hob_buf);
  33.174 +
  33.175 +int xc_ia64_build_hob(int xc_handle, uint32_t dom, unsigned long memsize){
  33.176 +
  33.177 +    char   hob_buf[GFW_HOB_SIZE];
  33.178 +
  33.179 +    if ( build_hob( hob_buf, GFW_HOB_SIZE, memsize<<20) < 0){
  33.180 +        PERROR("Could not build hob");
  33.181 +        return -1;
  33.182 +    }
  33.183 +
  33.184 +    if ( load_hob( xc_handle, dom, hob_buf) <0){
  33.185 +        PERROR("Could not load hob");
  33.186 +       return -1;
  33.187 +    }
  33.188 +
  33.189 +    return 0;
  33.190 +
  33.191 +}
  33.192 +static int
  33.193 +hob_init( void  *buffer ,unsigned long buf_size)
  33.194 +{
  33.195 +    HOB_INFO *phit;
  33.196 +    HOB_GENERIC_HEADER     *terminal;
  33.197 +
  33.198 +    if (sizeof(HOB_INFO) + sizeof(HOB_GENERIC_HEADER) > buf_size){
  33.199 +        // buffer too small
  33.200 +        return -1;
  33.201 +    }
  33.202 +    
  33.203 +    phit = (HOB_INFO*)buffer;
  33.204 +    phit->header.signature = HOB_SIGNATURE;
  33.205 +    phit->header.type = HOB_TYPE_INFO;
  33.206 +    phit->header.length = sizeof(HOB_INFO);
  33.207 +    phit->length = sizeof(HOB_INFO) + sizeof(HOB_GENERIC_HEADER);
  33.208 +    phit->cur_pos = 0;
  33.209 +    phit->buf_size = buf_size;
  33.210 +    
  33.211 +    terminal = (HOB_GENERIC_HEADER*) (buffer + sizeof(HOB_INFO));
  33.212 +    terminal->signature= HOB_SIGNATURE;
  33.213 +    terminal->type = HOB_TYPE_TERMINAL;
  33.214 +    terminal->length = sizeof(HOB_GENERIC_HEADER);
  33.215 +
  33.216 +    return 0;
  33.217 +}
  33.218 +
  33.219 +/*
  33.220 + *  Add a new HOB to the HOB List.
  33.221 + *       
  33.222 + *  hob_start  -  start address of hob buffer
  33.223 + *  type       -  type of the hob to be added
  33.224 + *  data       -  data of the hob to be added
  33.225 + *  data_size  -  size of the data
  33.226 + */
  33.227 +static int
  33.228 +hob_add(
  33.229 +     void*  hob_start,
  33.230 +     int    type,
  33.231 +     void*  data,
  33.232 +     int    data_size
  33.233 +)
  33.234 +{
  33.235 +    HOB_INFO *phit;
  33.236 +    HOB_GENERIC_HEADER     *newhob,*tail;   
  33.237 +    
  33.238 +    phit = (HOB_INFO*)hob_start;
  33.239 +
  33.240 +    if (phit->length + data_size > phit->buf_size){
  33.241 +        // no space for new hob
  33.242 +        return -1;
  33.243 +    }
  33.244 +
  33.245 +    //append new HOB 
  33.246 +    newhob = (HOB_GENERIC_HEADER*)
  33.247 +        (hob_start + phit->length - sizeof(HOB_GENERIC_HEADER));
  33.248 +    newhob->signature = HOB_SIGNATURE;
  33.249 +    newhob->type = type;
  33.250 +    newhob->length = data_size + sizeof(HOB_GENERIC_HEADER);
  33.251 +    memcpy((void*)newhob + sizeof(HOB_GENERIC_HEADER), data, data_size);
  33.252 +
  33.253 +    // append terminal HOB  
  33.254 +    tail = (HOB_GENERIC_HEADER*) ( hob_start + phit->length + data_size);
  33.255 +    tail->signature = HOB_SIGNATURE;
  33.256 +    tail->type = HOB_TYPE_TERMINAL;
  33.257 +    tail->length = sizeof(HOB_GENERIC_HEADER);
  33.258 +
  33.259 +    // adjust HOB list length
  33.260 +    phit->length += sizeof(HOB_GENERIC_HEADER)+ data_size;
  33.261 +
  33.262 +    return 0;
  33.263 +
  33.264 +}
  33.265 +
  33.266 +int get_hob_size(void* hob_buf){
  33.267 +    
  33.268 +    HOB_INFO *phit = (HOB_INFO*)hob_buf;
  33.269 +    
  33.270 +    if (phit->header.signature != HOB_SIGNATURE){
  33.271 +        PERROR("xc_get_hob_size:Incorrect signature");
  33.272 +        return -1;
  33.273 +    }
  33.274 +    return phit->length;
  33.275 +}
  33.276 +
  33.277 +int build_hob (void* hob_buf, unsigned long hob_buf_size,
  33.278 +                  unsigned long dom_mem_size)
  33.279 +{   
  33.280 +    //Init HOB List 
  33.281 +    if (hob_init (hob_buf, hob_buf_size)<0){
  33.282 +        PERROR("buffer too small");
  33.283 +        goto err_out;
  33.284 +    }
  33.285 +    
  33.286 +    if ( add_mem_hob( hob_buf,dom_mem_size) < 0){
  33.287 +        PERROR("Add memory hob failed, buffer too small");
  33.288 +        goto err_out;
  33.289 +    }
  33.290 +    
  33.291 +    if ( add_pal_hob( hob_buf ) < 0 ){
  33.292 +        PERROR("Add PAL hob failed, buffer too small");
  33.293 +        goto err_out;
  33.294 +    }
  33.295 +    
  33.296 +    return 0;
  33.297 +
  33.298 +err_out:
  33.299 +    return -1;  
  33.300 +}
  33.301 +
  33.302 +static int 
  33.303 +load_hob(int xc_handle, uint32_t dom, void *hob_buf)
  33.304 +{
  33.305 +    // hob_buf should be page aligned
  33.306 +    int hob_size;
  33.307 +    int nr_pages;
  33.308 +
  33.309 +    if ((hob_size = get_hob_size(hob_buf)) < 0){
  33.310 +        PERROR("Invalid hob data");
  33.311 +        return -1;
  33.312 +    }
  33.313 +
  33.314 +    if (hob_size > GFW_HOB_SIZE){
  33.315 +        PERROR("No enough memory for hob data");
  33.316 +        return -1;
  33.317 +    }
  33.318 +
  33.319 +    nr_pages = (hob_size + PAGE_SIZE -1) >> PAGE_SHIFT;
  33.320 +    
  33.321 +    return xc_ia64_copy_to_domain_pages(xc_handle, dom,
  33.322 +            hob_buf, GFW_HOB_START, nr_pages );
  33.323 +}
  33.324 +
  33.325 +#define MIN(x, y) ((x) < (y)) ? (x) : (y)
  33.326 +static int 
  33.327 +add_mem_hob(void* hob_buf, unsigned long dom_mem_size){
  33.328 +    hob_mem_t memhob;
  33.329 +
  33.330 +    // less than 3G
  33.331 +    memhob.start = 0;
  33.332 +    memhob.size = MIN(dom_mem_size, 0xC0000000);
  33.333 +    
  33.334 +    if (hob_add(hob_buf, HOB_TYPE_MEM, &memhob, sizeof(memhob)) < 0){
  33.335 +	return -1;
  33.336 +    }
  33.337 +
  33.338 +    if (dom_mem_size > 0xC0000000) {
  33.339 +        // 4G ~ 4G+remain
  33.340 +        memhob.start = 0x100000000; //4G
  33.341 +        memhob.size = dom_mem_size - 0xC0000000;
  33.342 +        if (hob_add(hob_buf, HOB_TYPE_MEM, &memhob, sizeof(memhob)) < 0)
  33.343 +            return -1;
  33.344 +    }
  33.345 +    return 0;
  33.346 +}
  33.347 +
  33.348 +unsigned char config_pal_bus_get_features_data[24] = {
  33.349 +    0, 0, 0, 32, 0, 0, 240, 189, 0, 0, 0, 0, 0, 0,
  33.350 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  33.351 +};
  33.352 +unsigned char config_pal_cache_summary[16] = {
  33.353 +    3, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0};
  33.354 +unsigned char config_pal_mem_attrib[8] =    {
  33.355 +    241, 0, 0, 0, 0, 0, 0, 0
  33.356 +};
  33.357 +unsigned char config_pal_cache_info[152] = {
  33.358 +    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.359 +    6, 4, 6, 7, 255, 1, 0, 1, 0, 64, 0, 0, 12, 12, 
  33.360 +    49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 7, 0, 1,
  33.361 +    0, 1, 0, 64, 0, 0, 12, 12, 49, 0, 0, 0, 0, 0, 0, 
  33.362 +    0, 0, 0, 6, 8, 7, 7, 255, 7, 0, 11, 0, 0, 16, 0, 
  33.363 +    12, 17, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 7, 
  33.364 +    7, 7, 5, 9, 11, 0, 0, 4, 0, 12, 15, 49, 0, 254, 255,
  33.365 +    255, 255, 255, 255, 255, 255, 2, 8, 7, 7, 7, 5, 9, 
  33.366 +    11, 0, 0, 4, 0, 12, 15, 49, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.367 +    0, 3, 12, 7, 7, 7, 14, 1, 3, 0, 0, 192, 0, 12, 20, 49, 0
  33.368 +};
  33.369 +unsigned char config_pal_cache_prot_info[200] = {
  33.370 +    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.371 +    45, 0, 16, 8, 0, 76, 12, 64, 0, 0, 0, 0, 0, 0, 0,
  33.372 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.373 +    8, 0, 16, 4, 0, 76, 44, 68, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.374 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 
  33.375 +    0, 16, 8, 0, 81, 44, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.376 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0,
  33.377 +    112, 12, 0, 79, 124, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.378 +    0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 255, 255, 255, 
  33.379 +    32, 0, 112, 12, 0, 79, 124, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.380 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 160, 
  33.381 +    12, 0, 84, 124, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.382 +    0, 0, 0
  33.383 +};
  33.384 +unsigned char config_pal_debug_info[16] = {
  33.385 +    2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0
  33.386 +};
  33.387 +unsigned char config_pal_fixed_addr[8] = {
  33.388 +    0, 0, 0, 0, 0, 0, 0, 0
  33.389 +};
  33.390 +unsigned char config_pal_freq_base[8] = {
  33.391 +    109, 219, 182, 13, 0, 0, 0, 0
  33.392 +};
  33.393 +unsigned char config_pal_freq_ratios[24] = {
  33.394 +    11, 1, 0, 0, 77, 7, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 4, 
  33.395 +    0, 0, 0, 7, 0, 0, 0
  33.396 +};
  33.397 +unsigned char config_pal_halt_info[64] = {
  33.398 +    0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.399 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.400 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.401 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  33.402 +};
  33.403 +unsigned char config_pal_perf_mon_info[136] = {
  33.404 +    12, 47, 18, 8, 0, 0, 0, 0, 241, 255, 0, 0, 255, 7, 0, 0, 
  33.405 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.406 +    0, 0, 0, 0, 0, 0, 0, 0, 241, 255, 0, 0, 223, 0, 255, 255, 
  33.407 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.408 +    0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 0, 0, 0, 0, 0, 0, 
  33.409 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.410 +    0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 0, 0, 0, 0, 0, 0, 
  33.411 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.412 +    0, 0, 0, 0, 0, 0, 0, 0
  33.413 +};
  33.414 +unsigned char config_pal_proc_get_features[104] = {
  33.415 +    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.416 +    0, 0, 0, 0, 64, 6, 64, 49, 0, 0, 0, 0, 64, 6, 0, 0, 
  33.417 +    0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 
  33.418 +    231, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 
  33.419 +    0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 
  33.420 +    63, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0,
  33.421 +    0, 0, 0, 0, 0, 0, 0, 0
  33.422 +};
  33.423 +unsigned char config_pal_ptce_info[24] = {
  33.424 +    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 
  33.425 +    0, 0, 0, 0, 0, 0, 0, 0
  33.426 +};
  33.427 +unsigned char config_pal_register_info[64] = {
  33.428 +    255, 0, 47, 127, 17, 17, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0,
  33.429 +    255, 208, 128, 238, 238, 0, 0, 248, 255, 255, 255, 255, 255, 0, 0, 7, 3,
  33.430 +    251, 3, 0, 0, 0, 0, 255, 7, 3, 0, 0, 0, 0, 0, 248, 252, 4,
  33.431 +    252, 255, 255, 255, 255, 2, 248, 252, 255, 255, 255, 255, 255
  33.432 +};
  33.433 +unsigned char config_pal_rse_info[16] = {
  33.434 +    96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  33.435 +};
  33.436 +unsigned char config_pal_test_info[48] = {
  33.437 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.438 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.439 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  33.440 +};
  33.441 +unsigned char config_pal_vm_summary[16] = {
  33.442 +    101, 18, 15, 2, 7, 7, 4, 2, 59, 18, 0, 0, 0, 0, 0, 0
  33.443 +};
  33.444 +unsigned char config_pal_vm_info[104] = {
  33.445 +    2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
  33.446 +    32, 32, 0, 0, 0, 0, 0, 0, 112, 85, 21, 0, 0, 0, 0, 0, 0,
  33.447 +    0, 0, 0, 0, 0, 0, 1, 32, 32, 0, 0, 0, 0, 0, 0, 112, 85,
  33.448 +    21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 128, 128, 0,
  33.449 +    4, 0, 0, 0, 0, 112, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  33.450 +    0, 0, 0, 1, 128, 128, 0, 4, 0, 0, 0, 0, 112, 85, 0, 0, 0, 0, 0
  33.451 +};
  33.452 +unsigned char config_pal_vm_page_size[16] = {
  33.453 +    0, 112, 85, 21, 0, 0, 0, 0, 0, 112, 85, 21, 0, 0, 0, 0
  33.454 +};
  33.455 +
  33.456 +typedef struct{
  33.457 +    hob_type_t type;
  33.458 +    void* data;
  33.459 +    unsigned long size;     
  33.460 +}hob_batch_t;
  33.461 +
  33.462 +hob_batch_t hob_batch[]={
  33.463 +    {  HOB_TYPE_PAL_BUS_GET_FEATURES_DATA,
  33.464 +        &config_pal_bus_get_features_data,
  33.465 +        sizeof(config_pal_bus_get_features_data)
  33.466 +    },
  33.467 +    {  HOB_TYPE_PAL_CACHE_SUMMARY,
  33.468 +        &config_pal_cache_summary,
  33.469 +        sizeof(config_pal_cache_summary)
  33.470 +    },
  33.471 +    {  HOB_TYPE_PAL_MEM_ATTRIB,
  33.472 +        &config_pal_mem_attrib,
  33.473 +        sizeof(config_pal_mem_attrib)
  33.474 +    },
  33.475 +    {  HOB_TYPE_PAL_CACHE_INFO,
  33.476 +        &config_pal_cache_info,
  33.477 +        sizeof(config_pal_cache_info)
  33.478 +    },
  33.479 +    {  HOB_TYPE_PAL_CACHE_PROT_INFO,
  33.480 +        &config_pal_cache_prot_info,
  33.481 +        sizeof(config_pal_cache_prot_info)
  33.482 +    },
  33.483 +    {  HOB_TYPE_PAL_DEBUG_INFO,
  33.484 +        &config_pal_debug_info,
  33.485 +        sizeof(config_pal_debug_info)
  33.486 +    },
  33.487 +    {  HOB_TYPE_PAL_FIXED_ADDR,
  33.488 +        &config_pal_fixed_addr,
  33.489 +        sizeof(config_pal_fixed_addr)
  33.490 +    },
  33.491 +    {  HOB_TYPE_PAL_FREQ_BASE,
  33.492 +        &config_pal_freq_base,
  33.493 +        sizeof(config_pal_freq_base)
  33.494 +    },
  33.495 +    {  HOB_TYPE_PAL_FREQ_RATIOS,
  33.496 +        &config_pal_freq_ratios,
  33.497 +        sizeof(config_pal_freq_ratios)
  33.498 +    },
  33.499 +    {  HOB_TYPE_PAL_HALT_INFO,
  33.500 +        &config_pal_halt_info,
  33.501 +        sizeof(config_pal_halt_info)
  33.502 +    },
  33.503 +    {  HOB_TYPE_PAL_PERF_MON_INFO,
  33.504 +        &config_pal_perf_mon_info,
  33.505 +        sizeof(config_pal_perf_mon_info)
  33.506 +    },
  33.507 +    {  HOB_TYPE_PAL_PROC_GET_FEATURES,
  33.508 +        &config_pal_proc_get_features,
  33.509 +        sizeof(config_pal_proc_get_features)
  33.510 +    },
  33.511 +    {  HOB_TYPE_PAL_PTCE_INFO,
  33.512 +        &config_pal_ptce_info,
  33.513 +        sizeof(config_pal_ptce_info)
  33.514 +    },
  33.515 +    {  HOB_TYPE_PAL_REGISTER_INFO,
  33.516 +        &config_pal_register_info,
  33.517 +        sizeof(config_pal_register_info)
  33.518 +    },
  33.519 +    {  HOB_TYPE_PAL_RSE_INFO,
  33.520 +        &config_pal_rse_info,
  33.521 +        sizeof(config_pal_rse_info)
  33.522 +    },
  33.523 +    {  HOB_TYPE_PAL_TEST_INFO,
  33.524 +        &config_pal_test_info,
  33.525 +        sizeof(config_pal_test_info)
  33.526 +    },
  33.527 +    {  HOB_TYPE_PAL_VM_SUMMARY,
  33.528 +        &config_pal_vm_summary,
  33.529 +        sizeof(config_pal_vm_summary)
  33.530 +    },
  33.531 +    {  HOB_TYPE_PAL_VM_INFO,
  33.532 +        &config_pal_vm_info,
  33.533 +        sizeof(config_pal_vm_info)
  33.534 +    },
  33.535 +    {  HOB_TYPE_PAL_VM_PAGE_SIZE,
  33.536 +        &config_pal_vm_page_size,
  33.537 +        sizeof(config_pal_vm_page_size)
  33.538 +    },      
  33.539 +};
  33.540 +
  33.541 +static int add_pal_hob(void* hob_buf){
  33.542 +    int i;
  33.543 +    for (i=0; i<sizeof(hob_batch)/sizeof(hob_batch_t); i++){
  33.544 +        if (hob_add(hob_buf, hob_batch[i].type, 
  33.545 +                    hob_batch[i].data,
  33.546 +                    hob_batch[i].size)<0)
  33.547 +            return -1;
  33.548 +    }
  33.549 +    return 0;
  33.550 +}
  33.551 +
  33.552 +static int setup_guest(  int xc_handle,
  33.553 +                         uint32_t dom, unsigned long memsize,
  33.554 +                         char *image, unsigned long image_size,
  33.555 +                         unsigned int control_evtchn,
  33.556 +                         unsigned int store_evtchn,
  33.557 +                         unsigned long *store_mfn)
  33.558 +{
  33.559 +    unsigned long page_array[2];
  33.560 +    shared_iopage_t *sp;
  33.561 +    // FIXME: initialize pfn list for a temp hack
  33.562 +    if (xc_ia64_get_pfn_list(xc_handle, dom, NULL, -1, -1) == -1) {
  33.563 +	PERROR("Could not allocate continuous memory");
  33.564 +	goto error_out;
  33.565 +    }
  33.566 +    
  33.567 +    if ((image_size > 12 * MEM_M) || (image_size & (PAGE_SIZE - 1))) {
  33.568 +        PERROR("Guest firmware size is incorrect [%ld]?", image_size);
  33.569 +        return -1;
  33.570 +    }
  33.571 +
  33.572 +    /* Load guest firmware */
  33.573 +    if( xc_ia64_copy_to_domain_pages( xc_handle, dom, 
  33.574 +            image, 4*MEM_G-image_size, image_size>>PAGE_SHIFT)) {
  33.575 +        PERROR("Could not load guest firmware into domain");
  33.576 +        goto error_out;
  33.577 +    }
  33.578 +
  33.579 +    /* Hand-off state passed to guest firmware */
  33.580 +    if (xc_ia64_build_hob(xc_handle, dom, memsize) < 0){
  33.581 +        PERROR("Could not build hob\n");
  33.582 +       goto error_out;
  33.583 +    }
  33.584 +
  33.585 +    /* Retrieve special pages like io, xenstore, etc. */
  33.586 +    if ( xc_ia64_get_pfn_list(xc_handle, dom, page_array, IO_PAGE_START>>PAGE_SHIFT, 2) != 2 )
  33.587 +    {
  33.588 +        PERROR("Could not get the page frame list");
  33.589 +        goto error_out;
  33.590 +    }
  33.591 +
  33.592 +    *store_mfn = page_array[1];
  33.593 +    if ((sp = (shared_iopage_t *) xc_map_foreign_range(
  33.594 +		xc_handle, dom, PAGE_SIZE, PROT_READ|PROT_WRITE,
  33.595 +		page_array[0])) == 0)
  33.596 +	goto error_out;
  33.597 +    memset(sp, 0, PAGE_SIZE);
  33.598 +    sp->sp_global.eport = control_evtchn;
  33.599 +    munmap(sp, PAGE_SIZE);
  33.600 +
  33.601 +    return 0;
  33.602 +
  33.603 + error_out:
  33.604 +    return -1;
  33.605 +}
  33.606 +
  33.607 +int xc_vmx_build(int xc_handle,
  33.608 +                 uint32_t domid,
  33.609 +                 int memsize,
  33.610 +                 const char *image_name,
  33.611 +                 unsigned int control_evtchn,
  33.612 +                 unsigned int vcpus,
  33.613 +                 unsigned int store_evtchn,
  33.614 +                 unsigned long *store_mfn)
  33.615 +{
  33.616 +    dom0_op_t launch_op, op;
  33.617 +    int rc ;
  33.618 +    vcpu_guest_context_t st_ctxt, *ctxt = &st_ctxt;
  33.619 +    char         *image = NULL;
  33.620 +    unsigned long image_size;
  33.621 +    unsigned long nr_pages;
  33.622 +
  33.623 +    if ( (nr_pages = xc_get_max_pages(xc_handle, domid)) < 0 )
  33.624 +    {
  33.625 +        PERROR("Could not find total pages for domain");
  33.626 +        goto error_out;
  33.627 +    }
  33.628 +
  33.629 +    if ( (image = xc_read_kernel_image(image_name, &image_size)) == NULL ){
  33.630 +        PERROR("Could not read guest firmware image %s",image_name);
  33.631 +        goto error_out;
  33.632 +    }
  33.633 +
  33.634 +    image_size = (image_size + PAGE_SIZE - 1) & PAGE_MASK;
  33.635 +
  33.636 +    if ( mlock(&st_ctxt, sizeof(st_ctxt) ) ){   
  33.637 +        PERROR("Unable to mlock ctxt");
  33.638 +        return 1;
  33.639 +    }
  33.640 +
  33.641 +    op.cmd = DOM0_GETDOMAININFO;
  33.642 +    op.u.getdomaininfo.domain = (domid_t)domid;
  33.643 +    if ( (do_dom0_op(xc_handle, &op) < 0) || 
  33.644 +         ((uint16_t)op.u.getdomaininfo.domain != domid) ) {
  33.645 +        PERROR("Could not get info on domain");
  33.646 +        goto error_out;
  33.647 +    }
  33.648 +
  33.649 +    if ( xc_domain_get_vcpu_context(xc_handle, domid, 0, ctxt) ){
  33.650 +        PERROR("Could not get vcpu context");
  33.651 +        goto error_out;
  33.652 +    }
  33.653 +
  33.654 +    if ( !(op.u.getdomaininfo.flags & DOMFLAGS_PAUSED) ) {
  33.655 +        ERROR("Domain is already constructed");
  33.656 +        goto error_out;
  33.657 +    }
  33.658 +
  33.659 +    if ( setup_guest(xc_handle, domid, (unsigned long)memsize, image, image_size, 
  33.660 +                       control_evtchn, store_evtchn, store_mfn ) < 0 ){
  33.661 +        ERROR("Error constructing guest OS");
  33.662 +        goto error_out;
  33.663 +    }
  33.664 +
  33.665 +    if ( image != NULL )
  33.666 +        free(image);
  33.667 +
  33.668 +    ctxt->flags = VGCF_VMX_GUEST;
  33.669 +    ctxt->regs.cr_iip = 0x80000000ffffffb0UL;
  33.670 +    ctxt->vcpu.privregs = 0;
  33.671 +
  33.672 +    memset( &launch_op, 0, sizeof(launch_op) );
  33.673 +
  33.674 +    launch_op.u.setdomaininfo.domain = (domid_t)domid;
  33.675 +    launch_op.u.setdomaininfo.vcpu   = 0;
  33.676 +    launch_op.u.setdomaininfo.ctxt   = ctxt;
  33.677 +
  33.678 +    launch_op.cmd = DOM0_SETDOMAININFO;
  33.679 +    rc = do_dom0_op(xc_handle, &launch_op);
  33.680 +    return rc;
  33.681 +
  33.682 + error_out:
  33.683 +    if ( image != NULL )
  33.684 +        free(image);
  33.685 +
  33.686 +    return -1;
  33.687 +}
  33.688 +
  33.689  /*
  33.690   * Local variables:
  33.691   * mode: C

    34.1 --- a/tools/libxc/xc_linux_build.c	Sun Oct 30 13:52:38 2005 +0100
    34.2 +++ b/tools/libxc/xc_linux_build.c	Sun Oct 30 14:00:35 2005 +0100
    34.3 @@ -350,6 +350,8 @@ static int setup_guest(int xc_handle,
    34.4      start_info = xc_map_foreign_range(
    34.5          xc_handle, dom, PAGE_SIZE, PROT_READ|PROT_WRITE, page_array[0]);
    34.6      memset(start_info, 0, sizeof(*start_info));
    34.7 +    rc = xc_version(xc_handle, XENVER_version, NULL);
    34.8 +    sprintf(start_info->magic, "Xen-%i.%i", rc >> 16, rc & (0xFFFF));
    34.9      start_info->flags        = flags;
   34.10      start_info->store_mfn    = nr_pages - 2;
   34.11      start_info->store_evtchn = store_evtchn;
   34.12 @@ -624,6 +626,8 @@ static int setup_guest(int xc_handle,
   34.13          xc_handle, dom, PAGE_SIZE, PROT_READ|PROT_WRITE,
   34.14          page_array[(vstartinfo_start-dsi.v_start)>>PAGE_SHIFT]);
   34.15      memset(start_info, 0, sizeof(*start_info));
   34.16 +    rc = xc_version(xc_handle, XENVER_version, NULL);
   34.17 +    sprintf(start_info->magic, "Xen-%i.%i", rc >> 16, rc & (0xFFFF));
   34.18      start_info->nr_pages     = nr_pages;
   34.19      start_info->shared_info  = shared_info_frame << PAGE_SHIFT;
   34.20      start_info->flags        = flags;

    35.1 --- a/tools/libxc/xc_private.c	Sun Oct 30 13:52:38 2005 +0100
    35.2 +++ b/tools/libxc/xc_private.c	Sun Oct 30 14:00:35 2005 +0100
    35.3 @@ -313,46 +313,6 @@ int xc_get_pfn_list(int xc_handle,
    35.4      return (ret < 0) ? -1 : op.u.getmemlist.num_pfns;
    35.5  }
    35.6  
    35.7 -#ifdef __ia64__
    35.8 -int xc_ia64_get_pfn_list(int xc_handle,
    35.9 -                         uint32_t domid, 
   35.10 -                         unsigned long *pfn_buf, 
   35.11 -                         unsigned int start_page,
   35.12 -                         unsigned int nr_pages)
   35.13 -{
   35.14 -    dom0_op_t op;
   35.15 -    int ret;
   35.16 -
   35.17 -    op.cmd = DOM0_GETMEMLIST;
   35.18 -    op.u.getmemlist.domain   = (domid_t)domid;
   35.19 -    op.u.getmemlist.max_pfns = ((unsigned long)start_page << 32) | nr_pages;
   35.20 -    op.u.getmemlist.buffer   = pfn_buf;
   35.21 -
   35.22 -    if ( mlock(pfn_buf, nr_pages * sizeof(unsigned long)) != 0 )
   35.23 -    {
   35.24 -        PERROR("Could not lock pfn list buffer");
   35.25 -        return -1;
   35.26 -    }    
   35.27 -
   35.28 -    /* XXX Hack to put pages in TLB, hypervisor should be able to handle this */
   35.29 -    memset(pfn_buf, 0, nr_pages * sizeof(unsigned long));
   35.30 -    ret = do_dom0_op(xc_handle, &op);
   35.31 -
   35.32 -    (void)munlock(pfn_buf, nr_pages * sizeof(unsigned long));
   35.33 -
   35.34 -    return (ret < 0) ? -1 : op.u.getmemlist.num_pfns;
   35.35 -}
   35.36 -
   35.37 -long xc_get_max_pages(int xc_handle, uint32_t domid)
   35.38 -{
   35.39 -    dom0_op_t op;
   35.40 -    op.cmd = DOM0_GETDOMAININFO;
   35.41 -    op.u.getdomaininfo.domain = (domid_t)domid;
   35.42 -    return (do_dom0_op(xc_handle, &op) < 0) ? 
   35.43 -        -1 : op.u.getdomaininfo.max_pages;
   35.44 -}
   35.45 -#endif
   35.46 -
   35.47  long xc_get_tot_pages(int xc_handle, uint32_t domid)
   35.48  {
   35.49      dom0_op_t op;

    36.1 --- a/tools/libxc/xc_vmx_build.c	Sun Oct 30 13:52:38 2005 +0100
    36.2 +++ b/tools/libxc/xc_vmx_build.c	Sun Oct 30 14:00:35 2005 +0100
    36.3 @@ -279,6 +279,7 @@ static int setup_guest(int xc_handle,
    36.4                         vcpu_guest_context_t *ctxt,
    36.5                         unsigned long shared_info_frame,
    36.6                         unsigned int control_evtchn,
    36.7 +                       unsigned int lapic,
    36.8                         unsigned int vcpus,
    36.9                         unsigned int store_evtchn,
   36.10                         unsigned long *store_mfn)
   36.11 @@ -554,7 +555,7 @@ static int setup_guest(int xc_handle,
   36.12      ctxt->user_regs.eax = 0;
   36.13      ctxt->user_regs.esp = 0;
   36.14      ctxt->user_regs.ebx = 0; /* startup_32 expects this to be 0 to signal boot cpu */
   36.15 -    ctxt->user_regs.ecx = 0;
   36.16 +    ctxt->user_regs.ecx = lapic;
   36.17      ctxt->user_regs.esi = 0;
   36.18      ctxt->user_regs.edi = 0;
   36.19      ctxt->user_regs.ebp = 0;
   36.20 @@ -597,6 +598,7 @@ int xc_vmx_build(int xc_handle,
   36.21                   int memsize,
   36.22                   const char *image_name,
   36.23                   unsigned int control_evtchn,
   36.24 +                 unsigned int lapic,
   36.25                   unsigned int vcpus,
   36.26                   unsigned int store_evtchn,
   36.27                   unsigned long *store_mfn)
   36.28 @@ -651,9 +653,9 @@ int xc_vmx_build(int xc_handle,
   36.29          goto error_out;
   36.30      }
   36.31  
   36.32 -    if ( setup_guest(xc_handle, domid, memsize, image, image_size,
   36.33 -                     nr_pages, ctxt, op.u.getdomaininfo.shared_info_frame,
   36.34 -                     control_evtchn, vcpus, store_evtchn, store_mfn) < 0)
   36.35 +    if ( setup_guest(xc_handle, domid, memsize, image, image_size, nr_pages,
   36.36 +                     ctxt, op.u.getdomaininfo.shared_info_frame, control_evtchn,
   36.37 +                     lapic, vcpus, store_evtchn, store_mfn) < 0)
   36.38      {
   36.39          ERROR("Error constructing guest OS");
   36.40          goto error_out;

    37.1 --- a/tools/libxc/xenctrl.h	Sun Oct 30 13:52:38 2005 +0100
    37.2 +++ b/tools/libxc/xenctrl.h	Sun Oct 30 14:00:35 2005 +0100
    37.3 @@ -414,6 +414,12 @@ int xc_ia64_get_pfn_list(int xc_handle, 
    37.4                           unsigned long *pfn_buf, 
    37.5                           unsigned int start_page, unsigned int nr_pages);
    37.6  
    37.7 +int xc_copy_to_domain_page(int xc_handle, uint32_t domid,
    37.8 +			   unsigned long dst_pfn, void *src_page);
    37.9 +
   37.10 +int xc_ia64_copy_to_domain_pages(int xc_handle, uint32_t domid,
   37.11 +        void* src_page, unsigned long dst_pfn, int nr_pages);
   37.12 +
   37.13  long xc_get_max_pages(int xc_handle, uint32_t domid);
   37.14  
   37.15  int xc_mmuext_op(int xc_handle, struct mmuext_op *op, unsigned int nr_ops,

    38.1 --- a/tools/libxc/xenguest.h	Sun Oct 30 13:52:38 2005 +0100
    38.2 +++ b/tools/libxc/xenguest.h	Sun Oct 30 14:00:35 2005 +0100
    38.3 @@ -56,6 +56,7 @@ int xc_vmx_build(int xc_handle,
    38.4                   int memsize,
    38.5                   const char *image_name,
    38.6                   unsigned int control_evtchn,
    38.7 +                 unsigned int lapic,
    38.8                   unsigned int vcpus,
    38.9                   unsigned int store_evtchn,
   38.10                   unsigned long *store_mfn);

    39.1 --- a/tools/misc/cpuperf/cpuperf.c	Sun Oct 30 13:52:38 2005 +0100
    39.2 +++ b/tools/misc/cpuperf/cpuperf.c	Sun Oct 30 14:00:35 2005 +0100
    39.3 @@ -16,7 +16,6 @@
    39.4  
    39.5  #include <sys/types.h>
    39.6  #include <sched.h>
    39.7 -#include <error.h>
    39.8  #include <stdio.h>
    39.9  #include <unistd.h>
   39.10  #include <stdlib.h>

    40.1 --- a/tools/misc/miniterm/miniterm.c	Sun Oct 30 13:52:38 2005 +0100
    40.2 +++ b/tools/misc/miniterm/miniterm.c	Sun Oct 30 14:00:35 2005 +0100
    40.3 @@ -29,7 +29,7 @@
    40.4  #include <stdlib.h>
    40.5  #include <unistd.h>
    40.6  #include <fcntl.h>
    40.7 -#include <sys/signal.h>
    40.8 +#include <signal.h>
    40.9  #include <sys/types.h>
   40.10  #include <sys/wait.h>
   40.11  

    41.1 --- a/tools/python/xen/lowlevel/xc/xc.c	Sun Oct 30 13:52:38 2005 +0100
    41.2 +++ b/tools/python/xen/lowlevel/xc/xc.c	Sun Oct 30 14:00:35 2005 +0100
    41.3 @@ -438,19 +438,20 @@ static PyObject *pyxc_vmx_build(PyObject
    41.4      char *image;
    41.5      int control_evtchn, store_evtchn;
    41.6      int vcpus = 1;
    41.7 +    int lapic = 0;
    41.8      int memsize;
    41.9      unsigned long store_mfn = 0;
   41.10  
   41.11      static char *kwd_list[] = { "dom", "control_evtchn", "store_evtchn",
   41.12 -                                "memsize", "image", "vcpus", NULL };
   41.13 +                                "memsize", "image", "lapic", "vcpus", NULL };
   41.14  
   41.15 -    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiiisi", kwd_list,
   41.16 +    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiiisii", kwd_list,
   41.17                                        &dom, &control_evtchn, &store_evtchn,
   41.18 -                                      &memsize, &image, &vcpus) )
   41.19 +                                      &memsize, &image, &lapic, &vcpus) )
   41.20          return NULL;
   41.21  
   41.22      if ( xc_vmx_build(xc->xc_handle, dom, memsize, image, control_evtchn,
   41.23 -                      vcpus, store_evtchn, &store_mfn) != 0 )
   41.24 +                      lapic, vcpus, store_evtchn, &store_mfn) != 0 )
   41.25          return PyErr_SetFromErrno(xc_error);
   41.26  
   41.27      return Py_BuildValue("{s:i}", "store_mfn", store_mfn);

    42.1 --- a/tools/python/xen/web/tcp.py	Sun Oct 30 13:52:38 2005 +0100
    42.2 +++ b/tools/python/xen/web/tcp.py	Sun Oct 30 14:00:35 2005 +0100
    42.3 @@ -99,7 +99,7 @@ def listenTCP(port, factory, interface='
    42.4      return l
    42.5  
    42.6  def SetCloExec(SocketListener):
    42.7 -    SocketListener.SetCloExec()
    42.8 +    SocketListener.setCloExec()
    42.9  
   42.10  def connectTCP(host, port, factory, timeout=None, bindAddress=None):
   42.11      c = TCPConnector(host, port, factory, timeout=timeout, bindAddress=bindAddress)

    43.1 --- a/tools/python/xen/xend/image.py	Sun Oct 30 13:52:38 2005 +0100
    43.2 +++ b/tools/python/xen/xend/image.py	Sun Oct 30 14:00:35 2005 +0100
    43.3 @@ -203,6 +203,10 @@ class VmxImageHandler(ImageHandler):
    43.4  
    43.5          self.dmargs += self.configVNC(imageConfig)
    43.6  
    43.7 +        self.lapic = 0
    43.8 +        lapic = sxp.child_value(imageConfig, 'lapic')
    43.9 +        if not lapic is None:
   43.10 +            self.lapic = int(lapic)
   43.11  
   43.12      def buildDomain(self):
   43.13          # Create an event channel
   43.14 @@ -217,6 +221,7 @@ class VmxImageHandler(ImageHandler):
   43.15          log.debug("control_evtchn = %d", self.device_channel)
   43.16          log.debug("store_evtchn   = %d", store_evtchn)
   43.17          log.debug("memsize        = %d", self.vm.getMemoryTarget() / 1024)
   43.18 +        log.debug("lapic          = %d", self.lapic)
   43.19          log.debug("vcpus          = %d", self.vm.getVCpuCount())
   43.20  
   43.21          return xc.vmx_build(dom            = self.vm.getDomid(),
   43.22 @@ -224,6 +229,7 @@ class VmxImageHandler(ImageHandler):
   43.23                              control_evtchn = self.device_channel,
   43.24                              store_evtchn   = store_evtchn,
   43.25                              memsize        = self.vm.getMemoryTarget() / 1024,
   43.26 +                            lapic          = self.lapic,
   43.27                              vcpus          = self.vm.getVCpuCount())
   43.28  
   43.29  
   43.30 @@ -342,12 +348,15 @@ class VmxImageHandler(ImageHandler):
   43.31  
   43.32      def getDomainMemory(self, mem):
   43.33          """@see ImageHandler.getDomainMemory"""
   43.34 +	page_kb = 4
   43.35 +	if os.uname()[4] == 'ia64':
   43.36 +	    page_kb = 16
   43.37          # for ioreq_t and xenstore
   43.38          static_pages = 2
   43.39 -        return mem + self.getPageTableSize(mem / 1024) + 4 * static_pages
   43.40 +        return mem + (self.getPageTableSize(mem / 1024) + static_pages) * page_kb
   43.41              
   43.42      def getPageTableSize(self, mem_mb):
   43.43 -        """Return the size of memory needed for 1:1 page tables for physical
   43.44 +        """Return the pages of memory needed for 1:1 page tables for physical
   43.45             mode.
   43.46  
   43.47          @param mem_mb: size in MB
   43.48 @@ -355,13 +364,13 @@ class VmxImageHandler(ImageHandler):
   43.49          """
   43.50          # 1 page for the PGD + 1 pte page for 4MB of memory (rounded)
   43.51          if os.uname()[4] == 'x86_64':
   43.52 -            return (5 + ((mem_mb + 1) >> 1)) * 4
   43.53 +            return 5 + ((mem_mb + 1) >> 1)
   43.54          elif os.uname()[4] == 'ia64':
   43.55 -            # XEN/IA64 has p2m table allocated on demand, so only return
   43.56 -            # guest firmware size here.
   43.57 -            return 16 * 1024
   43.58 +            # 1:1 pgtable is allocated on demand ia64, so just return rom size
   43.59 +	    # for guest firmware
   43.60 +            return 1024
   43.61          else:
   43.62 -            return (1 + ((mem_mb + 3) >> 2)) * 4
   43.63 +            return 1 + ((mem_mb + 3) >> 2)
   43.64  
   43.65  
   43.66  """Table of image handler classes for virtual machine images.  Indexed by

    44.1 --- a/tools/python/xen/xend/server/event.py	Sun Oct 30 13:52:38 2005 +0100
    44.2 +++ b/tools/python/xen/xend/server/event.py	Sun Oct 30 14:00:35 2005 +0100
    44.3 @@ -192,4 +192,5 @@ def listenEvent(daemon):
    44.4      if xroot.get_xend_http_server():
    44.5          port = xroot.get_xend_event_port()
    44.6          interface = xroot.get_xend_address()
    44.7 -        tcp.listenTCP(port, factory, interface=interface)
    44.8 +        l = tcp.listenTCP(port, factory, interface=interface)
    44.9 +        l.setCloExec()

    46.1 --- a/tools/python/xen/xm/create.py	Sun Oct 30 13:52:38 2005 +0100
    46.2 +++ b/tools/python/xen/xm/create.py	Sun Oct 30 14:00:35 2005 +0100
    46.3 @@ -157,6 +157,10 @@ gopts.var('cpu', val='CPU',
    46.4            fn=set_int, default=None,
    46.5            use="CPU to run the domain on.")
    46.6  
    46.7 +gopts.var('lapic', val='LAPIC',
    46.8 +          fn=set_int, default=0,
    46.9 +          use="Disable or enable local APIC of VMX domain.")
   46.10 +
   46.11  gopts.var('vcpus', val='VCPUS',
   46.12            fn=set_int, default=1,
   46.13            use="# of Virtual CPUS in domain.")
   46.14 @@ -315,10 +319,6 @@ gopts.var('nfs_root', val="PATH",
   46.15            fn=set_value, default=None,
   46.16            use="Set the path of the root NFS directory.")
   46.17  
   46.18 -gopts.var('memmap', val='FILE',
   46.19 -          fn=set_value, default='',
   46.20 -          use="Path to memap SXP file.")
   46.21 -
   46.22  gopts.var('device_model', val='FILE',
   46.23            fn=set_value, default='',
   46.24            use="Path to device model program.")
   46.25 @@ -556,9 +556,9 @@ def configure_vfr(config, vals):
   46.26  def configure_vmx(config_image, vals):
   46.27      """Create the config for VMX devices.
   46.28      """
   46.29 -    args = [ 'memmap', 'device_model', 'vcpus', 'cdrom',
   46.30 -             'boot', 'fda', 'fdb', 'localtime', 'serial', 'macaddr', 'stdvga', 
   46.31 -             'isa', 'nographic', 'vnc', 'vncviewer', 'sdl', 'display', 'ne2000']
   46.32 +    args = [ 'device_model', 'vcpus', 'cdrom', 'boot', 'fda', 'fdb',
   46.33 +             'localtime', 'serial', 'macaddr', 'stdvga', 'isa', 'nographic',
   46.34 +             'vnc', 'vncviewer', 'sdl', 'display', 'ne2000', 'lapic']
   46.35      for a in args:
   46.36          if (vals.__dict__[a]):
   46.37              config_image.append([a, vals.__dict__[a]])

    47.1 --- a/tools/python/xen/xm/main.py	Sun Oct 30 13:52:38 2005 +0100
    47.2 +++ b/tools/python/xen/xm/main.py	Sun Oct 30 14:00:35 2005 +0100
    47.3 @@ -61,6 +61,8 @@ xm common subcommands:
    47.4      top                     monitor system and domains in real-time
    47.5      unpause <DomId>         unpause a paused domain
    47.6  
    47.7 +<DomName> can be substituted for <DomId> in xm subcommands.
    47.8 +
    47.9  For a complete list of subcommands run 'xm help --long'
   47.10  For more help on xm see the xm(1) man page
   47.11  For more help on xm create, see the xmdomain.cfg(5) man page"""
   47.12 @@ -119,6 +121,8 @@ xm full list of subcommands:
   47.13      vnet-create <config>       create a vnet from a config file
   47.14      vnet-delete <vnetid>       delete a vnet
   47.15  
   47.16 +<DomName> can be substituted for <DomId> in xm subcommands.
   47.17 +
   47.18  For a short list of subcommands run 'xm help'
   47.19  For more help on xm see the xm(1) man page
   47.20  For more help on xm create, see the xmdomain.cfg(5) man page"""

    48.1 --- a/tools/security/getlabel.sh	Sun Oct 30 13:52:38 2005 +0100
    48.2 +++ b/tools/security/getlabel.sh	Sun Oct 30 14:00:35 2005 +0100
    48.3 @@ -36,18 +36,21 @@ source labelfuncs.sh
    48.4  
    48.5  usage ()
    48.6  {
    48.7 -	echo "Usage: $0 -sid <ssidref> [<policy name>] or"
    48.8 -	echo "       $0 -dom <domid>   [<policy name>]  "
    48.9 -	echo ""
   48.10 -	echo "policy name : the name of the policy, i.e. 'chwall'"
   48.11 -	echo "              If the policy name is omitted, the grub.conf"
   48.12 -	echo "              entry of the running system is tried to be read"
   48.13 -	echo "              and the policy name determined from there."
   48.14 -	echo "ssidref     : an ssidref in hex or decimal format, i.e., '0x00010002'"
   48.15 -	echo "              or '65538'"
   48.16 -	echo "domid       : id of the domain, i.e., '1'; Use numbers from the 2nd"
   48.17 -	echo "              column shown when invoking 'xm list'"
   48.18 -	echo ""
   48.19 +echo "Use this tool to display the label of a domain or the label that is
   48.20 +corresponding to an ssidref given the name of the running policy.
   48.21 +
   48.22 +Usage: $0 -sid <ssidref> [<policy name>] or
   48.23 +       $0 -dom <domid>   [<policy name>]
   48.24 +
   48.25 +policy name : the name of the policy, i.e. 'chwall'
   48.26 +              If the policy name is omitted, the grub.conf
   48.27 +              entry of the running system is tried to be read
   48.28 +              and the policy name determined from there.
   48.29 +ssidref     : an ssidref in hex or decimal format, i.e., '0x00010002'
   48.30 +              or '65538'
   48.31 +domid       : id of the domain, i.e., '1'; Use numbers from the 2nd
   48.32 +              column shown when invoking 'xm list'
   48.33 +"
   48.34  }
   48.35  
   48.36  

    49.1 --- a/tools/security/setlabel.sh	Sun Oct 30 13:52:38 2005 +0100
    49.2 +++ b/tools/security/setlabel.sh	Sun Oct 30 14:00:35 2005 +0100
    49.3 @@ -39,21 +39,27 @@ source labelfuncs.sh
    49.4  
    49.5  usage ()
    49.6  {
    49.7 -	echo "Usage: $0 [Option] <vmfile> <label> [<policy name>]"
    49.8 -	echo "    or $0 -l [<policy name>]"
    49.9 -	echo ""
   49.10 -	echo "Valid options are:"
   49.11 -	echo "-r          : to relabel a file without being prompted"
   49.12 -	echo ""
   49.13 -	echo "vmfile      : XEN vm configuration file"
   49.14 -	echo "label       : the label to map to an ssidref"
   49.15 -	echo "policy name : the name of the policy, i.e. 'chwall'"
   49.16 -	echo "              If the policy name is omitted, it is attempted"
   49.17 -	echo "              to find the current policy's name in grub.conf."
   49.18 -	echo ""
   49.19 -	echo "-l [<policy name>] is used to show valid labels in the map file of"
   49.20 -	echo "                   the given or current policy."
   49.21 -	echo ""
   49.22 +echo "Use this tool to put the ssidref corresponding to a label of a policy into
   49.23 +the VM configuration file, or use it to display all labels of a policy.
   49.24 +
   49.25 +Usage: $0 [Option] <vmfile> <label> [<policy name>]
   49.26 +    or $0 -l [<policy name>]
   49.27 +
   49.28 +Valid options are:
   49.29 +-r          : to relabel a file without being prompted
   49.30 +
   49.31 +vmfile      : XEN vm configuration file; give complete path
   49.32 +label       : the label to map to an ssidref
   49.33 +policy name : the name of the policy, i.e. 'chwall'
   49.34 +              If the policy name is omitted, it is attempted
   49.35 +              to find the current policy's name in grub.conf.
   49.36 +
   49.37 +-l [<policy name>] is used to show valid labels in the map file of
   49.38 +                   the given or current policy. If the policy name
   49.39 +                   is omitted, it will be tried to determine the
   49.40 +                   current policy from grub.conf (/boot/grub/grub.conf)
   49.41 +
   49.42 +"
   49.43  }
   49.44  
   49.45  
   49.46 @@ -83,7 +89,7 @@ if [ "$mode" == "show" ]; then
   49.47  			exit -1;
   49.48  		fi
   49.49  	else
   49.50 -		policy=$3;
   49.51 +		policy=$1;
   49.52  	fi
   49.53  
   49.54  
   49.55 @@ -92,7 +98,7 @@ if [ "$mode" == "show" ]; then
   49.56  	if [ "$res" != "0" ]; then
   49.57  		showLabels $mapfile
   49.58  	else
   49.59 -		echo "Could not find map file for policy '$1'."
   49.60 +		echo "Could not find map file for policy '$policy'."
   49.61  	fi
   49.62  elif [ "$mode" == "usage" ]; then
   49.63  	usage

    50.1 --- a/tools/security/updategrub.sh	Sun Oct 30 13:52:38 2005 +0100
    50.2 +++ b/tools/security/updategrub.sh	Sun Oct 30 14:00:35 2005 +0100
    50.3 @@ -26,11 +26,16 @@ fi
    50.4  # Show usage of this program
    50.5  usage ()
    50.6  {
    50.7 -	echo "Usage: $0 <policy name> <root of xen repository>"
    50.8 -	echo ""
    50.9 -	echo "<policy name>             : The name of the policy, i.e. xen_null"
   50.10 -	echo "<root of xen repository>  : The root of the XEN repositrory."
   50.11 -	echo ""
   50.12 +echo "Use this tool to add the binary policy to the Xen grub entry and
   50.13 +have Xen automatically enforce the policy when starting.
   50.14 +
   50.15 +Usage: $0 <policy name> <root of xen repository>
   50.16 +
   50.17 +<policy name>             : The name of the policy, i.e. xen_null
   50.18 +<root of xen repository>  : The root of the XEN repository. Give
   50.19 +                            complete path.
   50.20 +
   50.21 +"
   50.22  }
   50.23  
   50.24  # This function sets the global variable 'linux'
   50.25 @@ -43,11 +48,24 @@ getLinuxVersion ()
   50.26  	for f in $path/linux-*-xen0 ; do
   50.27  		versionfile=$f/include/linux/version.h
   50.28  		if [ -r $versionfile ]; then
   50.29 -			lnx=`cat $versionfile | \
   50.30 -			     grep UTS_RELEASE | \
   50.31 -			     awk '{             \
   50.32 -			       len=length($3);  \
   50.33 -			       print substr($3,2,len-2) }'`
   50.34 +			lnx=`cat $versionfile |                \
   50.35 +			     grep UTS_RELEASE |                \
   50.36 +			     awk '{                            \
   50.37 +			       len=length($3);                 \
   50.38 +			       version=substr($3,2,len-2);     \
   50.39 +			       split(version,numbers,".");     \
   50.40 +			       if (numbers[4]=="") {           \
   50.41 +			         printf("%s.%s.%s",            \
   50.42 +			                 numbers[1],           \
   50.43 +			                 numbers[2],           \
   50.44 +			                 numbers[3]);          \
   50.45 +			       } else {                        \
   50.46 +			         printf("%s.%s.%s[.0-9]*-xen0",\
   50.47 +			                numbers[1],            \
   50.48 +			                numbers[2],            \
   50.49 +			                numbers[3]);           \
   50.50 +			       }                               \
   50.51 +			     }'`
   50.52  		fi
   50.53  		if [ "$lnx" != "" ]; then
   50.54  			linux="[./0-9a-zA-z]*$lnx"
   50.55 @@ -143,10 +161,19 @@ updateGrub ()
   50.56  		echo "Could not create temporary file! Aborting."
   50.57  		exit -1
   50.58  	fi
   50.59 -	mv -f $tmpfile $grubconf
   50.60 +	diff $tmpfile $grubconf > /dev/null
   50.61 +	RES=$?
   50.62 +	if [ "$RES" == "0" ]; then
   50.63 +		echo "No changes were made to $grubconf."
   50.64 +	else
   50.65 +		echo "Successfully updated $grubconf."
   50.66 +		mv -f $tmpfile $grubconf
   50.67 +	fi
   50.68  }
   50.69  
   50.70  if [ "$1" == "" -o "$2" == "" ]; then
   50.71 +	echo "Error: Not enough command line parameters."
   50.72 +	echo ""
   50.73  	usage
   50.74  	exit -1
   50.75  fi

    51.1 --- a/tools/xenstore/Makefile	Sun Oct 30 13:52:38 2005 +0100
    51.2 +++ b/tools/xenstore/Makefile	Sun Oct 30 14:00:35 2005 +0100
    51.3 @@ -77,7 +77,7 @@ libxenstore.so: xs.opic xs_lib.opic
    51.4  clean: testsuite-clean
    51.5  	rm -f *.o *.opic *.so
    51.6  	rm -f xenstored xs_random xs_stress xs_crashme
    51.7 -	rm -f xs_test xenstored_test
    51.8 +	rm -f xs_test xenstored_test xs_tdb_dump
    51.9  	$(RM) $(PROG_DEP)
   51.10  
   51.11  print-dir:

    52.1 --- a/xen/acm/acm_simple_type_enforcement_hooks.c	Sun Oct 30 13:52:38 2005 +0100
    52.2 +++ b/xen/acm/acm_simple_type_enforcement_hooks.c	Sun Oct 30 14:00:35 2005 +0100
    52.3 @@ -392,8 +392,11 @@ check_cache(struct domain *dom, domid_t 
    52.4      int i;
    52.5  
    52.6      printkd("checking cache: %x --> %x.\n", dom->domain_id, rdom);
    52.7 +
    52.8 +    if (dom->ssid == NULL)
    52.9 +        return 0;
   52.10      ste_ssid = GET_SSIDP(ACM_SIMPLE_TYPE_ENFORCEMENT_POLICY, 
   52.11 -                         (struct acm_ssid_domain *)(dom)->ssid);
   52.12 +                         (struct acm_ssid_domain *)(dom->ssid));
   52.13  
   52.14      for(i=0; i< ACM_TE_CACHE_SIZE; i++) {
   52.15          if ((ste_ssid->ste_cache[i].valid == VALID) &&
   52.16 @@ -412,6 +415,8 @@ cache_result(struct domain *subj, struct
   52.17      struct ste_ssid *ste_ssid;
   52.18      int i;
   52.19      printkd("caching from doms: %x --> %x.\n", subj->domain_id, obj->domain_id);
   52.20 +    if (subj->ssid == NULL)
   52.21 +        return;
   52.22      ste_ssid = GET_SSIDP(ACM_SIMPLE_TYPE_ENFORCEMENT_POLICY, 
   52.23                           (struct acm_ssid_domain *)(subj)->ssid);
   52.24      for(i=0; i< ACM_TE_CACHE_SIZE; i++)
   52.25 @@ -431,26 +436,34 @@ clean_id_from_cache(domid_t id)
   52.26      struct ste_ssid *ste_ssid;
   52.27      int i;
   52.28      struct domain **pd;
   52.29 +    struct acm_ssid_domain *ssid;
   52.30  
   52.31      printkd("deleting cache for dom %x.\n", id);
   52.32 -
   52.33      read_lock(&domlist_lock); /* look through caches of all domains */
   52.34      pd = &domain_list;
   52.35      for ( pd = &domain_list; *pd != NULL; pd = &(*pd)->next_in_list ) {
   52.36 -        ste_ssid = GET_SSIDP(ACM_SIMPLE_TYPE_ENFORCEMENT_POLICY, 
   52.37 -                             (struct acm_ssid_domain *)(*pd)->ssid);
   52.38 +        ssid = (struct acm_ssid_domain *)((*pd)->ssid);
   52.39 +
   52.40 +        if (ssid == NULL)
   52.41 +            continue; /* hanging domain structure, no ssid any more ... */
   52.42 +        ste_ssid = GET_SSIDP(ACM_SIMPLE_TYPE_ENFORCEMENT_POLICY, ssid);
   52.43 +        if (!ste_ssid) {
   52.44 +            printk("%s: deleting ID from cache ERROR (no ste_ssid)!\n",
   52.45 +                   __func__);
   52.46 +            goto out;
   52.47 +        }
   52.48          for (i=0; i<ACM_TE_CACHE_SIZE; i++)
   52.49              if ((ste_ssid->ste_cache[i].valid == VALID) &&
   52.50 -                (ste_ssid->ste_cache[i].id = id))
   52.51 +                (ste_ssid->ste_cache[i].id == id))
   52.52                  ste_ssid->ste_cache[i].valid = FREE;
   52.53      }
   52.54 + out:
   52.55      read_unlock(&domlist_lock);
   52.56  }
   52.57  
   52.58  /***************************
   52.59   * Authorization functions
   52.60   **************************/
   52.61 -
   52.62  static int 
   52.63  ste_pre_domain_create(void *subject_ssid, ssidref_t ssidref)
   52.64  {      
   52.65 @@ -484,44 +497,13 @@ ste_post_domain_destroy(void *subject_ss
   52.66  
   52.67  /* -------- EVENTCHANNEL OPERATIONS -----------*/
   52.68  static int
   52.69 -ste_pre_eventchannel_unbound(domid_t id) {
   52.70 -    struct domain *subj, *obj;
   52.71 -    int ret;
   52.72 -    traceprintk("%s: dom%x-->dom%x.\n", 
   52.73 -                __func__, current->domain->domain_id, id);
   52.74 -
   52.75 -    if (check_cache(current->domain, id)) {
   52.76 -        atomic_inc(&ste_bin_pol.ec_cachehit_count);
   52.77 -        return ACM_ACCESS_PERMITTED;
   52.78 -    }
   52.79 -    atomic_inc(&ste_bin_pol.ec_eval_count);
   52.80 -    subj = current->domain;
   52.81 -    obj = find_domain_by_id(id);
   52.82 -
   52.83 -    if (share_common_type(subj, obj)) {
   52.84 -        cache_result(subj, obj);
   52.85 -        ret = ACM_ACCESS_PERMITTED;
   52.86 -    } else {
   52.87 -        atomic_inc(&ste_bin_pol.ec_denied_count); 
   52.88 -        ret = ACM_ACCESS_DENIED; 
   52.89 -    }
   52.90 -    if (obj != NULL)
   52.91 -        put_domain(obj);
   52.92 -    return ret;
   52.93 -}
   52.94 -
   52.95 -static int
   52.96 -ste_pre_eventchannel_interdomain(domid_t id1, domid_t id2)
   52.97 -{
   52.98 +ste_pre_eventchannel_unbound(domid_t id1, domid_t id2) {
   52.99      struct domain *subj, *obj;
  52.100      int ret;
  52.101      traceprintk("%s: dom%x-->dom%x.\n", __func__,
  52.102                  (id1 == DOMID_SELF) ? current->domain->domain_id : id1,
  52.103                  (id2 == DOMID_SELF) ? current->domain->domain_id : id2);
  52.104  
  52.105 -    /* following is a bit longer but ensures that we
  52.106 -     * "put" only domains that we where "find"-ing 
  52.107 -     */
  52.108      if (id1 == DOMID_SELF) id1 = current->domain->domain_id;
  52.109      if (id2 == DOMID_SELF) id2 = current->domain->domain_id;
  52.110  
  52.111 @@ -531,7 +513,7 @@ ste_pre_eventchannel_interdomain(domid_t
  52.112          ret = ACM_ACCESS_DENIED;
  52.113          goto out;
  52.114      }
  52.115 -    /* cache check late, but evtchn is not on performance critical path */
  52.116 +    /* cache check late */
  52.117      if (check_cache(subj, obj->domain_id)) {
  52.118          atomic_inc(&ste_bin_pol.ec_cachehit_count);
  52.119          ret = ACM_ACCESS_PERMITTED;
  52.120 @@ -546,7 +528,7 @@ ste_pre_eventchannel_interdomain(domid_t
  52.121          atomic_inc(&ste_bin_pol.ec_denied_count); 
  52.122          ret = ACM_ACCESS_DENIED; 
  52.123      }
  52.124 - out:
  52.125 +  out:
  52.126      if (obj != NULL)
  52.127          put_domain(obj);
  52.128      if (subj != NULL)
  52.129 @@ -554,6 +536,50 @@ ste_pre_eventchannel_interdomain(domid_t
  52.130      return ret;
  52.131  }
  52.132  
  52.133 +static int
  52.134 +ste_pre_eventchannel_interdomain(domid_t id)
  52.135 +{
  52.136 +    struct domain *subj=NULL, *obj=NULL;
  52.137 +    int ret;
  52.138 +
  52.139 +    traceprintk("%s: dom%x-->dom%x.\n", __func__,
  52.140 +                current->domain->domain_id,
  52.141 +                (id == DOMID_SELF) ? current->domain->domain_id : id);
  52.142 +
  52.143 +    /* following is a bit longer but ensures that we
  52.144 +     * "put" only domains that we where "find"-ing 
  52.145 +     */
  52.146 +    if (id == DOMID_SELF) id = current->domain->domain_id;
  52.147 +
  52.148 +    subj = current->domain;
  52.149 +    obj  = find_domain_by_id(id);
  52.150 +    if (obj == NULL) {
  52.151 +        ret = ACM_ACCESS_DENIED;
  52.152 +        goto out;
  52.153 +    }
  52.154 +
  52.155 +    /* cache check late, but evtchn is not on performance critical path */
  52.156 +    if (check_cache(subj, obj->domain_id)) {
  52.157 +        atomic_inc(&ste_bin_pol.ec_cachehit_count);
  52.158 +        ret = ACM_ACCESS_PERMITTED;
  52.159 +        goto out;
  52.160 +    }
  52.161 +
  52.162 +    atomic_inc(&ste_bin_pol.ec_eval_count);
  52.163 +
  52.164 +    if (share_common_type(subj, obj)) {
  52.165 +        cache_result(subj, obj);
  52.166 +        ret = ACM_ACCESS_PERMITTED;
  52.167 +    } else {
  52.168 +        atomic_inc(&ste_bin_pol.ec_denied_count); 
  52.169 +        ret = ACM_ACCESS_DENIED; 
  52.170 +    }
  52.171 + out:
  52.172 +    if (obj != NULL)
  52.173 +        put_domain(obj);
  52.174 +    return ret;
  52.175 +}
  52.176 +
  52.177  /* -------- SHARED MEMORY OPERATIONS -----------*/
  52.178  
  52.179  static int

    53.1 --- a/xen/arch/ia64/asm-offsets.c	Sun Oct 30 13:52:38 2005 +0100
    53.2 +++ b/xen/arch/ia64/asm-offsets.c	Sun Oct 30 14:00:35 2005 +0100
    53.3 @@ -59,6 +59,8 @@ void foo(void)
    53.4  	DEFINE(XSI_BANKNUM_OFS, offsetof(mapped_regs_t, banknum));
    53.5  	DEFINE(XSI_BANK0_OFS, offsetof(mapped_regs_t, bank0_regs[0]));
    53.6  	DEFINE(XSI_BANK1_OFS, offsetof(mapped_regs_t, bank1_regs[0]));
    53.7 +	DEFINE(XSI_B0NATS_OFS, offsetof(mapped_regs_t, vbnat));
    53.8 +	DEFINE(XSI_B1NATS_OFS, offsetof(mapped_regs_t, vnat));
    53.9  	DEFINE(XSI_RR0_OFS, offsetof(mapped_regs_t, rrs[0]));
   53.10  	DEFINE(XSI_METAPHYS_OFS, offsetof(mapped_regs_t, metaphysical_mode));
   53.11  	DEFINE(XSI_PRECOVER_IFS_OFS, offsetof(mapped_regs_t, precover_ifs));
   53.12 @@ -79,13 +81,17 @@ void foo(void)
   53.13  	//DEFINE(IA64_TASK_SIGHAND_OFFSET,offsetof (struct task_struct, sighand));
   53.14  	//DEFINE(IA64_TASK_SIGNAL_OFFSET,offsetof (struct task_struct, signal));
   53.15  	//DEFINE(IA64_TASK_TGID_OFFSET, offsetof (struct task_struct, tgid));
   53.16 +	DEFINE(IA64_PGD, offsetof(struct domain, arch.mm));
   53.17  	DEFINE(IA64_TASK_THREAD_KSP_OFFSET, offsetof (struct vcpu, arch._thread.ksp));
   53.18  	DEFINE(IA64_TASK_THREAD_ON_USTACK_OFFSET, offsetof (struct vcpu, arch._thread.on_ustack));
   53.19  
   53.20 +	DEFINE(IA64_VCPU_DOMAIN_OFFSET, offsetof (struct vcpu, domain));
   53.21  	DEFINE(IA64_VCPU_META_RR0_OFFSET, offsetof (struct vcpu, arch.metaphysical_rr0));
   53.22  	DEFINE(IA64_VCPU_META_SAVED_RR0_OFFSET, offsetof (struct vcpu, arch.metaphysical_saved_rr0));
   53.23  	DEFINE(IA64_VCPU_BREAKIMM_OFFSET, offsetof (struct vcpu, arch.breakimm));
   53.24  	DEFINE(IA64_VCPU_IVA_OFFSET, offsetof (struct vcpu, arch.iva));
   53.25 +	DEFINE(IA64_VCPU_DTLB_PTE_OFFSET, offsetof (struct vcpu, arch.dtlb_pte));
   53.26 +	DEFINE(IA64_VCPU_ITLB_PTE_OFFSET, offsetof (struct vcpu, arch.itlb_pte));
   53.27  	DEFINE(IA64_VCPU_IRR0_OFFSET, offsetof (struct vcpu, arch.irr[0]));
   53.28  	DEFINE(IA64_VCPU_IRR3_OFFSET, offsetof (struct vcpu, arch.irr[3]));
   53.29  	DEFINE(IA64_VCPU_INSVC3_OFFSET, offsetof (struct vcpu, arch.insvc[3]));

    54.1 --- a/xen/arch/ia64/linux-xen/entry.S	Sun Oct 30 13:52:38 2005 +0100
    54.2 +++ b/xen/arch/ia64/linux-xen/entry.S	Sun Oct 30 14:00:35 2005 +0100
    54.3 @@ -900,10 +900,17 @@ GLOBAL_ENTRY(ia64_leave_kernel)
    54.4      adds r7 = PT(EML_UNAT)+16,r12
    54.5  	;;
    54.6      ld8 r7 = [r7]
    54.7 +	;;
    54.8 +#if 0
    54.9 +leave_kernel_self:
   54.10 +    cmp.ne p8,p0 = r0, r7
   54.11 +(p8) br.sptk.few leave_kernel_self
   54.12 +	;; 
   54.13 +#endif
   54.14  (p6)	br.call.sptk.many b0=deliver_pending_interrupt
   54.15      ;;
   54.16  	mov ar.pfs=loc0
   54.17 -    mov ar.unat=r7  /* load eml_unat  */
   54.18 +	mov ar.unat=r7  /* load eml_unat  */
   54.19  	mov r31=r0
   54.20  
   54.21  

    55.1 --- a/xen/arch/ia64/linux-xen/head.S	Sun Oct 30 13:52:38 2005 +0100
    55.2 +++ b/xen/arch/ia64/linux-xen/head.S	Sun Oct 30 14:00:35 2005 +0100
    55.3 @@ -324,6 +324,9 @@ 1:	// now we are in virtual mode
    55.4  	mov r16=-1
    55.5  (isBP)	br.cond.dpnt .load_current // BP stack is on region 5 --- no need to map it
    55.6  
    55.7 +#ifndef XEN
    55.8 +	// XEN:	stack is allocated in xenheap, which is currently always
    55.9 +	//  mapped.
   55.10  	// load mapping for stack (virtaddr in r2, physaddr in r3)
   55.11  	rsm psr.ic
   55.12  	movl r17=PAGE_KERNEL
   55.13 @@ -353,7 +356,8 @@ 1:	// now we are in virtual mode
   55.14  	ssm psr.ic
   55.15  	srlz.d
   55.16    	;;
   55.17 -
   55.18 +#endif
   55.19 +	
   55.20  .load_current:
   55.21  	// load the "current" pointer (r13) and ar.k6 with the current task
   55.22  #if defined(XEN) && defined(VALIDATE_VT)

    56.1 --- a/xen/arch/ia64/linux-xen/irq_ia64.c	Sun Oct 30 13:52:38 2005 +0100
    56.2 +++ b/xen/arch/ia64/linux-xen/irq_ia64.c	Sun Oct 30 14:00:35 2005 +0100
    56.3 @@ -281,5 +281,8 @@ ia64_send_ipi (int cpu, int vector, int 
    56.4  	ipi_data = (delivery_mode << 8) | (vector & 0xff);
    56.5  	ipi_addr = ipi_base_addr + ((phys_cpu_id << 4) | ((redirect & 1) << 3));
    56.6  
    56.7 +#ifdef XEN
    56.8 +	printf ("send_ipi to %d (%x)\n", cpu, phys_cpu_id);
    56.9 +#endif
   56.10  	writeq(ipi_data, ipi_addr);
   56.11  }

    57.1 --- a/xen/arch/ia64/linux-xen/mm_contig.c	Sun Oct 30 13:52:38 2005 +0100
    57.2 +++ b/xen/arch/ia64/linux-xen/mm_contig.c	Sun Oct 30 14:00:35 2005 +0100
    57.3 @@ -193,8 +193,8 @@ per_cpu_init (void)
    57.4  	 */
    57.5  	if (smp_processor_id() == 0) {
    57.6  #ifdef XEN
    57.7 -		cpu_data = alloc_xenheap_pages(PERCPU_PAGE_SHIFT -
    57.8 -			PAGE_SHIFT + get_order(NR_CPUS));
    57.9 +		cpu_data = alloc_xenheap_pages(get_order(NR_CPUS
   57.10 +							 * PERCPU_PAGE_SIZE));
   57.11  #else
   57.12  		cpu_data = __alloc_bootmem(PERCPU_PAGE_SIZE * NR_CPUS,
   57.13  					   PERCPU_PAGE_SIZE, __pa(MAX_DMA_ADDRESS));

    58.1 --- a/xen/arch/ia64/linux-xen/setup.c	Sun Oct 30 13:52:38 2005 +0100
    58.2 +++ b/xen/arch/ia64/linux-xen/setup.c	Sun Oct 30 14:00:35 2005 +0100
    58.3 @@ -366,6 +366,7 @@ check_for_logical_procs (void)
    58.4  }
    58.5  #endif
    58.6  
    58.7 +void __init
    58.8  #ifdef XEN
    58.9  early_setup_arch (char **cmdline_p)
   58.10  #else
   58.11 @@ -377,14 +378,12 @@ setup_arch (char **cmdline_p)
   58.12  	ia64_patch_vtop((u64) __start___vtop_patchlist, (u64) __end___vtop_patchlist);
   58.13  
   58.14  	*cmdline_p = __va(ia64_boot_param->command_line);
   58.15 -#ifdef XEN
   58.16 -	efi_init();
   58.17 -#else
   58.18 +#ifndef XEN
   58.19  	strlcpy(saved_command_line, *cmdline_p, COMMAND_LINE_SIZE);
   58.20 +#endif
   58.21  
   58.22  	efi_init();
   58.23  	io_port_init();
   58.24 -#endif
   58.25  
   58.26  #ifdef CONFIG_IA64_GENERIC
   58.27  	{
   58.28 @@ -414,11 +413,17 @@ setup_arch (char **cmdline_p)
   58.29  #ifdef XEN
   58.30  	early_cmdline_parse(cmdline_p);
   58.31  	cmdline_parse(*cmdline_p);
   58.32 -#undef CONFIG_ACPI_BOOT
   58.33  #endif
   58.34  	if (early_console_setup(*cmdline_p) == 0)
   58.35  		mark_bsp_online();
   58.36  
   58.37 +#ifdef XEN
   58.38 +}
   58.39 +
   58.40 +void __init
   58.41 +late_setup_arch (char **cmdline_p)
   58.42 +{
   58.43 +#endif
   58.44  #ifdef CONFIG_ACPI_BOOT
   58.45  	/* Initialize the ACPI boot-time table parser */
   58.46  	acpi_table_init();
   58.47 @@ -433,20 +438,16 @@ setup_arch (char **cmdline_p)
   58.48  
   58.49  #ifndef XEN
   58.50  	find_memory();
   58.51 -#else
   58.52 -	io_port_init();
   58.53 -}
   58.54 +#endif
   58.55  
   58.56 -void __init
   58.57 -late_setup_arch (char **cmdline_p)
   58.58 -{
   58.59 -#undef CONFIG_ACPI_BOOT
   58.60 -	acpi_table_init();
   58.61 -#endif
   58.62  	/* process SAL system table: */
   58.63  	ia64_sal_init(efi.sal_systab);
   58.64  
   58.65  #ifdef CONFIG_SMP
   58.66 +#ifdef XEN
   58.67 +	init_smp_config ();
   58.68 +#endif
   58.69 +
   58.70  	cpu_physical_id(0) = hard_smp_processor_id();
   58.71  
   58.72  	cpu_set(0, cpu_sibling_map[0]);
   58.73 @@ -768,6 +769,11 @@ cpu_init (void)
   58.74  
   58.75  	cpu_data = per_cpu_init();
   58.76  
   58.77 +#ifdef XEN
   58.78 +	printf ("cpu_init: current=%p, current->domain->arch.mm=%p\n",
   58.79 +		current, current->domain->arch.mm);
   58.80 +#endif
   58.81 +
   58.82  	/*
   58.83  	 * We set ar.k3 so that assembly code in MCA handler can compute
   58.84  	 * physical addresses of per cpu variables with a simple:
   58.85 @@ -887,6 +893,16 @@ cpu_init (void)
   58.86  #ifndef XEN
   58.87  	pm_idle = default_idle;
   58.88  #endif
   58.89 +
   58.90 +#ifdef XEN
   58.91 +    /* surrender usage of kernel registers to domain, use percpu area instead */
   58.92 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_IO_BASE] = ia64_get_kr(IA64_KR_IO_BASE);
   58.93 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_PER_CPU_DATA] = ia64_get_kr(IA64_KR_PER_CPU_DATA);
   58.94 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_CURRENT_STACK] = ia64_get_kr(IA64_KR_CURRENT_STACK);
   58.95 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_FPU_OWNER] = ia64_get_kr(IA64_KR_FPU_OWNER);
   58.96 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_CURRENT] = ia64_get_kr(IA64_KR_CURRENT);
   58.97 +    __get_cpu_var(cpu_kr)._kr[IA64_KR_PT_BASE] = ia64_get_kr(IA64_KR_PT_BASE);
   58.98 +#endif
   58.99  }
  58.100  
  58.101  void

    59.1 --- a/xen/arch/ia64/linux-xen/smp.c	Sun Oct 30 13:52:38 2005 +0100
    59.2 +++ b/xen/arch/ia64/linux-xen/smp.c	Sun Oct 30 14:00:35 2005 +0100
    59.3 @@ -63,9 +63,18 @@ void flush_tlb_mask(cpumask_t mask)
    59.4  //Huh? This seems to be used on ia64 even if !CONFIG_SMP
    59.5  void smp_send_event_check_mask(cpumask_t mask)
    59.6  {
    59.7 -	printf("smp_send_event_check_mask called\n");
    59.8 -	//dummy();
    59.9 -	//send_IPI_mask(cpu_mask, EVENT_CHECK_VECTOR);
   59.10 +    int cpu;
   59.11 +
   59.12 +    /*  Not for me.  */
   59.13 +    cpu_clear(smp_processor_id(), mask);
   59.14 +    if (cpus_empty(mask))
   59.15 +        return;
   59.16 +
   59.17 +    printf("smp_send_event_check_mask called\n");
   59.18 +
   59.19 +    for (cpu = 0; cpu < NR_CPUS; ++cpu)
   59.20 +        if (cpu_isset(cpu, mask))
   59.21 +	    platform_send_ipi(cpu, IA64_IPI_RESCHEDULE, IA64_IPI_DM_INT, 0);
   59.22  }
   59.23  
   59.24  
   59.25 @@ -249,6 +258,7 @@ send_IPI_self (int op)
   59.26  	send_IPI_single(smp_processor_id(), op);
   59.27  }
   59.28  
   59.29 +#ifndef XEN
   59.30  /*
   59.31   * Called with preeemption disabled.
   59.32   */
   59.33 @@ -257,6 +267,7 @@ smp_send_reschedule (int cpu)
   59.34  {
   59.35  	platform_send_ipi(cpu, IA64_IPI_RESCHEDULE, IA64_IPI_DM_INT, 0);
   59.36  }
   59.37 +#endif
   59.38  
   59.39  void
   59.40  smp_flush_tlb_all (void)
   59.41 @@ -395,15 +406,14 @@ smp_call_function (void (*func) (void *i
   59.42  	if (wait)
   59.43  		atomic_set(&data.finished, 0);
   59.44  
   59.45 -	printk("smp_call_function: about to spin_lock \n");
   59.46  	spin_lock(&call_lock);
   59.47 -	printk("smp_call_function: done with spin_lock \n");
   59.48 +#if 0 //def XEN
   59.49 +	printk("smp_call_function: %d lock\n", smp_processor_id ());
   59.50 +#endif
   59.51  
   59.52  	call_data = &data;
   59.53  	mb();	/* ensure store to call_data precedes setting of IPI_CALL_FUNC */
   59.54 -	printk("smp_call_function: about to send_IPI \n");
   59.55  	send_IPI_allbutself(IPI_CALL_FUNC);
   59.56 -	printk("smp_call_function: done with send_IPI \n");
   59.57  
   59.58  	/* Wait for response */
   59.59  	while (atomic_read(&data.started) != cpus)
   59.60 @@ -414,9 +424,10 @@ smp_call_function (void (*func) (void *i
   59.61  			cpu_relax();
   59.62  	call_data = NULL;
   59.63  
   59.64 -	printk("smp_call_function: about to spin_unlock \n");
   59.65  	spin_unlock(&call_lock);
   59.66 +#if 0 //def XEN
   59.67  	printk("smp_call_function: DONE WITH spin_unlock, returning \n");
   59.68 +#endif
   59.69  	return 0;
   59.70  }
   59.71  EXPORT_SYMBOL(smp_call_function);

    60.1 --- a/xen/arch/ia64/linux-xen/smpboot.c	Sun Oct 30 13:52:38 2005 +0100
    60.2 +++ b/xen/arch/ia64/linux-xen/smpboot.c	Sun Oct 30 14:00:35 2005 +0100
    60.3 @@ -477,6 +477,22 @@ do_boot_cpu (int sapicid, int cpu)
    60.4  
    60.5  do_rest:
    60.6  	task_for_booting_cpu = c_idle.idle;
    60.7 +#else
    60.8 +	struct domain *idle;
    60.9 +	struct vcpu *v;
   60.10 +	void *stack;
   60.11 +
   60.12 +	if ( (idle = do_createdomain(IDLE_DOMAIN_ID, cpu)) == NULL )
   60.13 +		panic("failed 'createdomain' for CPU %d", cpu);
   60.14 +	set_bit(_DOMF_idle_domain, &idle->domain_flags);
   60.15 +	v = idle->vcpu[0];
   60.16 +
   60.17 +	printf ("do_boot_cpu: cpu=%d, domain=%p, vcpu=%p\n", cpu, idle, v);
   60.18 +
   60.19 +	task_for_booting_cpu = v;
   60.20 +
   60.21 +	/* Set cpu number.  */
   60.22 +	get_thread_info(v)->cpu = cpu;
   60.23  #endif
   60.24  
   60.25  	Dprintk("Sending wakeup vector %lu to AP 0x%x/0x%x.\n", ap_wakeup_vector, cpu, sapicid);

    61.1 --- a/xen/arch/ia64/vmx/mm.c	Sun Oct 30 13:52:38 2005 +0100
    61.2 +++ b/xen/arch/ia64/vmx/mm.c	Sun Oct 30 14:00:35 2005 +0100
    61.3 @@ -87,7 +87,7 @@
    61.4   */
    61.5  
    61.6  #include <xen/config.h>
    61.7 -#include <public/xen.h>
    61.8 +//#include <public/xen.h>
    61.9  #include <xen/init.h>
   61.10  #include <xen/lib.h>
   61.11  #include <xen/mm.h>

    62.1 --- a/xen/arch/ia64/vmx/vmx_entry.S	Sun Oct 30 13:52:38 2005 +0100
    62.2 +++ b/xen/arch/ia64/vmx/vmx_entry.S	Sun Oct 30 14:00:35 2005 +0100
    62.3 @@ -720,11 +720,11 @@ 1:
    62.4  
    62.5     // re-pin mappings for guest_vhpt
    62.6  
    62.7 -   mov r24=IA64_TR_VHPT
    62.8 +   mov r24=IA64_TR_PERVP_VHPT
    62.9     movl r25=PAGE_KERNEL
   62.10     ;;
   62.11     or loc5 = r25,loc5          // construct PA | page properties
   62.12 -   mov r23 = VCPU_TLB_SHIFT<<2
   62.13 +   mov r23 = IA64_GRANULE_SHIFT <<2
   62.14     ;;
   62.15     ptr.d   in3,r23
   62.16     ;;

    63.1 --- a/xen/arch/ia64/vmx/vmx_hypercall.c	Sun Oct 30 13:52:38 2005 +0100
    63.2 +++ b/xen/arch/ia64/vmx/vmx_hypercall.c	Sun Oct 30 14:00:35 2005 +0100
    63.3 @@ -22,7 +22,7 @@
    63.4  #include <xen/config.h>
    63.5  #include <xen/errno.h>
    63.6  #include <asm/vmx_vcpu.h>
    63.7 -#include <public/xen.h>
    63.8 +//#include <public/xen.h>
    63.9  #include <public/event_channel.h>
   63.10  #include <asm/vmmu.h>
   63.11  #include <asm/tlb.h>

    64.1 --- a/xen/arch/ia64/vmx/vmx_init.c	Sun Oct 30 13:52:38 2005 +0100
    64.2 +++ b/xen/arch/ia64/vmx/vmx_init.c	Sun Oct 30 14:00:35 2005 +0100
    64.3 @@ -47,6 +47,7 @@
    64.4  #include <asm/processor.h>
    64.5  #include <asm/vmx.h>
    64.6  #include <xen/mm.h>
    64.7 +#include <public/arch-ia64.h>
    64.8  
    64.9  /* Global flag to identify whether Intel vmx feature is on */
   64.10  u32 vmx_enabled = 0;
   64.11 @@ -136,39 +137,6 @@ vmx_init_env(void)
   64.12  #endif 
   64.13  }
   64.14  
   64.15 -void vmx_setup_platform(struct vcpu *v, struct vcpu_guest_context *c)
   64.16 -{
   64.17 -	struct domain *d = v->domain;
   64.18 -	shared_iopage_t *sp;
   64.19 -
   64.20 -	ASSERT(d != dom0); /* only for non-privileged vti domain */
   64.21 -	d->arch.vmx_platform.shared_page_va = __va(c->share_io_pg);
   64.22 -	sp = get_sp(d);
   64.23 -	memset((char *)sp,0,PAGE_SIZE);
   64.24 -	/* FIXME: temp due to old CP */
   64.25 -	sp->sp_global.eport = 2;
   64.26 -#ifdef V_IOSAPIC_READY
   64.27 -	sp->vcpu_number = 1;
   64.28 -#endif
   64.29 -	/* TEMP */
   64.30 -	d->arch.vmx_platform.pib_base = 0xfee00000UL;
   64.31 -
   64.32 -	/* One more step to enable interrupt assist */
   64.33 -	set_bit(ARCH_VMX_INTR_ASSIST, &v->arch.arch_vmx.flags);
   64.34 -	/* Only open one port for I/O and interrupt emulation */
   64.35 -	if (v == d->vcpu[0]) {
   64.36 -	    memset(&d->shared_info->evtchn_mask[0], 0xff,
   64.37 -		sizeof(d->shared_info->evtchn_mask));
   64.38 -	    clear_bit(iopacket_port(d), &d->shared_info->evtchn_mask[0]);
   64.39 -	}
   64.40 -
   64.41 -	/* FIXME: only support PMT table continuously by far */
   64.42 -//	d->arch.pmt = __va(c->pt_base);
   64.43 -
   64.44 -
   64.45 -	vmx_final_setup_domain(d);
   64.46 -}
   64.47 -
   64.48  typedef union {
   64.49  	u64 value;
   64.50  	struct {
   64.51 @@ -376,40 +344,6 @@ vmx_final_setup_domain(struct domain *d)
   64.52  	/* Other vmx specific initialization work */
   64.53  }
   64.54  
   64.55 -/*
   64.56 - * Following stuff should really move to domain builder. However currently
   64.57 - * XEN/IA64 doesn't export physical -> machine page table to domain builder,
   64.58 - * instead only the copy. Also there's no hypercall to notify hypervisor
   64.59 - * IO ranges by far. Let's enhance it later.
   64.60 - */
   64.61 -
   64.62 -#define MEM_G   (1UL << 30)	
   64.63 -#define MEM_M   (1UL << 20)	
   64.64 -
   64.65 -#define MMIO_START       (3 * MEM_G)
   64.66 -#define MMIO_SIZE        (512 * MEM_M)
   64.67 -
   64.68 -#define VGA_IO_START     0xA0000UL
   64.69 -#define VGA_IO_SIZE      0x20000
   64.70 -
   64.71 -#define LEGACY_IO_START  (MMIO_START + MMIO_SIZE)
   64.72 -#define LEGACY_IO_SIZE   (64*MEM_M)  
   64.73 -
   64.74 -#define IO_PAGE_START (LEGACY_IO_START + LEGACY_IO_SIZE)
   64.75 -#define IO_PAGE_SIZE  PAGE_SIZE
   64.76 -
   64.77 -#define STORE_PAGE_START (IO_PAGE_START + IO_PAGE_SIZE)
   64.78 -#define STORE_PAGE_SIZE	 PAGE_SIZE
   64.79 -
   64.80 -#define IO_SAPIC_START   0xfec00000UL
   64.81 -#define IO_SAPIC_SIZE    0x100000
   64.82 -
   64.83 -#define PIB_START 0xfee00000UL
   64.84 -#define PIB_SIZE 0x100000 
   64.85 -
   64.86 -#define GFW_START        (4*MEM_G -16*MEM_M)
   64.87 -#define GFW_SIZE         (16*MEM_M)
   64.88 -
   64.89  typedef struct io_range {
   64.90  	unsigned long start;
   64.91  	unsigned long size;
   64.92 @@ -424,18 +358,26 @@ io_range_t io_ranges[] = {
   64.93  	{PIB_START, PIB_SIZE, GPFN_PIB},
   64.94  };
   64.95  
   64.96 -#define VMX_SYS_PAGES	(2 + GFW_SIZE >> PAGE_SHIFT)
   64.97 +#define VMX_SYS_PAGES	(2 + (GFW_SIZE >> PAGE_SHIFT))
   64.98  #define VMX_CONFIG_PAGES(d) ((d)->max_pages - VMX_SYS_PAGES)
   64.99  
  64.100  int vmx_alloc_contig_pages(struct domain *d)
  64.101  {
  64.102 -	unsigned int order, i, j;
  64.103 -	unsigned long start, end, pgnr, conf_nr;
  64.104 +	unsigned int order;
  64.105 +	unsigned long i, j, start, end, pgnr, conf_nr;
  64.106  	struct pfn_info *page;
  64.107  	struct vcpu *v = d->vcpu[0];
  64.108  
  64.109  	ASSERT(!test_bit(ARCH_VMX_CONTIG_MEM, &v->arch.arch_vmx.flags));
  64.110  
  64.111 +	/* Mark I/O ranges */
  64.112 +	for (i = 0; i < (sizeof(io_ranges) / sizeof(io_range_t)); i++) {
  64.113 +	    for (j = io_ranges[i].start;
  64.114 +		 j < io_ranges[i].start + io_ranges[i].size;
  64.115 +		 j += PAGE_SIZE)
  64.116 +		map_domain_page(d, j, io_ranges[i].type);
  64.117 +	}
  64.118 +
  64.119  	conf_nr = VMX_CONFIG_PAGES(d);
  64.120  	order = get_order_from_pages(conf_nr);
  64.121  	if (unlikely((page = alloc_domheap_pages(d, order, 0)) == NULL)) {
  64.122 @@ -462,32 +404,64 @@ int vmx_alloc_contig_pages(struct domain
  64.123  
  64.124  	d->arch.max_pfn = end >> PAGE_SHIFT;
  64.125  
  64.126 -	order = get_order_from_pages(VMX_SYS_PAGES);
  64.127 +	order = get_order_from_pages(GFW_SIZE >> PAGE_SHIFT);
  64.128  	if (unlikely((page = alloc_domheap_pages(d, order, 0)) == NULL)) {
  64.129  	    printk("Could not allocate order=%d pages for vmx contig alloc\n",
  64.130  			order);
  64.131  	    return -1;
  64.132  	}
  64.133  
  64.134 +	/* Map guest firmware */
  64.135 +	pgnr = page_to_pfn(page);
  64.136 +	for (i = GFW_START; i < GFW_START + GFW_SIZE; i += PAGE_SIZE, pgnr++)
  64.137 +	    map_domain_page(d, i, pgnr << PAGE_SHIFT);
  64.138 +
  64.139 +	if (unlikely((page = alloc_domheap_pages(d, 1, 0)) == NULL)) {
  64.140 +	    printk("Could not allocate order=1 pages for vmx contig alloc\n");
  64.141 +	    return -1;
  64.142 +	}
  64.143 +
  64.144  	/* Map for shared I/O page and xenstore */
  64.145  	pgnr = page_to_pfn(page);
  64.146  	map_domain_page(d, IO_PAGE_START, pgnr << PAGE_SHIFT);
  64.147  	pgnr++;
  64.148  	map_domain_page(d, STORE_PAGE_START, pgnr << PAGE_SHIFT);
  64.149 -	pgnr++;
  64.150 -
  64.151 -	/* Map guest firmware */
  64.152 -	for (i = GFW_START; i < GFW_START + GFW_SIZE; i += PAGE_SIZE, pgnr++)
  64.153 -	    map_domain_page(d, i, pgnr << PAGE_SHIFT);
  64.154 -
  64.155 -	/* Mark I/O ranges */
  64.156 -	for (i = 0; i < (sizeof(io_ranges) / sizeof(io_range_t)); i++) {
  64.157 -	    for (j = io_ranges[i].start;
  64.158 -		 j < io_ranges[i].start + io_ranges[i].size;
  64.159 -		 j += PAGE_SIZE)
  64.160 -		map_domain_page(d, j, io_ranges[i].type);
  64.161 -	}
  64.162  
  64.163  	set_bit(ARCH_VMX_CONTIG_MEM, &v->arch.arch_vmx.flags);
  64.164  	return 0;
  64.165  }
  64.166 +
  64.167 +void vmx_setup_platform(struct vcpu *v, struct vcpu_guest_context *c)
  64.168 +{
  64.169 +	struct domain *d = v->domain;
  64.170 +	shared_iopage_t *sp;
  64.171 +
  64.172 +	ASSERT(d != dom0); /* only for non-privileged vti domain */
  64.173 +	d->arch.vmx_platform.shared_page_va =
  64.174 +		__va(__gpa_to_mpa(d, IO_PAGE_START));
  64.175 +	sp = get_sp(d);
  64.176 +	//memset((char *)sp,0,PAGE_SIZE);
  64.177 +	//sp->sp_global.eport = 2;
  64.178 +#ifdef V_IOSAPIC_READY
  64.179 +	sp->vcpu_number = 1;
  64.180 +#endif
  64.181 +	/* TEMP */
  64.182 +	d->arch.vmx_platform.pib_base = 0xfee00000UL;
  64.183 +
  64.184 +	/* One more step to enable interrupt assist */
  64.185 +	set_bit(ARCH_VMX_INTR_ASSIST, &v->arch.arch_vmx.flags);
  64.186 +	/* Only open one port for I/O and interrupt emulation */
  64.187 +	if (v == d->vcpu[0]) {
  64.188 +	    memset(&d->shared_info->evtchn_mask[0], 0xff,
  64.189 +		sizeof(d->shared_info->evtchn_mask));
  64.190 +	    clear_bit(iopacket_port(d), &d->shared_info->evtchn_mask[0]);
  64.191 +	}
  64.192 +
  64.193 +	/* FIXME: only support PMT table continuously by far */
  64.194 +//	d->arch.pmt = __va(c->pt_base);
  64.195 +
  64.196 +
  64.197 +	vmx_final_setup_domain(d);
  64.198 +}
  64.199 +
  64.200 +

    65.1 --- a/xen/arch/ia64/vmx/vmx_irq_ia64.c	Sun Oct 30 13:52:38 2005 +0100
    65.2 +++ b/xen/arch/ia64/vmx/vmx_irq_ia64.c	Sun Oct 30 14:00:35 2005 +0100
    65.3 @@ -101,7 +101,10 @@ vmx_ia64_handle_irq (ia64_vector vector,
    65.4  
    65.5  		if (vector != IA64_TIMER_VECTOR) {
    65.6  			/* FIXME: Leave IRQ re-route later */
    65.7 -			vmx_vcpu_pend_interrupt(dom0->vcpu[0],vector);
    65.8 +			if (!VMX_DOMAIN(dom0->vcpu[0]))
    65.9 +				vcpu_pend_interrupt(dom0->vcpu[0],vector);
   65.10 +			else
   65.11 +				vmx_vcpu_pend_interrupt(dom0->vcpu[0],vector);
   65.12  			wake_dom0 = 1;
   65.13  		}
   65.14  		else {	// FIXME: Handle Timer only now

    66.1 --- a/xen/arch/ia64/vmx/vmx_phy_mode.c	Sun Oct 30 13:52:38 2005 +0100
    66.2 +++ b/xen/arch/ia64/vmx/vmx_phy_mode.c	Sun Oct 30 14:00:35 2005 +0100
    66.3 @@ -157,13 +157,6 @@ physical_itlb_miss_domn(VCPU *vcpu, u64 
    66.4  #endif
    66.5  
    66.6  void
    66.7 -physical_itlb_miss(VCPU *vcpu, u64 vadr)
    66.8 -{
    66.9 -        physical_itlb_miss_dom0(vcpu, vadr);
   66.10 -}
   66.11 -
   66.12 -
   66.13 -void
   66.14  physical_itlb_miss_dom0(VCPU *vcpu, u64 vadr)
   66.15  {
   66.16      u64 psr;
   66.17 @@ -187,6 +180,13 @@ physical_itlb_miss_dom0(VCPU *vcpu, u64 
   66.18  
   66.19  
   66.20  void
   66.21 +physical_itlb_miss(VCPU *vcpu, u64 vadr)
   66.22 +{
   66.23 +        physical_itlb_miss_dom0(vcpu, vadr);
   66.24 +}
   66.25 +
   66.26 +
   66.27 +void
   66.28  physical_dtlb_miss(VCPU *vcpu, u64 vadr)
   66.29  {
   66.30      u64 psr;

    67.1 --- a/xen/arch/ia64/vmx/vmx_process.c	Sun Oct 30 13:52:38 2005 +0100
    67.2 +++ b/xen/arch/ia64/vmx/vmx_process.c	Sun Oct 30 14:00:35 2005 +0100
    67.3 @@ -56,6 +56,38 @@ extern struct ia64_sal_retval pal_emulat
    67.4  extern struct ia64_sal_retval sal_emulator(UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64);
    67.5  extern void rnat_consumption (VCPU *vcpu);
    67.6  #define DOMN_PAL_REQUEST    0x110000
    67.7 +
    67.8 +static UINT64 vec2off[68] = {0x0,0x400,0x800,0xc00,0x1000, 0x1400,0x1800,
    67.9 +    0x1c00,0x2000,0x2400,0x2800,0x2c00,0x3000,0x3400,0x3800,0x3c00,0x4000,
   67.10 +    0x4400,0x4800,0x4c00,0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,
   67.11 +    0x5700,0x5800,0x5900,0x5a00,0x5b00,0x5c00,0x5d00,0x5e00,0x5f00,0x6000,
   67.12 +    0x6100,0x6200,0x6300,0x6400,0x6500,0x6600,0x6700,0x6800,0x6900,0x6a00,
   67.13 +    0x6b00,0x6c00,0x6d00,0x6e00,0x6f00,0x7000,0x7100,0x7200,0x7300,0x7400,
   67.14 +    0x7500,0x7600,0x7700,0x7800,0x7900,0x7a00,0x7b00,0x7c00,0x7d00,0x7e00,
   67.15 +    0x7f00,
   67.16 +};
   67.17 +
   67.18 +
   67.19 +
   67.20 +void vmx_reflect_interruption(UINT64 ifa,UINT64 isr,UINT64 iim,
   67.21 +     UINT64 vector,REGS *regs)
   67.22 +{
   67.23 +    VCPU *vcpu = current;
   67.24 +    UINT64 viha,vpsr = vmx_vcpu_get_psr(vcpu);
   67.25 +    if(!(vpsr&IA64_PSR_IC)&&(vector!=5)){
   67.26 +        panic("Guest nested fault!");
   67.27 +    }
   67.28 +    VCPU(vcpu,isr)=isr;
   67.29 +    VCPU(vcpu,iipa) = regs->cr_iip;
   67.30 +    vector=vec2off[vector];
   67.31 +    if (vector == IA64_BREAK_VECTOR || vector == IA64_SPECULATION_VECTOR)
   67.32 +        VCPU(vcpu,iim) = iim;
   67.33 +    else {
   67.34 +        set_ifa_itir_iha(vcpu,ifa,1,1,1);
   67.35 +    }
   67.36 +    inject_guest_interruption(vcpu, vector);
   67.37 +}
   67.38 +
   67.39  IA64FAULT
   67.40  vmx_ia64_handle_break (unsigned long ifa, struct pt_regs *regs, unsigned long isr, unsigned long iim)
   67.41  {
   67.42 @@ -157,37 +189,6 @@ vmx_ia64_handle_break (unsigned long ifa
   67.43  		vmx_reflect_interruption(ifa,isr,iim,11,regs);
   67.44  }
   67.45  
   67.46 -static UINT64 vec2off[68] = {0x0,0x400,0x800,0xc00,0x1000, 0x1400,0x1800,
   67.47 -    0x1c00,0x2000,0x2400,0x2800,0x2c00,0x3000,0x3400,0x3800,0x3c00,0x4000,
   67.48 -    0x4400,0x4800,0x4c00,0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,
   67.49 -    0x5700,0x5800,0x5900,0x5a00,0x5b00,0x5c00,0x5d00,0x5e00,0x5f00,0x6000,
   67.50 -    0x6100,0x6200,0x6300,0x6400,0x6500,0x6600,0x6700,0x6800,0x6900,0x6a00,
   67.51 -    0x6b00,0x6c00,0x6d00,0x6e00,0x6f00,0x7000,0x7100,0x7200,0x7300,0x7400,
   67.52 -    0x7500,0x7600,0x7700,0x7800,0x7900,0x7a00,0x7b00,0x7c00,0x7d00,0x7e00,
   67.53 -    0x7f00,
   67.54 -};
   67.55 -
   67.56 -
   67.57 -
   67.58 -void vmx_reflect_interruption(UINT64 ifa,UINT64 isr,UINT64 iim,
   67.59 -     UINT64 vector,REGS *regs)
   67.60 -{
   67.61 -    VCPU *vcpu = current;
   67.62 -    UINT64 viha,vpsr = vmx_vcpu_get_psr(vcpu);
   67.63 -    if(!(vpsr&IA64_PSR_IC)&&(vector!=5)){
   67.64 -        panic("Guest nested fault!");
   67.65 -    }
   67.66 -    VCPU(vcpu,isr)=isr;
   67.67 -    VCPU(vcpu,iipa) = regs->cr_iip;
   67.68 -    vector=vec2off[vector];
   67.69 -    if (vector == IA64_BREAK_VECTOR || vector == IA64_SPECULATION_VECTOR)
   67.70 -        VCPU(vcpu,iim) = iim;
   67.71 -    else {
   67.72 -        set_ifa_itir_iha(vcpu,ifa,1,1,1);
   67.73 -    }
   67.74 -    inject_guest_interruption(vcpu, vector);
   67.75 -}
   67.76 -
   67.77  
   67.78  void save_banked_regs_to_vpd(VCPU *v, REGS *regs)
   67.79  {
   67.80 @@ -271,10 +272,10 @@ void vmx_hpw_miss(u64 vadr , u64 vec, RE
   67.81  {
   67.82      IA64_PSR vpsr;
   67.83      CACHE_LINE_TYPE type;
   67.84 -    u64 vhpt_adr;
   67.85 +    u64 vhpt_adr, gppa;
   67.86      ISR misr;
   67.87      ia64_rr vrr;
   67.88 -    REGS *regs;
   67.89 +//    REGS *regs;
   67.90      thash_cb_t *vtlb, *vhpt;
   67.91      thash_data_t *data, me;
   67.92      VCPU *v = current;
   67.93 @@ -314,9 +315,9 @@ void vmx_hpw_miss(u64 vadr , u64 vec, RE
   67.94  //    prepare_if_physical_mode(v);
   67.95  
   67.96      if(data=vtlb_lookup_ex(vtlb, vrr.rid, vadr,type)){
   67.97 -        if(v->domain!=dom0&&type==DSIDE_TLB && __gpfn_is_io(v->domain,data->ppn>>(PAGE_SHIFT-12))){
   67.98 -            vadr=(vadr&((1UL<<data->ps)-1))+(data->ppn>>(data->ps-12)<<data->ps);
   67.99 -            emulate_io_inst(v, vadr, data->ma);
  67.100 +	gppa = (vadr&((1UL<<data->ps)-1))+(data->ppn>>(data->ps-12)<<data->ps);
  67.101 +        if(v->domain!=dom0&&type==DSIDE_TLB && __gpfn_is_io(v->domain,gppa>>PAGE_SHIFT)){
  67.102 +            emulate_io_inst(v, gppa, data->ma);
  67.103              return IA64_FAULT;
  67.104          }
  67.105  

    68.1 --- a/xen/arch/ia64/vmx/vmx_support.c	Sun Oct 30 13:52:38 2005 +0100
    68.2 +++ b/xen/arch/ia64/vmx/vmx_support.c	Sun Oct 30 14:00:35 2005 +0100
    68.3 @@ -158,7 +158,7 @@ void vmx_intr_assist(struct vcpu *v)
    68.4  #ifdef V_IOSAPIC_READY
    68.5      vlapic_update_ext_irq(v);
    68.6  #else
    68.7 -    panic("IOSAPIC model is missed in qemu\n");
    68.8 +    //panic("IOSAPIC model is missed in qemu\n");
    68.9  #endif
   68.10      return;
   68.11  }

    69.1 --- a/xen/arch/ia64/vmx/vtlb.c	Sun Oct 30 13:52:38 2005 +0100
    69.2 +++ b/xen/arch/ia64/vmx/vtlb.c	Sun Oct 30 14:00:35 2005 +0100
    69.3 @@ -387,6 +387,15 @@ void vtlb_insert(thash_cb_t *hcb, thash_
    69.4         thash_insert(hcb->ts->vhpt, entry, va);
    69.5          return;
    69.6      }
    69.7 +
    69.8 +#if 1
    69.9 +    vrr=vmx_vcpu_rr(current, va);
   69.10 +    if (vrr.ps != entry->ps) {
   69.11 +	printk("not preferred ps with va: 0x%lx\n", va);
   69.12 +	return;
   69.13 +    }
   69.14 +#endif 
   69.15 +
   69.16      flag = 1;
   69.17      gppn = (POFFSET(va,entry->ps)|PAGEALIGN((entry->ppn<<12),entry->ps))>>PAGE_SHIFT;
   69.18      ppns = PAGEALIGN((entry->ppn<<12),entry->ps);

    70.1 --- a/xen/arch/ia64/xen/acpi.c	Sun Oct 30 13:52:38 2005 +0100
    70.2 +++ b/xen/arch/ia64/xen/acpi.c	Sun Oct 30 14:00:35 2005 +0100
    70.3 @@ -121,6 +121,7 @@ acpi_get_sysname (void)
    70.4  #ifdef CONFIG_ACPI_BOOT
    70.5  
    70.6  #define ACPI_MAX_PLATFORM_INTERRUPTS	256
    70.7 +#define NR_IOSAPICS 4
    70.8  
    70.9  #if 0
   70.10  /* Array to record platform interrupt vectors for generic interrupt routing. */
   70.11 @@ -162,7 +163,6 @@ static int			available_cpus __initdata;
   70.12  struct acpi_table_madt *	acpi_madt __initdata;
   70.13  static u8			has_8259;
   70.14  
   70.15 -#if 0
   70.16  static int __init
   70.17  acpi_parse_lapic_addr_ovr (
   70.18  	acpi_table_entry_header *header, const unsigned long end)
   70.19 @@ -247,12 +247,13 @@ acpi_parse_iosapic (acpi_table_entry_hea
   70.20  
   70.21  	acpi_table_print_madt_entry(header);
   70.22  
   70.23 +#if 0
   70.24  	iosapic_init(iosapic->address, iosapic->global_irq_base);
   70.25 +#endif
   70.26  
   70.27  	return 0;
   70.28  }
   70.29  
   70.30 -
   70.31  static int __init
   70.32  acpi_parse_plat_int_src (
   70.33  	acpi_table_entry_header *header, const unsigned long end)
   70.34 @@ -267,6 +268,7 @@ acpi_parse_plat_int_src (
   70.35  
   70.36  	acpi_table_print_madt_entry(header);
   70.37  
   70.38 +#if 0
   70.39  	/*
   70.40  	 * Get vector assignment for this interrupt, set attributes,
   70.41  	 * and program the IOSAPIC routing table.
   70.42 @@ -280,6 +282,7 @@ acpi_parse_plat_int_src (
   70.43  						(plintsrc->flags.trigger == 1) ? IOSAPIC_EDGE : IOSAPIC_LEVEL);
   70.44  
   70.45  	platform_intr_list[plintsrc->type] = vector;
   70.46 +#endif
   70.47  	return 0;
   70.48  }
   70.49  
   70.50 @@ -297,13 +300,14 @@ acpi_parse_int_src_ovr (
   70.51  
   70.52  	acpi_table_print_madt_entry(header);
   70.53  
   70.54 +#if 0
   70.55  	iosapic_override_isa_irq(p->bus_irq, p->global_irq,
   70.56  				 (p->flags.polarity == 1) ? IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
   70.57  				 (p->flags.trigger == 1) ? IOSAPIC_EDGE : IOSAPIC_LEVEL);
   70.58 +#endif
   70.59  	return 0;
   70.60  }
   70.61  
   70.62 -
   70.63  static int __init
   70.64  acpi_parse_nmi_src (acpi_table_entry_header *header, const unsigned long end)
   70.65  {
   70.66 @@ -331,8 +335,10 @@ void __init acpi_madt_oem_check(char *oe
   70.67  		 */
   70.68  		sal_platform_features |= IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT;
   70.69  
   70.70 +#if 0
   70.71  		/*Start cyclone clock*/
   70.72  		cyclone_setup(0);
   70.73 +#endif
   70.74  	}
   70.75  }
   70.76  
   70.77 @@ -350,7 +356,9 @@ acpi_parse_madt (unsigned long phys_addr
   70.78  #else
   70.79  	has_8259 = acpi_madt->flags.pcat_compat;
   70.80  #endif
   70.81 +#if 0
   70.82  	iosapic_system_init(has_8259);
   70.83 +#endif
   70.84  
   70.85  	/* Get base address of IPI Message Block */
   70.86  
   70.87 @@ -364,7 +372,6 @@ acpi_parse_madt (unsigned long phys_addr
   70.88  
   70.89  	return 0;
   70.90  }
   70.91 -#endif
   70.92  
   70.93  #ifdef CONFIG_ACPI_NUMA
   70.94  
   70.95 @@ -529,6 +536,7 @@ acpi_register_gsi (u32 gsi, int polarity
   70.96  	return acpi_register_irq(gsi, polarity, trigger);
   70.97  }
   70.98  EXPORT_SYMBOL(acpi_register_gsi);
   70.99 +#endif
  70.100  static int __init
  70.101  acpi_parse_fadt (unsigned long phys_addr, unsigned long size)
  70.102  {
  70.103 @@ -550,10 +558,11 @@ acpi_parse_fadt (unsigned long phys_addr
  70.104  	if (fadt->iapc_boot_arch & BAF_LEGACY_DEVICES)
  70.105  		acpi_legacy_devices = 1;
  70.106  
  70.107 +#if 0
  70.108  	acpi_register_gsi(fadt->sci_int, ACPI_ACTIVE_LOW, ACPI_LEVEL_SENSITIVE);
  70.109 +#endif
  70.110  	return 0;
  70.111  }
  70.112 -#endif
  70.113  
  70.114  unsigned long __init
  70.115  acpi_find_rsdp (void)
  70.116 @@ -567,7 +576,6 @@ acpi_find_rsdp (void)
  70.117  	return rsdp_phys;
  70.118  }
  70.119  
  70.120 -#if 0
  70.121  int __init
  70.122  acpi_boot_init (void)
  70.123  {
  70.124 @@ -646,6 +654,7 @@ acpi_boot_init (void)
  70.125  	printk(KERN_INFO "%d CPUs available, %d CPUs total\n", available_cpus, total_cpus);
  70.126  	return 0;
  70.127  }
  70.128 +#if 0
  70.129  int
  70.130  acpi_gsi_to_irq (u32 gsi, unsigned int *irq)
  70.131  {

    71.1 --- a/xen/arch/ia64/xen/dom0_ops.c	Sun Oct 30 13:52:38 2005 +0100
    71.2 +++ b/xen/arch/ia64/xen/dom0_ops.c	Sun Oct 30 14:00:35 2005 +0100
    71.3 @@ -177,13 +177,8 @@ long arch_do_dom0_op(dom0_op_t *op, dom0
    71.4  
    71.5              for ( i = start_page; i < (start_page + nr_pages); i++ )
    71.6              {
    71.7 -                page = map_new_domain_page(d, i << PAGE_SHIFT);
    71.8 -                if ( page == NULL )
    71.9 -                {
   71.10 -                    ret = -ENOMEM;
   71.11 -                    break;
   71.12 -                }
   71.13 -                pfn = page_to_pfn(page);
   71.14 +		pfn = __gpfn_to_mfn_foreign(d, i);
   71.15 +
   71.16                  if ( put_user(pfn, buffer) )
   71.17                  {
   71.18                      ret = -EFAULT;

    72.1 --- a/xen/arch/ia64/xen/dom_fw.c	Sun Oct 30 13:52:38 2005 +0100
    72.2 +++ b/xen/arch/ia64/xen/dom_fw.c	Sun Oct 30 14:00:35 2005 +0100
    72.3 @@ -301,7 +301,7 @@ xen_pal_emulator(unsigned long index, un
    72.4  	// pal code must be mapped by a TR when pal is called, however
    72.5  	// calls are rare enough that we will map it lazily rather than
    72.6  	// at every context switch
    72.7 -	efi_map_pal_code();
    72.8 +	//efi_map_pal_code();
    72.9  	switch (index) {
   72.10  	    case PAL_MEM_ATTRIB:
   72.11  		status = ia64_pal_mem_attrib(&r9);

    73.1 --- a/xen/arch/ia64/xen/domain.c	Sun Oct 30 13:52:38 2005 +0100
    73.2 +++ b/xen/arch/ia64/xen/domain.c	Sun Oct 30 14:00:35 2005 +0100
    73.3 @@ -23,11 +23,13 @@
    73.4  #include <asm/io.h>
    73.5  #include <asm/processor.h>
    73.6  #include <asm/desc.h>
    73.7 +#include <asm/hw_irq.h>
    73.8  //#include <asm/mpspec.h>
    73.9  #include <xen/irq.h>
   73.10  #include <xen/event.h>
   73.11  //#include <xen/shadow.h>
   73.12  #include <xen/console.h>
   73.13 +#include <xen/compile.h>
   73.14  
   73.15  #include <xen/elf.h>
   73.16  //#include <asm/page.h>
   73.17 @@ -58,6 +60,7 @@ unsigned long *domU_staging_area;
   73.18  
   73.19  // initialized by arch/ia64/setup.c:find_initrd()
   73.20  unsigned long initrd_start = 0, initrd_end = 0;
   73.21 +extern unsigned long running_on_sim;
   73.22  
   73.23  #define IS_XEN_ADDRESS(d,a) ((a >= d->xen_vastart) && (a <= d->xen_vaend))
   73.24  
   73.25 @@ -75,35 +78,21 @@ void free_perdomain_pt(struct domain *d)
   73.26  	//free_page((unsigned long)d->mm.perdomain_pt);
   73.27  }
   73.28  
   73.29 -int hlt_counter;
   73.30 -
   73.31 -void disable_hlt(void)
   73.32 +static void default_idle(void)
   73.33  {
   73.34 -	hlt_counter++;
   73.35 -}
   73.36 -
   73.37 -void enable_hlt(void)
   73.38 -{
   73.39 -	hlt_counter--;
   73.40 +	int cpu = smp_processor_id();
   73.41 +	local_irq_disable();
   73.42 +	if ( !softirq_pending(cpu))
   73.43 +	        safe_halt();
   73.44 +	local_irq_enable();
   73.45  }
   73.46  
   73.47 -static void default_idle(void)
   73.48 -{
   73.49 -	if ( hlt_counter == 0 )
   73.50 -	{
   73.51 -	local_irq_disable();
   73.52 -	    if ( !softirq_pending(smp_processor_id()) )
   73.53 -	        safe_halt();
   73.54 -	    //else
   73.55 -		local_irq_enable();
   73.56 -	}
   73.57 -}
   73.58 -
   73.59 -void continue_cpu_idle_loop(void)
   73.60 +static void continue_cpu_idle_loop(void)
   73.61  {
   73.62  	int cpu = smp_processor_id();
   73.63  	for ( ; ; )
   73.64  	{
   73.65 +	printf ("idle%dD\n", cpu);
   73.66  #ifdef IA64
   73.67  //        __IRQ_STAT(cpu, idle_timestamp) = jiffies
   73.68  #else
   73.69 @@ -111,23 +100,32 @@ void continue_cpu_idle_loop(void)
   73.70  #endif
   73.71  	    while ( !softirq_pending(cpu) )
   73.72  	        default_idle();
   73.73 +	    add_preempt_count(SOFTIRQ_OFFSET);
   73.74  	    raise_softirq(SCHEDULE_SOFTIRQ);
   73.75  	    do_softirq();
   73.76 +	    sub_preempt_count(SOFTIRQ_OFFSET);
   73.77  	}
   73.78  }
   73.79  
   73.80  void startup_cpu_idle_loop(void)
   73.81  {
   73.82 +	int cpu = smp_processor_id ();
   73.83  	/* Just some sanity to ensure that the scheduler is set up okay. */
   73.84  	ASSERT(current->domain == IDLE_DOMAIN_ID);
   73.85 +	printf ("idle%dA\n", cpu);
   73.86  	raise_softirq(SCHEDULE_SOFTIRQ);
   73.87 +#if 0   /* All this work is done within continue_cpu_idle_loop  */
   73.88 +	printf ("idle%dB\n", cpu);
   73.89 +	asm volatile ("mov ar.k2=r0");
   73.90  	do_softirq();
   73.91 +	printf ("idle%dC\n", cpu);
   73.92  
   73.93  	/*
   73.94  	 * Declares CPU setup done to the boot processor.
   73.95  	 * Therefore memory barrier to ensure state is visible.
   73.96  	 */
   73.97  	smp_mb();
   73.98 +#endif
   73.99  #if 0
  73.100  //do we have to ensure the idle task has a shared page so that, for example,
  73.101  //region registers can be loaded from it.  Apparently not...
  73.102 @@ -204,6 +202,15 @@ void arch_do_createdomain(struct vcpu *v
  73.103     		while (1);
  73.104  	}
  73.105  	memset(d->shared_info, 0, PAGE_SIZE);
  73.106 +	if (v == d->vcpu[0])
  73.107 +	    memset(&d->shared_info->evtchn_mask[0], 0xff,
  73.108 +		sizeof(d->shared_info->evtchn_mask));
  73.109 +#if 0
  73.110 +	d->vcpu[0].arch.privregs = 
  73.111 +			alloc_xenheap_pages(get_order(sizeof(mapped_regs_t)));
  73.112 +	printf("arch_vcpu_info=%p\n", d->vcpu[0].arch.privregs);
  73.113 +	memset(d->vcpu.arch.privregs, 0, PAGE_SIZE);
  73.114 +#endif
  73.115  	v->vcpu_info = &(d->shared_info->vcpu_data[0]);
  73.116  
  73.117  	d->max_pages = (128UL*1024*1024)/PAGE_SIZE; // 128MB default // FIXME
  73.118 @@ -233,17 +240,21 @@ void arch_do_createdomain(struct vcpu *v
  73.119  	v->arch.breakimm = d->arch.breakimm;
  73.120  
  73.121  	d->arch.sys_pgnr = 0;
  73.122 -	d->arch.mm = xmalloc(struct mm_struct);
  73.123 -	if (unlikely(!d->arch.mm)) {
  73.124 -		printk("Can't allocate mm_struct for domain %d\n",d->domain_id);
  73.125 -		return -ENOMEM;
  73.126 -	}
  73.127 -	memset(d->arch.mm, 0, sizeof(*d->arch.mm));
  73.128 -	d->arch.mm->pgd = pgd_alloc(d->arch.mm);
  73.129 -	if (unlikely(!d->arch.mm->pgd)) {
  73.130 -		printk("Can't allocate pgd for domain %d\n",d->domain_id);
  73.131 -		return -ENOMEM;
  73.132 -	}
  73.133 +	if (d->domain_id != IDLE_DOMAIN_ID) {
  73.134 +		d->arch.mm = xmalloc(struct mm_struct);
  73.135 +		if (unlikely(!d->arch.mm)) {
  73.136 +			printk("Can't allocate mm_struct for domain %d\n",d->domain_id);
  73.137 +			return -ENOMEM;
  73.138 +		}
  73.139 +		memset(d->arch.mm, 0, sizeof(*d->arch.mm));
  73.140 +		d->arch.mm->pgd = pgd_alloc(d->arch.mm);
  73.141 +		if (unlikely(!d->arch.mm->pgd)) {
  73.142 +			printk("Can't allocate pgd for domain %d\n",d->domain_id);
  73.143 +			return -ENOMEM;
  73.144 +		}
  73.145 +	} else
  73.146 + 		d->arch.mm = NULL;
  73.147 + 	printf ("arch_do_create_domain: domain=%p\n", d);
  73.148  }
  73.149  
  73.150  void arch_getdomaininfo_ctxt(struct vcpu *v, struct vcpu_guest_context *c)
  73.151 @@ -268,6 +279,14 @@ int arch_set_info_guest(struct vcpu *v, 
  73.152  	if ( test_bit(_VCPUF_initialised, &v->vcpu_flags) )
  73.153              return 0;
  73.154  
  73.155 +	/* Sync d/i cache conservatively */
  73.156 +	if (!running_on_sim) {
  73.157 +	    ret = ia64_pal_cache_flush(4, 0, &progress, NULL);
  73.158 +	    if (ret != PAL_STATUS_SUCCESS)
  73.159 +	        panic("PAL CACHE FLUSH failed for domain.\n");
  73.160 +	    printk("Sync i/d cache for dom0 image SUCC\n");
  73.161 +	}
  73.162 +
  73.163  	if (c->flags & VGCF_VMX_GUEST) {
  73.164  	    if (!vmx_enabled) {
  73.165  		printk("No VMX hardware feature for vmx domain.\n");
  73.166 @@ -527,7 +546,8 @@ tryagain:
  73.167  				if (pte_present(*pte)) {
  73.168  //printk("lookup_domain_page: found mapping for %lx, pte=%lx\n",mpaddr,pte_val(*pte));
  73.169  					return *(unsigned long *)pte;
  73.170 -				}
  73.171 +				} else if (VMX_DOMAIN(d->vcpu[0]))
  73.172 +					return GPFN_INV_MASK;
  73.173  			}
  73.174  		}
  73.175  	}
  73.176 @@ -779,7 +799,6 @@ void physdev_init_dom0(struct domain *d)
  73.177  	set_bit(_DOMF_physdev_access, &d->domain_flags);
  73.178  }
  73.179  
  73.180 -extern unsigned long running_on_sim;
  73.181  unsigned int vmx_dom0 = 0;
  73.182  int construct_dom0(struct domain *d, 
  73.183  	               unsigned long image_start, unsigned long image_len, 
  73.184 @@ -930,6 +949,7 @@ int construct_dom0(struct domain *d,
  73.185  	si = (start_info_t *)alloc_xenheap_page();
  73.186  	memset(si, 0, PAGE_SIZE);
  73.187  	d->shared_info->arch.start_info_pfn = __pa(si) >> PAGE_SHIFT;
  73.188 +	sprintf(si->magic, "Xen-%i.%i", XEN_VERSION, XEN_SUBVERSION);
  73.189  
  73.190  #if 0
  73.191  	si->nr_pages     = d->tot_pages;

    74.1 --- a/xen/arch/ia64/xen/hyperprivop.S	Sun Oct 30 13:52:38 2005 +0100
    74.2 +++ b/xen/arch/ia64/xen/hyperprivop.S	Sun Oct 30 14:00:35 2005 +0100
    74.3 @@ -14,6 +14,10 @@
    74.4  #include <asm/system.h>
    74.5  #include <public/arch-ia64.h>
    74.6  
    74.7 +#define	_PAGE_PPN_MASK	0x0003fffffffff000 //asm/pgtable.h doesn't do assembly
    74.8 +#define PAGE_PHYS	0x0010000000000761 //__pgprot(__DIRTY_BITS|_PAGE_PL_2|_PAGE_AR_RWX)
    74.9 +#define _PAGE_PL_2	(2<<7)
   74.10 +
   74.11  #if 1	 // change to 0 to turn off all fast paths
   74.12  #define FAST_HYPERPRIVOPS
   74.13  #define FAST_HYPERPRIVOP_CNT
   74.14 @@ -24,6 +28,7 @@
   74.15  #define FAST_RFI
   74.16  #define FAST_SSM_I
   74.17  #define FAST_PTC_GA
   74.18 +#undef FAST_ITC	// working but default off for now
   74.19  #undef RFI_TO_INTERRUPT // not working yet
   74.20  #endif
   74.21  
   74.22 @@ -802,8 +807,11 @@ just_do_rfi:
   74.23  	// OK, now all set to go except for switch to virtual bank1
   74.24  	mov r22=1;; st4 [r20]=r22;
   74.25  	mov r30=r2; mov r29=r3;;
   74.26 +    adds r16=XSI_B1NATS_OFS-XSI_PSR_IC_OFS,r18
   74.27  	adds r2=XSI_BANK1_OFS-XSI_PSR_IC_OFS,r18;
   74.28  	adds r3=(XSI_BANK1_OFS+8)-XSI_PSR_IC_OFS,r18;;
   74.29 +    ld8 r16=[r16];;
   74.30 +    mov ar.unat=r16;;
   74.31  	bsw.1;;
   74.32  	// FIXME?: ar.unat is not really handled correctly,
   74.33  	// but may not matter if the OS is NaT-clean
   74.34 @@ -1663,10 +1671,159 @@ 2:
   74.35  	;;
   74.36  END(hyper_ptc_ga)
   74.37  
   74.38 +//  Registers at entry
   74.39 +//	r17 = break immediate (XEN_HYPER_ITC_D or I)
   74.40 +//	r18 == XSI_PSR_IC_OFS
   74.41 +//	r31 == pr
   74.42 +GLOBAL_ENTRY(hyper_itc)
   74.43 +ENTRY(hyper_itc_i)
   74.44 +	// fall through, hyper_itc_d handles both i and d
   74.45  ENTRY(hyper_itc_d)
   74.46 +#ifndef FAST_ITC
   74.47  	br.spnt.many dispatch_break_fault ;;
   74.48 -END(hyper_itc_d)
   74.49 +#endif
   74.50 +	adds r23=XSI_ITIR_OFS-XSI_PSR_IC_OFS,r18 ;;
   74.51 +	ld8 r23=[r23];;
   74.52 +	extr.u r24=r23,2,6;;		// r24==logps
   74.53 +	cmp.gt p7,p0=PAGE_SHIFT,r24
   74.54 +(p7)	br.spnt.many dispatch_break_fault ;;
   74.55 +	// translate_domain_pte(r8=pteval,PSCB(ifa)=address,r24=itir)
   74.56 +	mov r19=1;;
   74.57 +	shl r20=r19,r24;;
   74.58 +	adds r20=-1,r20;;	// r20 == mask
   74.59 +	movl r19=_PAGE_PPN_MASK;;
   74.60 +	and r22=r8,r19;;	// r22 == pteval & _PAGE_PPN_MASK
   74.61 +	andcm r19=r22,r20;;
   74.62 +	adds r21=XSI_IFA_OFS-XSI_PSR_IC_OFS,r18 ;;
   74.63 +	ld8 r21=[r21];;
   74.64 +	and r20=r21,r20;;
   74.65 +	or r19=r19,r20;;	// r19 == mpaddr
   74.66 +	movl r27=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_OFFSET;;
   74.67 +	ld8 r27=[r27];;
   74.68 +	adds r27=IA64_VCPU_DOMAIN_OFFSET,r27;;
   74.69 +	ld8 r27=[r27];;
   74.70 +// FIXME: is the global var dom0 always pinned? assume so for now
   74.71 +	movl r28=dom0;;
   74.72 +	ld8 r28=[r28];;
   74.73 +// FIXME: for now, only handle dom0 (see lookup_domain_mpa below)
   74.74 +	cmp.ne p7,p0=r27,r28
   74.75 +(p7)	br.spnt.many dispatch_break_fault ;;
   74.76 +	// if region 6, go slow way
   74.77 +#ifdef FAST_HYPERPRIVOP_CNT
   74.78 +	cmp.eq p6,p7=XEN_HYPER_ITC_D,r17;;
   74.79 +(p6)	movl r20=fast_hyperpriv_cnt+(8*XEN_HYPER_ITC_D);;
   74.80 +(p7)	movl r20=fast_hyperpriv_cnt+(8*XEN_HYPER_ITC_I);;
   74.81 +	ld8 r21=[r20];;
   74.82 +	adds r21=1,r21;;
   74.83 +	st8 [r20]=r21;;
   74.84 +#endif
   74.85 +// FIXME: for now, just do domain0 and skip mpaddr range checks
   74.86 +	dep r20=r0,r19,0,PAGE_SHIFT
   74.87 +	movl r21=PAGE_PHYS ;;
   74.88 +	or r20=r20,r21 ;;	// r20==return value from lookup_domain_mpa
   74.89 +	// r8=pteval,r20=pteval2
   74.90 +	movl r19=_PAGE_PPN_MASK
   74.91 +	movl r21=_PAGE_PL_2;;
   74.92 +	andcm r25=r8,r19;;	// r25==pteval & ~_PAGE_PPN_MASK
   74.93 +	and r22=r20,r19;;
   74.94 +	or r22=r22,r21;;
   74.95 +	or r22=r22,r25;;	// r22==return value from translate_domain_pte
   74.96 +	// done with translate_domain_pte
   74.97 +	// now do vcpu_itc_no_srlz(vcpu,IorD,ifa,r22=pte,r8=mppte,r24=logps)
   74.98 +// FIXME: for now, just domain0 and skip range check
   74.99 +	// psr.ic already cleared
  74.100 +	// NOTE: r24 still contains ps (from above)
  74.101 +	shladd r24=r24,2,r0;;
  74.102 +	mov cr.itir=r24;;
  74.103 +	adds r23=XSI_IFA_OFS-XSI_PSR_IC_OFS,r18 ;;
  74.104 +	ld8 r23=[r23];;
  74.105 +	mov cr.ifa=r23;;
  74.106 +	cmp.eq p6,p7=XEN_HYPER_ITC_D,r17;;
  74.107 +(p6)	itc.d r22;;
  74.108 +(p7)	itc.i r22;;
  74.109 +	dv_serialize_data
  74.110 +	// FIXME: how do I make assembler warnings go away here?
  74.111 +	// vhpt_insert(r23=vaddr,r22=pte,r24=logps<<2)
  74.112 +	thash r28=r23
  74.113 +	or r26=1,r22;;
  74.114 +	ttag r21=r23
  74.115 +	adds r25=8,r28
  74.116 +	mov r19=r28;;
  74.117 +	st8 [r25]=r24
  74.118 +	adds r20=16,r28;;
  74.119 +	st8 [r19]=r26
  74.120 +	st8 [r20]=r21;;
  74.121 +	// vcpu_set_tr_entry(trp,r22=pte|1,r24=itir,r23=ifa)
  74.122 +	// TR_ENTRY = {page_flags,itir,addr,rid}
  74.123 +	cmp.eq p6,p7=XEN_HYPER_ITC_D,r17
  74.124 +	movl r27=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_OFFSET;;
  74.125 +	ld8 r27=[r27];;
  74.126 +	adds r28=IA64_VCPU_STARTING_RID_OFFSET,r27
  74.127 +(p6)	adds r27=IA64_VCPU_DTLB_OFFSET,r27
  74.128 +(p7)	adds r27=IA64_VCPU_ITLB_OFFSET,r27;;
  74.129 +	st8 [r27]=r22,8;;	// page_flags: already has pl >= 2 and p==1
  74.130 +	st8 [r27]=r24,8;;	// itir
  74.131 +	mov r19=-4096;;
  74.132 +	and r23=r23,r19;;
  74.133 +	st8 [r27]=r23,8;;	// ifa & ~0xfff
  74.134 +// ?? is virtualize_rid(v,get_rr(ifa))==vcpu_get_rr(ifa)?? YES!!
  74.135 +	adds r29 = XSI_RR0_OFS-XSI_PSR_IC_OFS,r18
  74.136 +	extr.u r25=r23,61,3;;
  74.137 +	shladd r29=r25,3,r29;;
  74.138 +	ld8 r29=[r29];;
  74.139 +	movl r20=0xffffff00;;
  74.140 +	and r29=r29,r20;;
  74.141 +	st8 [r27]=r29,-8;;		// rid
  74.142 +	//if ps > 12
  74.143 +	cmp.eq p7,p0=12<<2,r24
  74.144 +(p7)	br.cond.sptk.many 1f;;
  74.145 +	// if (ps > 12) {
  74.146 +	// trp->ppn &= ~((1UL<<(ps-12))-1); trp->vadr &= ~((1UL<<ps)-1); }
  74.147 +	extr.u r29=r24,2,6
  74.148 +	mov r28=1;;
  74.149 +	shl r26=r28,r29;;
  74.150 +	adds r29=-12,r29;;
  74.151 +	shl r25=r28,r29;;
  74.152 +	mov r29=-1
  74.153 +	adds r26=-1,r26
  74.154 +	adds r25=-1,r25;;
  74.155 +	andcm r26=r29,r26	// ~((1UL<<ps)-1)
  74.156 +	andcm r25=r29,r25;;	// ~((1UL<<(ps-12))-1)
  74.157 +	ld8 r29=[r27];;
  74.158 +	and r29=r29,r26;;
  74.159 +	st8 [r27]=r29,-16;;
  74.160 +	ld8 r29=[r27];;
  74.161 +	extr.u r28=r29,12,38;;
  74.162 +	movl r26=0xfffc000000000fff;;
  74.163 +	and r29=r29,r26
  74.164 +	and r28=r28,r25;;
  74.165 +	shl r28=r28,12;;
  74.166 +	or r29=r29,r28;;
  74.167 +	st8 [r27]=r29;;
  74.168 +1:	// done with vcpu_set_tr_entry
  74.169 +	//PSCBX(vcpu,i/dtlb_pte) = mp_pte
  74.170 +	movl r27=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_OFFSET;;
  74.171 +	ld8 r27=[r27];;
  74.172 +	cmp.eq p6,p7=XEN_HYPER_ITC_D,r17;;
  74.173 +(p6)	adds r27=IA64_VCPU_DTLB_PTE_OFFSET,r27
  74.174 +(p7)	adds r27=IA64_VCPU_ITLB_PTE_OFFSET,r27;;
  74.175 +	st8 [r27]=r8;;
  74.176 +	// done with vcpu_itc_no_srlz
  74.177  
  74.178 -ENTRY(hyper_itc_i)
  74.179 -	br.spnt.many dispatch_break_fault ;;
  74.180 -END(hyper_itc_i)
  74.181 +	// done, increment to point to next instruction
  74.182 +	mov r29=cr.ipsr
  74.183 +	mov r30=cr.iip;;
  74.184 +	extr.u r26=r29,41,2 ;;
  74.185 +	cmp.eq p6,p7=2,r26 ;;
  74.186 +(p6)	mov r26=0
  74.187 +(p6)	adds r30=16,r30
  74.188 +(p7)	adds r26=1,r26
  74.189 +	;;
  74.190 +	dep r29=r26,r29,41,2
  74.191 +	;;
  74.192 +	mov cr.ipsr=r29
  74.193 +	mov cr.iip=r30
  74.194 +	mov pr=r31,-1 ;;
  74.195 +	rfi
  74.196 +	;;
  74.197 +END(hyper_itc_d)

    75.1 --- a/xen/arch/ia64/xen/ivt.S	Sun Oct 30 13:52:38 2005 +0100
    75.2 +++ b/xen/arch/ia64/xen/ivt.S	Sun Oct 30 14:00:35 2005 +0100
    75.3 @@ -484,6 +484,7 @@ END(alt_dtlb_miss)
    75.4  /////////////////////////////////////////////////////////////////////////////////////////
    75.5  // 0x1400 Entry 5 (size 64 bundles) Data nested TLB (6,45)
    75.6  ENTRY(nested_dtlb_miss)
    75.7 +	DBG_FAULT(5)
    75.8  	/*
    75.9  	 * In the absence of kernel bugs, we get here when the virtually mapped linear
   75.10  	 * page table is accessed non-speculatively (e.g., in the Dirty-bit, Instruction
   75.11 @@ -552,10 +553,10 @@ END(nested_dtlb_miss)
   75.12  /////////////////////////////////////////////////////////////////////////////////////////
   75.13  // 0x1800 Entry 6 (size 64 bundles) Instruction Key Miss (24)
   75.14  ENTRY(ikey_miss)
   75.15 +	DBG_FAULT(6)
   75.16  #ifdef XEN
   75.17  	REFLECT(6)
   75.18  #endif
   75.19 -	DBG_FAULT(6)
   75.20  	FAULT(6)
   75.21  END(ikey_miss)
   75.22  
   75.23 @@ -597,10 +598,10 @@ END(page_fault)
   75.24  /////////////////////////////////////////////////////////////////////////////////////////
   75.25  // 0x1c00 Entry 7 (size 64 bundles) Data Key Miss (12,51)
   75.26  ENTRY(dkey_miss)
   75.27 +	DBG_FAULT(7)
   75.28  #ifdef XEN
   75.29  	REFLECT(7)
   75.30  #endif
   75.31 -	DBG_FAULT(7)
   75.32  	FAULT(7)
   75.33  END(dkey_miss)
   75.34  
   75.35 @@ -608,10 +609,10 @@ END(dkey_miss)
   75.36  /////////////////////////////////////////////////////////////////////////////////////////
   75.37  // 0x2000 Entry 8 (size 64 bundles) Dirty-bit (54)
   75.38  ENTRY(dirty_bit)
   75.39 +	DBG_FAULT(8)
   75.40  #ifdef XEN
   75.41  	REFLECT(8)
   75.42  #endif
   75.43 -	DBG_FAULT(8)
   75.44  	/*
   75.45  	 * What we do here is to simply turn on the dirty bit in the PTE.  We need to
   75.46  	 * update both the page-table and the TLB entry.  To efficiently access the PTE,
   75.47 @@ -673,6 +674,7 @@ END(dirty_bit)
   75.48  /////////////////////////////////////////////////////////////////////////////////////////
   75.49  // 0x2400 Entry 9 (size 64 bundles) Instruction Access-bit (27)
   75.50  ENTRY(iaccess_bit)
   75.51 +	DBG_FAULT(9)
   75.52  #ifdef XEN
   75.53  	mov r31=pr;
   75.54  	mov r16=cr.isr
   75.55 @@ -681,7 +683,6 @@ ENTRY(iaccess_bit)
   75.56  	movl r20=0x2400
   75.57  	br.sptk.many fast_access_reflect;;
   75.58  #endif
   75.59 -	DBG_FAULT(9)
   75.60  	// Like Entry 8, except for instruction access
   75.61  	mov r16=cr.ifa				// get the address that caused the fault
   75.62  	movl r30=1f				// load continuation point in case of nested fault
   75.63 @@ -746,6 +747,7 @@ END(iaccess_bit)
   75.64  /////////////////////////////////////////////////////////////////////////////////////////
   75.65  // 0x2800 Entry 10 (size 64 bundles) Data Access-bit (15,55)
   75.66  ENTRY(daccess_bit)
   75.67 +	DBG_FAULT(10)
   75.68  #ifdef XEN
   75.69  	mov r31=pr;
   75.70  	mov r16=cr.isr
   75.71 @@ -754,7 +756,6 @@ ENTRY(daccess_bit)
   75.72  	movl r20=0x2800
   75.73  	br.sptk.many fast_access_reflect;;
   75.74  #endif
   75.75 -	DBG_FAULT(10)
   75.76  	// Like Entry 8, except for data access
   75.77  	mov r16=cr.ifa				// get the address that caused the fault
   75.78  	movl r30=1f				// load continuation point in case of nested fault
   75.79 @@ -971,8 +972,10 @@ slow_interrupt:
   75.80  	mov out0=cr.ivr		// pass cr.ivr as first arg
   75.81  #endif
   75.82  	add out1=16,sp		// pass pointer to pt_regs as second arg
   75.83 +#ifndef XEN
   75.84  	;;
   75.85  	srlz.d			// make sure we see the effect of cr.ivr
   75.86 +#endif
   75.87  	movl r14=ia64_leave_kernel
   75.88  	;;
   75.89  	mov rp=r14
   75.90 @@ -1363,10 +1366,10 @@ END(dispatch_to_fault_handler)
   75.91  /////////////////////////////////////////////////////////////////////////////////////////
   75.92  // 0x5000 Entry 20 (size 16 bundles) Page Not Present (10,22,49)
   75.93  ENTRY(page_not_present)
   75.94 +	DBG_FAULT(20)
   75.95  #ifdef XEN
   75.96  	REFLECT(20)
   75.97  #endif
   75.98 -	DBG_FAULT(20)
   75.99  	mov r16=cr.ifa
  75.100  	rsm psr.dt
  75.101  	/*
  75.102 @@ -1386,10 +1389,10 @@ END(page_not_present)
  75.103  /////////////////////////////////////////////////////////////////////////////////////////
  75.104  // 0x5100 Entry 21 (size 16 bundles) Key Permission (13,25,52)
  75.105  ENTRY(key_permission)
  75.106 +	DBG_FAULT(21)
  75.107  #ifdef XEN
  75.108  	REFLECT(21)
  75.109  #endif
  75.110 -	DBG_FAULT(21)
  75.111  	mov r16=cr.ifa
  75.112  	rsm psr.dt
  75.113  	mov r31=pr
  75.114 @@ -1402,10 +1405,10 @@ END(key_permission)
  75.115  /////////////////////////////////////////////////////////////////////////////////////////
  75.116  // 0x5200 Entry 22 (size 16 bundles) Instruction Access Rights (26)
  75.117  ENTRY(iaccess_rights)
  75.118 +	DBG_FAULT(22)
  75.119  #ifdef XEN
  75.120  	REFLECT(22)
  75.121  #endif
  75.122 -	DBG_FAULT(22)
  75.123  	mov r16=cr.ifa
  75.124  	rsm psr.dt
  75.125  	mov r31=pr
  75.126 @@ -1418,6 +1421,7 @@ END(iaccess_rights)
  75.127  /////////////////////////////////////////////////////////////////////////////////////////
  75.128  // 0x5300 Entry 23 (size 16 bundles) Data Access Rights (14,53)
  75.129  ENTRY(daccess_rights)
  75.130 +	DBG_FAULT(23)
  75.131  #ifdef XEN
  75.132  	mov r31=pr;
  75.133  	mov r16=cr.isr
  75.134 @@ -1426,7 +1430,6 @@ ENTRY(daccess_rights)
  75.135  	movl r20=0x5300
  75.136  	br.sptk.many fast_access_reflect;;
  75.137  #endif
  75.138 -	DBG_FAULT(23)
  75.139  	mov r16=cr.ifa
  75.140  	rsm psr.dt
  75.141  	mov r31=pr
  75.142 @@ -1459,10 +1462,31 @@ END(general_exception)
  75.143  /////////////////////////////////////////////////////////////////////////////////////////
  75.144  // 0x5500 Entry 25 (size 16 bundles) Disabled FP-Register (35)
  75.145  ENTRY(disabled_fp_reg)
  75.146 +	DBG_FAULT(25)
  75.147  #ifdef XEN
  75.148 +#if 0
  75.149 +	mov r20=pr
  75.150 +	movl r16=0x2000000000000000
  75.151 +	movl r17=0x2000000000176b60
  75.152 +	mov r18=cr.iip
  75.153 +	mov r19=rr[r16]
  75.154 +	movl r22=0xe95d0439
  75.155 +	;;
  75.156 +	mov pr=r0,-1
  75.157 +	;;
  75.158 +	cmp.eq p6,p7=r22,r19
  75.159 +	;;
  75.160 +	(p6) cmp.eq p8,p9=r17,r18
  75.161 +	(p8) br.sptk.few floating_panic
  75.162 +	;;
  75.163 +	mov pr=r20,-1
  75.164 +	;;
  75.165 +#endif
  75.166  	REFLECT(25)
  75.167 +//floating_panic:
  75.168 +//	br.sptk.many floating_panic
  75.169 +	;;
  75.170  #endif
  75.171 -	DBG_FAULT(25)
  75.172  	rsm psr.dfh		// ensure we can access fph
  75.173  	;;
  75.174  	srlz.d
  75.175 @@ -1475,10 +1499,10 @@ END(disabled_fp_reg)
  75.176  /////////////////////////////////////////////////////////////////////////////////////////
  75.177  // 0x5600 Entry 26 (size 16 bundles) Nat Consumption (11,23,37,50)
  75.178  ENTRY(nat_consumption)
  75.179 +	DBG_FAULT(26)
  75.180  #ifdef XEN
  75.181  	REFLECT(26)
  75.182  #endif
  75.183 -	DBG_FAULT(26)
  75.184  	FAULT(26)
  75.185  END(nat_consumption)
  75.186  
  75.187 @@ -1486,11 +1510,11 @@ END(nat_consumption)
  75.188  /////////////////////////////////////////////////////////////////////////////////////////
  75.189  // 0x5700 Entry 27 (size 16 bundles) Speculation (40)
  75.190  ENTRY(speculation_vector)
  75.191 +	DBG_FAULT(27)
  75.192  #ifdef XEN
  75.193  	// this probably need not reflect...
  75.194  	REFLECT(27)
  75.195  #endif
  75.196 -	DBG_FAULT(27)
  75.197  	/*
  75.198  	 * A [f]chk.[as] instruction needs to take the branch to the recovery code but
  75.199  	 * this part of the architecture is not implemented in hardware on some CPUs, such
  75.200 @@ -1533,10 +1557,10 @@ END(speculation_vector)
  75.201  /////////////////////////////////////////////////////////////////////////////////////////
  75.202  // 0x5900 Entry 29 (size 16 bundles) Debug (16,28,56)
  75.203  ENTRY(debug_vector)
  75.204 +	DBG_FAULT(29)
  75.205  #ifdef XEN
  75.206  	REFLECT(29)
  75.207  #endif
  75.208 -	DBG_FAULT(29)
  75.209  	FAULT(29)
  75.210  END(debug_vector)
  75.211  
  75.212 @@ -1544,10 +1568,10 @@ END(debug_vector)
  75.213  /////////////////////////////////////////////////////////////////////////////////////////
  75.214  // 0x5a00 Entry 30 (size 16 bundles) Unaligned Reference (57)
  75.215  ENTRY(unaligned_access)
  75.216 +	DBG_FAULT(30)
  75.217  #ifdef XEN
  75.218  	REFLECT(30)
  75.219  #endif
  75.220 -	DBG_FAULT(30)
  75.221  	mov r16=cr.ipsr
  75.222  	mov r31=pr		// prepare to save predicates
  75.223  	;;
  75.224 @@ -1558,10 +1582,10 @@ END(unaligned_access)
  75.225  /////////////////////////////////////////////////////////////////////////////////////////
  75.226  // 0x5b00 Entry 31 (size 16 bundles) Unsupported Data Reference (57)
  75.227  ENTRY(unsupported_data_reference)
  75.228 +	DBG_FAULT(31)
  75.229  #ifdef XEN
  75.230  	REFLECT(31)
  75.231  #endif
  75.232 -	DBG_FAULT(31)
  75.233  	FAULT(31)
  75.234  END(unsupported_data_reference)
  75.235  
  75.236 @@ -1569,10 +1593,10 @@ END(unsupported_data_reference)
  75.237  /////////////////////////////////////////////////////////////////////////////////////////
  75.238  // 0x5c00 Entry 32 (size 16 bundles) Floating-Point Fault (64)
  75.239  ENTRY(floating_point_fault)
  75.240 +	DBG_FAULT(32)
  75.241  #ifdef XEN
  75.242  	REFLECT(32)
  75.243  #endif
  75.244 -	DBG_FAULT(32)
  75.245  	FAULT(32)
  75.246  END(floating_point_fault)
  75.247  
  75.248 @@ -1580,10 +1604,10 @@ END(floating_point_fault)
  75.249  /////////////////////////////////////////////////////////////////////////////////////////
  75.250  // 0x5d00 Entry 33 (size 16 bundles) Floating Point Trap (66)
  75.251  ENTRY(floating_point_trap)
  75.252 +	DBG_FAULT(33)
  75.253  #ifdef XEN
  75.254  	REFLECT(33)
  75.255  #endif
  75.256 -	DBG_FAULT(33)
  75.257  	FAULT(33)
  75.258  END(floating_point_trap)
  75.259  
  75.260 @@ -1591,10 +1615,10 @@ END(floating_point_trap)
  75.261  /////////////////////////////////////////////////////////////////////////////////////////
  75.262  // 0x5e00 Entry 34 (size 16 bundles) Lower Privilege Transfer Trap (66)
  75.263  ENTRY(lower_privilege_trap)
  75.264 +	DBG_FAULT(34)
  75.265  #ifdef XEN
  75.266  	REFLECT(34)
  75.267  #endif
  75.268 -	DBG_FAULT(34)
  75.269  	FAULT(34)
  75.270  END(lower_privilege_trap)
  75.271  
  75.272 @@ -1602,10 +1626,10 @@ END(lower_privilege_trap)
  75.273  /////////////////////////////////////////////////////////////////////////////////////////
  75.274  // 0x5f00 Entry 35 (size 16 bundles) Taken Branch Trap (68)
  75.275  ENTRY(taken_branch_trap)
  75.276 +	DBG_FAULT(35)
  75.277  #ifdef XEN
  75.278  	REFLECT(35)
  75.279  #endif
  75.280 -	DBG_FAULT(35)
  75.281  	FAULT(35)
  75.282  END(taken_branch_trap)
  75.283  
  75.284 @@ -1613,10 +1637,10 @@ END(taken_branch_trap)
  75.285  /////////////////////////////////////////////////////////////////////////////////////////
  75.286  // 0x6000 Entry 36 (size 16 bundles) Single Step Trap (69)
  75.287  ENTRY(single_step_trap)
  75.288 +	DBG_FAULT(36)
  75.289  #ifdef XEN
  75.290  	REFLECT(36)
  75.291  #endif
  75.292 -	DBG_FAULT(36)
  75.293  	FAULT(36)
  75.294  END(single_step_trap)
  75.295  
  75.296 @@ -1672,10 +1696,10 @@ END(single_step_trap)
  75.297  /////////////////////////////////////////////////////////////////////////////////////////
  75.298  // 0x6900 Entry 45 (size 16 bundles) IA-32 Exeception (17,18,29,41,42,43,44,58,60,61,62,72,73,75,76,77)
  75.299  ENTRY(ia32_exception)
  75.300 +	DBG_FAULT(45)
  75.301  #ifdef XEN
  75.302  	REFLECT(45)
  75.303  #endif
  75.304 -	DBG_FAULT(45)
  75.305  	FAULT(45)
  75.306  END(ia32_exception)
  75.307  
  75.308 @@ -1683,10 +1707,10 @@ END(ia32_exception)
  75.309  /////////////////////////////////////////////////////////////////////////////////////////
  75.310  // 0x6a00 Entry 46 (size 16 bundles) IA-32 Intercept  (30,31,59,70,71)
  75.311  ENTRY(ia32_intercept)
  75.312 +	DBG_FAULT(46)
  75.313  #ifdef XEN
  75.314  	REFLECT(46)
  75.315  #endif
  75.316 -	DBG_FAULT(46)
  75.317  #ifdef	CONFIG_IA32_SUPPORT
  75.318  	mov r31=pr
  75.319  	mov r16=cr.isr
  75.320 @@ -1716,10 +1740,10 @@ END(ia32_intercept)
  75.321  /////////////////////////////////////////////////////////////////////////////////////////
  75.322  // 0x6b00 Entry 47 (size 16 bundles) IA-32 Interrupt  (74)
  75.323  ENTRY(ia32_interrupt)
  75.324 +	DBG_FAULT(47)
  75.325  #ifdef XEN
  75.326  	REFLECT(47)
  75.327  #endif
  75.328 -	DBG_FAULT(47)
  75.329  #ifdef CONFIG_IA32_SUPPORT
  75.330  	mov r31=pr
  75.331  	br.sptk.many dispatch_to_ia32_handler