Imported xen patches.
[people/pmueller/ipfire-2.x.git] / src / patches / 60012_xen3-auto-common.patch1
1 Subject: xen3 common
2 From: http://xenbits.xensource.com/linux-2.6.18-xen.hg (tip 728:832aac894efd)
3 Patch-mainline: obsolete
4 Acked-by: jbeulich@novell.com
5
6 List of files that don't require modification anymore (and hence
7 removed from this patch), for reference and in case upstream wants to
8 take the forward porting patches:
9 2.6.22/include/linux/sched.h
10 2.6.22/kernel/softlockup.c
11 2.6.22/kernel/timer.c
12 2.6.25/mm/highmem.c
13
14 ---
15 drivers/Makefile | 1
16 drivers/acpi/Makefile | 3
17 drivers/acpi/hardware/hwsleep.c | 15
18 drivers/acpi/processor_core.c | 72 +++
19 drivers/acpi/processor_extcntl.c | 241 +++++++++++
20 drivers/acpi/processor_idle.c | 24 -
21 drivers/acpi/processor_perflib.c | 21
22 drivers/acpi/sleep/main.c | 9
23 drivers/char/agp/intel-agp.c | 10
24 drivers/char/mem.c | 16
25 drivers/char/tpm/Makefile | 2
26 drivers/char/tpm/tpm.h | 15
27 drivers/char/tpm/tpm_vtpm.c | 542 +++++++++++++++++++++++++
28 drivers/char/tpm/tpm_vtpm.h | 55 ++
29 drivers/char/tpm/tpm_xen.c | 722 ++++++++++++++++++++++++++++++++++
30 drivers/ide/ide-lib.c | 8
31 drivers/oprofile/buffer_sync.c | 87 +++-
32 drivers/oprofile/cpu_buffer.c | 51 +-
33 drivers/oprofile/cpu_buffer.h | 9
34 drivers/oprofile/event_buffer.h | 3
35 drivers/oprofile/oprof.c | 30 +
36 drivers/oprofile/oprof.h | 3
37 drivers/oprofile/oprofile_files.c | 201 +++++++++
38 fs/compat_ioctl.c | 19
39 include/acpi/processor.h | 143 ++++++
40 include/asm-generic/pci.h | 2
41 include/asm-generic/pgtable.h | 4
42 include/linux/aio.h | 5
43 include/linux/highmem.h | 8
44 include/linux/interrupt.h | 6
45 include/linux/kexec.h | 13
46 include/linux/mm.h | 8
47 include/linux/oprofile.h | 12
48 include/linux/page-flags.h | 26 +
49 include/linux/pci.h | 11
50 include/linux/vermagic.h | 7
51 kernel/irq/spurious.c | 2
52 kernel/kexec.c | 71 ++-
53 kernel/sysctl.c | 2
54 mm/memory.c | 42 +
55 mm/mprotect.c | 2
56 mm/page_alloc.c | 12
57 net/core/dev.c | 62 ++
58 net/core/skbuff.c | 4
59 net/ipv4/netfilter/nf_nat_proto_tcp.c | 3
60 net/ipv4/netfilter/nf_nat_proto_udp.c | 4
61 net/ipv4/xfrm4_output.c | 2
62 scripts/Makefile.build | 14
63 scripts/Makefile.lib | 6
64 51 files changed, 2671 insertions(+), 86 deletions(-)
65
66 --- a/drivers/acpi/hardware/hwsleep.c
67 +++ b/drivers/acpi/hardware/hwsleep.c
68 @@ -241,7 +241,11 @@ acpi_status asmlinkage acpi_enter_sleep_
69 u32 PM1Bcontrol;
70 struct acpi_bit_register_info *sleep_type_reg_info;
71 struct acpi_bit_register_info *sleep_enable_reg_info;
72 +#if !(defined(CONFIG_XEN) && defined(CONFIG_X86))
73 u32 in_value;
74 +#else
75 + int err;
76 +#endif
77 struct acpi_object_list arg_list;
78 union acpi_object arg;
79 acpi_status status;
80 @@ -351,6 +355,7 @@ acpi_status asmlinkage acpi_enter_sleep_
81
82 ACPI_FLUSH_CPU_CACHE();
83
84 +#if !(defined(CONFIG_XEN) && defined(CONFIG_X86))
85 status = acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL,
86 PM1Acontrol);
87 if (ACPI_FAILURE(status)) {
88 @@ -397,6 +402,16 @@ acpi_status asmlinkage acpi_enter_sleep_
89 /* Spin until we wake */
90
91 } while (!in_value);
92 +#else
93 + /* PV ACPI just need check hypercall return value */
94 + err = acpi_notify_hypervisor_state(sleep_state,
95 + PM1Acontrol, PM1Bcontrol);
96 + if (err) {
97 + ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
98 + "Hypervisor failure [%d]\n", err));
99 + return_ACPI_STATUS(AE_ERROR);
100 + }
101 +#endif
102
103 return_ACPI_STATUS(AE_OK);
104 }
105 --- a/drivers/acpi/Makefile
106 +++ b/drivers/acpi/Makefile
107 @@ -34,6 +34,9 @@ processor-objs += processor_core.o proce
108 ifdef CONFIG_CPU_FREQ
109 processor-objs += processor_perflib.o
110 endif
111 +ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
112 +processor-objs += processor_perflib.o processor_extcntl.o
113 +endif
114
115 obj-y += sleep/
116 obj-y += bus.o glue.o
117 --- a/drivers/acpi/processor_core.c
118 +++ b/drivers/acpi/processor_core.c
119 @@ -620,7 +620,8 @@ static int acpi_processor_get_info(struc
120 */
121 if (pr->id == -1) {
122 if (ACPI_FAILURE
123 - (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
124 + (acpi_processor_hotadd_init(pr->handle, &pr->id)) &&
125 + !processor_cntl_external()) {
126 return -ENODEV;
127 }
128 }
129 @@ -662,7 +663,11 @@ static int acpi_processor_get_info(struc
130 return 0;
131 }
132
133 +#ifndef CONFIG_XEN
134 static DEFINE_PER_CPU(void *, processor_device_array);
135 +#else
136 +static void *processor_device_array[NR_ACPI_CPUS];
137 +#endif
138
139 static int __cpuinit acpi_processor_start(struct acpi_device *device)
140 {
141 @@ -671,30 +676,46 @@ static int __cpuinit acpi_processor_star
142 struct acpi_processor *pr;
143 struct sys_device *sysdev;
144
145 + processor_extcntl_init();
146 +
147 pr = acpi_driver_data(device);
148
149 result = acpi_processor_get_info(pr, device->flags.unique_id);
150 - if (result) {
151 + if (result ||
152 + ((pr->id == -1) && !processor_cntl_external())) {
153 /* Processor is physically not present */
154 return 0;
155 }
156
157 - BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
158 + BUG_ON(!processor_cntl_external() &&
159 + ((pr->id >= nr_cpu_ids) || (pr->id < 0)));
160
161 /*
162 * Buggy BIOS check
163 * ACPI id of processors can be reported wrongly by the BIOS.
164 * Don't trust it blindly
165 */
166 +#ifndef CONFIG_XEN
167 if (per_cpu(processor_device_array, pr->id) != NULL &&
168 per_cpu(processor_device_array, pr->id) != device) {
169 +#else
170 + BUG_ON(pr->acpi_id >= NR_ACPI_CPUS);
171 + if (processor_device_array[pr->acpi_id] != NULL &&
172 + processor_device_array[pr->acpi_id] != device) {
173 +#endif
174 printk(KERN_WARNING "BIOS reported wrong ACPI id "
175 "for the processor\n");
176 return -ENODEV;
177 }
178 +#ifndef CONFIG_XEN
179 per_cpu(processor_device_array, pr->id) = device;
180
181 per_cpu(processors, pr->id) = pr;
182 +#else
183 + processor_device_array[pr->acpi_id] = device;
184 + if (pr->id != -1)
185 + per_cpu(processors, pr->id) = pr;
186 +#endif
187
188 result = acpi_processor_add_fs(device);
189 if (result)
190 @@ -710,15 +731,28 @@ static int __cpuinit acpi_processor_star
191 /* _PDC call should be done before doing anything else (if reqd.). */
192 arch_acpi_processor_init_pdc(pr);
193 acpi_processor_set_pdc(pr);
194 -#ifdef CONFIG_CPU_FREQ
195 +#if defined(CONFIG_CPU_FREQ) || defined(CONFIG_PROCESSOR_EXTERNAL_CONTROL)
196 acpi_processor_ppc_has_changed(pr);
197 #endif
198 - acpi_processor_get_throttling_info(pr);
199 - acpi_processor_get_limit_info(pr);
200 +
201 + /*
202 + * pr->id may equal to -1 while processor_cntl_external enabled.
203 + * throttle and thermal module don't support this case.
204 + * Tx only works when dom0 vcpu == pcpu num by far, as we give
205 + * control to dom0.
206 + */
207 + if (pr->id != -1) {
208 + acpi_processor_get_throttling_info(pr);
209 + acpi_processor_get_limit_info(pr);
210 + }
211
212
213 acpi_processor_power_init(pr, device);
214
215 + result = processor_extcntl_prepare(pr);
216 + if (result)
217 + goto end;
218 +
219 pr->cdev = thermal_cooling_device_register("Processor", device,
220 &processor_cooling_ops);
221 if (IS_ERR(pr->cdev)) {
222 @@ -846,7 +880,7 @@ static int acpi_processor_remove(struct
223
224 pr = acpi_driver_data(device);
225
226 - if (pr->id >= nr_cpu_ids) {
227 + if (!processor_cntl_external() && pr->id >= nr_cpu_ids) {
228 kfree(pr);
229 return 0;
230 }
231 @@ -872,8 +906,14 @@ static int acpi_processor_remove(struct
232 pr->cdev = NULL;
233 }
234
235 +#ifndef CONFIG_XEN
236 per_cpu(processors, pr->id) = NULL;
237 per_cpu(processor_device_array, pr->id) = NULL;
238 +#else
239 + if (pr->id != -1)
240 + per_cpu(processors, pr->id) = NULL;
241 + processor_device_array[pr->acpi_id] = NULL;
242 +#endif
243 kfree(pr);
244
245 return 0;
246 @@ -933,6 +973,10 @@ int acpi_processor_device_add(acpi_handl
247 if (!pr)
248 return -ENODEV;
249
250 + if (processor_cntl_external())
251 + processor_notify_external(pr,
252 + PROCESSOR_HOTPLUG, HOTPLUG_TYPE_ADD);
253 +
254 if ((pr->id >= 0) && (pr->id < nr_cpu_ids)) {
255 kobject_uevent(&(*device)->dev.kobj, KOBJ_ONLINE);
256 }
257 @@ -972,6 +1016,10 @@ static void __ref acpi_processor_hotplug
258 break;
259 }
260
261 + if (processor_cntl_external())
262 + processor_notify_external(pr,
263 + PROCESSOR_HOTPLUG, HOTPLUG_TYPE_ADD);
264 +
265 if (pr->id >= 0 && (pr->id < nr_cpu_ids)) {
266 kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
267 break;
268 @@ -1003,6 +1051,11 @@ static void __ref acpi_processor_hotplug
269
270 if ((pr->id < nr_cpu_ids) && (cpu_present(pr->id)))
271 kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
272 +
273 + if (processor_cntl_external())
274 + processor_notify_external(pr, PROCESSOR_HOTPLUG,
275 + HOTPLUG_TYPE_REMOVE);
276 +
277 break;
278 default:
279 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
280 @@ -1067,6 +1120,11 @@ static acpi_status acpi_processor_hotadd
281
282 static int acpi_processor_handle_eject(struct acpi_processor *pr)
283 {
284 +#ifdef CONFIG_XEN
285 + if (pr->id == -1)
286 + return (0);
287 +#endif
288 +
289 if (cpu_online(pr->id))
290 cpu_down(pr->id);
291
292 --- /dev/null
293 +++ b/drivers/acpi/processor_extcntl.c
294 @@ -0,0 +1,241 @@
295 +/*
296 + * processor_extcntl.c - channel to external control logic
297 + *
298 + * Copyright (C) 2008, Intel corporation
299 + *
300 + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
301 + *
302 + * This program is free software; you can redistribute it and/or modify
303 + * it under the terms of the GNU General Public License as published by
304 + * the Free Software Foundation; either version 2 of the License, or (at
305 + * your option) any later version.
306 + *
307 + * This program is distributed in the hope that it will be useful, but
308 + * WITHOUT ANY WARRANTY; without even the implied warranty of
309 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
310 + * General Public License for more details.
311 + *
312 + * You should have received a copy of the GNU General Public License along
313 + * with this program; if not, write to the Free Software Foundation, Inc.,
314 + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
315 + *
316 + */
317 +
318 +#include <linux/kernel.h>
319 +#include <linux/init.h>
320 +#include <linux/types.h>
321 +#include <linux/acpi.h>
322 +#include <linux/pm.h>
323 +#include <linux/cpu.h>
324 +
325 +#include <acpi/processor.h>
326 +
327 +#define ACPI_PROCESSOR_COMPONENT 0x01000000
328 +#define ACPI_PROCESSOR_CLASS "processor"
329 +#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver"
330 +#define _COMPONENT ACPI_PROCESSOR_COMPONENT
331 +ACPI_MODULE_NAME("acpi_processor")
332 +
333 +static int processor_extcntl_parse_csd(struct acpi_processor *pr);
334 +static int processor_extcntl_get_performance(struct acpi_processor *pr);
335 +/*
336 + * External processor control logic may register with its own set of
337 + * ops to get ACPI related notification. One example is like VMM.
338 + */
339 +const struct processor_extcntl_ops *processor_extcntl_ops;
340 +EXPORT_SYMBOL(processor_extcntl_ops);
341 +
342 +static int processor_notify_smm(void)
343 +{
344 + acpi_status status;
345 + static int is_done = 0;
346 +
347 + /* only need successfully notify BIOS once */
348 + /* avoid double notification which may lead to unexpected result */
349 + if (is_done)
350 + return 0;
351 +
352 + /* Can't write pstate_cnt to smi_cmd if either value is zero */
353 + if ((!acpi_fadt.smi_cmd) || (!acpi_fadt.pstate_cnt)) {
354 + ACPI_DEBUG_PRINT((ACPI_DB_INFO,"No SMI port or pstate_cnt\n"));
355 + return 0;
356 + }
357 +
358 + ACPI_DEBUG_PRINT((ACPI_DB_INFO,
359 + "Writing pstate_cnt [0x%x] to smi_cmd [0x%x]\n",
360 + acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd));
361 +
362 + /* FADT v1 doesn't support pstate_cnt, many BIOS vendors use
363 + * it anyway, so we need to support it... */
364 + if (acpi_fadt_is_v1) {
365 + ACPI_DEBUG_PRINT((ACPI_DB_INFO,
366 + "Using v1.0 FADT reserved value for pstate_cnt\n"));
367 + }
368 +
369 + status = acpi_os_write_port(acpi_fadt.smi_cmd,
370 + (u32) acpi_fadt.pstate_cnt, 8);
371 + if (ACPI_FAILURE(status))
372 + return status;
373 +
374 + is_done = 1;
375 +
376 + return 0;
377 +}
378 +
379 +int processor_notify_external(struct acpi_processor *pr, int event, int type)
380 +{
381 + int ret = -EINVAL;
382 +
383 + if (!processor_cntl_external())
384 + return -EINVAL;
385 +
386 + switch (event) {
387 + case PROCESSOR_PM_INIT:
388 + case PROCESSOR_PM_CHANGE:
389 + if ((type >= PM_TYPE_MAX) ||
390 + !processor_extcntl_ops->pm_ops[type])
391 + break;
392 +
393 + ret = processor_extcntl_ops->pm_ops[type](pr, event);
394 + break;
395 + case PROCESSOR_HOTPLUG:
396 + if (processor_extcntl_ops->hotplug)
397 + ret = processor_extcntl_ops->hotplug(pr, type);
398 + break;
399 + default:
400 + printk(KERN_ERR "Unsupport processor events %d.\n", event);
401 + break;
402 + }
403 +
404 + return ret;
405 +}
406 +
407 +/*
408 + * External control logic can decide to grab full or part of physical
409 + * processor control bits. Take a VMM for example, physical processors
410 + * are owned by VMM and thus existence information like hotplug is
411 + * always required to be notified to VMM. Similar is processor idle
412 + * state which is also necessarily controlled by VMM. But for other
413 + * control bits like performance/throttle states, VMM may choose to
414 + * control or not upon its own policy.
415 + */
416 +void processor_extcntl_init(void)
417 +{
418 + if (!processor_extcntl_ops)
419 + arch_acpi_processor_init_extcntl(&processor_extcntl_ops);
420 +}
421 +
422 +/*
423 + * This is called from ACPI processor init, and targeted to hold
424 + * some tricky housekeeping jobs to satisfy external control model.
425 + * For example, we may put dependency parse stub here for idle
426 + * and performance state. Those information may be not available
427 + * if splitting from dom0 control logic like cpufreq driver.
428 + */
429 +int processor_extcntl_prepare(struct acpi_processor *pr)
430 +{
431 + /* parse cstate dependency information */
432 + if (processor_pm_external())
433 + processor_extcntl_parse_csd(pr);
434 +
435 + /* Initialize performance states */
436 + if (processor_pmperf_external())
437 + processor_extcntl_get_performance(pr);
438 +
439 + return 0;
440 +}
441 +
442 +/*
443 + * Currently no _CSD is implemented which is why existing ACPI code
444 + * doesn't parse _CSD at all. But to keep interface complete with
445 + * external control logic, we put a placeholder here for future
446 + * compatibility.
447 + */
448 +static int processor_extcntl_parse_csd(struct acpi_processor *pr)
449 +{
450 + int i;
451 +
452 + for (i = 0; i < pr->power.count; i++) {
453 + if (!pr->power.states[i].valid)
454 + continue;
455 +
456 + /* No dependency by default */
457 + pr->power.states[i].domain_info = NULL;
458 + pr->power.states[i].csd_count = 0;
459 + }
460 +
461 + return 0;
462 +}
463 +
464 +/*
465 + * Existing ACPI module does parse performance states at some point,
466 + * when acpi-cpufreq driver is loaded which however is something
467 + * we'd like to disable to avoid confliction with external control
468 + * logic. So we have to collect raw performance information here
469 + * when ACPI processor object is found and started.
470 + */
471 +static int processor_extcntl_get_performance(struct acpi_processor *pr)
472 +{
473 + int ret;
474 + struct acpi_processor_performance *perf;
475 + struct acpi_psd_package *pdomain;
476 +
477 + if (pr->performance)
478 + return -EBUSY;
479 +
480 + perf = kzalloc(sizeof(struct acpi_processor_performance), GFP_KERNEL);
481 + if (!perf)
482 + return -ENOMEM;
483 +
484 + pr->performance = perf;
485 + /* Get basic performance state information */
486 + ret = acpi_processor_get_performance_info(pr);
487 + if (ret < 0)
488 + goto err_out;
489 +
490 + /*
491 + * Well, here we need retrieve performance dependency information
492 + * from _PSD object. The reason why existing interface is not used
493 + * is due to the reason that existing interface sticks to Linux cpu
494 + * id to construct some bitmap, however we want to split ACPI
495 + * processor objects from Linux cpu id logic. For example, even
496 + * when Linux is configured as UP, we still want to parse all ACPI
497 + * processor objects to external logic. In this case, it's preferred
498 + * to use ACPI ID instead.
499 + */
500 + pdomain = &pr->performance->domain_info;
501 + pdomain->num_processors = 0;
502 + ret = acpi_processor_get_psd(pr);
503 + if (ret < 0) {
504 + /*
505 + * _PSD is optional - assume no coordination if absent (or
506 + * broken), matching native kernels' behavior.
507 + */
508 + pdomain->num_entries = ACPI_PSD_REV0_ENTRIES;
509 + pdomain->revision = ACPI_PSD_REV0_REVISION;
510 + pdomain->domain = pr->acpi_id;
511 + pdomain->coord_type = DOMAIN_COORD_TYPE_SW_ALL;
512 + pdomain->num_processors = 1;
513 + }
514 +
515 + /* Some sanity check */
516 + if ((pdomain->revision != ACPI_PSD_REV0_REVISION) ||
517 + (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) ||
518 + ((pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL) &&
519 + (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY) &&
520 + (pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL))) {
521 + ret = -EINVAL;
522 + goto err_out;
523 + }
524 +
525 + /* Last step is to notify BIOS that external logic exists */
526 + processor_notify_smm();
527 +
528 + processor_notify_external(pr, PROCESSOR_PM_INIT, PM_TYPE_PERF);
529 +
530 + return 0;
531 +err_out:
532 + pr->performance = NULL;
533 + kfree(perf);
534 + return ret;
535 +}
536 --- a/drivers/acpi/processor_idle.c
537 +++ b/drivers/acpi/processor_idle.c
538 @@ -905,7 +905,8 @@ static int acpi_processor_get_power_info
539 */
540 cx.entry_method = ACPI_CSTATE_HALT;
541 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
542 - } else {
543 + /* This doesn't apply to external control case */
544 + } else if (!processor_pm_external()) {
545 continue;
546 }
547 if (cx.type == ACPI_STATE_C1 &&
548 @@ -944,6 +945,12 @@ static int acpi_processor_get_power_info
549
550 cx.power = obj->integer.value;
551
552 +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
553 + /* cache control methods to notify external logic */
554 + if (processor_pm_external())
555 + memcpy(&cx.reg, reg, sizeof(*reg));
556 +#endif
557 +
558 current_count++;
559 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
560
561 @@ -1285,14 +1292,18 @@ int acpi_processor_cst_has_changed(struc
562 * been initialized.
563 */
564 if (pm_idle_save) {
565 - pm_idle = pm_idle_save;
566 + if (!processor_pm_external())
567 + pm_idle = pm_idle_save;
568 /* Relies on interrupts forcing exit from idle. */
569 synchronize_sched();
570 }
571
572 pr->flags.power = 0;
573 result = acpi_processor_get_power_info(pr);
574 - if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
575 + if (processor_pm_external())
576 + processor_notify_external(pr,
577 + PROCESSOR_PM_CHANGE, PM_TYPE_IDLE);
578 + else if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
579 pm_idle = acpi_processor_idle;
580
581 return result;
582 @@ -1814,7 +1825,7 @@ int __cpuinit acpi_processor_power_init(
583 printk(")\n");
584
585 #ifndef CONFIG_CPU_IDLE
586 - if (pr->id == 0) {
587 + if (!processor_pm_external() && (pr->id == 0)) {
588 pm_idle_save = pm_idle;
589 pm_idle = acpi_processor_idle;
590 }
591 @@ -1828,6 +1839,11 @@ int __cpuinit acpi_processor_power_init(
592 acpi_driver_data(device));
593 if (!entry)
594 return -EIO;
595 +
596 + if (processor_pm_external())
597 + processor_notify_external(pr,
598 + PROCESSOR_PM_INIT, PM_TYPE_IDLE);
599 +
600 return 0;
601 }
602
603 --- a/drivers/acpi/processor_perflib.c
604 +++ b/drivers/acpi/processor_perflib.c
605 @@ -80,6 +80,7 @@ MODULE_PARM_DESC(ignore_ppc, "If the fre
606
607 static int acpi_processor_ppc_status;
608
609 +#ifdef CONFIG_CPU_FREQ
610 static int acpi_processor_ppc_notifier(struct notifier_block *nb,
611 unsigned long event, void *data)
612 {
613 @@ -122,6 +123,7 @@ static int acpi_processor_ppc_notifier(s
614 static struct notifier_block acpi_ppc_notifier_block = {
615 .notifier_call = acpi_processor_ppc_notifier,
616 };
617 +#endif /* CONFIG_CPU_FREQ */
618
619 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
620 {
621 @@ -166,9 +168,15 @@ int acpi_processor_ppc_has_changed(struc
622 if (ret < 0)
623 return (ret);
624 else
625 +#ifdef CONFIG_CPU_FREQ
626 return cpufreq_update_policy(pr->id);
627 +#elif CONFIG_PROCESSOR_EXTERNAL_CONTROL
628 + return processor_notify_external(pr,
629 + PROCESSOR_PM_CHANGE, PM_TYPE_PERF);
630 +#endif
631 }
632
633 +#ifdef CONFIG_CPU_FREQ
634 void acpi_processor_ppc_init(void)
635 {
636 if (!cpufreq_register_notifier
637 @@ -187,6 +195,7 @@ void acpi_processor_ppc_exit(void)
638
639 acpi_processor_ppc_status &= ~PPC_REGISTERED;
640 }
641 +#endif /* CONFIG_CPU_FREQ */
642
643 static int acpi_processor_get_performance_control(struct acpi_processor *pr)
644 {
645 @@ -328,7 +337,10 @@ static int acpi_processor_get_performanc
646 return result;
647 }
648
649 -static int acpi_processor_get_performance_info(struct acpi_processor *pr)
650 +#ifndef CONFIG_PROCESSOR_EXTERNAL_CONTROL
651 +static
652 +#endif
653 +int acpi_processor_get_performance_info(struct acpi_processor *pr)
654 {
655 int result = 0;
656 acpi_status status = AE_OK;
657 @@ -356,6 +368,7 @@ static int acpi_processor_get_performanc
658 return 0;
659 }
660
661 +#ifdef CONFIG_CPU_FREQ
662 int acpi_processor_notify_smm(struct module *calling_module)
663 {
664 acpi_status status;
665 @@ -416,6 +429,7 @@ int acpi_processor_notify_smm(struct mod
666 }
667
668 EXPORT_SYMBOL(acpi_processor_notify_smm);
669 +#endif /* CONFIG_CPU_FREQ */
670
671 #ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
672 /* /proc/acpi/processor/../performance interface (DEPRECATED) */
673 @@ -507,7 +521,10 @@ static void acpi_cpufreq_remove_file(str
674 }
675 #endif /* CONFIG_X86_ACPI_CPUFREQ_PROC_INTF */
676
677 -static int acpi_processor_get_psd(struct acpi_processor *pr)
678 +#ifndef CONFIG_PROCESSOR_EXTERNAL_CONTROL
679 +static
680 +#endif
681 +int acpi_processor_get_psd(struct acpi_processor *pr)
682 {
683 int result = 0;
684 acpi_status status = AE_OK;
685 --- a/drivers/acpi/sleep/main.c
686 +++ b/drivers/acpi/sleep/main.c
687 @@ -27,6 +27,7 @@ u8 sleep_states[ACPI_S_STATE_COUNT];
688 static int acpi_sleep_prepare(u32 acpi_state)
689 {
690 #ifdef CONFIG_ACPI_SLEEP
691 +#ifndef CONFIG_ACPI_PV_SLEEP
692 /* do we have a wakeup address for S2 and S3? */
693 if (acpi_state == ACPI_STATE_S3) {
694 if (!acpi_wakeup_address) {
695 @@ -36,6 +37,7 @@ static int acpi_sleep_prepare(u32 acpi_s
696 (acpi_physical_address)acpi_wakeup_address);
697
698 }
699 +#endif
700 ACPI_FLUSH_CPU_CACHE();
701 acpi_enable_wakeup_device_prep(acpi_state);
702 #endif
703 @@ -208,7 +210,14 @@ static int acpi_suspend_enter(suspend_st
704 break;
705
706 case ACPI_STATE_S3:
707 +#ifdef CONFIG_ACPI_PV_SLEEP
708 + /* Hyperviosr will save and restore CPU context
709 + * and then we can skip low level housekeeping here.
710 + */
711 + acpi_enter_sleep_state(acpi_state);
712 +#else
713 do_suspend_lowlevel();
714 +#endif
715 break;
716 }
717
718 --- a/drivers/char/agp/intel-agp.c
719 +++ b/drivers/char/agp/intel-agp.c
720 @@ -247,6 +247,13 @@ static void *i8xx_alloc_pages(void)
721 if (page == NULL)
722 return NULL;
723
724 +#ifdef CONFIG_XEN
725 + if (xen_create_contiguous_region((unsigned long)page_address(page), 2, 32)) {
726 + __free_pages(page, 2);
727 + return NULL;
728 + }
729 +#endif
730 +
731 if (set_pages_uc(page, 4) < 0) {
732 set_pages_wb(page, 4);
733 __free_pages(page, 2);
734 @@ -266,6 +273,9 @@ static void i8xx_destroy_pages(void *add
735
736 page = virt_to_page(addr);
737 set_pages_wb(page, 4);
738 +#ifdef CONFIG_XEN
739 + xen_destroy_contiguous_region((unsigned long)page_address(page), 2);
740 +#endif
741 put_page(page);
742 __free_pages(page, 2);
743 atomic_dec(&agp_bridge->current_memory_agp);
744 --- a/drivers/char/mem.c
745 +++ b/drivers/char/mem.c
746 @@ -110,6 +110,7 @@ void __attribute__((weak)) unxlate_dev_m
747 {
748 }
749
750 +#ifndef ARCH_HAS_DEV_MEM
751 /*
752 * This funcion reads the *physical* memory. The f_pos points directly to the
753 * memory location.
754 @@ -254,6 +255,7 @@ static ssize_t write_mem(struct file * f
755 *ppos += written;
756 return written;
757 }
758 +#endif
759
760 int __attribute__((weak)) phys_mem_access_prot_allowed(struct file *file,
761 unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
762 @@ -372,6 +374,9 @@ static int mmap_mem(struct file * file,
763 static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
764 {
765 unsigned long pfn;
766 +#ifdef CONFIG_XEN
767 + unsigned long i, count;
768 +#endif
769
770 /* Turn a kernel-virtual address into a physical page frame */
771 pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
772 @@ -386,6 +391,13 @@ static int mmap_kmem(struct file * file,
773 if (!pfn_valid(pfn))
774 return -EIO;
775
776 +#ifdef CONFIG_XEN
777 + count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
778 + for (i = 0; i < count; i++)
779 + if ((pfn + i) != mfn_to_local_pfn(pfn_to_mfn(pfn + i)))
780 + return -EIO;
781 +#endif
782 +
783 vma->vm_pgoff = pfn;
784 return mmap_mem(file, vma);
785 }
786 @@ -802,6 +814,7 @@ static int open_port(struct inode * inod
787 #define open_kmem open_mem
788 #define open_oldmem open_mem
789
790 +#ifndef ARCH_HAS_DEV_MEM
791 static const struct file_operations mem_fops = {
792 .llseek = memory_lseek,
793 .read = read_mem,
794 @@ -810,6 +823,9 @@ static const struct file_operations mem_
795 .open = open_mem,
796 .get_unmapped_area = get_unmapped_area_mem,
797 };
798 +#else
799 +extern const struct file_operations mem_fops;
800 +#endif
801
802 #ifdef CONFIG_DEVKMEM
803 static const struct file_operations kmem_fops = {
804 --- a/drivers/char/tpm/Makefile
805 +++ b/drivers/char/tpm/Makefile
806 @@ -9,3 +9,5 @@ obj-$(CONFIG_TCG_TIS) += tpm_tis.o
807 obj-$(CONFIG_TCG_NSC) += tpm_nsc.o
808 obj-$(CONFIG_TCG_ATMEL) += tpm_atmel.o
809 obj-$(CONFIG_TCG_INFINEON) += tpm_infineon.o
810 +obj-$(CONFIG_TCG_XEN) += tpm_xenu.o
811 +tpm_xenu-y = tpm_xen.o tpm_vtpm.o
812 --- a/drivers/char/tpm/tpm.h
813 +++ b/drivers/char/tpm/tpm.h
814 @@ -107,6 +107,9 @@ struct tpm_chip {
815 struct dentry **bios_dir;
816
817 struct list_head list;
818 +#ifdef CONFIG_XEN
819 + void *priv;
820 +#endif
821 void (*release) (struct device *);
822 };
823
824 @@ -124,6 +127,18 @@ static inline void tpm_write_index(int b
825 outb(value & 0xFF, base+1);
826 }
827
828 +#ifdef CONFIG_XEN
829 +static inline void *chip_get_private(const struct tpm_chip *chip)
830 +{
831 + return chip->priv;
832 +}
833 +
834 +static inline void chip_set_private(struct tpm_chip *chip, void *priv)
835 +{
836 + chip->priv = priv;
837 +}
838 +#endif
839 +
840 extern void tpm_get_timeouts(struct tpm_chip *);
841 extern void tpm_gen_interrupt(struct tpm_chip *);
842 extern void tpm_continue_selftest(struct tpm_chip *);
843 --- /dev/null
844 +++ b/drivers/char/tpm/tpm_vtpm.c
845 @@ -0,0 +1,542 @@
846 +/*
847 + * Copyright (C) 2006 IBM Corporation
848 + *
849 + * Authors:
850 + * Stefan Berger <stefanb@us.ibm.com>
851 + *
852 + * Generic device driver part for device drivers in a virtualized
853 + * environment.
854 + *
855 + * This program is free software; you can redistribute it and/or
856 + * modify it under the terms of the GNU General Public License as
857 + * published by the Free Software Foundation, version 2 of the
858 + * License.
859 + *
860 + */
861 +
862 +#include <asm/uaccess.h>
863 +#include <linux/list.h>
864 +#include <linux/device.h>
865 +#include <linux/interrupt.h>
866 +#include <linux/platform_device.h>
867 +#include "tpm.h"
868 +#include "tpm_vtpm.h"
869 +
870 +/* read status bits */
871 +enum {
872 + STATUS_BUSY = 0x01,
873 + STATUS_DATA_AVAIL = 0x02,
874 + STATUS_READY = 0x04
875 +};
876 +
877 +struct transmission {
878 + struct list_head next;
879 +
880 + unsigned char *request;
881 + size_t request_len;
882 + size_t request_buflen;
883 +
884 + unsigned char *response;
885 + size_t response_len;
886 + size_t response_buflen;
887 +
888 + unsigned int flags;
889 +};
890 +
891 +enum {
892 + TRANSMISSION_FLAG_WAS_QUEUED = 0x1
893 +};
894 +
895 +
896 +enum {
897 + DATAEX_FLAG_QUEUED_ONLY = 0x1
898 +};
899 +
900 +
901 +/* local variables */
902 +
903 +/* local function prototypes */
904 +static int _vtpm_send_queued(struct tpm_chip *chip);
905 +
906 +
907 +/* =============================================================
908 + * Some utility functions
909 + * =============================================================
910 + */
911 +static void vtpm_state_init(struct vtpm_state *vtpms)
912 +{
913 + vtpms->current_request = NULL;
914 + spin_lock_init(&vtpms->req_list_lock);
915 + init_waitqueue_head(&vtpms->req_wait_queue);
916 + INIT_LIST_HEAD(&vtpms->queued_requests);
917 +
918 + vtpms->current_response = NULL;
919 + spin_lock_init(&vtpms->resp_list_lock);
920 + init_waitqueue_head(&vtpms->resp_wait_queue);
921 +
922 + vtpms->disconnect_time = jiffies;
923 +}
924 +
925 +
926 +static inline struct transmission *transmission_alloc(void)
927 +{
928 + return kzalloc(sizeof(struct transmission), GFP_ATOMIC);
929 +}
930 +
931 +static unsigned char *
932 +transmission_set_req_buffer(struct transmission *t,
933 + unsigned char *buffer, size_t len)
934 +{
935 + if (t->request_buflen < len) {
936 + kfree(t->request);
937 + t->request = kmalloc(len, GFP_KERNEL);
938 + if (!t->request) {
939 + t->request_buflen = 0;
940 + return NULL;
941 + }
942 + t->request_buflen = len;
943 + }
944 +
945 + memcpy(t->request, buffer, len);
946 + t->request_len = len;
947 +
948 + return t->request;
949 +}
950 +
951 +static unsigned char *
952 +transmission_set_res_buffer(struct transmission *t,
953 + const unsigned char *buffer, size_t len)
954 +{
955 + if (t->response_buflen < len) {
956 + kfree(t->response);
957 + t->response = kmalloc(len, GFP_ATOMIC);
958 + if (!t->response) {
959 + t->response_buflen = 0;
960 + return NULL;
961 + }
962 + t->response_buflen = len;
963 + }
964 +
965 + memcpy(t->response, buffer, len);
966 + t->response_len = len;
967 +
968 + return t->response;
969 +}
970 +
971 +static inline void transmission_free(struct transmission *t)
972 +{
973 + kfree(t->request);
974 + kfree(t->response);
975 + kfree(t);
976 +}
977 +
978 +/* =============================================================
979 + * Interface with the lower layer driver
980 + * =============================================================
981 + */
982 +/*
983 + * Lower layer uses this function to make a response available.
984 + */
985 +int vtpm_vd_recv(const struct tpm_chip *chip,
986 + const unsigned char *buffer, size_t count,
987 + void *ptr)
988 +{
989 + unsigned long flags;
990 + int ret_size = 0;
991 + struct transmission *t;
992 + struct vtpm_state *vtpms;
993 +
994 + vtpms = (struct vtpm_state *)chip_get_private(chip);
995 +
996 + /*
997 + * The list with requests must contain one request
998 + * only and the element there must be the one that
999 + * was passed to me from the front-end.
1000 + */
1001 + spin_lock_irqsave(&vtpms->resp_list_lock, flags);
1002 + if (vtpms->current_request != ptr) {
1003 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1004 + return 0;
1005 + }
1006 +
1007 + if ((t = vtpms->current_request)) {
1008 + transmission_free(t);
1009 + vtpms->current_request = NULL;
1010 + }
1011 +
1012 + t = transmission_alloc();
1013 + if (t) {
1014 + if (!transmission_set_res_buffer(t, buffer, count)) {
1015 + transmission_free(t);
1016 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1017 + return -ENOMEM;
1018 + }
1019 + ret_size = count;
1020 + vtpms->current_response = t;
1021 + wake_up_interruptible(&vtpms->resp_wait_queue);
1022 + }
1023 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1024 +
1025 + return ret_size;
1026 +}
1027 +
1028 +
1029 +/*
1030 + * Lower layer indicates its status (connected/disconnected)
1031 + */
1032 +void vtpm_vd_status(const struct tpm_chip *chip, u8 vd_status)
1033 +{
1034 + struct vtpm_state *vtpms;
1035 +
1036 + vtpms = (struct vtpm_state *)chip_get_private(chip);
1037 +
1038 + vtpms->vd_status = vd_status;
1039 + if ((vtpms->vd_status & TPM_VD_STATUS_CONNECTED) == 0) {
1040 + vtpms->disconnect_time = jiffies;
1041 + }
1042 +}
1043 +
1044 +/* =============================================================
1045 + * Interface with the generic TPM driver
1046 + * =============================================================
1047 + */
1048 +static int vtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count)
1049 +{
1050 + int rc = 0;
1051 + unsigned long flags;
1052 + struct vtpm_state *vtpms;
1053 +
1054 + vtpms = (struct vtpm_state *)chip_get_private(chip);
1055 +
1056 + /*
1057 + * Check if the previous operation only queued the command
1058 + * In this case there won't be a response, so I just
1059 + * return from here and reset that flag. In any other
1060 + * case I should receive a response from the back-end.
1061 + */
1062 + spin_lock_irqsave(&vtpms->resp_list_lock, flags);
1063 + if ((vtpms->flags & DATAEX_FLAG_QUEUED_ONLY) != 0) {
1064 + vtpms->flags &= ~DATAEX_FLAG_QUEUED_ONLY;
1065 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1066 + /*
1067 + * The first few commands (measurements) must be
1068 + * queued since it might not be possible to talk to the
1069 + * TPM, yet.
1070 + * Return a response of up to 30 '0's.
1071 + */
1072 +
1073 + count = min_t(size_t, count, 30);
1074 + memset(buf, 0x0, count);
1075 + return count;
1076 + }
1077 + /*
1078 + * Check whether something is in the responselist and if
1079 + * there's nothing in the list wait for something to appear.
1080 + */
1081 +
1082 + if (!vtpms->current_response) {
1083 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1084 + interruptible_sleep_on_timeout(&vtpms->resp_wait_queue,
1085 + 1000);
1086 + spin_lock_irqsave(&vtpms->resp_list_lock ,flags);
1087 + }
1088 +
1089 + if (vtpms->current_response) {
1090 + struct transmission *t = vtpms->current_response;
1091 + vtpms->current_response = NULL;
1092 + rc = min(count, t->response_len);
1093 + memcpy(buf, t->response, rc);
1094 + transmission_free(t);
1095 + }
1096 +
1097 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1098 + return rc;
1099 +}
1100 +
1101 +static int vtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
1102 +{
1103 + int rc = 0;
1104 + unsigned long flags;
1105 + struct transmission *t = transmission_alloc();
1106 + struct vtpm_state *vtpms;
1107 +
1108 + vtpms = (struct vtpm_state *)chip_get_private(chip);
1109 +
1110 + if (!t)
1111 + return -ENOMEM;
1112 + /*
1113 + * If there's a current request, it must be the
1114 + * previous request that has timed out.
1115 + */
1116 + spin_lock_irqsave(&vtpms->req_list_lock, flags);
1117 + if (vtpms->current_request != NULL) {
1118 + printk("WARNING: Sending although there is a request outstanding.\n"
1119 + " Previous request must have timed out.\n");
1120 + transmission_free(vtpms->current_request);
1121 + vtpms->current_request = NULL;
1122 + }
1123 + spin_unlock_irqrestore(&vtpms->req_list_lock, flags);
1124 +
1125 + /*
1126 + * Queue the packet if the driver below is not
1127 + * ready, yet, or there is any packet already
1128 + * in the queue.
1129 + * If the driver below is ready, unqueue all
1130 + * packets first before sending our current
1131 + * packet.
1132 + * For each unqueued packet, except for the
1133 + * last (=current) packet, call the function
1134 + * tpm_xen_recv to wait for the response to come
1135 + * back.
1136 + */
1137 + if ((vtpms->vd_status & TPM_VD_STATUS_CONNECTED) == 0) {
1138 + if (time_after(jiffies,
1139 + vtpms->disconnect_time + HZ * 10)) {
1140 + rc = -ENOENT;
1141 + } else {
1142 + goto queue_it;
1143 + }
1144 + } else {
1145 + /*
1146 + * Send all queued packets.
1147 + */
1148 + if (_vtpm_send_queued(chip) == 0) {
1149 +
1150 + vtpms->current_request = t;
1151 +
1152 + rc = vtpm_vd_send(vtpms->tpm_private,
1153 + buf,
1154 + count,
1155 + t);
1156 + /*
1157 + * The generic TPM driver will call
1158 + * the function to receive the response.
1159 + */
1160 + if (rc < 0) {
1161 + vtpms->current_request = NULL;
1162 + goto queue_it;
1163 + }
1164 + } else {
1165 +queue_it:
1166 + if (!transmission_set_req_buffer(t, buf, count)) {
1167 + transmission_free(t);
1168 + rc = -ENOMEM;
1169 + goto exit;
1170 + }
1171 + /*
1172 + * An error occurred. Don't event try
1173 + * to send the current request. Just
1174 + * queue it.
1175 + */
1176 + spin_lock_irqsave(&vtpms->req_list_lock, flags);
1177 + vtpms->flags |= DATAEX_FLAG_QUEUED_ONLY;
1178 + list_add_tail(&t->next, &vtpms->queued_requests);
1179 + spin_unlock_irqrestore(&vtpms->req_list_lock, flags);
1180 + }
1181 + }
1182 +
1183 +exit:
1184 + return rc;
1185 +}
1186 +
1187 +
1188 +/*
1189 + * Send all queued requests.
1190 + */
1191 +static int _vtpm_send_queued(struct tpm_chip *chip)
1192 +{
1193 + int rc;
1194 + int error = 0;
1195 + long flags;
1196 + unsigned char buffer[1];
1197 + struct vtpm_state *vtpms;
1198 + vtpms = (struct vtpm_state *)chip_get_private(chip);
1199 +
1200 + spin_lock_irqsave(&vtpms->req_list_lock, flags);
1201 +
1202 + while (!list_empty(&vtpms->queued_requests)) {
1203 + /*
1204 + * Need to dequeue them.
1205 + * Read the result into a dummy buffer.
1206 + */
1207 + struct transmission *qt = (struct transmission *)
1208 + vtpms->queued_requests.next;
1209 + list_del(&qt->next);
1210 + vtpms->current_request = qt;
1211 + spin_unlock_irqrestore(&vtpms->req_list_lock, flags);
1212 +
1213 + rc = vtpm_vd_send(vtpms->tpm_private,
1214 + qt->request,
1215 + qt->request_len,
1216 + qt);
1217 +
1218 + if (rc < 0) {
1219 + spin_lock_irqsave(&vtpms->req_list_lock, flags);
1220 + if ((qt = vtpms->current_request) != NULL) {
1221 + /*
1222 + * requeue it at the beginning
1223 + * of the list
1224 + */
1225 + list_add(&qt->next,
1226 + &vtpms->queued_requests);
1227 + }
1228 + vtpms->current_request = NULL;
1229 + error = 1;
1230 + break;
1231 + }
1232 + /*
1233 + * After this point qt is not valid anymore!
1234 + * It is freed when the front-end is delivering
1235 + * the data by calling tpm_recv
1236 + */
1237 + /*
1238 + * Receive response into provided dummy buffer
1239 + */
1240 + rc = vtpm_recv(chip, buffer, sizeof(buffer));
1241 + spin_lock_irqsave(&vtpms->req_list_lock, flags);
1242 + }
1243 +
1244 + spin_unlock_irqrestore(&vtpms->req_list_lock, flags);
1245 +
1246 + return error;
1247 +}
1248 +
1249 +static void vtpm_cancel(struct tpm_chip *chip)
1250 +{
1251 + unsigned long flags;
1252 + struct vtpm_state *vtpms = (struct vtpm_state *)chip_get_private(chip);
1253 +
1254 + spin_lock_irqsave(&vtpms->resp_list_lock,flags);
1255 +
1256 + if (!vtpms->current_response && vtpms->current_request) {
1257 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1258 + interruptible_sleep_on(&vtpms->resp_wait_queue);
1259 + spin_lock_irqsave(&vtpms->resp_list_lock,flags);
1260 + }
1261 +
1262 + if (vtpms->current_response) {
1263 + struct transmission *t = vtpms->current_response;
1264 + vtpms->current_response = NULL;
1265 + transmission_free(t);
1266 + }
1267 +
1268 + spin_unlock_irqrestore(&vtpms->resp_list_lock,flags);
1269 +}
1270 +
1271 +static u8 vtpm_status(struct tpm_chip *chip)
1272 +{
1273 + u8 rc = 0;
1274 + unsigned long flags;
1275 + struct vtpm_state *vtpms;
1276 +
1277 + vtpms = (struct vtpm_state *)chip_get_private(chip);
1278 +
1279 + spin_lock_irqsave(&vtpms->resp_list_lock, flags);
1280 + /*
1281 + * Data are available if:
1282 + * - there's a current response
1283 + * - the last packet was queued only (this is fake, but necessary to
1284 + * get the generic TPM layer to call the receive function.)
1285 + */
1286 + if (vtpms->current_response ||
1287 + 0 != (vtpms->flags & DATAEX_FLAG_QUEUED_ONLY)) {
1288 + rc = STATUS_DATA_AVAIL;
1289 + } else if (!vtpms->current_response && !vtpms->current_request) {
1290 + rc = STATUS_READY;
1291 + }
1292 +
1293 + spin_unlock_irqrestore(&vtpms->resp_list_lock, flags);
1294 + return rc;
1295 +}
1296 +
1297 +static struct file_operations vtpm_ops = {
1298 + .owner = THIS_MODULE,
1299 + .llseek = no_llseek,
1300 + .open = tpm_open,
1301 + .read = tpm_read,
1302 + .write = tpm_write,
1303 + .release = tpm_release,
1304 +};
1305 +
1306 +static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
1307 +static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
1308 +static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
1309 +static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
1310 +static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
1311 +static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated,
1312 + NULL);
1313 +static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
1314 +static DEVICE_ATTR(cancel, S_IWUSR |S_IWGRP, NULL, tpm_store_cancel);
1315 +
1316 +static struct attribute *vtpm_attrs[] = {
1317 + &dev_attr_pubek.attr,
1318 + &dev_attr_pcrs.attr,
1319 + &dev_attr_enabled.attr,
1320 + &dev_attr_active.attr,
1321 + &dev_attr_owned.attr,
1322 + &dev_attr_temp_deactivated.attr,
1323 + &dev_attr_caps.attr,
1324 + &dev_attr_cancel.attr,
1325 + NULL,
1326 +};
1327 +
1328 +static struct attribute_group vtpm_attr_grp = { .attrs = vtpm_attrs };
1329 +
1330 +#define TPM_LONG_TIMEOUT (10 * 60 * HZ)
1331 +
1332 +static struct tpm_vendor_specific tpm_vtpm = {
1333 + .recv = vtpm_recv,
1334 + .send = vtpm_send,
1335 + .cancel = vtpm_cancel,
1336 + .status = vtpm_status,
1337 + .req_complete_mask = STATUS_BUSY | STATUS_DATA_AVAIL,
1338 + .req_complete_val = STATUS_DATA_AVAIL,
1339 + .req_canceled = STATUS_READY,
1340 + .attr_group = &vtpm_attr_grp,
1341 + .miscdev = {
1342 + .fops = &vtpm_ops,
1343 + },
1344 + .duration = {
1345 + TPM_LONG_TIMEOUT,
1346 + TPM_LONG_TIMEOUT,
1347 + TPM_LONG_TIMEOUT,
1348 + },
1349 +};
1350 +
1351 +struct tpm_chip *init_vtpm(struct device *dev,
1352 + struct tpm_private *tp)
1353 +{
1354 + long rc;
1355 + struct tpm_chip *chip;
1356 + struct vtpm_state *vtpms;
1357 +
1358 + vtpms = kzalloc(sizeof(struct vtpm_state), GFP_KERNEL);
1359 + if (!vtpms)
1360 + return ERR_PTR(-ENOMEM);
1361 +
1362 + vtpm_state_init(vtpms);
1363 + vtpms->tpm_private = tp;
1364 +
1365 + chip = tpm_register_hardware(dev, &tpm_vtpm);
1366 + if (!chip) {
1367 + rc = -ENODEV;
1368 + goto err_free_mem;
1369 + }
1370 +
1371 + chip_set_private(chip, vtpms);
1372 +
1373 + return chip;
1374 +
1375 +err_free_mem:
1376 + kfree(vtpms);
1377 +
1378 + return ERR_PTR(rc);
1379 +}
1380 +
1381 +void cleanup_vtpm(struct device *dev)
1382 +{
1383 + struct tpm_chip *chip = dev_get_drvdata(dev);
1384 + struct vtpm_state *vtpms = (struct vtpm_state*)chip_get_private(chip);
1385 + tpm_remove_hardware(dev);
1386 + kfree(vtpms);
1387 +}
1388 --- /dev/null
1389 +++ b/drivers/char/tpm/tpm_vtpm.h
1390 @@ -0,0 +1,55 @@
1391 +#ifndef TPM_VTPM_H
1392 +#define TPM_VTPM_H
1393 +
1394 +struct tpm_chip;
1395 +struct tpm_private;
1396 +
1397 +struct vtpm_state {
1398 + struct transmission *current_request;
1399 + spinlock_t req_list_lock;
1400 + wait_queue_head_t req_wait_queue;
1401 +
1402 + struct list_head queued_requests;
1403 +
1404 + struct transmission *current_response;
1405 + spinlock_t resp_list_lock;
1406 + wait_queue_head_t resp_wait_queue; // processes waiting for responses
1407 +
1408 + u8 vd_status;
1409 + u8 flags;
1410 +
1411 + unsigned long disconnect_time;
1412 +
1413 + /*
1414 + * The following is a private structure of the underlying
1415 + * driver. It is passed as parameter in the send function.
1416 + */
1417 + struct tpm_private *tpm_private;
1418 +};
1419 +
1420 +
1421 +enum vdev_status {
1422 + TPM_VD_STATUS_DISCONNECTED = 0x0,
1423 + TPM_VD_STATUS_CONNECTED = 0x1
1424 +};
1425 +
1426 +/* this function is called from tpm_vtpm.c */
1427 +int vtpm_vd_send(struct tpm_private * tp,
1428 + const u8 * buf, size_t count, void *ptr);
1429 +
1430 +/* these functions are offered by tpm_vtpm.c */
1431 +struct tpm_chip *init_vtpm(struct device *,
1432 + struct tpm_private *);
1433 +void cleanup_vtpm(struct device *);
1434 +int vtpm_vd_recv(const struct tpm_chip* chip,
1435 + const unsigned char *buffer, size_t count, void *ptr);
1436 +void vtpm_vd_status(const struct tpm_chip *, u8 status);
1437 +
1438 +static inline struct tpm_private *tpm_private_from_dev(struct device *dev)
1439 +{
1440 + struct tpm_chip *chip = dev_get_drvdata(dev);
1441 + struct vtpm_state *vtpms = chip_get_private(chip);
1442 + return vtpms->tpm_private;
1443 +}
1444 +
1445 +#endif
1446 --- /dev/null
1447 +++ b/drivers/char/tpm/tpm_xen.c
1448 @@ -0,0 +1,722 @@
1449 +/*
1450 + * Copyright (c) 2005, IBM Corporation
1451 + *
1452 + * Author: Stefan Berger, stefanb@us.ibm.com
1453 + * Grant table support: Mahadevan Gomathisankaran
1454 + *
1455 + * This code has been derived from drivers/xen/netfront/netfront.c
1456 + *
1457 + * Copyright (c) 2002-2004, K A Fraser
1458 + *
1459 + * This program is free software; you can redistribute it and/or
1460 + * modify it under the terms of the GNU General Public License version 2
1461 + * as published by the Free Software Foundation; or, when distributed
1462 + * separately from the Linux kernel or incorporated into other
1463 + * software packages, subject to the following license:
1464 + *
1465 + * Permission is hereby granted, free of charge, to any person obtaining a copy
1466 + * of this source file (the "Software"), to deal in the Software without
1467 + * restriction, including without limitation the rights to use, copy, modify,
1468 + * merge, publish, distribute, sublicense, and/or sell copies of the Software,
1469 + * and to permit persons to whom the Software is furnished to do so, subject to
1470 + * the following conditions:
1471 + *
1472 + * The above copyright notice and this permission notice shall be included in
1473 + * all copies or substantial portions of the Software.
1474 + *
1475 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1476 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1477 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1478 + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1479 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
1480 + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
1481 + * IN THE SOFTWARE.
1482 + */
1483 +
1484 +#include <linux/errno.h>
1485 +#include <linux/err.h>
1486 +#include <linux/interrupt.h>
1487 +#include <linux/mutex.h>
1488 +#include <asm/uaccess.h>
1489 +#include <xen/evtchn.h>
1490 +#include <xen/interface/grant_table.h>
1491 +#include <xen/interface/io/tpmif.h>
1492 +#include <xen/gnttab.h>
1493 +#include <xen/xenbus.h>
1494 +#include "tpm.h"
1495 +#include "tpm_vtpm.h"
1496 +
1497 +#undef DEBUG
1498 +
1499 +/* local structures */
1500 +struct tpm_private {
1501 + struct tpm_chip *chip;
1502 +
1503 + tpmif_tx_interface_t *tx;
1504 + atomic_t refcnt;
1505 + unsigned int irq;
1506 + u8 is_connected;
1507 + u8 is_suspended;
1508 +
1509 + spinlock_t tx_lock;
1510 +
1511 + struct tx_buffer *tx_buffers[TPMIF_TX_RING_SIZE];
1512 +
1513 + atomic_t tx_busy;
1514 + void *tx_remember;
1515 +
1516 + domid_t backend_id;
1517 + wait_queue_head_t wait_q;
1518 +
1519 + struct xenbus_device *dev;
1520 + int ring_ref;
1521 +};
1522 +
1523 +struct tx_buffer {
1524 + unsigned int size; // available space in data
1525 + unsigned int len; // used space in data
1526 + unsigned char *data; // pointer to a page
1527 +};
1528 +
1529 +
1530 +/* locally visible variables */
1531 +static grant_ref_t gref_head;
1532 +static struct tpm_private *my_priv;
1533 +
1534 +/* local function prototypes */
1535 +static irqreturn_t tpmif_int(int irq,
1536 + void *tpm_priv,
1537 + struct pt_regs *ptregs);
1538 +static void tpmif_rx_action(unsigned long unused);
1539 +static int tpmif_connect(struct xenbus_device *dev,
1540 + struct tpm_private *tp,
1541 + domid_t domid);
1542 +static DECLARE_TASKLET(tpmif_rx_tasklet, tpmif_rx_action, 0);
1543 +static int tpmif_allocate_tx_buffers(struct tpm_private *tp);
1544 +static void tpmif_free_tx_buffers(struct tpm_private *tp);
1545 +static void tpmif_set_connected_state(struct tpm_private *tp,
1546 + u8 newstate);
1547 +static int tpm_xmit(struct tpm_private *tp,
1548 + const u8 * buf, size_t count, int userbuffer,
1549 + void *remember);
1550 +static void destroy_tpmring(struct tpm_private *tp);
1551 +void __exit tpmif_exit(void);
1552 +
1553 +#define DPRINTK(fmt, args...) \
1554 + pr_debug("xen_tpm_fr (%s:%d) " fmt, __FUNCTION__, __LINE__, ##args)
1555 +#define IPRINTK(fmt, args...) \
1556 + printk(KERN_INFO "xen_tpm_fr: " fmt, ##args)
1557 +#define WPRINTK(fmt, args...) \
1558 + printk(KERN_WARNING "xen_tpm_fr: " fmt, ##args)
1559 +
1560 +#define GRANT_INVALID_REF 0
1561 +
1562 +
1563 +static inline int
1564 +tx_buffer_copy(struct tx_buffer *txb, const u8 *src, int len,
1565 + int isuserbuffer)
1566 +{
1567 + int copied = len;
1568 +
1569 + if (len > txb->size)
1570 + copied = txb->size;
1571 + if (isuserbuffer) {
1572 + if (copy_from_user(txb->data, src, copied))
1573 + return -EFAULT;
1574 + } else {
1575 + memcpy(txb->data, src, copied);
1576 + }
1577 + txb->len = len;
1578 + return copied;
1579 +}
1580 +
1581 +static inline struct tx_buffer *tx_buffer_alloc(void)
1582 +{
1583 + struct tx_buffer *txb;
1584 +
1585 + txb = kzalloc(sizeof(struct tx_buffer), GFP_KERNEL);
1586 + if (!txb)
1587 + return NULL;
1588 +
1589 + txb->len = 0;
1590 + txb->size = PAGE_SIZE;
1591 + txb->data = (unsigned char *)__get_free_page(GFP_KERNEL);
1592 + if (txb->data == NULL) {
1593 + kfree(txb);
1594 + txb = NULL;
1595 + }
1596 +
1597 + return txb;
1598 +}
1599 +
1600 +
1601 +static inline void tx_buffer_free(struct tx_buffer *txb)
1602 +{
1603 + if (txb) {
1604 + free_page((long)txb->data);
1605 + kfree(txb);
1606 + }
1607 +}
1608 +
1609 +/**************************************************************
1610 + Utility function for the tpm_private structure
1611 +**************************************************************/
1612 +static void tpm_private_init(struct tpm_private *tp)
1613 +{
1614 + spin_lock_init(&tp->tx_lock);
1615 + init_waitqueue_head(&tp->wait_q);
1616 + atomic_set(&tp->refcnt, 1);
1617 +}
1618 +
1619 +static void tpm_private_put(void)
1620 +{
1621 + if (!atomic_dec_and_test(&my_priv->refcnt))
1622 + return;
1623 +
1624 + tpmif_free_tx_buffers(my_priv);
1625 + kfree(my_priv);
1626 + my_priv = NULL;
1627 +}
1628 +
1629 +static struct tpm_private *tpm_private_get(void)
1630 +{
1631 + int err;
1632 +
1633 + if (my_priv) {
1634 + atomic_inc(&my_priv->refcnt);
1635 + return my_priv;
1636 + }
1637 +
1638 + my_priv = kzalloc(sizeof(struct tpm_private), GFP_KERNEL);
1639 + if (!my_priv)
1640 + return NULL;
1641 +
1642 + tpm_private_init(my_priv);
1643 + err = tpmif_allocate_tx_buffers(my_priv);
1644 + if (err < 0)
1645 + tpm_private_put();
1646 +
1647 + return my_priv;
1648 +}
1649 +
1650 +/**************************************************************
1651 +
1652 + The interface to let the tpm plugin register its callback
1653 + function and send data to another partition using this module
1654 +
1655 +**************************************************************/
1656 +
1657 +static DEFINE_MUTEX(suspend_lock);
1658 +/*
1659 + * Send data via this module by calling this function
1660 + */
1661 +int vtpm_vd_send(struct tpm_private *tp,
1662 + const u8 * buf, size_t count, void *ptr)
1663 +{
1664 + int sent;
1665 +
1666 + mutex_lock(&suspend_lock);
1667 + sent = tpm_xmit(tp, buf, count, 0, ptr);
1668 + mutex_unlock(&suspend_lock);
1669 +
1670 + return sent;
1671 +}
1672 +
1673 +/**************************************************************
1674 + XENBUS support code
1675 +**************************************************************/
1676 +
1677 +static int setup_tpmring(struct xenbus_device *dev,
1678 + struct tpm_private *tp)
1679 +{
1680 + tpmif_tx_interface_t *sring;
1681 + int err;
1682 +
1683 + tp->ring_ref = GRANT_INVALID_REF;
1684 +
1685 + sring = (void *)__get_free_page(GFP_KERNEL);
1686 + if (!sring) {
1687 + xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring");
1688 + return -ENOMEM;
1689 + }
1690 + tp->tx = sring;
1691 +
1692 + err = xenbus_grant_ring(dev, virt_to_mfn(tp->tx));
1693 + if (err < 0) {
1694 + free_page((unsigned long)sring);
1695 + tp->tx = NULL;
1696 + xenbus_dev_fatal(dev, err, "allocating grant reference");
1697 + goto fail;
1698 + }
1699 + tp->ring_ref = err;
1700 +
1701 + err = tpmif_connect(dev, tp, dev->otherend_id);
1702 + if (err)
1703 + goto fail;
1704 +
1705 + return 0;
1706 +fail:
1707 + destroy_tpmring(tp);
1708 + return err;
1709 +}
1710 +
1711 +
1712 +static void destroy_tpmring(struct tpm_private *tp)
1713 +{
1714 + tpmif_set_connected_state(tp, 0);
1715 +
1716 + if (tp->ring_ref != GRANT_INVALID_REF) {
1717 + gnttab_end_foreign_access(tp->ring_ref, (unsigned long)tp->tx);
1718 + tp->ring_ref = GRANT_INVALID_REF;
1719 + tp->tx = NULL;
1720 + }
1721 +
1722 + if (tp->irq)
1723 + unbind_from_irqhandler(tp->irq, tp);
1724 +
1725 + tp->irq = 0;
1726 +}
1727 +
1728 +
1729 +static int talk_to_backend(struct xenbus_device *dev,
1730 + struct tpm_private *tp)
1731 +{
1732 + const char *message = NULL;
1733 + int err;
1734 + struct xenbus_transaction xbt;
1735 +
1736 + err = setup_tpmring(dev, tp);
1737 + if (err) {
1738 + xenbus_dev_fatal(dev, err, "setting up ring");
1739 + goto out;
1740 + }
1741 +
1742 +again:
1743 + err = xenbus_transaction_start(&xbt);
1744 + if (err) {
1745 + xenbus_dev_fatal(dev, err, "starting transaction");
1746 + goto destroy_tpmring;
1747 + }
1748 +
1749 + err = xenbus_printf(xbt, dev->nodename,
1750 + "ring-ref","%u", tp->ring_ref);
1751 + if (err) {
1752 + message = "writing ring-ref";
1753 + goto abort_transaction;
1754 + }
1755 +
1756 + err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
1757 + irq_to_evtchn_port(tp->irq));
1758 + if (err) {
1759 + message = "writing event-channel";
1760 + goto abort_transaction;
1761 + }
1762 +
1763 + err = xenbus_transaction_end(xbt, 0);
1764 + if (err == -EAGAIN)
1765 + goto again;
1766 + if (err) {
1767 + xenbus_dev_fatal(dev, err, "completing transaction");
1768 + goto destroy_tpmring;
1769 + }
1770 +
1771 + xenbus_switch_state(dev, XenbusStateConnected);
1772 +
1773 + return 0;
1774 +
1775 +abort_transaction:
1776 + xenbus_transaction_end(xbt, 1);
1777 + if (message)
1778 + xenbus_dev_error(dev, err, "%s", message);
1779 +destroy_tpmring:
1780 + destroy_tpmring(tp);
1781 +out:
1782 + return err;
1783 +}
1784 +
1785 +/**
1786 + * Callback received when the backend's state changes.
1787 + */
1788 +static void backend_changed(struct xenbus_device *dev,
1789 + enum xenbus_state backend_state)
1790 +{
1791 + struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
1792 + DPRINTK("\n");
1793 +
1794 + switch (backend_state) {
1795 + case XenbusStateInitialising:
1796 + case XenbusStateInitWait:
1797 + case XenbusStateInitialised:
1798 + case XenbusStateReconfiguring:
1799 + case XenbusStateReconfigured:
1800 + case XenbusStateUnknown:
1801 + break;
1802 +
1803 + case XenbusStateConnected:
1804 + tpmif_set_connected_state(tp, 1);
1805 + break;
1806 +
1807 + case XenbusStateClosing:
1808 + tpmif_set_connected_state(tp, 0);
1809 + xenbus_frontend_closed(dev);
1810 + break;
1811 +
1812 + case XenbusStateClosed:
1813 + tpmif_set_connected_state(tp, 0);
1814 + if (tp->is_suspended == 0)
1815 + device_unregister(&dev->dev);
1816 + xenbus_frontend_closed(dev);
1817 + break;
1818 + }
1819 +}
1820 +
1821 +static int tpmfront_probe(struct xenbus_device *dev,
1822 + const struct xenbus_device_id *id)
1823 +{
1824 + int err;
1825 + int handle;
1826 + struct tpm_private *tp = tpm_private_get();
1827 +
1828 + if (!tp)
1829 + return -ENOMEM;
1830 +
1831 + tp->chip = init_vtpm(&dev->dev, tp);
1832 + if (IS_ERR(tp->chip))
1833 + return PTR_ERR(tp->chip);
1834 +
1835 + err = xenbus_scanf(XBT_NIL, dev->nodename,
1836 + "handle", "%i", &handle);
1837 + if (XENBUS_EXIST_ERR(err))
1838 + return err;
1839 +
1840 + if (err < 0) {
1841 + xenbus_dev_fatal(dev,err,"reading virtual-device");
1842 + return err;
1843 + }
1844 +
1845 + tp->dev = dev;
1846 +
1847 + err = talk_to_backend(dev, tp);
1848 + if (err) {
1849 + tpm_private_put();
1850 + return err;
1851 + }
1852 +
1853 + return 0;
1854 +}
1855 +
1856 +
1857 +static int tpmfront_remove(struct xenbus_device *dev)
1858 +{
1859 + struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
1860 + destroy_tpmring(tp);
1861 + cleanup_vtpm(&dev->dev);
1862 + return 0;
1863 +}
1864 +
1865 +static int tpmfront_suspend(struct xenbus_device *dev)
1866 +{
1867 + struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
1868 + u32 ctr;
1869 +
1870 + /* Take the lock, preventing any application from sending. */
1871 + mutex_lock(&suspend_lock);
1872 + tp->is_suspended = 1;
1873 +
1874 + for (ctr = 0; atomic_read(&tp->tx_busy); ctr++) {
1875 + if ((ctr % 10) == 0)
1876 + printk("TPM-FE [INFO]: Waiting for outstanding "
1877 + "request.\n");
1878 + /* Wait for a request to be responded to. */
1879 + interruptible_sleep_on_timeout(&tp->wait_q, 100);
1880 + }
1881 +
1882 + return 0;
1883 +}
1884 +
1885 +static int tpmfront_suspend_finish(struct tpm_private *tp)
1886 +{
1887 + tp->is_suspended = 0;
1888 + /* Allow applications to send again. */
1889 + mutex_unlock(&suspend_lock);
1890 + return 0;
1891 +}
1892 +
1893 +static int tpmfront_suspend_cancel(struct xenbus_device *dev)
1894 +{
1895 + struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
1896 + return tpmfront_suspend_finish(tp);
1897 +}
1898 +
1899 +static int tpmfront_resume(struct xenbus_device *dev)
1900 +{
1901 + struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
1902 + destroy_tpmring(tp);
1903 + return talk_to_backend(dev, tp);
1904 +}
1905 +
1906 +static int tpmif_connect(struct xenbus_device *dev,
1907 + struct tpm_private *tp,
1908 + domid_t domid)
1909 +{
1910 + int err;
1911 +
1912 + tp->backend_id = domid;
1913 +
1914 + err = bind_listening_port_to_irqhandler(
1915 + domid, tpmif_int, SA_SAMPLE_RANDOM, "tpmif", tp);
1916 + if (err <= 0) {
1917 + WPRINTK("bind_listening_port_to_irqhandler failed "
1918 + "(err=%d)\n", err);
1919 + return err;
1920 + }
1921 + tp->irq = err;
1922 +
1923 + return 0;
1924 +}
1925 +
1926 +static struct xenbus_device_id tpmfront_ids[] = {
1927 + { "vtpm" },
1928 + { "" }
1929 +};
1930 +
1931 +static struct xenbus_driver tpmfront = {
1932 + .name = "vtpm",
1933 + .owner = THIS_MODULE,
1934 + .ids = tpmfront_ids,
1935 + .probe = tpmfront_probe,
1936 + .remove = tpmfront_remove,
1937 + .resume = tpmfront_resume,
1938 + .otherend_changed = backend_changed,
1939 + .suspend = tpmfront_suspend,
1940 + .suspend_cancel = tpmfront_suspend_cancel,
1941 +};
1942 +
1943 +static void __init init_tpm_xenbus(void)
1944 +{
1945 + xenbus_register_frontend(&tpmfront);
1946 +}
1947 +
1948 +static int tpmif_allocate_tx_buffers(struct tpm_private *tp)
1949 +{
1950 + unsigned int i;
1951 +
1952 + for (i = 0; i < TPMIF_TX_RING_SIZE; i++) {
1953 + tp->tx_buffers[i] = tx_buffer_alloc();
1954 + if (!tp->tx_buffers[i]) {
1955 + tpmif_free_tx_buffers(tp);
1956 + return -ENOMEM;
1957 + }
1958 + }
1959 + return 0;
1960 +}
1961 +
1962 +static void tpmif_free_tx_buffers(struct tpm_private *tp)
1963 +{
1964 + unsigned int i;
1965 +
1966 + for (i = 0; i < TPMIF_TX_RING_SIZE; i++)
1967 + tx_buffer_free(tp->tx_buffers[i]);
1968 +}
1969 +
1970 +static void tpmif_rx_action(unsigned long priv)
1971 +{
1972 + struct tpm_private *tp = (struct tpm_private *)priv;
1973 + int i = 0;
1974 + unsigned int received;
1975 + unsigned int offset = 0;
1976 + u8 *buffer;
1977 + tpmif_tx_request_t *tx = &tp->tx->ring[i].req;
1978 +
1979 + atomic_set(&tp->tx_busy, 0);
1980 + wake_up_interruptible(&tp->wait_q);
1981 +
1982 + received = tx->size;
1983 +
1984 + buffer = kmalloc(received, GFP_ATOMIC);
1985 + if (!buffer)
1986 + return;
1987 +
1988 + for (i = 0; i < TPMIF_TX_RING_SIZE && offset < received; i++) {
1989 + struct tx_buffer *txb = tp->tx_buffers[i];
1990 + tpmif_tx_request_t *tx;
1991 + unsigned int tocopy;
1992 +
1993 + tx = &tp->tx->ring[i].req;
1994 + tocopy = tx->size;
1995 + if (tocopy > PAGE_SIZE)
1996 + tocopy = PAGE_SIZE;
1997 +
1998 + memcpy(&buffer[offset], txb->data, tocopy);
1999 +
2000 + gnttab_release_grant_reference(&gref_head, tx->ref);
2001 +
2002 + offset += tocopy;
2003 + }
2004 +
2005 + vtpm_vd_recv(tp->chip, buffer, received, tp->tx_remember);
2006 + kfree(buffer);
2007 +}
2008 +
2009 +
2010 +static irqreturn_t tpmif_int(int irq, void *tpm_priv, struct pt_regs *ptregs)
2011 +{
2012 + struct tpm_private *tp = tpm_priv;
2013 + unsigned long flags;
2014 +
2015 + spin_lock_irqsave(&tp->tx_lock, flags);
2016 + tpmif_rx_tasklet.data = (unsigned long)tp;
2017 + tasklet_schedule(&tpmif_rx_tasklet);
2018 + spin_unlock_irqrestore(&tp->tx_lock, flags);
2019 +
2020 + return IRQ_HANDLED;
2021 +}
2022 +
2023 +
2024 +static int tpm_xmit(struct tpm_private *tp,
2025 + const u8 * buf, size_t count, int isuserbuffer,
2026 + void *remember)
2027 +{
2028 + tpmif_tx_request_t *tx;
2029 + TPMIF_RING_IDX i;
2030 + unsigned int offset = 0;
2031 +
2032 + spin_lock_irq(&tp->tx_lock);
2033 +
2034 + if (unlikely(atomic_read(&tp->tx_busy))) {
2035 + printk("tpm_xmit: There's an outstanding request/response "
2036 + "on the way!\n");
2037 + spin_unlock_irq(&tp->tx_lock);
2038 + return -EBUSY;
2039 + }
2040 +
2041 + if (tp->is_connected != 1) {
2042 + spin_unlock_irq(&tp->tx_lock);
2043 + return -EIO;
2044 + }
2045 +
2046 + for (i = 0; count > 0 && i < TPMIF_TX_RING_SIZE; i++) {
2047 + struct tx_buffer *txb = tp->tx_buffers[i];
2048 + int copied;
2049 +
2050 + if (!txb) {
2051 + DPRINTK("txb (i=%d) is NULL. buffers initilized?\n"
2052 + "Not transmitting anything!\n", i);
2053 + spin_unlock_irq(&tp->tx_lock);
2054 + return -EFAULT;
2055 + }
2056 +
2057 + copied = tx_buffer_copy(txb, &buf[offset], count,
2058 + isuserbuffer);
2059 + if (copied < 0) {
2060 + /* An error occurred */
2061 + spin_unlock_irq(&tp->tx_lock);
2062 + return copied;
2063 + }
2064 + count -= copied;
2065 + offset += copied;
2066 +
2067 + tx = &tp->tx->ring[i].req;
2068 + tx->addr = virt_to_machine(txb->data);
2069 + tx->size = txb->len;
2070 + tx->unused = 0;
2071 +
2072 + DPRINTK("First 4 characters sent by TPM-FE are "
2073 + "0x%02x 0x%02x 0x%02x 0x%02x\n",
2074 + txb->data[0],txb->data[1],txb->data[2],txb->data[3]);
2075 +
2076 + /* Get the granttable reference for this page. */
2077 + tx->ref = gnttab_claim_grant_reference(&gref_head);
2078 + if (tx->ref == -ENOSPC) {
2079 + spin_unlock_irq(&tp->tx_lock);
2080 + DPRINTK("Grant table claim reference failed in "
2081 + "func:%s line:%d file:%s\n",
2082 + __FUNCTION__, __LINE__, __FILE__);
2083 + return -ENOSPC;
2084 + }
2085 + gnttab_grant_foreign_access_ref(tx->ref,
2086 + tp->backend_id,
2087 + virt_to_mfn(txb->data),
2088 + 0 /*RW*/);
2089 + wmb();
2090 + }
2091 +
2092 + atomic_set(&tp->tx_busy, 1);
2093 + tp->tx_remember = remember;
2094 +
2095 + mb();
2096 +
2097 + notify_remote_via_irq(tp->irq);
2098 +
2099 + spin_unlock_irq(&tp->tx_lock);
2100 + return offset;
2101 +}
2102 +
2103 +
2104 +static void tpmif_notify_upperlayer(struct tpm_private *tp)
2105 +{
2106 + /* Notify upper layer about the state of the connection to the BE. */
2107 + vtpm_vd_status(tp->chip, (tp->is_connected
2108 + ? TPM_VD_STATUS_CONNECTED
2109 + : TPM_VD_STATUS_DISCONNECTED));
2110 +}
2111 +
2112 +
2113 +static void tpmif_set_connected_state(struct tpm_private *tp, u8 is_connected)
2114 +{
2115 + /*
2116 + * Don't notify upper layer if we are in suspend mode and
2117 + * should disconnect - assumption is that we will resume
2118 + * The mutex keeps apps from sending.
2119 + */
2120 + if (is_connected == 0 && tp->is_suspended == 1)
2121 + return;
2122 +
2123 + /*
2124 + * Unlock the mutex if we are connected again
2125 + * after being suspended - now resuming.
2126 + * This also removes the suspend state.
2127 + */
2128 + if (is_connected == 1 && tp->is_suspended == 1)
2129 + tpmfront_suspend_finish(tp);
2130 +
2131 + if (is_connected != tp->is_connected) {
2132 + tp->is_connected = is_connected;
2133 + tpmif_notify_upperlayer(tp);
2134 + }
2135 +}
2136 +
2137 +
2138 +
2139 +/* =================================================================
2140 + * Initialization function.
2141 + * =================================================================
2142 + */
2143 +
2144 +
2145 +static int __init tpmif_init(void)
2146 +{
2147 + struct tpm_private *tp;
2148 +
2149 + if (is_initial_xendomain())
2150 + return -EPERM;
2151 +
2152 + tp = tpm_private_get();
2153 + if (!tp)
2154 + return -ENOMEM;
2155 +
2156 + IPRINTK("Initialising the vTPM driver.\n");
2157 + if (gnttab_alloc_grant_references(TPMIF_TX_RING_SIZE,
2158 + &gref_head) < 0) {
2159 + tpm_private_put();
2160 + return -EFAULT;
2161 + }
2162 +
2163 + init_tpm_xenbus();
2164 + return 0;
2165 +}
2166 +
2167 +
2168 +module_init(tpmif_init);
2169 +
2170 +MODULE_LICENSE("Dual BSD/GPL");
2171 --- a/drivers/ide/ide-lib.c
2172 +++ b/drivers/ide/ide-lib.c
2173 @@ -177,12 +177,12 @@ void ide_toggle_bounce(ide_drive_t *driv
2174 {
2175 u64 addr = BLK_BOUNCE_HIGH; /* dma64_addr_t */
2176
2177 - if (!PCI_DMA_BUS_IS_PHYS) {
2178 - addr = BLK_BOUNCE_ANY;
2179 - } else if (on && drive->media == ide_disk) {
2180 + if (on && drive->media == ide_disk) {
2181 struct device *dev = drive->hwif->dev;
2182
2183 - if (dev && dev->dma_mask)
2184 + if (!PCI_DMA_BUS_IS_PHYS)
2185 + addr = BLK_BOUNCE_ANY;
2186 + else if (dev && dev->dma_mask)
2187 addr = *dev->dma_mask;
2188 }
2189
2190 --- a/drivers/Makefile
2191 +++ b/drivers/Makefile
2192 @@ -37,6 +37,7 @@ obj-y += base/ block/ misc/ mfd/ net/
2193 obj-$(CONFIG_NUBUS) += nubus/
2194 obj-$(CONFIG_ATM) += atm/
2195 obj-y += macintosh/
2196 +obj-$(CONFIG_XEN) += xen/
2197 obj-$(CONFIG_IDE) += ide/
2198 obj-$(CONFIG_SCSI) += scsi/
2199 obj-$(CONFIG_ATA) += ata/
2200 --- a/drivers/oprofile/buffer_sync.c
2201 +++ b/drivers/oprofile/buffer_sync.c
2202 @@ -6,6 +6,10 @@
2203 *
2204 * @author John Levon <levon@movementarian.org>
2205 *
2206 + * Modified by Aravind Menon for Xen
2207 + * These modifications are:
2208 + * Copyright (C) 2005 Hewlett-Packard Co.
2209 + *
2210 * This is the core of the buffer management. Each
2211 * CPU buffer is processed and entered into the
2212 * global event buffer. Such processing is necessary
2213 @@ -40,6 +44,7 @@ static cpumask_t marked_cpus = CPU_MASK_
2214 static DEFINE_SPINLOCK(task_mortuary);
2215 static void process_task_mortuary(void);
2216
2217 +static int cpu_current_domain[NR_CPUS];
2218
2219 /* Take ownership of the task struct and place it on the
2220 * list for processing. Only after two full buffer syncs
2221 @@ -148,6 +153,11 @@ static void end_sync(void)
2222 int sync_start(void)
2223 {
2224 int err;
2225 + int i;
2226 +
2227 + for (i = 0; i < NR_CPUS; i++) {
2228 + cpu_current_domain[i] = COORDINATOR_DOMAIN;
2229 + }
2230
2231 start_cpu_work();
2232
2233 @@ -274,15 +284,31 @@ static void add_cpu_switch(int i)
2234 last_cookie = INVALID_COOKIE;
2235 }
2236
2237 -static void add_kernel_ctx_switch(unsigned int in_kernel)
2238 +static void add_cpu_mode_switch(unsigned int cpu_mode)
2239 {
2240 add_event_entry(ESCAPE_CODE);
2241 - if (in_kernel)
2242 - add_event_entry(KERNEL_ENTER_SWITCH_CODE);
2243 - else
2244 - add_event_entry(KERNEL_EXIT_SWITCH_CODE);
2245 + switch (cpu_mode) {
2246 + case CPU_MODE_USER:
2247 + add_event_entry(USER_ENTER_SWITCH_CODE);
2248 + break;
2249 + case CPU_MODE_KERNEL:
2250 + add_event_entry(KERNEL_ENTER_SWITCH_CODE);
2251 + break;
2252 + case CPU_MODE_XEN:
2253 + add_event_entry(XEN_ENTER_SWITCH_CODE);
2254 + break;
2255 + default:
2256 + break;
2257 + }
2258 }
2259 -
2260 +
2261 +static void add_domain_switch(unsigned long domain_id)
2262 +{
2263 + add_event_entry(ESCAPE_CODE);
2264 + add_event_entry(DOMAIN_SWITCH_CODE);
2265 + add_event_entry(domain_id);
2266 +}
2267 +
2268 static void
2269 add_user_ctx_switch(struct task_struct const * task, unsigned long cookie)
2270 {
2271 @@ -347,9 +373,9 @@ static int add_us_sample(struct mm_struc
2272 * for later lookup from userspace.
2273 */
2274 static int
2275 -add_sample(struct mm_struct * mm, struct op_sample * s, int in_kernel)
2276 +add_sample(struct mm_struct * mm, struct op_sample * s, int cpu_mode)
2277 {
2278 - if (in_kernel) {
2279 + if (cpu_mode >= CPU_MODE_KERNEL) {
2280 add_sample_entry(s->eip, s->event);
2281 return 1;
2282 } else if (mm) {
2283 @@ -495,15 +521,21 @@ void sync_buffer(int cpu)
2284 struct mm_struct *mm = NULL;
2285 struct task_struct * new;
2286 unsigned long cookie = 0;
2287 - int in_kernel = 1;
2288 + int cpu_mode = 1;
2289 unsigned int i;
2290 sync_buffer_state state = sb_buffer_start;
2291 unsigned long available;
2292 + int domain_switch = 0;
2293
2294 mutex_lock(&buffer_mutex);
2295
2296 add_cpu_switch(cpu);
2297
2298 + /* We need to assign the first samples in this CPU buffer to the
2299 + same domain that we were processing at the last sync_buffer */
2300 + if (cpu_current_domain[cpu] != COORDINATOR_DOMAIN) {
2301 + add_domain_switch(cpu_current_domain[cpu]);
2302 + }
2303 /* Remember, only we can modify tail_pos */
2304
2305 available = get_slots(cpu_buf);
2306 @@ -511,16 +543,18 @@ void sync_buffer(int cpu)
2307 for (i = 0; i < available; ++i) {
2308 struct op_sample * s = &cpu_buf->buffer[cpu_buf->tail_pos];
2309
2310 - if (is_code(s->eip)) {
2311 - if (s->event <= CPU_IS_KERNEL) {
2312 - /* kernel/userspace switch */
2313 - in_kernel = s->event;
2314 + if (is_code(s->eip) && !domain_switch) {
2315 + if (s->event <= CPU_MODE_XEN) {
2316 + /* xen/kernel/userspace switch */
2317 + cpu_mode = s->event;
2318 if (state == sb_buffer_start)
2319 state = sb_sample_start;
2320 - add_kernel_ctx_switch(s->event);
2321 + add_cpu_mode_switch(s->event);
2322 } else if (s->event == CPU_TRACE_BEGIN) {
2323 state = sb_bt_start;
2324 add_trace_begin();
2325 + } else if (s->event == CPU_DOMAIN_SWITCH) {
2326 + domain_switch = 1;
2327 } else {
2328 struct mm_struct * oldmm = mm;
2329
2330 @@ -534,11 +568,21 @@ void sync_buffer(int cpu)
2331 add_user_ctx_switch(new, cookie);
2332 }
2333 } else {
2334 - if (state >= sb_bt_start &&
2335 - !add_sample(mm, s, in_kernel)) {
2336 - if (state == sb_bt_start) {
2337 - state = sb_bt_ignore;
2338 - atomic_inc(&oprofile_stats.bt_lost_no_mapping);
2339 + if (domain_switch) {
2340 + cpu_current_domain[cpu] = s->eip;
2341 + add_domain_switch(s->eip);
2342 + domain_switch = 0;
2343 + } else {
2344 + if (cpu_current_domain[cpu] !=
2345 + COORDINATOR_DOMAIN) {
2346 + add_sample_entry(s->eip, s->event);
2347 + }
2348 + else if (state >= sb_bt_start &&
2349 + !add_sample(mm, s, cpu_mode)) {
2350 + if (state == sb_bt_start) {
2351 + state = sb_bt_ignore;
2352 + atomic_inc(&oprofile_stats.bt_lost_no_mapping);
2353 + }
2354 }
2355 }
2356 }
2357 @@ -547,6 +591,11 @@ void sync_buffer(int cpu)
2358 }
2359 release_mm(mm);
2360
2361 + /* We reset domain to COORDINATOR at each CPU switch */
2362 + if (cpu_current_domain[cpu] != COORDINATOR_DOMAIN) {
2363 + add_domain_switch(COORDINATOR_DOMAIN);
2364 + }
2365 +
2366 mark_done(cpu);
2367
2368 mutex_unlock(&buffer_mutex);
2369 --- a/drivers/oprofile/cpu_buffer.c
2370 +++ b/drivers/oprofile/cpu_buffer.c
2371 @@ -6,6 +6,10 @@
2372 *
2373 * @author John Levon <levon@movementarian.org>
2374 *
2375 + * Modified by Aravind Menon for Xen
2376 + * These modifications are:
2377 + * Copyright (C) 2005 Hewlett-Packard Co.
2378 + *
2379 * Each CPU has a local buffer that stores PC value/event
2380 * pairs. We also log context switches when we notice them.
2381 * Eventually each CPU's buffer is processed into the global
2382 @@ -34,6 +38,8 @@ static void wq_sync_buffer(struct work_s
2383 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
2384 static int work_enabled;
2385
2386 +static int32_t current_domain = COORDINATOR_DOMAIN;
2387 +
2388 void free_cpu_buffers(void)
2389 {
2390 int i;
2391 @@ -72,7 +78,7 @@ int alloc_cpu_buffers(void)
2392 goto fail;
2393
2394 b->last_task = NULL;
2395 - b->last_is_kernel = -1;
2396 + b->last_cpu_mode = -1;
2397 b->tracing = 0;
2398 b->buffer_size = buffer_size;
2399 b->tail_pos = 0;
2400 @@ -130,7 +136,7 @@ void cpu_buffer_reset(struct oprofile_cp
2401 * collected will populate the buffer with proper
2402 * values to initialize the buffer
2403 */
2404 - cpu_buf->last_is_kernel = -1;
2405 + cpu_buf->last_cpu_mode = -1;
2406 cpu_buf->last_task = NULL;
2407 }
2408
2409 @@ -180,13 +186,13 @@ add_code(struct oprofile_cpu_buffer * bu
2410 * because of the head/tail separation of the writer and reader
2411 * of the CPU buffer.
2412 *
2413 - * is_kernel is needed because on some architectures you cannot
2414 + * cpu_mode is needed because on some architectures you cannot
2415 * tell if you are in kernel or user space simply by looking at
2416 - * pc. We tag this in the buffer by generating kernel enter/exit
2417 - * events whenever is_kernel changes
2418 + * pc. We tag this in the buffer by generating kernel/user (and xen)
2419 + * enter events whenever cpu_mode changes
2420 */
2421 static int log_sample(struct oprofile_cpu_buffer * cpu_buf, unsigned long pc,
2422 - int is_kernel, unsigned long event)
2423 + int cpu_mode, unsigned long event)
2424 {
2425 struct task_struct * task;
2426
2427 @@ -202,18 +208,18 @@ static int log_sample(struct oprofile_cp
2428 return 0;
2429 }
2430
2431 - is_kernel = !!is_kernel;
2432 -
2433 task = current;
2434
2435 /* notice a switch from user->kernel or vice versa */
2436 - if (cpu_buf->last_is_kernel != is_kernel) {
2437 - cpu_buf->last_is_kernel = is_kernel;
2438 - add_code(cpu_buf, is_kernel);
2439 + if (cpu_buf->last_cpu_mode != cpu_mode) {
2440 + cpu_buf->last_cpu_mode = cpu_mode;
2441 + add_code(cpu_buf, cpu_mode);
2442 }
2443 -
2444 +
2445 /* notice a task switch */
2446 - if (cpu_buf->last_task != task) {
2447 + /* if not processing other domain samples */
2448 + if ((cpu_buf->last_task != task) &&
2449 + (current_domain == COORDINATOR_DOMAIN)) {
2450 cpu_buf->last_task = task;
2451 add_code(cpu_buf, (unsigned long)task);
2452 }
2453 @@ -297,6 +303,25 @@ void oprofile_add_trace(unsigned long pc
2454 add_sample(cpu_buf, pc, 0);
2455 }
2456
2457 +int oprofile_add_domain_switch(int32_t domain_id)
2458 +{
2459 + struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];
2460 +
2461 + /* should have space for switching into and out of domain
2462 + (2 slots each) plus one sample and one cpu mode switch */
2463 + if (((nr_available_slots(cpu_buf) < 6) &&
2464 + (domain_id != COORDINATOR_DOMAIN)) ||
2465 + (nr_available_slots(cpu_buf) < 2))
2466 + return 0;
2467 +
2468 + add_code(cpu_buf, CPU_DOMAIN_SWITCH);
2469 + add_sample(cpu_buf, domain_id, 0);
2470 +
2471 + current_domain = domain_id;
2472 +
2473 + return 1;
2474 +}
2475 +
2476 /*
2477 * This serves to avoid cpu buffer overflow, and makes sure
2478 * the task mortuary progresses
2479 --- a/drivers/oprofile/cpu_buffer.h
2480 +++ b/drivers/oprofile/cpu_buffer.h
2481 @@ -37,7 +37,7 @@ struct oprofile_cpu_buffer {
2482 volatile unsigned long tail_pos;
2483 unsigned long buffer_size;
2484 struct task_struct * last_task;
2485 - int last_is_kernel;
2486 + int last_cpu_mode;
2487 int tracing;
2488 struct op_sample * buffer;
2489 unsigned long sample_received;
2490 @@ -53,7 +53,10 @@ DECLARE_PER_CPU(struct oprofile_cpu_buff
2491 void cpu_buffer_reset(struct oprofile_cpu_buffer * cpu_buf);
2492
2493 /* transient events for the CPU buffer -> event buffer */
2494 -#define CPU_IS_KERNEL 1
2495 -#define CPU_TRACE_BEGIN 2
2496 +#define CPU_MODE_USER 0
2497 +#define CPU_MODE_KERNEL 1
2498 +#define CPU_MODE_XEN 2
2499 +#define CPU_TRACE_BEGIN 3
2500 +#define CPU_DOMAIN_SWITCH 4
2501
2502 #endif /* OPROFILE_CPU_BUFFER_H */
2503 --- a/drivers/oprofile/event_buffer.h
2504 +++ b/drivers/oprofile/event_buffer.h
2505 @@ -30,6 +30,9 @@ void wake_up_buffer_waiter(void);
2506 #define INVALID_COOKIE ~0UL
2507 #define NO_COOKIE 0UL
2508
2509 +/* Constant used to refer to coordinator domain (Xen) */
2510 +#define COORDINATOR_DOMAIN -1
2511 +
2512 extern const struct file_operations event_buffer_fops;
2513
2514 /* mutex between sync_cpu_buffers() and the
2515 --- a/drivers/oprofile/oprof.c
2516 +++ b/drivers/oprofile/oprof.c
2517 @@ -5,6 +5,10 @@
2518 * @remark Read the file COPYING
2519 *
2520 * @author John Levon <levon@movementarian.org>
2521 + *
2522 + * Modified by Aravind Menon for Xen
2523 + * These modifications are:
2524 + * Copyright (C) 2005 Hewlett-Packard Co.
2525 */
2526
2527 #include <linux/kernel.h>
2528 @@ -33,6 +37,32 @@ static DEFINE_MUTEX(start_mutex);
2529 */
2530 static int timer = 0;
2531
2532 +int oprofile_set_active(int active_domains[], unsigned int adomains)
2533 +{
2534 + int err;
2535 +
2536 + if (!oprofile_ops.set_active)
2537 + return -EINVAL;
2538 +
2539 + mutex_lock(&start_mutex);
2540 + err = oprofile_ops.set_active(active_domains, adomains);
2541 + mutex_unlock(&start_mutex);
2542 + return err;
2543 +}
2544 +
2545 +int oprofile_set_passive(int passive_domains[], unsigned int pdomains)
2546 +{
2547 + int err;
2548 +
2549 + if (!oprofile_ops.set_passive)
2550 + return -EINVAL;
2551 +
2552 + mutex_lock(&start_mutex);
2553 + err = oprofile_ops.set_passive(passive_domains, pdomains);
2554 + mutex_unlock(&start_mutex);
2555 + return err;
2556 +}
2557 +
2558 int oprofile_setup(void)
2559 {
2560 int err;
2561 --- a/drivers/oprofile/oprof.h
2562 +++ b/drivers/oprofile/oprof.h
2563 @@ -35,5 +35,8 @@ void oprofile_create_files(struct super_
2564 void oprofile_timer_init(struct oprofile_operations * ops);
2565
2566 int oprofile_set_backtrace(unsigned long depth);
2567 +
2568 +int oprofile_set_active(int active_domains[], unsigned int adomains);
2569 +int oprofile_set_passive(int passive_domains[], unsigned int pdomains);
2570
2571 #endif /* OPROF_H */
2572 --- a/drivers/oprofile/oprofile_files.c
2573 +++ b/drivers/oprofile/oprofile_files.c
2574 @@ -5,15 +5,21 @@
2575 * @remark Read the file COPYING
2576 *
2577 * @author John Levon <levon@movementarian.org>
2578 + *
2579 + * Modified by Aravind Menon for Xen
2580 + * These modifications are:
2581 + * Copyright (C) 2005 Hewlett-Packard Co.
2582 */
2583
2584 #include <linux/fs.h>
2585 #include <linux/oprofile.h>
2586 +#include <asm/uaccess.h>
2587 +#include <linux/ctype.h>
2588
2589 #include "event_buffer.h"
2590 #include "oprofile_stats.h"
2591 #include "oprof.h"
2592 -
2593 +
2594 unsigned long fs_buffer_size = 131072;
2595 unsigned long fs_cpu_buffer_size = 8192;
2596 unsigned long fs_buffer_watershed = 32768; /* FIXME: tune */
2597 @@ -117,11 +123,202 @@ static ssize_t dump_write(struct file *
2598 static const struct file_operations dump_fops = {
2599 .write = dump_write,
2600 };
2601 -
2602 +
2603 +#define TMPBUFSIZE 512
2604 +
2605 +static unsigned int adomains = 0;
2606 +static int active_domains[MAX_OPROF_DOMAINS + 1];
2607 +static DEFINE_MUTEX(adom_mutex);
2608 +
2609 +static ssize_t adomain_write(struct file * file, char const __user * buf,
2610 + size_t count, loff_t * offset)
2611 +{
2612 + char *tmpbuf;
2613 + char *startp, *endp;
2614 + int i;
2615 + unsigned long val;
2616 + ssize_t retval = count;
2617 +
2618 + if (*offset)
2619 + return -EINVAL;
2620 + if (count > TMPBUFSIZE - 1)
2621 + return -EINVAL;
2622 +
2623 + if (!(tmpbuf = kmalloc(TMPBUFSIZE, GFP_KERNEL)))
2624 + return -ENOMEM;
2625 +
2626 + if (copy_from_user(tmpbuf, buf, count)) {
2627 + kfree(tmpbuf);
2628 + return -EFAULT;
2629 + }
2630 + tmpbuf[count] = 0;
2631 +
2632 + mutex_lock(&adom_mutex);
2633 +
2634 + startp = tmpbuf;
2635 + /* Parse one more than MAX_OPROF_DOMAINS, for easy error checking */
2636 + for (i = 0; i <= MAX_OPROF_DOMAINS; i++) {
2637 + val = simple_strtoul(startp, &endp, 0);
2638 + if (endp == startp)
2639 + break;
2640 + while (ispunct(*endp) || isspace(*endp))
2641 + endp++;
2642 + active_domains[i] = val;
2643 + if (active_domains[i] != val)
2644 + /* Overflow, force error below */
2645 + i = MAX_OPROF_DOMAINS + 1;
2646 + startp = endp;
2647 + }
2648 + /* Force error on trailing junk */
2649 + adomains = *startp ? MAX_OPROF_DOMAINS + 1 : i;
2650 +
2651 + kfree(tmpbuf);
2652 +
2653 + if (adomains > MAX_OPROF_DOMAINS
2654 + || oprofile_set_active(active_domains, adomains)) {
2655 + adomains = 0;
2656 + retval = -EINVAL;
2657 + }
2658 +
2659 + mutex_unlock(&adom_mutex);
2660 + return retval;
2661 +}
2662 +
2663 +static ssize_t adomain_read(struct file * file, char __user * buf,
2664 + size_t count, loff_t * offset)
2665 +{
2666 + char * tmpbuf;
2667 + size_t len;
2668 + int i;
2669 + ssize_t retval;
2670 +
2671 + if (!(tmpbuf = kmalloc(TMPBUFSIZE, GFP_KERNEL)))
2672 + return -ENOMEM;
2673 +
2674 + mutex_lock(&adom_mutex);
2675 +
2676 + len = 0;
2677 + for (i = 0; i < adomains; i++)
2678 + len += snprintf(tmpbuf + len,
2679 + len < TMPBUFSIZE ? TMPBUFSIZE - len : 0,
2680 + "%u ", active_domains[i]);
2681 + WARN_ON(len > TMPBUFSIZE);
2682 + if (len != 0 && len <= TMPBUFSIZE)
2683 + tmpbuf[len-1] = '\n';
2684 +
2685 + mutex_unlock(&adom_mutex);
2686 +
2687 + retval = simple_read_from_buffer(buf, count, offset, tmpbuf, len);
2688 +
2689 + kfree(tmpbuf);
2690 + return retval;
2691 +}
2692 +
2693 +
2694 +static struct file_operations active_domain_ops = {
2695 + .read = adomain_read,
2696 + .write = adomain_write,
2697 +};
2698 +
2699 +static unsigned int pdomains = 0;
2700 +static int passive_domains[MAX_OPROF_DOMAINS];
2701 +static DEFINE_MUTEX(pdom_mutex);
2702 +
2703 +static ssize_t pdomain_write(struct file * file, char const __user * buf,
2704 + size_t count, loff_t * offset)
2705 +{
2706 + char *tmpbuf;
2707 + char *startp, *endp;
2708 + int i;
2709 + unsigned long val;
2710 + ssize_t retval = count;
2711 +
2712 + if (*offset)
2713 + return -EINVAL;
2714 + if (count > TMPBUFSIZE - 1)
2715 + return -EINVAL;
2716 +
2717 + if (!(tmpbuf = kmalloc(TMPBUFSIZE, GFP_KERNEL)))
2718 + return -ENOMEM;
2719 +
2720 + if (copy_from_user(tmpbuf, buf, count)) {
2721 + kfree(tmpbuf);
2722 + return -EFAULT;
2723 + }
2724 + tmpbuf[count] = 0;
2725 +
2726 + mutex_lock(&pdom_mutex);
2727 +
2728 + startp = tmpbuf;
2729 + /* Parse one more than MAX_OPROF_DOMAINS, for easy error checking */
2730 + for (i = 0; i <= MAX_OPROF_DOMAINS; i++) {
2731 + val = simple_strtoul(startp, &endp, 0);
2732 + if (endp == startp)
2733 + break;
2734 + while (ispunct(*endp) || isspace(*endp))
2735 + endp++;
2736 + passive_domains[i] = val;
2737 + if (passive_domains[i] != val)
2738 + /* Overflow, force error below */
2739 + i = MAX_OPROF_DOMAINS + 1;
2740 + startp = endp;
2741 + }
2742 + /* Force error on trailing junk */
2743 + pdomains = *startp ? MAX_OPROF_DOMAINS + 1 : i;
2744 +
2745 + kfree(tmpbuf);
2746 +
2747 + if (pdomains > MAX_OPROF_DOMAINS
2748 + || oprofile_set_passive(passive_domains, pdomains)) {
2749 + pdomains = 0;
2750 + retval = -EINVAL;
2751 + }
2752 +
2753 + mutex_unlock(&pdom_mutex);
2754 + return retval;
2755 +}
2756 +
2757 +static ssize_t pdomain_read(struct file * file, char __user * buf,
2758 + size_t count, loff_t * offset)
2759 +{
2760 + char * tmpbuf;
2761 + size_t len;
2762 + int i;
2763 + ssize_t retval;
2764 +
2765 + if (!(tmpbuf = kmalloc(TMPBUFSIZE, GFP_KERNEL)))
2766 + return -ENOMEM;
2767 +
2768 + mutex_lock(&pdom_mutex);
2769 +
2770 + len = 0;
2771 + for (i = 0; i < pdomains; i++)
2772 + len += snprintf(tmpbuf + len,
2773 + len < TMPBUFSIZE ? TMPBUFSIZE - len : 0,
2774 + "%u ", passive_domains[i]);
2775 + WARN_ON(len > TMPBUFSIZE);
2776 + if (len != 0 && len <= TMPBUFSIZE)
2777 + tmpbuf[len-1] = '\n';
2778 +
2779 + mutex_unlock(&pdom_mutex);
2780 +
2781 + retval = simple_read_from_buffer(buf, count, offset, tmpbuf, len);
2782 +
2783 + kfree(tmpbuf);
2784 + return retval;
2785 +}
2786 +
2787 +static struct file_operations passive_domain_ops = {
2788 + .read = pdomain_read,
2789 + .write = pdomain_write,
2790 +};
2791 +
2792 void oprofile_create_files(struct super_block * sb, struct dentry * root)
2793 {
2794 oprofilefs_create_file(sb, root, "enable", &enable_fops);
2795 oprofilefs_create_file_perm(sb, root, "dump", &dump_fops, 0666);
2796 + oprofilefs_create_file(sb, root, "active_domains", &active_domain_ops);
2797 + oprofilefs_create_file(sb, root, "passive_domains", &passive_domain_ops);
2798 oprofilefs_create_file(sb, root, "buffer", &event_buffer_fops);
2799 oprofilefs_create_ulong(sb, root, "buffer_size", &fs_buffer_size);
2800 oprofilefs_create_ulong(sb, root, "buffer_watershed", &fs_buffer_watershed);
2801 #--- a/fs/aio.c
2802 #+++ b/fs/aio.c
2803 #@@ -36,6 +36,11 @@
2804 # #include <asm/uaccess.h>
2805 # #include <asm/mmu_context.h>
2806
2807 #+#ifdef CONFIG_EPOLL
2808 #+#include <linux/poll.h>
2809 #+#include <linux/eventpoll.h>
2810 #+#endif
2811 #+
2812 # #if DEBUG > 1
2813 # #define dprintk printk
2814 # #else
2815 #@@ -1010,6 +1015,11 @@ put_rq:
2816 # if (waitqueue_active(&ctx->wait))
2817 # wake_up(&ctx->wait);
2818 #
2819 #+#ifdef CONFIG_EPOLL
2820 #+ if (ctx->file && waitqueue_active(&ctx->poll_wait))
2821 #+ wake_up(&ctx->poll_wait);
2822 #+#endif
2823 #+
2824 # spin_unlock_irqrestore(&ctx->ctx_lock, flags);
2825 # return ret;
2826 # }
2827 #@@ -1017,6 +1027,8 @@ put_rq:
2828 # /* aio_read_evt
2829 # * Pull an event off of the ioctx's event ring. Returns the number of
2830 # * events fetched (0 or 1 ;-)
2831 #+ * If ent parameter is 0, just returns the number of events that would
2832 #+ * be fetched.
2833 # * FIXME: make this use cmpxchg.
2834 # * TODO: make the ringbuffer user mmap()able (requires FIXME).
2835 # */
2836 #@@ -1039,13 +1051,18 @@ static int aio_read_evt(struct kioctx *i
2837 #
2838 # head = ring->head % info->nr;
2839 # if (head != ring->tail) {
2840 #- struct io_event *evp = aio_ring_event(info, head, KM_USER1);
2841 #- *ent = *evp;
2842 #- head = (head + 1) % info->nr;
2843 #- smp_mb(); /* finish reading the event before updatng the head */
2844 #- ring->head = head;
2845 #- ret = 1;
2846 #- put_aio_ring_event(evp, KM_USER1);
2847 #+ if (ent) { /* event requested */
2848 #+ struct io_event *evp =
2849 #+ aio_ring_event(info, head, KM_USER1);
2850 #+ *ent = *evp;
2851 #+ head = (head + 1) % info->nr;
2852 #+ /* finish reading the event before updatng the head */
2853 #+ smp_mb();
2854 #+ ring->head = head;
2855 #+ ret = 1;
2856 #+ put_aio_ring_event(evp, KM_USER1);
2857 #+ } else /* only need to know availability */
2858 #+ ret = 1;
2859 # }
2860 # spin_unlock(&info->ring_lock);
2861 #
2862 #@@ -1235,6 +1252,13 @@ static void io_destroy(struct kioctx *io
2863 #
2864 # aio_cancel_all(ioctx);
2865 # wait_for_all_aios(ioctx);
2866 #+#ifdef CONFIG_EPOLL
2867 #+ /* forget the poll file, but it's up to the user to close it */
2868 #+ if (ioctx->file) {
2869 #+ ioctx->file->private_data = 0;
2870 #+ ioctx->file = 0;
2871 #+ }
2872 #+#endif
2873 #
2874 # /*
2875 # * Wake up any waiters. The setting of ctx->dead must be seen
2876 #@@ -1245,6 +1269,67 @@ static void io_destroy(struct kioctx *io
2877 # put_ioctx(ioctx); /* once for the lookup */
2878 # }
2879 #
2880 #+#ifdef CONFIG_EPOLL
2881 #+
2882 #+static int aio_queue_fd_close(struct inode *inode, struct file *file)
2883 #+{
2884 #+ struct kioctx *ioctx = file->private_data;
2885 #+ if (ioctx) {
2886 #+ file->private_data = 0;
2887 #+ spin_lock_irq(&ioctx->ctx_lock);
2888 #+ ioctx->file = 0;
2889 #+ spin_unlock_irq(&ioctx->ctx_lock);
2890 #+ }
2891 #+ return 0;
2892 #+}
2893 #+
2894 #+static unsigned int aio_queue_fd_poll(struct file *file, poll_table *wait)
2895 #+{ unsigned int pollflags = 0;
2896 #+ struct kioctx *ioctx = file->private_data;
2897 #+
2898 #+ if (ioctx) {
2899 #+
2900 #+ spin_lock_irq(&ioctx->ctx_lock);
2901 #+ /* Insert inside our poll wait queue */
2902 #+ poll_wait(file, &ioctx->poll_wait, wait);
2903 #+
2904 #+ /* Check our condition */
2905 #+ if (aio_read_evt(ioctx, 0))
2906 #+ pollflags = POLLIN | POLLRDNORM;
2907 #+ spin_unlock_irq(&ioctx->ctx_lock);
2908 #+ }
2909 #+
2910 #+ return pollflags;
2911 #+}
2912 #+
2913 #+static const struct file_operations aioq_fops = {
2914 #+ .release = aio_queue_fd_close,
2915 #+ .poll = aio_queue_fd_poll
2916 #+};
2917 #+
2918 #+/* make_aio_fd:
2919 #+ * Create a file descriptor that can be used to poll the event queue.
2920 #+ * Based and piggybacked on the excellent epoll code.
2921 #+ */
2922 #+
2923 #+static int make_aio_fd(struct kioctx *ioctx)
2924 #+{
2925 #+ int error, fd;
2926 #+ struct inode *inode;
2927 #+ struct file *file;
2928 #+
2929 #+ error = ep_getfd(&fd, &inode, &file, NULL, &aioq_fops);
2930 #+ if (error)
2931 #+ return error;
2932 #+
2933 #+ /* associate the file with the IO context */
2934 #+ file->private_data = ioctx;
2935 #+ ioctx->file = file;
2936 #+ init_waitqueue_head(&ioctx->poll_wait);
2937 #+ return fd;
2938 #+}
2939 #+#endif
2940 #+
2941 # /* sys_io_setup:
2942 # * Create an aio_context capable of receiving at least nr_events.
2943 # * ctxp must not point to an aio_context that already exists, and
2944 #@@ -1257,18 +1342,30 @@ static void io_destroy(struct kioctx *io
2945 # * resources are available. May fail with -EFAULT if an invalid
2946 # * pointer is passed for ctxp. Will fail with -ENOSYS if not
2947 # * implemented.
2948 #+ *
2949 #+ * To request a selectable fd, the user context has to be initialized
2950 #+ * to 1, instead of 0, and the return value is the fd.
2951 #+ * This keeps the system call compatible, since a non-zero value
2952 #+ * was not allowed so far.
2953 # */
2954 # asmlinkage long sys_io_setup(unsigned nr_events, aio_context_t __user *ctxp)
2955 # {
2956 # struct kioctx *ioctx = NULL;
2957 # unsigned long ctx;
2958 # long ret;
2959 #+ int make_fd = 0;
2960 #
2961 # ret = get_user(ctx, ctxp);
2962 # if (unlikely(ret))
2963 # goto out;
2964 #
2965 # ret = -EINVAL;
2966 #+#ifdef CONFIG_EPOLL
2967 #+ if (ctx == 1) {
2968 #+ make_fd = 1;
2969 #+ ctx = 0;
2970 #+ }
2971 #+#endif
2972 # if (unlikely(ctx || nr_events == 0)) {
2973 # pr_debug("EINVAL: io_setup: ctx %lu nr_events %u\n",
2974 # ctx, nr_events);
2975 #@@ -1279,8 +1376,12 @@ asmlinkage long sys_io_setup(unsigned nr
2976 # ret = PTR_ERR(ioctx);
2977 # if (!IS_ERR(ioctx)) {
2978 # ret = put_user(ioctx->user_id, ctxp);
2979 #- if (!ret)
2980 #- return 0;
2981 #+#ifdef CONFIG_EPOLL
2982 #+ if (make_fd && ret >= 0)
2983 #+ ret = make_aio_fd(ioctx);
2984 #+#endif
2985 #+ if (ret >= 0)
2986 #+ return ret;
2987 #
2988 # get_ioctx(ioctx); /* io_destroy() expects us to hold a ref */
2989 # io_destroy(ioctx);
2990 --- a/fs/compat_ioctl.c
2991 +++ b/fs/compat_ioctl.c
2992 @@ -114,6 +114,13 @@
2993 #include <asm/fbio.h>
2994 #endif
2995
2996 +#ifdef CONFIG_XEN
2997 +#include <xen/interface/xen.h>
2998 +#include <xen/public/evtchn.h>
2999 +#include <xen/public/privcmd.h>
3000 +#include <xen/compat_ioctl.h>
3001 +#endif
3002 +
3003 static int do_ioctl32_pointer(unsigned int fd, unsigned int cmd,
3004 unsigned long arg, struct file *f)
3005 {
3006 @@ -2727,6 +2734,18 @@ IGNORE_IOCTL(FBIOGETCMAP32)
3007 IGNORE_IOCTL(FBIOSCURSOR32)
3008 IGNORE_IOCTL(FBIOGCURSOR32)
3009 #endif
3010 +
3011 +#ifdef CONFIG_XEN
3012 +HANDLE_IOCTL(IOCTL_PRIVCMD_MMAP_32, privcmd_ioctl_32)
3013 +HANDLE_IOCTL(IOCTL_PRIVCMD_MMAPBATCH_32, privcmd_ioctl_32)
3014 +COMPATIBLE_IOCTL(IOCTL_PRIVCMD_HYPERCALL)
3015 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_BIND_VIRQ)
3016 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_BIND_INTERDOMAIN)
3017 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_BIND_UNBOUND_PORT)
3018 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_UNBIND)
3019 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_NOTIFY)
3020 +COMPATIBLE_IOCTL(IOCTL_EVTCHN_RESET)
3021 +#endif
3022 };
3023
3024 #define IOCTL_HASHSIZE 256
3025 --- a/include/acpi/processor.h
3026 +++ b/include/acpi/processor.h
3027 @@ -17,6 +17,12 @@
3028 #define ACPI_PROCESSOR_MAX_THROTTLE 250 /* 25% */
3029 #define ACPI_PROCESSOR_MAX_DUTY_WIDTH 4
3030
3031 +#ifdef CONFIG_XEN
3032 +#define NR_ACPI_CPUS (NR_CPUS < 256 ? 256 : NR_CPUS)
3033 +#else
3034 +#define NR_ACPI_CPUS NR_CPUS
3035 +#endif /* CONFIG_XEN */
3036 +
3037 #define ACPI_PDC_REVISION_ID 0x1
3038
3039 #define ACPI_PSD_REV0_REVISION 0 /* Support for _PSD as in ACPI 3.0 */
3040 @@ -42,6 +48,17 @@
3041
3042 struct acpi_processor_cx;
3043
3044 +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
3045 +struct acpi_csd_package {
3046 + acpi_integer num_entries;
3047 + acpi_integer revision;
3048 + acpi_integer domain;
3049 + acpi_integer coord_type;
3050 + acpi_integer num_processors;
3051 + acpi_integer index;
3052 +} __attribute__ ((packed));
3053 +#endif
3054 +
3055 struct acpi_power_register {
3056 u8 descriptor;
3057 u16 length;
3058 @@ -74,6 +91,12 @@ struct acpi_processor_cx {
3059 u32 power;
3060 u32 usage;
3061 u64 time;
3062 +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
3063 + /* Require raw information for external control logic */
3064 + struct acpi_power_register reg;
3065 + u32 csd_count;
3066 + struct acpi_csd_package *domain_info;
3067 +#endif
3068 struct acpi_processor_cx_policy promotion;
3069 struct acpi_processor_cx_policy demotion;
3070 char desc[ACPI_CX_DESC_LEN];
3071 @@ -304,6 +327,9 @@ static inline void acpi_processor_ppc_ex
3072 {
3073 return;
3074 }
3075 +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
3076 +int acpi_processor_ppc_has_changed(struct acpi_processor *pr);
3077 +#else
3078 static inline int acpi_processor_ppc_has_changed(struct acpi_processor *pr)
3079 {
3080 static unsigned int printout = 1;
3081 @@ -316,6 +342,7 @@ static inline int acpi_processor_ppc_has
3082 }
3083 return 0;
3084 }
3085 +#endif /* CONFIG_PROCESSOR_EXTERNAL_CONTROL */
3086 #endif /* CONFIG_CPU_FREQ */
3087
3088 /* in processor_throttling.c */
3089 @@ -352,4 +379,120 @@ static inline void acpi_thermal_cpufreq_
3090 }
3091 #endif
3092
3093 +/*
3094 + * Following are interfaces geared to external processor PM control
3095 + * logic like a VMM
3096 + */
3097 +/* Events notified to external control logic */
3098 +#define PROCESSOR_PM_INIT 1
3099 +#define PROCESSOR_PM_CHANGE 2
3100 +#define PROCESSOR_HOTPLUG 3
3101 +
3102 +/* Objects for the PM events */
3103 +#define PM_TYPE_IDLE 0
3104 +#define PM_TYPE_PERF 1
3105 +#define PM_TYPE_THR 2
3106 +#define PM_TYPE_MAX 3
3107 +
3108 +/* Processor hotplug events */
3109 +#define HOTPLUG_TYPE_ADD 0
3110 +#define HOTPLUG_TYPE_REMOVE 1
3111 +
3112 +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL
3113 +struct processor_extcntl_ops {
3114 + /* Transfer processor PM events to external control logic */
3115 + int (*pm_ops[PM_TYPE_MAX])(struct acpi_processor *pr, int event);
3116 + /* Notify physical processor status to external control logic */
3117 + int (*hotplug)(struct acpi_processor *pr, int type);
3118 +};
3119 +extern const struct processor_extcntl_ops *processor_extcntl_ops;
3120 +
3121 +static inline int processor_cntl_external(void)
3122 +{
3123 + return (processor_extcntl_ops != NULL);
3124 +}
3125 +
3126 +static inline int processor_pm_external(void)
3127 +{
3128 + return processor_cntl_external() &&
3129 + (processor_extcntl_ops->pm_ops[PM_TYPE_IDLE] != NULL);
3130 +}
3131 +
3132 +static inline int processor_pmperf_external(void)
3133 +{
3134 + return processor_cntl_external() &&
3135 + (processor_extcntl_ops->pm_ops[PM_TYPE_PERF] != NULL);
3136 +}
3137 +
3138 +static inline int processor_pmthr_external(void)
3139 +{
3140 + return processor_cntl_external() &&
3141 + (processor_extcntl_ops->pm_ops[PM_TYPE_THR] != NULL);
3142 +}
3143 +
3144 +extern int processor_notify_external(struct acpi_processor *pr,
3145 + int event, int type);
3146 +extern void processor_extcntl_init(void);
3147 +extern int processor_extcntl_prepare(struct acpi_processor *pr);
3148 +extern int acpi_processor_get_performance_info(struct acpi_processor *pr);
3149 +extern int acpi_processor_get_psd(struct acpi_processor *pr);
3150 +void arch_acpi_processor_init_extcntl(const struct processor_extcntl_ops **);
3151 +#else
3152 +static inline int processor_cntl_external(void) {return 0;}
3153 +static inline int processor_pm_external(void) {return 0;}
3154 +static inline int processor_pmperf_external(void) {return 0;}
3155 +static inline int processor_pmthr_external(void) {return 0;}
3156 +static inline int processor_notify_external(struct acpi_processor *pr,
3157 + int event, int type)
3158 +{
3159 + return 0;
3160 +}
3161 +static inline void processor_extcntl_init(void) {}
3162 +static inline int processor_extcntl_prepare(struct acpi_processor *pr)
3163 +{
3164 + return 0;
3165 +}
3166 +#endif /* CONFIG_PROCESSOR_EXTERNAL_CONTROL */
3167 +
3168 +#ifdef CONFIG_XEN
3169 +static inline void xen_convert_pct_reg(struct xen_pct_register *xpct,
3170 + struct acpi_pct_register *apct)
3171 +{
3172 + xpct->descriptor = apct->descriptor;
3173 + xpct->length = apct->length;
3174 + xpct->space_id = apct->space_id;
3175 + xpct->bit_width = apct->bit_width;
3176 + xpct->bit_offset = apct->bit_offset;
3177 + xpct->reserved = apct->reserved;
3178 + xpct->address = apct->address;
3179 +}
3180 +
3181 +static inline void xen_convert_pss_states(struct xen_processor_px *xpss,
3182 + struct acpi_processor_px *apss, int state_count)
3183 +{
3184 + int i;
3185 + for(i=0; i<state_count; i++) {
3186 + xpss->core_frequency = apss->core_frequency;
3187 + xpss->power = apss->power;
3188 + xpss->transition_latency = apss->transition_latency;
3189 + xpss->bus_master_latency = apss->bus_master_latency;
3190 + xpss->control = apss->control;
3191 + xpss->status = apss->status;
3192 + xpss++;
3193 + apss++;
3194 + }
3195 +}
3196 +
3197 +static inline void xen_convert_psd_pack(struct xen_psd_package *xpsd,
3198 + struct acpi_psd_package *apsd)
3199 +{
3200 + xpsd->num_entries = apsd->num_entries;
3201 + xpsd->revision = apsd->revision;
3202 + xpsd->domain = apsd->domain;
3203 + xpsd->coord_type = apsd->coord_type;
3204 + xpsd->num_processors = apsd->num_processors;
3205 +}
3206 +
3207 +#endif /* CONFIG_XEN */
3208 +
3209 #endif
3210 --- a/include/asm-generic/pci.h
3211 +++ b/include/asm-generic/pci.h
3212 @@ -43,7 +43,9 @@ pcibios_select_root(struct pci_dev *pdev
3213 return root;
3214 }
3215
3216 +#ifndef pcibios_scan_all_fns
3217 #define pcibios_scan_all_fns(a, b) 0
3218 +#endif
3219
3220 #ifndef HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ
3221 static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
3222 --- a/include/asm-generic/pgtable.h
3223 +++ b/include/asm-generic/pgtable.h
3224 @@ -99,6 +99,10 @@ static inline void ptep_set_wrprotect(st
3225 }
3226 #endif
3227
3228 +#ifndef arch_change_pte_range
3229 +#define arch_change_pte_range(mm, pmd, addr, end, newprot) 0
3230 +#endif
3231 +
3232 #ifndef __HAVE_ARCH_PTE_SAME
3233 #define pte_same(A,B) (pte_val(A) == pte_val(B))
3234 #endif
3235 --- a/include/linux/aio.h
3236 +++ b/include/linux/aio.h
3237 @@ -199,6 +199,11 @@ struct kioctx {
3238 struct aio_ring_info ring_info;
3239
3240 struct delayed_work wq;
3241 +#ifdef CONFIG_EPOLL
3242 + // poll integration
3243 + wait_queue_head_t poll_wait;
3244 + struct file *file;
3245 +#endif
3246 };
3247
3248 /* prototypes */
3249 --- a/include/linux/highmem.h
3250 +++ b/include/linux/highmem.h
3251 @@ -62,6 +62,7 @@ static inline void *kmap_atomic(struct p
3252
3253 #endif /* CONFIG_HIGHMEM */
3254
3255 +#ifndef __HAVE_ARCH_CLEAR_USER_HIGHPAGE
3256 /* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */
3257 static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
3258 {
3259 @@ -69,6 +70,7 @@ static inline void clear_user_highpage(s
3260 clear_user_page(addr, vaddr, page);
3261 kunmap_atomic(addr, KM_USER0);
3262 }
3263 +#endif
3264
3265 #ifndef __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE
3266 /**
3267 @@ -115,12 +117,14 @@ alloc_zeroed_user_highpage_movable(struc
3268 return __alloc_zeroed_user_highpage(__GFP_MOVABLE, vma, vaddr);
3269 }
3270
3271 +#ifndef __HAVE_ARCH_CLEAR_HIGHPAGE
3272 static inline void clear_highpage(struct page *page)
3273 {
3274 void *kaddr = kmap_atomic(page, KM_USER0);
3275 clear_page(kaddr);
3276 kunmap_atomic(kaddr, KM_USER0);
3277 }
3278 +#endif
3279
3280 static inline void zero_user_segments(struct page *page,
3281 unsigned start1, unsigned end1,
3282 @@ -174,6 +178,8 @@ static inline void copy_user_highpage(st
3283
3284 #endif
3285
3286 +#ifndef __HAVE_ARCH_COPY_HIGHPAGE
3287 +
3288 static inline void copy_highpage(struct page *to, struct page *from)
3289 {
3290 char *vfrom, *vto;
3291 @@ -185,4 +191,6 @@ static inline void copy_highpage(struct
3292 kunmap_atomic(vto, KM_USER1);
3293 }
3294
3295 +#endif
3296 +
3297 #endif /* _LINUX_HIGHMEM_H */
3298 --- a/include/linux/interrupt.h
3299 +++ b/include/linux/interrupt.h
3300 @@ -218,6 +218,12 @@ static inline int disable_irq_wake(unsig
3301 }
3302 #endif /* CONFIG_GENERIC_HARDIRQS */
3303
3304 +#ifdef CONFIG_HAVE_IRQ_IGNORE_UNHANDLED
3305 +int irq_ignore_unhandled(unsigned int irq);
3306 +#else
3307 +#define irq_ignore_unhandled(irq) 0
3308 +#endif
3309 +
3310 #ifndef __ARCH_SET_SOFTIRQ_PENDING
3311 #define set_softirq_pending(x) (local_softirq_pending() = (x))
3312 #define or_softirq_pending(x) (local_softirq_pending() |= (x))
3313 --- a/include/linux/kexec.h
3314 +++ b/include/linux/kexec.h
3315 @@ -46,6 +46,13 @@
3316 KEXEC_CORE_NOTE_NAME_BYTES + \
3317 KEXEC_CORE_NOTE_DESC_BYTES )
3318
3319 +#ifndef KEXEC_ARCH_HAS_PAGE_MACROS
3320 +#define kexec_page_to_pfn(page) page_to_pfn(page)
3321 +#define kexec_pfn_to_page(pfn) pfn_to_page(pfn)
3322 +#define kexec_virt_to_phys(addr) virt_to_phys(addr)
3323 +#define kexec_phys_to_virt(addr) phys_to_virt(addr)
3324 +#endif
3325 +
3326 /*
3327 * This structure is used to hold the arguments that are used when loading
3328 * kernel binaries.
3329 @@ -108,6 +115,12 @@ struct kimage {
3330 extern void machine_kexec(struct kimage *image);
3331 extern int machine_kexec_prepare(struct kimage *image);
3332 extern void machine_kexec_cleanup(struct kimage *image);
3333 +#ifdef CONFIG_XEN
3334 +extern int xen_machine_kexec_load(struct kimage *image);
3335 +extern void xen_machine_kexec_unload(struct kimage *image);
3336 +extern void xen_machine_kexec_setup_resources(void);
3337 +extern void xen_machine_kexec_register_resources(struct resource *res);
3338 +#endif
3339 extern asmlinkage long sys_kexec_load(unsigned long entry,
3340 unsigned long nr_segments,
3341 struct kexec_segment __user *segments,
3342 --- a/include/linux/mm.h
3343 +++ b/include/linux/mm.h
3344 @@ -113,6 +113,9 @@ extern unsigned int kobjsize(const void
3345 #define VM_CAN_NONLINEAR 0x08000000 /* Has ->fault & does nonlinear pages */
3346 #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */
3347 #define VM_SAO 0x20000000 /* Strong Access Ordering (powerpc) */
3348 +#ifdef CONFIG_XEN
3349 +#define VM_FOREIGN 0x40000000 /* Has pages belonging to another VM */
3350 +#endif
3351
3352 #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */
3353 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
3354 @@ -183,6 +186,11 @@ struct vm_operations_struct {
3355 */
3356 int (*access)(struct vm_area_struct *vma, unsigned long addr,
3357 void *buf, int len, int write);
3358 +
3359 + /* Area-specific function for clearing the PTE at @ptep. Returns the
3360 + * original value of @ptep. */
3361 + pte_t (*zap_pte)(struct vm_area_struct *vma,
3362 + unsigned long addr, pte_t *ptep, int is_fullmm);
3363 #ifdef CONFIG_NUMA
3364 /*
3365 * set_policy() op must add a reference to any non-NULL @new mempolicy
3366 --- a/include/linux/oprofile.h
3367 +++ b/include/linux/oprofile.h
3368 @@ -16,6 +16,8 @@
3369 #include <linux/types.h>
3370 #include <linux/spinlock.h>
3371 #include <asm/atomic.h>
3372 +
3373 +#include <xen/interface/xenoprof.h>
3374
3375 /* Each escaped entry is prefixed by ESCAPE_CODE
3376 * then one of the following codes, then the
3377 @@ -28,7 +30,7 @@
3378 #define CPU_SWITCH_CODE 2
3379 #define COOKIE_SWITCH_CODE 3
3380 #define KERNEL_ENTER_SWITCH_CODE 4
3381 -#define KERNEL_EXIT_SWITCH_CODE 5
3382 +#define USER_ENTER_SWITCH_CODE 5
3383 #define MODULE_LOADED_CODE 6
3384 #define CTX_TGID_CODE 7
3385 #define TRACE_BEGIN_CODE 8
3386 @@ -36,6 +38,7 @@
3387 #define XEN_ENTER_SWITCH_CODE 10
3388 #define SPU_PROFILING_CODE 11
3389 #define SPU_CTX_SWITCH_CODE 12
3390 +#define DOMAIN_SWITCH_CODE 13
3391
3392 struct super_block;
3393 struct dentry;
3394 @@ -47,6 +50,11 @@ struct oprofile_operations {
3395 /* create any necessary configuration files in the oprofile fs.
3396 * Optional. */
3397 int (*create_files)(struct super_block * sb, struct dentry * root);
3398 + /* setup active domains with Xen */
3399 + int (*set_active)(int *active_domains, unsigned int adomains);
3400 + /* setup passive domains with Xen */
3401 + int (*set_passive)(int *passive_domains, unsigned int pdomains);
3402 +
3403 /* Do any necessary interrupt setup. Optional. */
3404 int (*setup)(void);
3405 /* Do any necessary interrupt shutdown. Optional. */
3406 @@ -106,6 +114,8 @@ void oprofile_add_pc(unsigned long pc, i
3407 /* add a backtrace entry, to be called from the ->backtrace callback */
3408 void oprofile_add_trace(unsigned long eip);
3409
3410 +/* add a domain switch entry */
3411 +int oprofile_add_domain_switch(int32_t domain_id);
3412
3413 /**
3414 * Create a file of the given name as a child of the given root, with
3415 --- a/include/linux/page-flags.h
3416 +++ b/include/linux/page-flags.h
3417 @@ -97,6 +97,9 @@ enum pageflags {
3418 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
3419 PG_uncached, /* Page has been mapped as uncached */
3420 #endif
3421 +#ifdef CONFIG_XEN
3422 + PG_foreign, /* Page is owned by foreign allocator. */
3423 +#endif
3424 __NR_PAGEFLAGS,
3425
3426 /* Filesystems */
3427 @@ -269,6 +272,19 @@ static inline void SetPageUptodate(struc
3428
3429 CLEARPAGEFLAG(Uptodate, uptodate)
3430
3431 +#define PageForeign(page) test_bit(PG_foreign, &(page)->flags)
3432 +#define SetPageForeign(_page, dtor) do { \
3433 + set_bit(PG_foreign, &(_page)->flags); \
3434 + BUG_ON((dtor) == (void (*)(struct page *))0); \
3435 + (_page)->index = (long)(dtor); \
3436 +} while (0)
3437 +#define ClearPageForeign(page) do { \
3438 + clear_bit(PG_foreign, &(page)->flags); \
3439 + (page)->index = 0; \
3440 +} while (0)
3441 +#define PageForeignDestructor(_page) \
3442 + ((void (*)(struct page *))(_page)->index)(_page)
3443 +
3444 extern void cancel_dirty_page(struct page *page, unsigned int account_size);
3445
3446 int test_clear_page_writeback(struct page *page);
3447 @@ -339,8 +355,16 @@ PAGEFLAG(MemError, memerror)
3448 PAGEFLAG_FALSE(MemError)
3449 #endif
3450
3451 +#if !defined(CONFIG_XEN)
3452 +# define PAGE_FLAGS_XEN 0
3453 +#elif defined(CONFIG_X86)
3454 +# define PAGE_FLAGS_XEN ((1 << PG_pinned) | (1 << PG_foreign))
3455 +#else
3456 +# define PAGE_FLAGS_XEN (1 << PG_foreign)
3457 +#endif
3458 +
3459 #define PAGE_FLAGS (1 << PG_lru | 1 << PG_private | 1 << PG_locked | \
3460 - 1 << PG_buddy | 1 << PG_writeback | \
3461 + 1 << PG_buddy | 1 << PG_writeback | PAGE_FLAGS_XEN | \
3462 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active)
3463
3464 /*
3465 --- a/include/linux/pci.h
3466 +++ b/include/linux/pci.h
3467 @@ -211,6 +211,9 @@ struct pci_dev {
3468 * directly, use the values stored here. They might be different!
3469 */
3470 unsigned int irq;
3471 +#ifdef CONFIG_XEN
3472 + unsigned int irq_old;
3473 +#endif
3474 struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
3475
3476 /* These fields are used by common fixups */
3477 @@ -767,6 +770,10 @@ static inline void msi_remove_pci_irq_ve
3478
3479 static inline void pci_restore_msi_state(struct pci_dev *dev)
3480 { }
3481 +#ifdef CONFIG_XEN
3482 +#define register_msi_get_owner(func) 0
3483 +#define unregister_msi_get_owner(func) 0
3484 +#endif
3485 #else
3486 extern int pci_enable_msi(struct pci_dev *dev);
3487 extern void pci_msi_shutdown(struct pci_dev *dev);
3488 @@ -777,6 +784,10 @@ extern void pci_msix_shutdown(struct pci
3489 extern void pci_disable_msix(struct pci_dev *dev);
3490 extern void msi_remove_pci_irq_vectors(struct pci_dev *dev);
3491 extern void pci_restore_msi_state(struct pci_dev *dev);
3492 +#ifdef CONFIG_XEN
3493 +extern int register_msi_get_owner(int (*func)(struct pci_dev *dev));
3494 +extern int unregister_msi_get_owner(int (*func)(struct pci_dev *dev));
3495 +#endif
3496 #endif
3497
3498 #ifdef CONFIG_HT_IRQ
3499 #--- a/include/linux/skbuff.h
3500 #+++ b/include/linux/skbuff.h
3501 #@@ -217,6 +217,8 @@ typedef unsigned char *sk_buff_data_t;
3502 # * @local_df: allow local fragmentation
3503 # * @cloned: Head may be cloned (check refcnt to be sure)
3504 # * @nohdr: Payload reference only, must not modify header
3505 #+ * @proto_data_valid: Protocol data validated since arriving at localhost
3506 #+ * @proto_csum_blank: Protocol csum must be added before leaving localhost
3507 # * @pkt_type: Packet class
3508 # * @fclone: skbuff clone status
3509 # * @ip_summed: Driver fed us an IP checksum
3510 #@@ -323,7 +325,11 @@ struct sk_buff {
3511 # #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
3512 # __u8 do_not_encrypt:1;
3513 # #endif
3514 #- /* 0/13/14 bit hole */
3515 #+#ifdef CONFIG_XEN
3516 #+ __u8 proto_data_valid:1,
3517 #+ proto_csum_blank:1;
3518 #+#endif
3519 #+ /* 10-16 bit hole */
3520
3521 #ifdef CONFIG_NET_DMA
3522 # dma_cookie_t dma_cookie;
3523 --- a/include/linux/vermagic.h
3524 +++ b/include/linux/vermagic.h
3525 @@ -22,6 +22,11 @@
3526 #else
3527 #define MODULE_VERMAGIC_MODVERSIONS ""
3528 #endif
3529 +#ifdef CONFIG_XEN
3530 +#define MODULE_VERMAGIC_XEN "Xen "
3531 +#else
3532 +#define MODULE_VERMAGIC_XEN
3533 +#endif
3534 #ifndef MODULE_ARCH_VERMAGIC
3535 #define MODULE_ARCH_VERMAGIC ""
3536 #endif
3537 @@ -30,5 +35,5 @@
3538 UTS_RELEASE " " \
3539 MODULE_VERMAGIC_SMP MODULE_VERMAGIC_PREEMPT \
3540 MODULE_VERMAGIC_MODULE_UNLOAD MODULE_VERMAGIC_MODVERSIONS \
3541 - MODULE_ARCH_VERMAGIC
3542 + MODULE_VERMAGIC_XEN MODULE_ARCH_VERMAGIC
3543
3544 --- a/kernel/irq/spurious.c
3545 +++ b/kernel/irq/spurious.c
3546 @@ -182,7 +182,7 @@ void note_interrupt(unsigned int irq, st
3547 */
3548 if (time_after(jiffies, desc->last_unhandled + HZ/10))
3549 desc->irqs_unhandled = 1;
3550 - else
3551 + else if (!irq_ignore_unhandled(irq))
3552 desc->irqs_unhandled++;
3553 desc->last_unhandled = jiffies;
3554 if (unlikely(action_ret != IRQ_NONE))
3555 --- a/kernel/kexec.c
3556 +++ b/kernel/kexec.c
3557 @@ -359,13 +359,26 @@ static int kimage_is_destination_range(s
3558 return 0;
3559 }
3560
3561 -static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order)
3562 +static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order, unsigned long limit)
3563 {
3564 struct page *pages;
3565
3566 pages = alloc_pages(gfp_mask, order);
3567 if (pages) {
3568 unsigned int count, i;
3569 +#ifdef CONFIG_XEN
3570 + int address_bits;
3571 +
3572 + if (limit == ~0UL)
3573 + address_bits = BITS_PER_LONG;
3574 + else
3575 + address_bits = long_log2(limit);
3576 +
3577 + if (xen_limit_pages_to_max_mfn(pages, order, address_bits) < 0) {
3578 + __free_pages(pages, order);
3579 + return NULL;
3580 + }
3581 +#endif
3582 pages->mapping = NULL;
3583 set_page_private(pages, order);
3584 count = 1 << order;
3585 @@ -384,6 +397,9 @@ static void kimage_free_pages(struct pag
3586 count = 1 << order;
3587 for (i = 0; i < count; i++)
3588 ClearPageReserved(page + i);
3589 +#ifdef CONFIG_XEN
3590 + xen_destroy_contiguous_region((unsigned long)page_address(page), order);
3591 +#endif
3592 __free_pages(page, order);
3593 }
3594
3595 @@ -429,10 +445,10 @@ static struct page *kimage_alloc_normal_
3596 do {
3597 unsigned long pfn, epfn, addr, eaddr;
3598
3599 - pages = kimage_alloc_pages(GFP_KERNEL, order);
3600 + pages = kimage_alloc_pages(GFP_KERNEL, order, KEXEC_CONTROL_MEMORY_LIMIT);
3601 if (!pages)
3602 break;
3603 - pfn = page_to_pfn(pages);
3604 + pfn = kexec_page_to_pfn(pages);
3605 epfn = pfn + count;
3606 addr = pfn << PAGE_SHIFT;
3607 eaddr = epfn << PAGE_SHIFT;
3608 @@ -466,6 +482,7 @@ static struct page *kimage_alloc_normal_
3609 return pages;
3610 }
3611
3612 +#ifndef CONFIG_XEN
3613 static struct page *kimage_alloc_crash_control_pages(struct kimage *image,
3614 unsigned int order)
3615 {
3616 @@ -519,7 +536,7 @@ static struct page *kimage_alloc_crash_c
3617 }
3618 /* If I don't overlap any segments I have found my hole! */
3619 if (i == image->nr_segments) {
3620 - pages = pfn_to_page(hole_start >> PAGE_SHIFT);
3621 + pages = kexec_pfn_to_page(hole_start >> PAGE_SHIFT);
3622 break;
3623 }
3624 }
3625 @@ -546,6 +563,13 @@ struct page *kimage_alloc_control_pages(
3626
3627 return pages;
3628 }
3629 +#else /* !CONFIG_XEN */
3630 +struct page *kimage_alloc_control_pages(struct kimage *image,
3631 + unsigned int order)
3632 +{
3633 + return kimage_alloc_normal_control_pages(image, order);
3634 +}
3635 +#endif
3636
3637 static int kimage_add_entry(struct kimage *image, kimage_entry_t entry)
3638 {
3639 @@ -561,7 +585,7 @@ static int kimage_add_entry(struct kimag
3640 return -ENOMEM;
3641
3642 ind_page = page_address(page);
3643 - *image->entry = virt_to_phys(ind_page) | IND_INDIRECTION;
3644 + *image->entry = kexec_virt_to_phys(ind_page) | IND_INDIRECTION;
3645 image->entry = ind_page;
3646 image->last_entry = ind_page +
3647 ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1);
3648 @@ -620,13 +644,13 @@ static void kimage_terminate(struct kima
3649 #define for_each_kimage_entry(image, ptr, entry) \
3650 for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
3651 ptr = (entry & IND_INDIRECTION)? \
3652 - phys_to_virt((entry & PAGE_MASK)): ptr +1)
3653 + kexec_phys_to_virt((entry & PAGE_MASK)): ptr +1)
3654
3655 static void kimage_free_entry(kimage_entry_t entry)
3656 {
3657 struct page *page;
3658
3659 - page = pfn_to_page(entry >> PAGE_SHIFT);
3660 + page = kexec_pfn_to_page(entry >> PAGE_SHIFT);
3661 kimage_free_pages(page);
3662 }
3663
3664 @@ -638,6 +662,10 @@ static void kimage_free(struct kimage *i
3665 if (!image)
3666 return;
3667
3668 +#ifdef CONFIG_XEN
3669 + xen_machine_kexec_unload(image);
3670 +#endif
3671 +
3672 kimage_free_extra_pages(image);
3673 for_each_kimage_entry(image, ptr, entry) {
3674 if (entry & IND_INDIRECTION) {
3675 @@ -713,7 +741,7 @@ static struct page *kimage_alloc_page(st
3676 * have a match.
3677 */
3678 list_for_each_entry(page, &image->dest_pages, lru) {
3679 - addr = page_to_pfn(page) << PAGE_SHIFT;
3680 + addr = kexec_page_to_pfn(page) << PAGE_SHIFT;
3681 if (addr == destination) {
3682 list_del(&page->lru);
3683 return page;
3684 @@ -724,16 +752,16 @@ static struct page *kimage_alloc_page(st
3685 kimage_entry_t *old;
3686
3687 /* Allocate a page, if we run out of memory give up */
3688 - page = kimage_alloc_pages(gfp_mask, 0);
3689 + page = kimage_alloc_pages(gfp_mask, 0, KEXEC_SOURCE_MEMORY_LIMIT);
3690 if (!page)
3691 return NULL;
3692 /* If the page cannot be used file it away */
3693 - if (page_to_pfn(page) >
3694 + if (kexec_page_to_pfn(page) >
3695 (KEXEC_SOURCE_MEMORY_LIMIT >> PAGE_SHIFT)) {
3696 list_add(&page->lru, &image->unuseable_pages);
3697 continue;
3698 }
3699 - addr = page_to_pfn(page) << PAGE_SHIFT;
3700 + addr = kexec_page_to_pfn(page) << PAGE_SHIFT;
3701
3702 /* If it is the destination page we want use it */
3703 if (addr == destination)
3704 @@ -756,7 +784,7 @@ static struct page *kimage_alloc_page(st
3705 struct page *old_page;
3706
3707 old_addr = *old & PAGE_MASK;
3708 - old_page = pfn_to_page(old_addr >> PAGE_SHIFT);
3709 + old_page = kexec_pfn_to_page(old_addr >> PAGE_SHIFT);
3710 copy_highpage(page, old_page);
3711 *old = addr | (*old & ~PAGE_MASK);
3712
3713 @@ -812,7 +840,7 @@ static int kimage_load_normal_segment(st
3714 result = -ENOMEM;