int ret;
if (vector & ~0xff) {
- DPRINTK("vmx_vcpu_pend_interrupt: bad vector\n");
+ dprintk(XENLOG_WARNING, "vmx_vcpu_pend_interrupt: bad vector\n");
return -1;
}
vcpu->arch.arch_vmx.vlapic.vcpu = vcpu;
hvm_vioapic_add_lapic(&vcpu->arch.arch_vmx.vlapic, vcpu);
#endif
- DPRINTK(XENLOG_INFO "VLSAPIC inservice base=%p\n", &VLSAPIC_INSVC(vcpu,0) );
+ dprintk(XENLOG_INFO, "VLSAPIC inservice base=%p\n", &VLSAPIC_INSVC(vcpu,0) );
}
/*
int ret;
if (vector & ~0xff) {
- DPRINTK(XENLOG_G_INFO "vmx_vcpu_pend_interrupt: bad vector\n");
+ gdprintk(XENLOG_INFO, "vmx_vcpu_pend_interrupt: bad vector\n");
return -1;
}
local_irq_save(spsr);
}
default:
- DPRINTK(XENLOG_G_INFO "Bad HVM op %ld.\n", op);
+ gdprintk(XENLOG_INFO, "Bad HVM op %ld.\n", op);
rc = -ENOSYS;
}
return rc;
p = get_vio(v->domain, o->vcpu_id);
o->arch.arch_vmx.xen_port = p->vp_eport =
alloc_unbound_xen_event_channel(o, 0);
- DPRINTK(XENLOG_G_INFO "Allocated port %d for hvm.\n",
+ gdprintk(XENLOG_INFO, "Allocated port %d for hvm.\n",
o->arch.arch_vmx.xen_port);
}
}
case IA64_DOM0VP_phystomach:
ret = ____lookup_domain_mpa(d, arg0 << PAGE_SHIFT);
if (ret == INVALID_MFN) {
- DPRINTK(XENLOG_INFO "%s: INVALID_MFN ret: 0x%lx\n",
+ dprintk(XENLOG_INFO, "%s: INVALID_MFN ret: 0x%lx\n",
__func__, ret);
} else {
ret = (ret & _PFN_MASK) >> PAGE_SHIFT;//XXX pte_pfn()
#ifdef CONFIG_XEN_IA64_PERVCPU_VHPT
d->arch.has_pervcpu_vhpt = opt_pervcpu_vhpt;
- DPRINTK("%s:%d domain %d pervcpu_vhpt %d\n",
+ dprintk(XENLOG_WARNING, "%s:%d domain %d pervcpu_vhpt %d\n",
__func__, __LINE__, d->domain_id, d->arch.has_pervcpu_vhpt);
#endif
if (tlb_track_create(d) < 0)
//struct vcpu *v;
if (unlikely(d == current->domain)) {
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Don't try to do a shadow op on yourself!\n");
return -EINVAL;
}
{
if ( desc->action != NULL )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. In use by '%s'.\n",
irq, desc->action->name);
rc = -EBUSY;
action = xmalloc(irq_guest_action_t);
if ( (desc->action = (struct irqaction *)action) == NULL )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. Out of memory.\n",
irq);
rc = -ENOMEM;
}
else if ( !will_share || !action->shareable )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. Will not share with others.\n",
irq);
rc = -EBUSY;
if ( action->nr_guests == IRQ_MAX_GUESTS )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. Already at max share.\n",
irq);
rc = -EBUSY;
if (unlikely(!(x & PGC_allocated)) || unlikely(_nd != _d)) {
struct domain* nd = unpickle_domptr(_nd);
if (nd == NULL) {
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: "
+ gdprintk(XENLOG_INFO, "gnttab_transfer: "
"Bad page %p: ed=%p(%u) 0x%x, "
"sd=%p 0x%x,"
" caf=%016lx, taf=%" PRtype_info "\n",
arflags2 = pteval2 & _PAGE_AR_MASK;
if (arflags != _PAGE_AR_R && arflags2 == _PAGE_AR_R) {
#if 0
- DPRINTK("%s:%d "
+ dprintk(XENLOG_WARNING,
+ "%s:%d "
"pteval 0x%lx arflag 0x%lx address 0x%lx itir 0x%lx "
"pteval2 0x%lx arflags2 0x%lx mpaddr 0x%lx\n",
__func__, __LINE__,
if (start <= physaddr && physaddr < end) {
if ((physaddr + size) > end) {
- DPRINTK(XENLOG_G_INFO "%s: physaddr 0x%lx size = 0x%lx\n",
+ gdprintk(XENLOG_INFO, "%s: physaddr 0x%lx size = 0x%lx\n",
__func__, physaddr, size);
return 0;
}
unsigned long mpaddr, unsigned long size)
{
if (size == 0) {
- DPRINTK(XENLOG_G_INFO "%s: domain %p mpaddr 0x%lx size = 0x%lx\n",
+ gdprintk(XENLOG_INFO, "%s: domain %p mpaddr 0x%lx size = 0x%lx\n",
__func__, d, mpaddr, size);
}
if (!efi_mmio(mpaddr, size)) {
#ifndef NDEBUG
- DPRINTK(XENLOG_G_INFO "%s: domain %p mpaddr 0x%lx size = 0x%lx\n",
+ gdprintk(XENLOG_INFO, "%s: domain %p mpaddr 0x%lx size = 0x%lx\n",
__func__, d, mpaddr, size);
#endif
return -EINVAL;
old_mfn = page_to_mfn(old_page);
old_pte = pfn_pte(old_mfn, __pgprot(old_prot));
if (!pte_present(old_pte)) {
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"%s: old_pte 0x%lx old_prot 0x%lx old_mfn 0x%lx\n",
__func__, pte_val(old_pte), old_prot, old_mfn);
return -EINVAL;
goto again;
}
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"%s: old_pte 0x%lx old_prot 0x%lx old_mfn 0x%lx "
"ret_pte 0x%lx ret_mfn 0x%lx\n",
__func__,
goto again;
}
- DPRINTK(XENLOG_G_INFO "%s: old_pte 0x%lx old_arflags 0x%lx mfn 0x%lx "
+ gdprintk(XENLOG_INFO, "%s: old_pte 0x%lx old_arflags 0x%lx mfn 0x%lx "
"ret_pte 0x%lx ret_mfn 0x%lx\n",
__func__,
pte_val(old_pte), old_arflags, mfn,
rd = dom_io;
break;
default:
- DPRINTK(XENLOG_G_INFO "d 0x%p domid %d "
+ gdprintk(XENLOG_INFO, "d 0x%p domid %d "
"pgfn 0x%lx mfn 0x%lx flags 0x%lx domid %d\n",
d, d->domain_id, gpfn, mfn, flags, domid);
return -ESRCH;
(conv_start_gpfn % granule_pfn) != 0 ||
(assign_start_gpfn % granule_pfn) != 0 ||
(expose_num_pfn % granule_pfn) != 0) {
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"%s conv_start_gpfn 0x%016lx assign_start_gpfn 0x%016lx "
"expose_size 0x%016lx granulte_pfn 0x%016lx\n", __func__,
conv_start_gpfn, assign_start_gpfn, expose_size, granule_pfn);
}
if (granule_pfn != PTRS_PER_PTE) {
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"%s granule_pfn 0x%016lx PTRS_PER_PTE 0x%016lx\n",
__func__, granule_pfn, PTRS_PER_PTE);
return -ENOSYS;
assign_pte = lookup_alloc_domain_pte(d, (assign_start_gpfn <<
PAGE_SHIFT) + i * sizeof(pte_t));
if (assign_pte == NULL) {
- DPRINTK(XENLOG_G_INFO "%s failed to allocate pte page\n", __func__);
+ gdprintk(XENLOG_INFO, "%s failed to allocate pte page\n", __func__);
return -ENOMEM;
}
if (expose_p2m_page(d, (assign_start_gpfn << PAGE_SHIFT) +
i * sizeof(pte_t), virt_to_page(conv_pte)) < 0) {
- DPRINTK(XENLOG_G_INFO "%s failed to assign page\n", __func__);
+ gdprintk(XENLOG_INFO, "%s failed to assign page\n", __func__);
return -EAGAIN;
}
}
if (expose_p2m_page(d, (assign_start_gpfn + i) << PAGE_SHIFT,
p2m_pte_zero_page) < 0) {
- DPRINTK(XENLOG_G_INFO "%s failed to assign zero-pte page\n", __func__);
+ gdprintk(XENLOG_INFO, "%s failed to assign zero-pte page\n", __func__);
return -EAGAIN;
}
}
if (flags & (GNTMAP_device_map |
GNTMAP_application_map | GNTMAP_contains_pte)) {
- DPRINTK(XENLOG_G_INFO "%s: flags 0x%x\n", __func__, flags);
+ gdprintk(XENLOG_INFO, "%s: flags 0x%x\n", __func__, flags);
return GNTST_general_error;
}
struct page_info* page;
if (flags & (GNTMAP_application_map | GNTMAP_contains_pte)) {
- DPRINTK(XENLOG_G_INFO "%s: flags 0x%x\n", __func__, flags);
+ gdprintk(XENLOG_INFO, "%s: flags 0x%x\n", __func__, flags);
return GNTST_general_error;
}
pte = lookup_noalloc_domain_pte(d, gpaddr);
if (pte == NULL) {
- DPRINTK(XENLOG_G_INFO "%s: gpaddr 0x%lx mfn 0x%lx\n",
+ gdprintk(XENLOG_INFO, "%s: gpaddr 0x%lx mfn 0x%lx\n",
__func__, gpaddr, mfn);
return GNTST_general_error;
}
cur_arflags = pte_val(*pte) & ~_PAGE_PPN_MASK;
cur_pte = pfn_pte(mfn, __pgprot(cur_arflags));
if (!pte_present(cur_pte)) {
- DPRINTK(XENLOG_G_INFO "%s: gpaddr 0x%lx mfn 0x%lx cur_pte 0x%lx\n",
+ gdprintk(XENLOG_INFO, "%s: gpaddr 0x%lx mfn 0x%lx cur_pte 0x%lx\n",
__func__, gpaddr, mfn, pte_val(cur_pte));
return GNTST_general_error;
}
old_pte = ptep_cmpxchg_rel(&d->arch.mm, gpaddr, pte, cur_pte, new_pte);
if (unlikely(!pte_present(old_pte))) {
- DPRINTK(XENLOG_G_INFO "%s: gpaddr 0x%lx mfn 0x%lx"
+ gdprintk(XENLOG_INFO, "%s: gpaddr 0x%lx mfn 0x%lx"
" cur_pte 0x%lx old_pte 0x%lx\n",
__func__, gpaddr, mfn, pte_val(cur_pte), pte_val(old_pte));
return GNTST_general_error;
if (pte_pfn(old_pte) == mfn) {
goto again;
}
- DPRINTK(XENLOG_G_INFO "%s gpaddr 0x%lx mfn 0x%lx cur_pte "
+ gdprintk(XENLOG_INFO, "%s gpaddr 0x%lx mfn 0x%lx cur_pte "
"0x%lx old_pte 0x%lx\n",
__func__, gpaddr, mfn, pte_val(cur_pte), pte_val(old_pte));
return GNTST_general_error;
u64 x, nx, y;
if (page_get_owner(page) != d) {
- DPRINTK(XENLOG_G_INFO "%s d 0x%p owner 0x%p\n",
+ gdprintk(XENLOG_INFO, "%s d 0x%p owner 0x%p\n",
__func__, d, page_get_owner(page));
return -1;
}
new = alloc_domheap_page(d);
if (new == NULL) {
- DPRINTK(XENLOG_G_INFO "alloc_domheap_page() failed\n");
+ gdprintk(XENLOG_INFO, "alloc_domheap_page() failed\n");
return -1;
}
// zero out pages for security reasons
ret = assign_domain_page_cmpxchg_rel(d, gpfn << PAGE_SHIFT, page, new,
ASSIGN_writable);
if (ret < 0) {
- DPRINTK(XENLOG_G_INFO "assign_domain_page_cmpxchg_rel failed %d\n",
+ gdprintk(XENLOG_INFO, "assign_domain_page_cmpxchg_rel failed %d\n",
ret);
set_gpfn_from_mfn(new_mfn, INVALID_M2P_ENTRY);
free_domheap_page(new);
unlikely(_nd != _d)) {
struct domain* nd = unpickle_domptr(_nd);
if (nd == NULL) {
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: "
+ gdprintk(XENLOG_INFO, "gnttab_transfer: "
"Bad page %p: ed=%p(%u) 0x%x, "
"sd=%p 0x%x,"
" caf=%016lx, taf=%" PRtype_info
page->u.inuse.type_info,
memflags);
} else {
- DPRINTK(XENLOG_G_WARNING "gnttab_transfer: "
+ gdprintk(XENLOG_WARNING, "gnttab_transfer: "
"Bad page %p: ed=%p(%u) 0x%x, "
"sd=%p(%u) 0x%x,"
" caf=%016lx, taf=%" PRtype_info
switch (tlb_track_search_and_remove(d->arch.tlb_track,
ptep, old_pte, &entry)) {
case TLB_TRACK_NOT_TRACKED:
- // DPRINTK("%s TLB_TRACK_NOT_TRACKED\n", __func__);
+ // dprintk(XENLOG_WARNING, "%s TLB_TRACK_NOT_TRACKED\n", __func__);
domain_flush_vtlb_all();
break;
case TLB_TRACK_NOT_FOUND:
/* do nothing */
- // DPRINTK("%s TLB_TRACK_NOT_FOUND\n", __func__);
+ // dprintk(XENLOG_WARNING, "%s TLB_TRACK_NOT_FOUND\n", __func__);
break;
case TLB_TRACK_FOUND:
- // DPRINTK("%s TLB_TRACK_FOUND\n", __func__);
+ // dprintk(XENLOG_WARNING, "%s TLB_TRACK_FOUND\n", __func__);
domain_flush_vtlb_track_entry(d, entry);
tlb_track_free_entry(d->arch.tlb_track, entry);
break;
case TLB_TRACK_MANY:
- DPRINTK(XENLOG_G_INFO "%s TLB_TRACK_MANY\n", __func__);
+ gdprintk(XENLOG_INFO, "%s TLB_TRACK_MANY\n", __func__);
domain_flush_vtlb_all();
break;
case TLB_TRACK_AGAIN:
- DPRINTK(XENLOG_G_ERR "%s TLB_TRACK_AGAIN\n", __func__);
+ gdprintk(XENLOG_ERR, "%s TLB_TRACK_AGAIN\n", __func__);
BUG();
break;
}
BUG_ON(tlb_track->num_free > 0);
if (tlb_track->num_entries >= tlb_track->limit) {
- DPRINTK("%s: num_entries %d limit %d\n",
+ dprintk(XENLOG_WARNING, "%s: num_entries %d limit %d\n",
__func__, tlb_track->num_entries, tlb_track->limit);
return -ENOMEM;
}
entry_page = alloc_domheap_page(NULL);
if (entry_page == NULL) {
- DPRINTK("%s: domheap page failed. num_entries %d limit %d\n",
+ dprintk(XENLOG_WARNING,
+ "%s: domheap page failed. num_entries %d limit %d\n",
__func__, tlb_track->num_entries, tlb_track->limit);
return -ENOMEM;
}
// Last itc.i value is cached to PSCBX(vcpu, itlb).
tr = PSCBX(vcpu, itlb);
if (vcpu_match_tr_entry(&tr, gip, rid)) {
- //DPRINTK("%s gip 0x%lx gpip 0x%lx\n", __func__,
- // gip, gpip);
+ //dprintk(XENLOG_WARNING,
+ // "%s gip 0x%lx gpip 0x%lx\n", __func__,
+ // gip, gpip);
goto found;
}
trp = vcpu_tr_lookup(vcpu, gip, rid, 1);
set_metaphysical_rr0();
}
if (bundle->i64[0] == 0 && bundle->i64[1] == 0) {
- DPRINTK(XENLOG_INFO "%s gip 0x%lx\n", __func__, gip);
+ dprintk(XENLOG_INFO, "%s gip 0x%lx\n", __func__, gip);
return 0;
}
return 1;
d->arch.rma_page = alloc_domheap_pages(d, order, 0);
if (d->arch.rma_page == NULL) {
- DPRINTK(XENLOG_G_INFO "Could not allocate order=%d RMA for domain %u\n",
+ gdprintk(XENLOG_INFO, "Could not allocate order=%d RMA for domain %u\n",
order, d->domain_id);
return -ENOMEM;
}
{
if ( unlikely(d == current->domain) )
{
- DPRINTK(XENLOG_G_INFO "Don't try to do a shadow op on yourself!\n");
+ gdprintk(XENLOG_INFO, "Don't try to do a shadow op on yourself!\n");
return -EINVAL;
}
switch ( sc->op )
{
case XEN_DOMCTL_SHADOW_OP_OFF:
- DPRINTK(XENLOG_G_INFO "Shadow is mandatory!\n");
+ gdprintk(XENLOG_INFO, "Shadow is mandatory!\n");
return -EINVAL;
case XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION:
put_user(regs->r11, rsp-10) |
put_user(regs->rcx, rsp-11) )
{
- DPRINTK(XENLOG_G_ERR "Error while creating failsafe "
+ gdprintk(XENLOG_ERR, "Error while creating failsafe "
"callback frame.\n");
domain_crash(n->domain);
}
unsigned long addr = (unsigned long)regs->eip;
unsigned long fixup = search_one_table(
__start___pre_ex_table, __stop___pre_ex_table-1, addr);
- DPRINTK(XENLOG_INFO "Pre-exception: %p -> %p\n", _p(addr), _p(fixup));
+ dprintk(XENLOG_INFO, "Pre-exception: %p -> %p\n", _p(addr), _p(fixup));
#ifdef PERF_COUNTERS
if ( fixup )
perfc_incrc(exception_fixed);
p = get_vio(v->domain, o->vcpu_id);
o->arch.hvm_vcpu.xen_port = p->vp_eport =
alloc_unbound_xen_event_channel(o, 0);
- DPRINTK(XENLOG_INFO "Allocated port %d for hvm.\n",
+ dprintk(XENLOG_INFO, "Allocated port %d for hvm.\n",
o->arch.hvm_vcpu.xen_port);
}
}
struct domain *d = v->domain;
int online_count = 0;
- DPRINTK(XENLOG_G_INFO "DOM%d/VCPU%d: going offline.\n",
+ gdprintk(XENLOG_INFO, "DOM%d/VCPU%d: going offline.\n",
d->domain_id, v->vcpu_id);
/* Doesn't halt us immediately, but we'll never return to guest context. */
/* ... Shut down the domain if not. */
if ( online_count == 0 )
{
- DPRINTK(XENLOG_G_INFO "DOM%d: all CPUs offline -- powering off.\n",
+ gdprintk(XENLOG_INFO, "DOM%d: all CPUs offline -- powering off.\n",
d->domain_id);
domain_shutdown(d, SHUTDOWN_poweroff);
}
if ( (pregs->eax >= NR_hypercalls) || !hvm_hypercall_table[pregs->eax] )
{
- DPRINTK(XENLOG_G_INFO "HVM vcpu %d:%d did a bad hypercall %d.\n",
+ gdprintk(XENLOG_INFO, "HVM vcpu %d:%d did a bad hypercall %d.\n",
current->domain->domain_id, current->vcpu_id,
pregs->eax);
pregs->eax = -ENOSYS;
}
default:
- DPRINTK(XENLOG_G_INFO "memory_op %d.\n", cmd);
+ gdprintk(XENLOG_INFO, "memory_op %d.\n", cmd);
rc = -ENOSYS;
break;
}
pregs->rax = (uint32_t)pregs->eax; /* mask in case compat32 caller */
if ( (pregs->rax >= NR_hypercalls) || !hvm_hypercall64_table[pregs->rax] )
{
- DPRINTK(XENLOG_G_INFO "HVM vcpu %d:%d did a bad hypercall %ld.\n",
+ gdprintk(XENLOG_INFO, "HVM vcpu %d:%d did a bad hypercall %ld.\n",
current->domain->domain_id, current->vcpu_id,
pregs->rax);
pregs->rax = -ENOSYS;
if ( bsp->vcpu_id != 0 )
{
- DPRINTK(XENLOG_G_ERR "Not calling hvm_bringup_ap from BSP context.\n");
+ gdprintk(XENLOG_ERR, "Not calling hvm_bringup_ap from BSP context.\n");
domain_crash_synchronous();
}
if ( (ctxt = xmalloc(struct vcpu_guest_context)) == NULL )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Failed to allocate memory in hvm_bringup_ap.\n");
return -ENOMEM;
}
if ( rc != 0 )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"AP %d bringup failed in boot_vcpu %x.\n", vcpuid, rc);
goto out;
}
if ( test_and_clear_bit(_VCPUF_down, &d->vcpu[vcpuid]->vcpu_flags) )
vcpu_wake(d->vcpu[vcpuid]);
- DPRINTK(XENLOG_G_INFO "AP %d bringup suceeded.\n", vcpuid);
+ gdprintk(XENLOG_INFO, "AP %d bringup suceeded.\n", vcpuid);
out:
xfree(ctxt);
default:
{
- DPRINTK(XENLOG_G_INFO "Bad HVM op %ld.\n", op);
+ gdprintk(XENLOG_INFO, "Bad HVM op %ld.\n", op);
rc = -ENOSYS;
break;
}
/* Set it on the 8259s */
ps = &s->pics[irq >> 3];
- if (!(ps->elcr & (1 << (irq & 7)))) {
- DPRINTK("edge-triggered override IRQ?\n");
- domain_crash(current->domain);
- }
+ if (!(ps->elcr & (1 << (irq & 7))))
+ gdprintk(XENLOG_WARNING, "edge-triggered override IRQ?\n");
if (level) {
ps->irr_xen |= 1 << (irq & 7);
} else {
if ( modrm_mod == 3 )
{
- DPRINTK(XENLOG_G_WARNING "Cannot parse ModRM.mod == 3.\n");
+ gdprintk(XENLOG_WARNING, "Cannot parse ModRM.mod == 3.\n");
goto cannot_emulate;
}
return length;
cannot_emulate:
- DPRINTK(XENLOG_G_WARNING
+ gdprintk(XENLOG_WARNING,
"Cannot emulate %02x at address %lx (eip %lx, mode %d)\n",
b, (unsigned long)_regs.eip, (unsigned long)regs->eip, mode);
return -1;
}
if ( addr & (size - 1) )
- DPRINTK("Unaligned ioport access: %lx, %d\n", addr, size);
+ gdprintk(XENLOG_WARNING,
+ "Unaligned ioport access: %lx, %d\n", addr, size);
/*
* In case of a movs spanning multiple pages, we break the accesses
if ( (addr & PAGE_MASK) != ((addr + size - 1) & PAGE_MASK) ) {
unsigned long value = 0;
- DPRINTK("Single io request in a movs crossing page boundary.\n");
+ gdprintk(XENLOG_WARNING,
+ "Single io request in a movs crossing page boundary.\n");
mmio_op->flags |= OVERLAP;
if ( dir == IOREQ_WRITE ) {
if ( !shadow_mode_external(d) )
{
- DPRINTK(XENLOG_G_ERR "Can't init HVM for dom %u vcpu %u: "
+ gdprintk(XENLOG_ERR, "Can't init HVM for dom %u vcpu %u: "
"not in shadow external mode\n", d->domain_id, v->vcpu_id);
domain_crash(d);
}
s->redirtbl[irq].RedirForm.mask)
return;
- if (s->redirtbl[irq].RedirForm.trigmod != IOAPIC_LEVEL_TRIGGER) {
- DPRINTK("Forcing edge triggered APIC irq %d?\n", irq);
- domain_crash(d);
- }
+ if (s->redirtbl[irq].RedirForm.trigmod != IOAPIC_LEVEL_TRIGGER)
+ gdprintk(XENLOG_WARNING, "Forcing edge triggered APIC irq %d?\n", irq);
if (level)
s->irr_xen |= 1 << irq;
if ( (vmcs = alloc_xenheap_page()) == NULL )
{
- DPRINTK(XENLOG_G_WARNING "Failed to allocate VMCS.\n");
+ gdprintk(XENLOG_WARNING, "Failed to allocate VMCS.\n");
return NULL;
}
if ( !shadow_mode_external(d) )
{
- DPRINTK(XENLOG_ERR "Can't init HVM for dom %u vcpu %u: "
+ dprintk(XENLOG_ERR, "Can't init HVM for dom %u vcpu %u: "
"not in shadow external mode\n",
d->domain_id, v->vcpu_id);
domain_crash(d);
if ( (rc = vmx_create_vmcs(vc)) != 0 )
{
- DPRINTK(XENLOG_WARNING
+ dprintk(XENLOG_WARNING,
"Failed to create VMCS for vcpu %d: err=%d.\n",
vc->vcpu_id, rc);
return 0;
if ( (io_bitmap_a = alloc_xenheap_pages(IO_BITMAP_ORDER)) == NULL )
{
- DPRINTK(XENLOG_WARNING
+ dprintk(XENLOG_WARNING,
"Failed to allocate io bitmap b for vcpu %d.\n",
vc->vcpu_id);
return 0;
if ( (io_bitmap_b = alloc_xenheap_pages(IO_BITMAP_ORDER)) == NULL )
{
- DPRINTK(XENLOG_WARNING
+ dprintk(XENLOG_WARNING,
"Failed to allocate io bitmap b for vcpu %d.\n",
vc->vcpu_id);
return 0;
unsigned long mfn = get_mfn_from_gpfn(value >> PAGE_SHIFT);
char *p;
- DPRINTK(XENLOG_G_INFO "Input address is 0x%"PRIx64".\n", value);
+ gdprintk(XENLOG_INFO, "Input address is 0x%"PRIx64".\n", value);
/* 8-byte aligned valid pseudophys address from vmxassist, please. */
if ( (value & 7) || (mfn == INVALID_MFN) ||
value = *((uint64_t *)(p + (value & (PAGE_SIZE - 1))));
unmap_domain_page(p);
- DPRINTK(XENLOG_G_INFO "Output value is 0x%"PRIx64".\n", value);
+ gdprintk(XENLOG_INFO, "Output value is 0x%"PRIx64".\n", value);
ecx = (u32)(value >> 0);
edx = (u32)(value >> 32);
}
}
#define WARN_BOGUS_WRITE(f, a...) \
- DPRINTK(XENLOG_INFO "\n%s: " \
+ dprintk(XENLOG_INFO, "\n%s: " \
"apic=%d, pin=%d, old_irq=%d, new_irq=%d\n" \
"%s: old_entry=%08x, new_entry=%08x\n" \
"%s: " f, __FUNCTION__, apic, pin, old_irq, new_irq, \
{
if ( desc->action != NULL )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. In use by '%s'.\n",
irq, desc->action->name);
rc = -EBUSY;
action = xmalloc(irq_guest_action_t);
if ( (desc->action = (struct irqaction *)action) == NULL )
{
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Cannot bind IRQ %d to guest. Out of memory.\n",
irq);
rc = -ENOMEM;
}
else if ( !will_share || !action->shareable )
{
- DPRINTK(XENLOG_G_INFO "Cannot bind IRQ %d to guest. "
+ gdprintk(XENLOG_INFO, "Cannot bind IRQ %d to guest. "
"Will not share with others.\n",
irq);
rc = -EBUSY;
if ( action->nr_guests == IRQ_MAX_GUESTS )
{
- DPRINTK(XENLOG_G_INFO "Cannot bind IRQ %d to guest. "
+ gdprintk(XENLOG_INFO, "Cannot bind IRQ %d to guest. "
"Already at max share.\n", irq);
rc = -EBUSY;
goto out;
#include <asm/e820.h>
#include <public/memory.h>
-#ifdef VERBOSE
-#define MEM_LOG(_f, _a...) \
- do { \
- if ( printk_ratelimit() ) \
- printk("DOM%u: (file=mm.c, line=%d) " _f "\n", \
- current->domain->domain_id , __LINE__ , ## _a ); \
- } while (0)
-#else
-#define MEM_LOG(_f, _a...) ((void)0)
-#endif
+#define MEM_LOG(_f, _a...) gdprintk(XENLOG_WARNING , _f , ## _a)
/*
* PTE updates can be done with ordinary writes except:
{
if ( shadow_mode_refcounts(d) )
{
- DPRINTK(XENLOG_INFO
- "mmu update on shadow-refcounted domain!");
+ MEM_LOG("mmu update on shadow-refcounted domain!");
break;
}
x = y;
if (unlikely((x & (PGC_count_mask|PGC_allocated)) !=
(1 | PGC_allocated)) || unlikely(_nd != _d)) {
- DPRINTK(XENLOG_G_WARNING
- "gnttab_transfer: Bad page %p: ed=%p(%u), sd=%p,"
+ MEM_LOG("gnttab_transfer: Bad page %p: ed=%p(%u), sd=%p,"
" caf=%08x, taf=%" PRtype_info "\n",
(void *) page_to_mfn(page),
d, d->domain_id, unpickle_domptr(_nd), x,
if ( unlikely(d == current->domain) )
{
- DPRINTK(XENLOG_G_INFO "Don't try to do a shadow op on yourself!\n");
+ gdprintk(XENLOG_INFO, "Don't try to do a shadow op on yourself!\n");
return -EINVAL;
}
case QUIRK_IOAPIC_GOOD_REGSEL:
#ifndef sis_apic_bug
sis_apic_bug = (quirk_id == QUIRK_IOAPIC_BAD_REGSEL);
- DPRINTK(XENLOG_INFO "Domain 0 says that IO-APIC REGSEL is %s\n",
+ dprintk(XENLOG_INFO, "Domain 0 says that IO-APIC REGSEL is %s\n",
sis_apic_bug ? "bad" : "good");
#else
BUG_ON(sis_apic_bug != (quirk_id == QUIRK_IOAPIC_BAD_REGSEL));
if ( likely((fixup = search_exception_table(regs->eip)) != 0) )
{
- DPRINTK(XENLOG_ERR "Trap %d: %p -> %p\n",
+ dprintk(XENLOG_ERR, "Trap %d: %p -> %p\n",
trapnr, _p(regs->eip), _p(fixup));
regs->eip = fixup;
return 0;
if ( idx > 0 )
{
- DPRINTK(XENLOG_G_WARNING
+ gdprintk(XENLOG_WARNING,
"Dom%d: Out of range index %u to MSR %08x\n",
d->domain_id, idx, 0x40000000);
return 0;
if ( !mfn_valid(mfn) ||
!get_page_and_type(mfn_to_page(mfn), d, PGT_writable_page) )
{
- DPRINTK(XENLOG_G_WARNING
+ gdprintk(XENLOG_WARNING,
"Dom%d: Bad GMFN %lx (MFN %lx) to MSR %08x\n",
d->domain_id, gmfn, mfn, 0x40000000);
return 0;
return 0;
spurious:
- DPRINTK(XENLOG_WARNING "Spurious fault in domain %u:%u "
+ dprintk(XENLOG_WARNING, "Spurious fault in domain %u:%u "
"at addr %lx, e/c %04x\n",
current->domain->domain_id, current->vcpu_id,
addr, regs->error_code);
#if CONFIG_PAGING_LEVELS >= 4
- DPRINTK(XENLOG_WARNING " l4e = %"PRIpte"\n", l4e_get_intpte(l4e));
+ dprintk(XENLOG_WARNING, " l4e = %"PRIpte"\n", l4e_get_intpte(l4e));
#endif
#if CONFIG_PAGING_LEVELS >= 3
- DPRINTK(XENLOG_WARNING " l3e = %"PRIpte"\n", l3e_get_intpte(l3e));
+ dprintk(XENLOG_WARNING, " l3e = %"PRIpte"\n", l3e_get_intpte(l3e));
#endif
- DPRINTK(XENLOG_WARNING " l2e = %"PRIpte"\n", l2e_get_intpte(l2e));
- DPRINTK(XENLOG_WARNING " l1e = %"PRIpte"\n", l1e_get_intpte(l1e));
+ dprintk(XENLOG_WARNING, " l2e = %"PRIpte"\n", l2e_get_intpte(l2e));
+ dprintk(XENLOG_WARNING, " l1e = %"PRIpte"\n", l1e_get_intpte(l1e));
#ifndef NDEBUG
show_registers(regs);
#endif
case 0: /* Write CR0 */
if ( (*reg ^ read_cr0()) & ~X86_CR0_TS )
{
- DPRINTK(XENLOG_G_WARNING
+ gdprintk(XENLOG_WARNING,
"Attempt to change unmodifiable CR0 flags.\n");
goto fail;
}
case 4:
if ( *reg != (read_cr4() & ~(X86_CR4_PGE|X86_CR4_PSE)) )
{
- DPRINTK(XENLOG_G_WARNING "Attempt to change CR4 flags.\n");
+ gdprintk(XENLOG_WARNING, "Attempt to change CR4 flags.\n");
goto fail;
}
break;
if ( (rdmsr_safe(regs->ecx, l, h) != 0) ||
(regs->eax != l) || (regs->edx != h) )
- DPRINTK(XENLOG_G_WARNING "Domain attempted WRMSR %p from "
+ gdprintk(XENLOG_WARNING, "Domain attempted WRMSR %p from "
"%08x:%08x to %08lx:%08lx.\n",
_p(regs->ecx), h, l, (long)regs->edx, (long)regs->eax);
break;
break;
}
/* Everyone can read the MSR space. */
- /*DPRINTK("Domain attempted RDMSR %p.\n", _p(regs->ecx));*/
+ /* gdprintk(XENLOG_WARNING,"Domain attempted RDMSR %p.\n",
+ _p(regs->ecx));*/
if ( rdmsr_safe(regs->ecx, regs->eax, regs->edx) )
goto fail;
break;
if ( likely((fixup = search_exception_table(regs->eip)) != 0) )
{
- DPRINTK(XENLOG_WARNING "GPF (%04x): %p -> %p\n",
+ dprintk(XENLOG_WARNING, "GPF (%04x): %p -> %p\n",
regs->error_code, _p(regs->eip), _p(fixup));
regs->eip = fixup;
return 0;
table = (unsigned long *)LDT_VIRT_START(d);
if ( idx >= d->arch.guest_context.ldt_ents )
{
- DPRINTK(XENLOG_DEBUG "Segment %04x out of LDT range (%ld)\n",
+ dprintk(XENLOG_DEBUG, "Segment %04x out of LDT range (%ld)\n",
seg, d->arch.guest_context.ldt_ents);
goto fail;
}
table = (unsigned long *)GDT_VIRT_START(d);
if ( idx >= d->arch.guest_context.gdt_ents )
{
- DPRINTK(XENLOG_DEBUG "Segment %04x out of GDT range (%ld)\n",
+ dprintk(XENLOG_DEBUG, "Segment %04x out of GDT range (%ld)\n",
seg, d->arch.guest_context.gdt_ents);
goto fail;
}
if ( __get_user(a, &table[2*idx+0]) ||
__get_user(b, &table[2*idx+1]) )
{
- DPRINTK(XENLOG_DEBUG "Fault while reading segment %04x\n", seg);
+ dprintk(XENLOG_DEBUG, "Fault while reading segment %04x\n", seg);
goto fail; /* Barking up the wrong tree. Decode needs a page fault.*/
}
_SEGMENT_G|_SEGMENT_CODE|_SEGMENT_DPL)) !=
(_SEGMENT_P|_SEGMENT_S|_SEGMENT_DB|_SEGMENT_G|_SEGMENT_DPL) )
{
- DPRINTK(XENLOG_DEBUG "Bad segment %08lx:%08lx\n", a, b);
+ dprintk(XENLOG_DEBUG, "Bad segment %08lx:%08lx\n", a, b);
goto fail;
}
}
}
- DPRINTK(XENLOG_DEBUG "None of the above! "
+ dprintk(XENLOG_DEBUG, "None of the above! "
"(%08lx:%08lx, %08lx, %08lx, %08lx)\n",
a, b, base, limit, base+limit);
/* WARNING: We only work for ring-3 segments. */
if ( unlikely(vm86_mode(regs)) || unlikely(!ring_3(regs)) )
{
- DPRINTK(XENLOG_DEBUG "Taken fault at bad CS %04x\n", regs->cs);
+ dprintk(XENLOG_DEBUG, "Taken fault at bad CS %04x\n", regs->cs);
goto fail;
}
if ( !linearise_address((u16)regs->cs, regs->eip, (unsigned long *)&eip) )
{
- DPRINTK(XENLOG_DEBUG "Cannot linearise %04x:%08x\n",
+ dprintk(XENLOG_DEBUG, "Cannot linearise %04x:%08x\n",
regs->cs, regs->eip);
goto fail;
}
{
if ( get_user(b, pb) )
{
- DPRINTK(XENLOG_DEBUG
+ dprintk(XENLOG_DEBUG,
"Fault while accessing byte %d of instruction\n",
pb-eip);
goto page_fault;
if ( (pb - eip) >= 15 )
{
- DPRINTK(XENLOG_DEBUG "Too many instruction prefixes for a "
+ dprintk(XENLOG_DEBUG, "Too many instruction prefixes for a "
"legal instruction\n");
goto fail;
}
case 0x26: /* ES override */
case 0x64: /* FS override */
case 0x36: /* SS override */
- DPRINTK(XENLOG_DEBUG "Unhandled prefix %02x\n", b);
+ dprintk(XENLOG_DEBUG, "Unhandled prefix %02x\n", b);
goto fail;
case 0x66: /* Operand-size override */
case 0xf0: /* LOCK */
if ( !gs_override )
{
- DPRINTK(XENLOG_DEBUG "Only instructions with GS override\n");
+ dprintk(XENLOG_DEBUG, "Only instructions with GS override\n");
goto fail;
}
pb++;
if ( decode == 0 )
{
- DPRINTK(XENLOG_DEBUG "Unsupported opcode %02x\n", b);
+ dprintk(XENLOG_DEBUG, "Unsupported opcode %02x\n", b);
goto fail;
}
if ( get_user(offset, (u32 *)pb) )
{
- DPRINTK(XENLOG_DEBUG "Fault while extracting <disp32>.\n");
+ dprintk(XENLOG_DEBUG, "Fault while extracting <disp32>.\n");
goto page_fault;
}
pb += 4;
if ( get_user(modrm, pb) )
{
- DPRINTK(XENLOG_DEBUG "Fault while extracting modrm byte\n");
+ dprintk(XENLOG_DEBUG, "Fault while extracting modrm byte\n");
goto page_fault;
}
if ( rm == 4 )
{
- DPRINTK(XENLOG_DEBUG "FIXME: Add decoding for the SIB byte.\n");
+ dprintk(XENLOG_DEBUG, "FIXME: Add decoding for the SIB byte.\n");
goto fixme;
}
memreg = NULL;
if ( get_user(disp32, (u32 *)pb) )
{
- DPRINTK(XENLOG_DEBUG "Fault while extracting <disp8>.\n");
+ dprintk(XENLOG_DEBUG, "Fault while extracting <disp8>.\n");
goto page_fault;
}
pb += 4;
case 1:
if ( get_user(disp8, pb) )
{
- DPRINTK(XENLOG_DEBUG "Fault while extracting <disp8>.\n");
+ dprintk(XENLOG_DEBUG, "Fault while extracting <disp8>.\n");
goto page_fault;
}
pb++;
case 2:
if ( get_user(disp32, (u32 *)pb) )
{
- DPRINTK(XENLOG_DEBUG "Fault while extracting <disp8>.\n");
+ dprintk(XENLOG_DEBUG, "Fault while extracting <disp8>.\n");
goto page_fault;
}
pb += 4;
break;
case 3:
- DPRINTK(XENLOG_DEBUG "Not a memory operand!\n");
+ dprintk(XENLOG_DEBUG, "Not a memory operand!\n");
goto fail;
}
return EXCRET_fault_fixed;
fixme:
- DPRINTK(XENLOG_DEBUG "Undecodable instruction "
+ dprintk(XENLOG_DEBUG, "Undecodable instruction "
"%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
"caused GPF(0) at %04x:%08x\n",
eip[0], eip[1], eip[2], eip[3],
if ( unlikely(copy_from_user(&iret_saved, (void *)regs->rsp,
sizeof(iret_saved))) )
{
- DPRINTK(XENLOG_G_ERR "Fault while reading IRET context from "
+ gdprintk(XENLOG_ERR, "Fault while reading IRET context from "
"guest stack\n");
domain_crash_synchronous();
}
{
if ( unlikely(pagetable_is_null(v->arch.guest_table_user)) )
{
- DPRINTK(XENLOG_G_ERR "Guest switching to user mode with no "
+ gdprintk(XENLOG_ERR, "Guest switching to user mode with no "
"user page tables\n");
domain_crash_synchronous();
}
#include <stdio.h>
#include <stdint.h>
#include <public/xen.h>
-#define DPRINTF(_f, _a...) printf( _f , ## _a )
+#define dprintf(_f, _a...) printf( _f , ## _a )
#else
#include <xen/config.h>
#include <xen/types.h>
#include <xen/lib.h>
#include <xen/mm.h>
#include <asm/regs.h>
-#define DPRINTF DPRINTK
+#define dprintf(_f, _a...) gdprintk(XENLOG_WARNING, _f , ## _a )
#endif
#include <asm-x86/x86_emulate.h>
if ( modrm_mod == 3 )
{
- DPRINTF("Cannot parse ModRM.mod == 3.\n");
+ dprintf("Cannot parse ModRM.mod == 3.\n");
goto cannot_emulate;
}
_regs.edi, (_regs.eflags & EFLG_DF) ? -dst.bytes : dst.bytes);
break;
case 0xa6 ... 0xa7: /* cmps */
- DPRINTF("Urk! I don't handle CMPS.\n");
+ dprintf("Urk! I don't handle CMPS.\n");
goto cannot_emulate;
case 0xaa ... 0xab: /* stos */
dst.type = OP_MEM;
_regs.esi, (_regs.eflags & EFLG_DF) ? -dst.bytes : dst.bytes);
break;
case 0xae ... 0xaf: /* scas */
- DPRINTF("Urk! I don't handle SCAS.\n");
+ dprintf("Urk! I don't handle SCAS.\n");
goto cannot_emulate;
}
goto writeback;
goto writeback;
cannot_emulate:
- DPRINTF("Cannot emulate %02x\n", b);
+ dprintf("Cannot emulate %02x\n", b);
return -1;
}
struct vcpu *idle_vcpu[NR_CPUS] __read_mostly;
+int current_domain_id(void)
+{
+ return current->domain->domain_id;
+}
+
struct domain *alloc_domain(domid_t domid)
{
struct domain *d;
return d;
}
-
void free_domain(struct domain *d)
{
struct vcpu *v;
xfree(d);
}
-
struct vcpu *alloc_vcpu(
struct domain *d, unsigned int vcpu_id, unsigned int cpu_id)
{
#define ERROR_EXIT(_errno) \
do { \
- DPRINTK(XENLOG_G_WARNING \
+ gdprintk(XENLOG_WARNING, \
"EVTCHNOP failure: domain %d, error %d, line %d\n", \
current->domain->domain_id, (_errno), __LINE__); \
rc = (_errno); \
#define PIN_FAIL(_lbl, _rc, _f, _a...) \
do { \
- DPRINTK( XENLOG_G_WARNING _f, ## _a ); \
+ gdprintk(XENLOG_WARNING, _f, ## _a ); \
rc = (_rc); \
goto _lbl; \
} while ( 0 )
if ( unlikely(op->ref >= NR_GRANT_ENTRIES) ||
unlikely((op->flags & (GNTMAP_device_map|GNTMAP_host_map)) == 0) )
{
- DPRINTK(XENLOG_G_INFO "Bad ref (%d) or flags (%x).\n",
+ gdprintk(XENLOG_INFO, "Bad ref (%d) or flags (%x).\n",
op->ref, op->flags);
op->status = GNTST_bad_gntref;
return;
{
if ( rd != NULL )
put_domain(rd);
- DPRINTK(XENLOG_G_INFO "Could not find domain %d\n", op->dom);
+ gdprintk(XENLOG_INFO, "Could not find domain %d\n", op->dom);
op->status = GNTST_bad_domain;
return;
}
if ( (lgt->maptrack_limit << 1) > MAPTRACK_MAX_ENTRIES )
{
put_domain(rd);
- DPRINTK(XENLOG_G_INFO "Maptrack table is at maximum size.\n");
+ gdprintk(XENLOG_INFO, "Maptrack table is at maximum size.\n");
op->status = GNTST_no_device_space;
return;
}
if ( new_mt == NULL )
{
put_domain(rd);
- DPRINTK(XENLOG_G_INFO "No more map handles available.\n");
+ gdprintk(XENLOG_INFO, "No more map handles available.\n");
op->status = GNTST_no_device_space;
return;
}
lgt->maptrack_order += 1;
lgt->maptrack_limit <<= 1;
- DPRINTK(XENLOG_G_INFO "Doubled maptrack size\n");
+ gdprintk(XENLOG_INFO, "Doubled maptrack size\n");
handle = get_maptrack_handle(ld->grant_table);
}
if ( unlikely(op->handle >= ld->grant_table->maptrack_limit) ||
unlikely(!map->flags) )
{
- DPRINTK(XENLOG_G_INFO "Bad handle (%d).\n", op->handle);
+ gdprintk(XENLOG_INFO, "Bad handle (%d).\n", op->handle);
op->status = GNTST_bad_handle;
return;
}
{
if ( rd != NULL )
put_domain(rd);
- DPRINTK(XENLOG_G_INFO "Could not find domain %d\n", dom);
+ gdprintk(XENLOG_INFO, "Could not find domain %d\n", dom);
op->status = GNTST_bad_domain;
return;
}
if ( unlikely(copy_from_guest(&op, uop, 1) != 0) )
{
- DPRINTK(XENLOG_G_INFO "Fault while reading gnttab_setup_table_t.\n");
+ gdprintk(XENLOG_INFO, "Fault while reading gnttab_setup_table_t.\n");
return -EFAULT;
}
if ( unlikely(op.nr_frames > NR_GRANT_FRAMES) )
{
- DPRINTK(XENLOG_G_INFO "Xen only supports up to %d grant-table frames"
+ gdprintk(XENLOG_INFO, "Xen only supports up to %d grant-table frames"
" per domain.\n",
NR_GRANT_FRAMES);
op.status = GNTST_general_error;
if ( unlikely((d = find_domain_by_id(dom)) == NULL) )
{
- DPRINTK(XENLOG_G_INFO "Bad domid %d.\n", dom);
+ gdprintk(XENLOG_INFO, "Bad domid %d.\n", dom);
op.status = GNTST_bad_domain;
goto out;
}
if ( unlikely((rgt = rd->grant_table) == NULL) ||
unlikely(ref >= NR_GRANT_ENTRIES) )
{
- DPRINTK(XENLOG_G_INFO "Dom %d has no g.t., or ref is bad (%d).\n",
+ gdprintk(XENLOG_INFO, "Dom %d has no g.t., or ref is bad (%d).\n",
rd->domain_id, ref);
return 0;
}
if ( unlikely(scombo.shorts.flags != GTF_accept_transfer) ||
unlikely(scombo.shorts.domid != ld->domain_id) )
{
- DPRINTK(XENLOG_G_INFO "Bad flags (%x) or dom (%d). "
+ gdprintk(XENLOG_INFO, "Bad flags (%x) or dom (%d). "
"(NB. expected dom %d)\n",
scombo.shorts.flags, scombo.shorts.domid,
ld->domain_id);
if ( retries++ == 4 )
{
- DPRINTK(XENLOG_G_WARNING "Shared grant entry is unstable.\n");
+ gdprintk(XENLOG_WARNING, "Shared grant entry is unstable.\n");
goto fail;
}
/* Read from caller address space. */
if ( unlikely(__copy_from_guest_offset(&gop, uop, i, 1)) )
{
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: error reading req %d/%d\n",
+ gdprintk(XENLOG_INFO, "gnttab_transfer: error reading req %d/%d\n",
i, count);
return -EFAULT;
}
/* Check the passed page frame for basic validity. */
if ( unlikely(!mfn_valid(mfn)) )
{
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: out-of-range %lx\n",
+ gdprintk(XENLOG_INFO, "gnttab_transfer: out-of-range %lx\n",
(unsigned long)gop.mfn);
gop.status = GNTST_bad_page;
goto copyback;
page = mfn_to_page(mfn);
if ( unlikely(IS_XEN_HEAP_FRAME(page)) )
{
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: xen frame %lx\n",
+ gdprintk(XENLOG_INFO, "gnttab_transfer: xen frame %lx\n",
(unsigned long)gop.mfn);
gop.status = GNTST_bad_page;
goto copyback;
/* Find the target domain. */
if ( unlikely((e = find_domain_by_id(gop.domid)) == NULL) )
{
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: can't find domain %d\n",
+ gdprintk(XENLOG_INFO, "gnttab_transfer: can't find domain %d\n",
gop.domid);
page->count_info &= ~(PGC_count_mask|PGC_allocated);
free_domheap_page(page);
unlikely(!gnttab_prepare_for_transfer(e, d, gop.ref)) )
{
if ( !test_bit(_DOMF_dying, &e->domain_flags) )
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: "
+ gdprintk(XENLOG_INFO, "gnttab_transfer: "
"Transferee has no reservation "
"headroom (%d,%d) or provided a bad grant ref (%08x) "
"or is dying (%lx)\n",
copyback:
if ( unlikely(__copy_to_guest_offset(uop, i, &gop, 1)) )
{
- DPRINTK(XENLOG_G_INFO "gnttab_transfer: error writing resp %d/%d\n",
+ gdprintk(XENLOG_INFO, "gnttab_transfer: error writing resp %d/%d\n",
i, count);
return -EFAULT;
}
ref = map->ref;
- DPRINTK(XENLOG_G_INFO "Grant release (%hu) ref:(%hu) "
+ gdprintk(XENLOG_INFO, "Grant release (%hu) ref:(%hu) "
"flags:(%x) dom:(%hu)\n",
handle, ref, map->flags, map->domid);
if ( unlikely((page = __alloc_domheap_pages( d, cpu,
extent_order, memflags )) == NULL) )
{
- DPRINTK(XENLOG_G_INFO "Could not allocate order=%d extent: "
+ gdprintk(XENLOG_INFO, "Could not allocate order=%d extent: "
"id=%d memflags=%x (%ld of %d)\n",
extent_order, d->domain_id, memflags, i, nr_extents);
return i;
if ( unlikely((page = __alloc_domheap_pages( d, cpu,
extent_order, memflags )) == NULL) )
{
- DPRINTK(XENLOG_G_INFO "Could not allocate order=%d extent: "
+ gdprintk(XENLOG_INFO, "Could not allocate order=%d extent: "
"id=%d memflags=%x (%ld of %d)\n",
extent_order, d->domain_id, memflags, i, nr_extents);
goto out;
mfn = gmfn_to_mfn(d, gmfn);
if ( unlikely(!mfn_valid(mfn)) )
{
- DPRINTK(XENLOG_G_INFO "Domain %u page number %lx invalid\n",
+ gdprintk(XENLOG_INFO, "Domain %u page number %lx invalid\n",
d->domain_id, gmfn);
return 0;
}
page = mfn_to_page(mfn);
if ( unlikely(!get_page(page, d)) )
{
- DPRINTK(XENLOG_G_INFO "Bad page free for domain %u\n", d->domain_id);
+ gdprintk(XENLOG_INFO, "Bad page free for domain %u\n", d->domain_id);
return 0;
}
if ( unlikely(!page_is_removable(page)) )
{
/* We'll make this a guest-visible error in future, so take heed! */
- DPRINTK(XENLOG_G_INFO "Dom%d freeing in-use page %lx (pseudophys %lx):"
+ gdprintk(XENLOG_INFO, "Dom%d freeing in-use page %lx (pseudophys %lx):"
" count=%lx type=%lx\n",
d->domain_id, mfn, get_gpfn_from_mfn(mfn),
(unsigned long)page->count_info, page->u.inuse.type_info);
if ( unlikely(__test_and_set_bit(_MCSF_in_multicall, &mcs->flags)) )
{
- DPRINTK(XENLOG_G_INFO "Multicall reentry is disallowed.\n");
+ gdprintk(XENLOG_INFO, "Multicall reentry is disallowed.\n");
return -EINVAL;
}
if ( unlikely(test_bit(_DOMF_dying, &d->domain_flags)) )
{
- DPRINTK(XENLOG_G_INFO "Cannot assign page to domain%d -- dying.\n",
+ gdprintk(XENLOG_INFO, "Cannot assign page to domain%d -- dying.\n",
d->domain_id);
goto fail;
}
{
if ( unlikely((d->tot_pages + (1 << order)) > d->max_pages) )
{
- DPRINTK(XENLOG_G_INFO "Over-allocation for domain %u: %u > %u\n",
+ gdprintk(XENLOG_INFO, "Over-allocation for domain %u: %u > %u\n",
d->domain_id, d->tot_pages + (1 << order), d->max_pages);
goto fail;
}
* timeout in this case can burn a lot of CPU. We therefore go for a
* reasonable middleground of triggering a timer event in 100ms.
*/
- DPRINTK(XENLOG_G_INFO "Warning: huge timeout set by domain %d (vcpu %d):"
+ gdprintk(XENLOG_INFO, "Warning: huge timeout set by domain %d (vcpu %d):"
" %"PRIx64"\n",
v->domain->domain_id, v->vcpu_id, (uint64_t)timeout);
set_timer(&v->timer, NOW() + MILLISECS(100));
*/
if ( (opt_tbuf_size != 0) || (size <= 0) )
{
- DPRINTK(XENLOG_G_INFO "tb_set_size from %d to %d not implemented\n",
+ gdprintk(XENLOG_INFO, "tb_set_size from %d to %d not implemented\n",
opt_tbuf_size, size);
return -EINVAL;
}
static DEFINE_SPINLOCK(console_lock);
+/*
+ * To control the amount of printing, thresholds are added.
+ * These thresholds correspond to the XENLOG logging levels.
+ * There's an upper and lower threshold for non-guest messages and for
+ * guest-provoked messages. This works as follows, for a given log level L:
+ *
+ * L < lower_threshold : always logged
+ * lower_threshold <= L < upper_threshold : rate-limited logging
+ * upper_threshold <= L : never logged
+ *
+ * Note, in the above algorithm, to disable rate limiting simply make
+ * the lower threshold equal to the upper.
+ */
+#define XENLOG_UPPER_THRESHOLD 2 /* Do not print INFO and DEBUG */
+#define XENLOG_LOWER_THRESHOLD 2 /* Always print ERR and WARNING */
+#define XENLOG_GUEST_UPPER_THRESHOLD 2 /* Do not print INFO and DEBUG */
+#define XENLOG_GUEST_LOWER_THRESHOLD 0 /* Rate-limit ERR and WARNING */
+/*
+ * The XENLOG_DEFAULT is the default given to printks that
+ * do not have any print level associated with them.
+ */
+#define XENLOG_DEFAULT 1 /* XENLOG_WARNING */
+#define XENLOG_GUEST_DEFAULT 1 /* XENLOG_WARNING */
+
int xenlog_upper_thresh = XENLOG_UPPER_THRESHOLD;
int xenlog_lower_thresh = XENLOG_LOWER_THRESHOLD;
int xenlog_guest_upper_thresh = XENLOG_GUEST_UPPER_THRESHOLD;
if ( !print_regardless )
{
- if ( level > upper_thresh )
+ if ( level >= upper_thresh )
goto out;
if ( (level >= lower_thresh) && (!printk_ratelimit()) )
goto out;
unlikely((nx & PGC_count_mask) == 0) || /* Count overflow? */
unlikely((x >> 32) != _domain)) { /* Wrong owner? */
- DPRINTK(XENLOG_G_INFO "Error pfn %lx: rd=%p, od=%p, caf=%016lx, taf=%"
+ gdprintk(XENLOG_INFO, "Error pfn %lx: rd=%p, od=%p, caf=%016lx, taf=%"
PRtype_info "\n", page_to_mfn(page), domain,
unpickle_domptr(x >> 32), x, page->u.inuse.type_info);
return 0;
unlikely(d != _domain) ) /* Wrong owner? */
{
if ( !_shadow_mode_refcounts(domain) )
- DPRINTK(XENLOG_G_INFO
+ gdprintk(XENLOG_INFO,
"Error pfn %lx: rd=%p, od=%p, caf=%08x, taf=%"
PRtype_info "\n",
page_to_mfn(page), domain, unpickle_domptr(d),
* it to allow for DoS by causing the HV to print out a lot of
* info, so where ever the guest has control of what is printed
* we use the XENLOG_GUEST to distinguish that the output is
- * controled by the Guest.
+ * controlled by the guest.
*
* To make it easier on the typing, the above log levels all
* have a corresponding _G_ equivalent that appends the
#define XENLOG_MAX 3
-/*
- * To control the amount of printing, thresholds are added.
- * These thresholds correspond to the above log levels.
- * There's an upper and lower threshold for non-guests
- * and Guest. This works as follows:
- *
- * If printk log level > upper threshold
- * don't print anything
- *
- * If printk log level >= lower threshold
- * rate limit the print (keep the amount down)
- *
- * Otherwise, just print.
- *
- * Note, in the above algorithm, to never rate limit
- * simply make the lower threshold greater than the upper.
- * This way the output will never be rate limited.
- *
- * For example:
- * lower = 2; upper = 1;
- * This will always print ERR and WARNING messages
- * but will not print anything else. Nothing is
- * rate limited.
- */
-/*
- * Defaults:
- * For the HV, always print ERR and WARNING
- * but nothing for INFO and DEBUG.
- *
- * For Guests, always rate limit ERR and WARNING
- * but never print for INFO and DEBUG.
- */
-#ifndef XENLOG_UPPER_THRESHOLD
-#define XENLOG_UPPER_THRESHOLD 1
-#endif
-#ifndef XENLOG_LOWER_THRESHOLD
-#define XENLOG_LOWER_THRESHOLD 2
-#endif
-#ifndef XENLOG_GUEST_UPPER_THRESHOLD
-#define XENLOG_GUEST_UPPER_THRESHOLD 1
-#endif
-#ifndef XENLOG_GUEST_LOWER_THRESHOLD
-#define XENLOG_GUEST_LOWER_THRESHOLD 0
-#endif
-
-/*
- * The XENLOG_DEFAULT is the default given to printks that
- * do not have any print level associated to it.
- */
-#ifndef XENLOG_DEFAULT
-#define XENLOG_DEFAULT 1 /* Warning */
-#endif
-#ifndef XENLOG_GUEST_DEFAULT
-#define XENLOG_GUEST_DEFAULT 1 /* Warning */
-#endif
-
/*
* Some code is copied directly from Linux.
* Match some of the Linux log levels to Xen.
- * (Should these be Guest logs?? - SDR)
*/
#define KERN_ERR XENLOG_ERR
#define KERN_CRIT XENLOG_ERR
#define __iomem
#define __user
-#define DPRINTK(_f, _a...) printk("(file=%s, line=%d) " _f, \
- __FILE__ , __LINE__ , ## _a )
-
#ifndef __ASSEMBLY__
+
+int current_domain_id(void);
+#define dprintk(_l, _f, _a...) \
+ printk(_l "%s:%d: " _f, __FILE__ , __LINE__ , ## _a )
+#define gdprintk(_l, _f, _a...) \
+ printk(XENLOG_GUEST _l "%s:%d:d%d " _f, __FILE__, \
+ __LINE__, current_domain_id() , ## _a )
+
#include <xen/compiler.h>
-#endif
+
+#endif /* !__ASSEMBLY__ */
#define __STR(...) #__VA_ARGS__
#define STR(...) __STR(__VA_ARGS__)
projects / xen.git / commitdiff