int barrier;
int flush;
};
-struct blkfront_dev *init_blkfront(char *nodename, struct blkfront_info *info);
+struct blkfront_dev *blkfront_init(char *nodename, struct blkfront_info *info);
void blkfront_aio(struct blkfront_aiocb *aiocbp, int write);
#define blkfront_aio_read(aiocbp) blkfront_aio(aiocbp, 0)
#define blkfront_aio_write(aiocbp) blkfront_aio(aiocbp, 1)
void blkfront_aio_push_operation(struct blkfront_aiocb *aiocbp, uint8_t op);
int blkfront_aio_poll(struct blkfront_dev *dev);
void blkfront_sync(struct blkfront_dev *dev);
-void shutdown_blkfront(struct blkfront_dev *dev);
+void blkfront_shutdown(struct blkfront_dev *dev);
extern struct wait_queue_head blkfront_queue;
void print(int direct, const char *fmt, va_list args);
-void printk(const char *fmt, ...);
+void minios_printk(const char *fmt, ...);
void xprintk(const char *fmt, ...);
void panic(const char *fmt, ...);
void xencons_tx(void);
void init_console(void);
-void console_print(struct consfront_dev *dev, char *data, int length);
+void minios_console_print(struct consfront_dev *dev, char *data, int length);
void fini_console(struct consfront_dev *dev);
/* Low level functions defined in xencons_ring.c */
/* prototypes */
int do_event(evtchn_port_t port, struct pt_regs *regs);
-evtchn_port_t bind_virq(uint32_t virq, evtchn_handler_t handler, void *data);
-evtchn_port_t bind_pirq(uint32_t pirq, int will_share, evtchn_handler_t handler, void *data);
-evtchn_port_t bind_evtchn(evtchn_port_t port, evtchn_handler_t handler,
+evtchn_port_t minios_bind_virq(uint32_t virq, evtchn_handler_t handler, void *data);
+evtchn_port_t minios_bind_pirq(uint32_t pirq, int will_share, evtchn_handler_t handler, void *data);
+evtchn_port_t minios_bind_evtchn(evtchn_port_t port, evtchn_handler_t handler,
void *data);
-void unbind_evtchn(evtchn_port_t port);
+void minios_unbind_evtchn(evtchn_port_t port);
void init_events(void);
-int evtchn_alloc_unbound(domid_t pal, evtchn_handler_t handler,
+int minios_evtchn_alloc_unbound(domid_t pal, evtchn_handler_t handler,
void *data, evtchn_port_t *port);
-int evtchn_bind_interdomain(domid_t pal, evtchn_port_t remote_port,
+int minios_evtchn_bind_interdomain(domid_t pal, evtchn_port_t remote_port,
evtchn_handler_t handler, void *data,
evtchn_port_t *local_port);
void unbind_all_ports(void);
start_info_t start_info;
char padding[512];
};
-extern union start_info_union start_info_union;
-#define start_info (start_info_union.start_info)
+extern union start_info_union _minios_start_info_union;
+#define start_info (_minios_start_info_union.start_info)
/* hypervisor.c */
-void force_evtchn_callback(void);
-void do_hypervisor_callback(struct pt_regs *regs);
-void mask_evtchn(uint32_t port);
-void unmask_evtchn(uint32_t port);
-void clear_evtchn(uint32_t port);
+void minios_force_evtchn_callback(void);
+void minios_do_hypervisor_callback(struct pt_regs *regs);
+void minios_mask_evtchn(uint32_t port);
+void minios_unmask_evtchn(uint32_t port);
+void minios_clear_evtchn(uint32_t port);
-extern int in_callback;
+extern int _minios_in_hypervisor_callback;
#endif /* __MINIOS_HYPERVISOR_H__ */
extern int app_main(start_info_t *);
-extern void do_exit(void) __attribute__((noreturn));
+extern void minios_do_exit(void) __attribute__((noreturn));
extern void stop_kernel(void);
#endif /* _MINIOS_KERNEL_H_ */
#define ASSERT(x) \
do { \
if (!(x)) { \
- printk("ASSERTION FAILED: %s at %s:%d.\n", \
+ minios_printk("ASSERTION FAILED: %s at %s:%d.\n", \
# x , \
__FILE__, \
__LINE__); \
void init_mm(void);
-unsigned long alloc_pages(int order);
-#define alloc_page() alloc_pages(0)
-void free_pages(void *pointer, int order);
-#define free_page(p) free_pages(p, 0)
+unsigned long minios_alloc_pages(int order);
+#define minios_alloc_page() minios_alloc_pages(0)
+void minios_free_pages(void *pointer, int order);
+#define minios_free_page(p) minios_free_pages(p, 0)
static __inline__ int get_order(unsigned long size)
{
#include <mini-os/wait.h>
struct netfront_dev;
-struct netfront_dev *init_netfront(char *nodename, void (*netif_rx)(struct netfront_dev *, unsigned char *data, int len), unsigned char rawmac[6], char **ip, void *priv);
+struct netfront_dev *netfront_init(char *nodename, void (*netif_rx)(struct netfront_dev *, unsigned char *data, int len), unsigned char rawmac[6], char **ip, void *priv);
void netfront_xmit(struct netfront_dev *dev, unsigned char* data,int len);
-void shutdown_netfront(struct netfront_dev *dev);
+void netfront_shutdown(struct netfront_dev *dev);
void *netfront_get_private(struct netfront_dev *);
#define USED __attribute__ ((used))
-#define BUG do_exit
+#define BUG minios_do_exit
#include <mini-os/machine/os.h>
void init_sched(void);
void run_idle_thread(void);
-struct thread* create_thread(const char *name, void *cookie,
+struct thread* minios_create_thread(const char *name, void *cookie,
void (*f)(void *), void *data, void *stack);
-void exit_thread(void) __attribute__((noreturn));
-void join_thread(struct thread *);
-void set_sched_hook(void (*hook)(void *, void *));
-struct thread *init_mainlwp(void *cookie);
-void schedule(void);
+void minios_exit_thread(void) __attribute__((noreturn));
+void minios_join_thread(struct thread *);
+void minios_set_sched_hook(void (*hook)(void *, void *));
+struct thread *minios_init_mainlwp(void *cookie);
+void minios_schedule(void);
#define current get_current()
-void wake(struct thread *thread);
-void block(struct thread *thread);
-int msleep(uint32_t millisecs);
-int absmsleep(uint32_t millisecs);
+void minios_wake(struct thread *thread);
+void minios_block(struct thread *thread);
+int minios_msleep(uint32_t millisecs);
+int minios_absmsleep(uint32_t millisecs);
#endif /* __MINIOS_SCHED_H__ */
static inline void init_SEMAPHORE(struct semaphore *sem, int count)
{
sem->count = count;
- init_waitqueue_head(&sem->wait);
+ minios_init_waitqueue_head(&sem->wait);
}
#define init_MUTEX(sem) init_SEMAPHORE(sem, 1)
{
unsigned long flags;
while (1) {
- wait_event(sem->wait, sem->count > 0);
+ minios_wait_event(sem->wait, sem->count > 0);
local_irq_save(flags);
if (sem->count > 0)
break;
unsigned long flags;
local_irq_save(flags);
sem->count++;
- wake_up(&sem->wait);
+ minios_wake_up(&sem->wait);
local_irq_restore(flags);
}
}
-static inline void init_waitqueue_head(struct wait_queue_head *h)
+static inline void minios_init_waitqueue_head(struct wait_queue_head *h)
{
STAILQ_INIT(h);
}
-static inline void init_waitqueue_entry(struct wait_queue *q, struct thread *thread)
+static inline void minios_init_waitqueue_entry(struct wait_queue *q, struct thread *thread)
{
q->thread = thread;
q->waiting = 0;
}
-static inline void add_wait_queue(struct wait_queue_head *h, struct wait_queue *q)
+static inline void minios_add_wait_queue(struct wait_queue_head *h, struct wait_queue *q)
{
if (!q->waiting) {
STAILQ_INSERT_HEAD(h, q, thread_list);
}
}
-static inline void remove_wait_queue(struct wait_queue_head *h, struct wait_queue *q)
+static inline void minios_remove_wait_queue(struct wait_queue_head *h, struct wait_queue *q)
{
if (q->waiting) {
STAILQ_REMOVE(h, q, wait_queue, thread_list);
}
}
-static inline void wake_up(struct wait_queue_head *head)
+static inline void minios_wake_up(struct wait_queue_head *head)
{
unsigned long flags;
struct wait_queue *curr, *tmp;
local_irq_save(flags);
STAILQ_FOREACH_SAFE(curr, head, thread_list, tmp)
- wake(curr->thread);
+ minios_wake(curr->thread);
local_irq_restore(flags);
}
-#define add_waiter(w, wq) do { \
+#define minios_add_waiter(w, wq) do { \
unsigned long flags; \
local_irq_save(flags); \
- add_wait_queue(&wq, &w); \
- block(get_current()); \
+ minios_add_wait_queue(&wq, &w); \
+ minios_block(get_current()); \
local_irq_restore(flags); \
} while (0)
-#define remove_waiter(w, wq) do { \
+#define minios_remove_waiter(w, wq) do { \
unsigned long flags; \
local_irq_save(flags); \
- remove_wait_queue(&wq, &w); \
+ minios_remove_wait_queue(&wq, &w); \
local_irq_restore(flags); \
} while (0)
-#define wait_event_deadline(wq, condition, deadline) do { \
+#define minios_wait_event_deadline(wq, condition, deadline) do { \
unsigned long flags; \
DEFINE_WAIT(__wait); \
if(condition) \
{ \
/* protect the list */ \
local_irq_save(flags); \
- add_wait_queue(&wq, &__wait); \
+ minios_add_wait_queue(&wq, &__wait); \
get_current()->wakeup_time = deadline; \
clear_runnable(get_current()); \
local_irq_restore(flags); \
if((condition) || (deadline && NOW() >= deadline)) \
break; \
- schedule(); \
+ minios_schedule(); \
} \
local_irq_save(flags); \
/* need to wake up */ \
- wake(get_current()); \
- remove_wait_queue(&wq, &__wait); \
+ minios_wake(get_current()); \
+ minios_remove_wait_queue(&wq, &__wait); \
local_irq_restore(flags); \
} while(0)
-#define wait_event(wq, condition) wait_event_deadline(wq, condition, 0)
+#define minios_wait_event(wq, condition) minios_wait_event_deadline(wq, condition, 0)
typedef unsigned long maddr_t;
#endif
-extern unsigned long *phys_to_machine_mapping;
+extern unsigned long *_minios_phys_to_machine_mapping;
extern char _text, _etext, _erodata, _edata, _end;
-extern unsigned long mfn_zero;
-#define pfn_to_mfn(_pfn) (phys_to_machine_mapping[(_pfn)])
+extern unsigned long _minios_mfn_zero;
+#define pfn_to_mfn(_pfn) (_minios_phys_to_machine_mapping[(_pfn)])
static __inline__ maddr_t phys_to_machine(paddr_t phys)
{
maddr_t machine = pfn_to_mfn(phys >> PAGE_SHIFT);
_vcpu->evtchn_upcall_mask = 0; \
barrier(); /* unmask then check (avoid races) */ \
if ( unlikely(_vcpu->evtchn_upcall_pending) ) \
- force_evtchn_callback(); \
+ minios_force_evtchn_callback(); \
} while (0)
#define __save_flags(x) \
if ((_vcpu->evtchn_upcall_mask = (x)) == 0) { \
barrier(); /* unmask then check (avoid races) */ \
if ( unlikely(_vcpu->evtchn_upcall_pending) ) \
- force_evtchn_callback(); \
+ minios_force_evtchn_callback(); \
}\
} while (0)
*lid = ++curlwpid;
scd->scd_lwpid = *lid;
- scd->scd_thread = create_thread("lwp", scd,
+ scd->scd_thread = minios_create_thread("lwp", scd,
scd->scd_start, scd->scd_arg, scd->scd_stack);
if (scd->scd_thread == NULL)
return EBUSY; /* ??? */
return -1;
}
- wake(scd->scd_thread);
+ minios_wake(scd->scd_thread);
return 0;
}
_lwp_rumpxen_scheduler_init(void)
{
- set_sched_hook(schedhook);
- mainthread.scd_thread = init_mainlwp(&mainthread.scd_tls);
+ minios_set_sched_hook(schedhook);
+ mainthread.scd_thread = minios_init_mainlwp(&mainthread.scd_tls);
TAILQ_INSERT_TAIL(&scheds, &mainthread, entries);
}
uint32_t msecs = ts->tv_sec*1000 + ts->tv_nsec/(1000*1000);
if (flags & TIMER_ABSTIME) {
- rv = absmsleep(msecs);
+ rv = minios_absmsleep(msecs);
} else {
- rv = msleep(msecs);
+ rv = minios_msleep(msecs);
}
if (rv) {
rv = ETIMEDOUT;
}
} else {
- block(mylwp->scd_thread);
- schedule();
+ minios_block(mylwp->scd_thread);
+ minios_schedule();
rv = 0;
}
scd->scd_lwpctl.lc_curcpu = LWPCTL_CPU_EXITED;
TAILQ_REMOVE(&scheds, scd, entries);
- exit_thread();
+ minios_exit_thread();
}
void
struct schedulable *scd;
if ((scd = lwpid2scd(lid)) != NULL)
- wake(scd->scd_thread);
+ minios_wake(scd->scd_thread);
}
void
struct schedulable *scd;
if ((scd = lwpid2scd(lid)) != NULL)
- block(scd->scd_thread);
+ minios_block(scd->scd_thread);
}
int
if ((scd = lwpid2scd(lid)) == NULL)
return ESRCH;
- wake(scd->scd_thread);
+ minios_wake(scd->scd_thread);
return ENODEV;
}
_sched_yield(void)
{
- schedule();
+ minios_schedule();
}
__weak_alias(sched_yield,_sched_yield);
__strong_alias(_sys_sched_yield,_sched_yield);
_exit(int eval)
{
- do_exit();
+ minios_do_exit();
}
static int done = 0; \
errno = ENOTSUP; \
if (done) return ENOTSUP; done = 1; \
- printk("STUB ``%s'' called\n", #name); \
+ minios_printk("STUB ``%s'' called\n", #name); \
return ENOTSUP;}
STUB(__sigaction14);
#ifdef MEMALLOC_TESTING
v = malloc((1<<shift) * pagesz);
#else
- v = (void *)alloc_pages(shift);
+ v = (void *)minios_alloc_pages(shift);
#endif
return v;
{
if (version != RUMPHYPER_MYVERSION) {
- printk("Unsupported hypercall versions requested, %d vs %d\n",
+ minios_printk("Unsupported hypercall versions requested, %d vs %d\n",
version, RUMPHYPER_MYVERSION);
return 1;
}
{
char c = (char)ch;
- console_print(NULL, &c, 1);
+ minios_console_print(NULL, &c, 1);
}
void
char *buf;
va_list va;
- buf = (void *)alloc_pages(0);
+ buf = (void *)minios_alloc_pages(0);
if (!buf)
return;
va_start(va, fmt);
vsnprintf(buf, PAGE_SIZE, fmt, va);
va_end(va);
- console_print(NULL, buf, strlen(buf));
+ minios_console_print(NULL, buf, strlen(buf));
- free_pages(buf, 0);
+ minios_free_pages(buf, 0);
}
static struct {
switch (rclk) {
case RUMPUSER_CLOCK_RELWALL:
msec = sec * 1000 + nsec / (1000*1000UL);
- msleep(msec);
+ minios_msleep(msec);
break;
case RUMPUSER_CLOCK_ABSMONO:
thread = get_current();
thread->wakeup_time = sec * (1000*1000*1000ULL) + nsec;
clear_runnable(thread);
- schedule();
+ minios_schedule();
break;
}
rumpkern_sched(nlocks, NULL);
*/
if (len == PAGE_SIZE) {
ASSERT(alignment <= PAGE_SIZE);
- *retval = (void *)alloc_page();
+ *retval = (void *)minios_alloc_page();
} else {
*retval = memalloc(len, alignment);
}
{
if (buflen == PAGE_SIZE)
- free_page(buf);
+ minios_free_page(buf);
else
memfree(buf);
}
rumpuser_exit(int value)
{
- do_exit();
+ minios_do_exit();
}
#define NBLKDEV 10
snprintf(buf, sizeof(buf), "device/vbd/%d", devnum);
rumpkern_unsched(&nlocks, NULL);
- blkdevs[num] = init_blkfront(buf, &blkinfos[num]);
+ blkdevs[num] = blkfront_init(buf, &blkinfos[num]);
rumpkern_sched(nlocks, NULL);
if (blkdevs[num] != NULL) {
/* not sure if this appropriately prevents races either ... */
blkdevs[rfd] = NULL;
- shutdown_blkfront(toclose);
+ blkfront_shutdown(toclose);
}
return 0;
}
if (did)
break;
- add_waiter(w, blkfront_queue);
+ minios_add_waiter(w, blkfront_queue);
local_irq_restore(flags);
- schedule();
+ minios_schedule();
local_irq_save(flags);
}
local_irq_restore(flags);
if (!bio_inited) {
bio_inited = 1;
rumpuser_mutex_exit(bio_mtx);
- create_thread("biopoll", NULL,
+ minios_create_thread("biopoll", NULL,
biothread, NULL, NULL);
} else {
rumpuser_mutex_exit(bio_mtx);
}
if (dlen > MAXPKT) {
- printk("myrecv: pkt len %d too big\n", dlen);
+ minios_printk("myrecv: pkt len %d too big\n", dlen);
return;
}
viu->viu_write = nextw;
if (viu->viu_rcvr)
- wake(viu->viu_rcvr);
+ minios_wake(viu->viu_rcvr);
}
static void
for (;;) {
while (viu->viu_read == viu->viu_write) {
viu->viu_rcvr = me;
- block(viu->viu_rcvr);
+ minios_block(viu->viu_rcvr);
local_irq_restore(flags);
- schedule();
+ minios_schedule();
local_irq_save(flags);
viu->viu_rcvr = NULL;
}
memset(viu, 0, sizeof(*viu));
viu->viu_vifsc = vif_sc;
- viu->viu_dev = init_netfront(NULL, myrecv, enaddr, NULL, viu);
+ viu->viu_dev = netfront_init(NULL, myrecv, enaddr, NULL, viu);
if (!viu->viu_dev) {
rv = EINVAL; /* ? */
free(viu);
goto out;
}
- if (create_thread("xenifp", NULL, pusher, viu, NULL) == NULL) {
- printk("fatal thread creation failure\n"); /* XXX */
- do_exit();
+ if (minios_create_thread("xenifp", NULL, pusher, viu, NULL) == NULL) {
+ minios_printk("fatal thread creation failure\n"); /* XXX */
+ minios_do_exit();
}
rv = 0;
ihan->i_handler = handler;
ihan->i_data = data;
- prt = bind_pirq(pirq, 1, hyperhandler, ihan);
- unmask_evtchn(prt);
+ prt = minios_bind_pirq(pirq, 1, hyperhandler, ihan);
+ minios_unmask_evtchn(prt);
ihan->i_prt = prt;
return ihan;
w.who = get_current();
TAILQ_INSERT_TAIL(wh, &w, entries);
w.onlist = 1;
- block(w.who);
+ minios_block(w.who);
if (nsec)
w.who->wakeup_time = NOW() + nsec;
- schedule();
+ minios_schedule();
/* woken up by timeout? */
if (w.onlist)
if ((w = TAILQ_FIRST(wh)) != NULL) {
TAILQ_REMOVE(wh, w, entries);
w->onlist = 0;
- wake(w->who);
+ minios_wake(w->who);
}
}
while ((w = TAILQ_FIRST(wh)) != NULL) {
TAILQ_REMOVE(wh, w, entries);
w->onlist = 0;
- wake(w->who);
+ minios_wake(w->who);
}
}
{
struct thread *thr;
- thr = create_thread(thrname, NULL, (void (*)(void *))f, arg, NULL);
+ thr = minios_create_thread(thrname, NULL, (void (*)(void *))f, arg, NULL);
/*
* XXX: should be supplied as a flag to create_thread() so as to
* _ensure_ it's set before the thread runs (and could exit).
rumpuser_thread_exit(void)
{
- exit_thread();
+ minios_exit_thread();
}
int
rumpuser_thread_join(void *p)
{
- join_thread(p);
+ minios_join_thread(p);
return 0;
}
rv = rumpuser_mutex_tryenter(mtx);
/* one VCPU supported, no preemption => must succeed */
if (rv != 0) {
- printk("no voi ei\n");
+ minios_printk("no voi ei\n");
}
}
CPPFLAGS+= -I${.CURDIR}
CPPFLAGS+= -I${.CURDIR}/../include -D__RUMP_KERNEL__ -I${.CURDIR}/..
-RUMP_SYM_NORENAME=xenbus_|HYPERVISOR_|wake$$|block$$|schedule$$|force_evtchn
+RUMP_SYM_NORENAME=xenbus_|HYPERVISOR_|minios_
.include "${RUMPTOP}/Makefile.rump"
.include <bsd.lib.mk>
DPRINTF(("/dev/xen/xenbus: about to block err_r=%p\n", err_r));
- add_waiter(w, d->replies.waitq);
+ minios_add_waiter(w, d->replies.waitq);
spin_unlock(&xenbus_req_lock);
mutex_exit(&d->lock);
rumpkern_unsched(&nlocks, 0);
- schedule();
+ minios_schedule();
rumpkern_sched(nlocks, 0);
mutex_enter(&d->lock);
spin_lock(&xenbus_req_lock);
- remove_waiter(w, d->replies.waitq);
+ minios_remove_waiter(w, d->replies.waitq);
}
struct xenbus_event *event = STAILQ_FIRST(&d->replies.events);
STAILQ_REMOVE_HEAD(&d->replies.events, entry);
DPRINTF(("/dev/xen/xenbus: wakeup\n"));
struct xenbus_dev_data *d =
container_of(queue, struct xenbus_dev_data, replies);
- wake_up(&d->replies.waitq);
+ minios_wake_up(&d->replies.waitq);
selnotify(&d->selinfo, RBITS, NOTE_SUBMIT);
}
spin_lock(&xenbus_req_lock);
d->want_restart |= 1;
- wake_up(&d->replies.waitq);
+ minios_wake_up(&d->replies.waitq);
spin_unlock(&xenbus_req_lock);
mutex_exit(&d->lock);
{
if ( mfn_is_ram(mfn) )
{
- printk("ioremap: mfn 0x%ulx is RAM\n", mfn);
+ minios_printk("ioremap: mfn 0x%ulx is RAM\n", mfn);
goto mfn_invalid;
}
}
#ifdef MM_DEBUG
#define DEBUG(_f, _a...) \
- printk("MINI_OS(file=mm.c, line=%d) " _f "\n", __LINE__, ## _a)
+ minios_printk("MINI_OS(file=mm.c, line=%d) " _f "\n", __LINE__, ## _a)
#else
#define DEBUG(_f, _a...) ((void)0)
#endif
-unsigned long *phys_to_machine_mapping;
-unsigned long mfn_zero;
-extern char stack[];
+unsigned long *_minios_phys_to_machine_mapping;
+unsigned long _minios_mfn_zero;
+extern char _minios_stack[];
extern void page_walk(unsigned long va);
/*
break;
#endif
default:
- printk("new_pt_frame() called with invalid level number %d\n", level);
- do_exit();
+ minios_printk("new_pt_frame() called with invalid level number %d\n", level);
+ minios_do_exit();
break;
}
if ( (rc = HYPERVISOR_mmu_update(mmu_updates, 1, NULL, DOMID_SELF)) < 0 )
{
- printk("ERROR: PTE for new page table page could not be updated\n");
- printk(" mmu_update failed with rc=%d\n", rc);
- do_exit();
+ minios_printk("ERROR: PTE for new page table page could not be updated\n");
+ minios_printk(" mmu_update failed with rc=%d\n", rc);
+ minios_do_exit();
}
/* Hook the new page table page into the hierarchy */
if ( (rc = HYPERVISOR_mmu_update(mmu_updates, 1, NULL, DOMID_SELF)) < 0 )
{
- printk("ERROR: mmu_update failed with rc=%d\n", rc);
- do_exit();
+ minios_printk("ERROR: mmu_update failed with rc=%d\n", rc);
+ minios_do_exit();
}
*pt_pfn += 1;
if ( level == L1_FRAME )
return 1;
- printk("ERROR: Unknown frame level %d, hypervisor %llx,%llx\n",
+ minios_printk("ERROR: Unknown frame level %d, hypervisor %llx,%llx\n",
level, hyp_virt_start, hyp_virt_end);
return -1;
}
if ( *max_pfn >= virt_to_pfn(HYPERVISOR_VIRT_START) )
{
- printk("WARNING: Mini-OS trying to use Xen virtual space. "
+ minios_printk("WARNING: Mini-OS trying to use Xen virtual space. "
"Truncating memory from %dMB to ",
((unsigned long)pfn_to_virt(*max_pfn) -
(unsigned long)&_text)>>20);
*max_pfn = virt_to_pfn(HYPERVISOR_VIRT_START - PAGE_SIZE);
- printk("%dMB\n",
+ minios_printk("%dMB\n",
((unsigned long)pfn_to_virt(*max_pfn) -
(unsigned long)&_text)>>20);
}
end_address = (unsigned long)pfn_to_virt(*max_pfn);
/* We worked out the virtual memory range to map, now mapping loop */
- printk("Mapping memory range 0x%lx - 0x%lx\n", start_address, end_address);
+ minios_printk("Mapping memory range 0x%lx - 0x%lx\n", start_address, end_address);
while ( start_address < end_address )
{
rc = HYPERVISOR_mmu_update(mmu_updates, count, NULL, DOMID_SELF);
if ( rc < 0 )
{
- printk("ERROR: build_pagetable(): PTE could not be updated\n");
- printk(" mmu_update failed with rc=%d\n", rc);
- do_exit();
+ minios_printk("ERROR: build_pagetable(): PTE could not be updated\n");
+ minios_printk(" mmu_update failed with rc=%d\n", rc);
+ minios_do_exit();
}
count = 0;
}
int count = 0;
int rc;
- printk("setting %p-%p readonly\n", text, etext);
+ minios_printk("setting %p-%p readonly\n", text, etext);
while ( start_address + PAGE_SIZE <= end_address )
{
count++;
}
else
- printk("skipped %p\n", start_address);
+ minios_printk("skipped %p\n", start_address);
start_address += PAGE_SIZE;
rc = HYPERVISOR_mmu_update(mmu_updates, count, NULL, DOMID_SELF);
if ( rc < 0 )
{
- printk("ERROR: set_readonly(): PTE could not be updated\n");
- do_exit();
+ minios_printk("ERROR: set_readonly(): PTE could not be updated\n");
+ minios_do_exit();
}
count = 0;
}
/* write values and print page walks */
if ( verbose && (((unsigned long)start_va) & 0xfffff) )
{
- printk("MemTest Start: 0x%lx\n", start_va);
+ minios_printk("MemTest Start: 0x%lx\n", start_va);
page_walk((unsigned long)start_va);
}
for ( pointer = start_va; pointer < end_va; pointer++ )
{
if ( verbose && !(((unsigned long)pointer) & 0xfffff) )
{
- printk("Writing to %lx\n", pointer);
+ minios_printk("Writing to %lx\n", pointer);
page_walk((unsigned long)pointer);
}
*pointer = (unsigned long)pointer & ~mask;
}
if ( verbose && (((unsigned long)end_va) & 0xfffff) )
{
- printk("MemTest End: %lx\n", end_va-1);
+ minios_printk("MemTest End: %lx\n", end_va-1);
page_walk((unsigned long)end_va-1);
}
{
if ( ((unsigned long)pointer & ~mask) != *pointer )
{
- printk("Read error at 0x%lx. Read: 0x%lx, should read 0x%lx\n",
+ minios_printk("Read error at 0x%lx. Read: 0x%lx, should read 0x%lx\n",
(unsigned long)pointer, *pointer,
((unsigned long)pointer & ~mask));
error_count++;
if ( error_count >= MEM_TEST_MAX_ERRORS )
{
- printk("mem_test: too many errors\n");
+ minios_printk("mem_test: too many errors\n");
return -1;
}
}
offset = l4_table_offset(va);
if ( !(tab[offset] & _PAGE_PRESENT) )
{
- pt_pfn = virt_to_pfn(alloc_page());
+ pt_pfn = virt_to_pfn(minios_alloc_page());
new_pt_frame(&pt_pfn, pt_mfn, offset, L3_FRAME);
}
ASSERT(tab[offset] & _PAGE_PRESENT);
offset = l3_table_offset(va);
if ( !(tab[offset] & _PAGE_PRESENT) )
{
- pt_pfn = virt_to_pfn(alloc_page());
+ pt_pfn = virt_to_pfn(minios_alloc_page());
new_pt_frame(&pt_pfn, pt_mfn, offset, L2_FRAME);
}
ASSERT(tab[offset] & _PAGE_PRESENT);
offset = l2_table_offset(va);
if ( !(tab[offset] & _PAGE_PRESENT) )
{
- pt_pfn = virt_to_pfn(alloc_page());
+ pt_pfn = virt_to_pfn(minios_alloc_page());
new_pt_frame(&pt_pfn, pt_mfn, offset, L1_FRAME);
}
ASSERT(tab[offset] & _PAGE_PRESENT);
demand_map_area_start = (unsigned long) pfn_to_virt(cur_pfn);
cur_pfn += DEMAND_MAP_PAGES;
- printk("Demand map pfns at %lx-%lx.\n",
+ minios_printk("Demand map pfns at %lx-%lx.\n",
demand_map_area_start, pfn_to_virt(cur_pfn));
}
}
if ( y != n )
{
- printk("Failed to find %ld frames!\n", n);
+ minios_printk("Failed to find %ld frames!\n", n);
return 0;
}
return demand_map_area_start + x * PAGE_SIZE;
if ( !mfns )
{
- printk("do_map_frames: no mfns supplied\n");
+ minios_printk("do_map_frames: no mfns supplied\n");
return;
}
DEBUG("va=%p n=0x%lx, mfns[0]=0x%lx stride=0x%lx incr=0x%lx prot=0x%lx\n",
if (err)
err[done * stride] = rc;
else {
- printk("Map %ld (%lx, ...) at %p failed: %d.\n",
+ minios_printk("Map %ld (%lx, ...) at %p failed: %d.\n",
todo, mfns[done * stride] + done * incr, va, rc);
- do_exit();
+ minios_do_exit();
}
}
}
ret = HYPERVISOR_multicall(call, n);
if ( ret )
{
- printk("update_va_mapping hypercall failed with rc=%d.\n", ret);
+ minios_printk("update_va_mapping hypercall failed with rc=%d.\n", ret);
return -ret;
}
{
if ( call[i].result )
{
- printk("update_va_mapping failed for with rc=%d.\n", ret);
+ minios_printk("update_va_mapping failed for with rc=%d.\n", ret);
return -(call[i].result);
}
}
if ( order > MAX_CONTIG_ORDER )
{
- printk("alloc_contig_pages: order too large 0x%x > 0x%x\n",
+ minios_printk("alloc_contig_pages: order too large 0x%x > 0x%x\n",
order, MAX_CONTIG_ORDER);
return 0;
}
/* Allocate some potentially discontiguous pages */
- in_va = alloc_pages(order);
+ in_va = minios_alloc_pages(order);
if ( !in_va )
{
- printk("alloc_contig_pages: could not get enough pages (order=0x%x\n",
+ minios_printk("alloc_contig_pages: could not get enough pages (order=0x%x\n",
order);
return 0;
}
in_frames[i] = virt_to_mfn(va);
/* update P2M mapping */
- phys_to_machine_mapping[virt_to_pfn(va)] = INVALID_P2M_ENTRY;
+ _minios_phys_to_machine_mapping[virt_to_pfn(va)] = INVALID_P2M_ENTRY;
/* build multi call */
call[i].op = __HYPERVISOR_update_va_mapping;
ret = HYPERVISOR_multicall(call, i);
if ( ret )
{
- printk("Odd, update_va_mapping hypercall failed with rc=%d.\n", ret);
+ minios_printk("Odd, update_va_mapping hypercall failed with rc=%d.\n", ret);
return 0;
}
out_frames = virt_to_pfn(in_va); /* PFNs to populate */
ret = HYPERVISOR_memory_op(XENMEM_exchange, &exchange);
if ( ret ) {
- printk("mem exchanged order=0x%x failed with rc=%d, nr_exchanged=%d\n",
+ minios_printk("mem exchanged order=0x%x failed with rc=%d, nr_exchanged=%d\n",
order, ret, exchange.nr_exchanged);
/* we still need to return the allocated pages above to the pool
* ie. map them back into the 1:1 mapping etc. so we continue but
pte = __pte(mfn << PAGE_SHIFT | L1_PROT);
/* update P2M mapping */
- phys_to_machine_mapping[virt_to_pfn(va)] = mfn;
+ _minios_phys_to_machine_mapping[virt_to_pfn(va)] = mfn;
/* build multi call */
call[i].op = __HYPERVISOR_update_va_mapping;
ret = HYPERVISOR_multicall(call, i);
if ( ret )
{
- printk("update_va_mapping hypercall no. 2 failed with rc=%d.\n", ret);
+ minios_printk("update_va_mapping hypercall no. 2 failed with rc=%d.\n", ret);
return 0;
}
if ( !exch_success )
{
/* since the exchanged failed we just free the pages as well */
- free_pages((void *) in_va, order);
+ minios_free_pages((void *) in_va, order);
return 0;
}
/* Use first page as the CoW zero page */
memset(&_text, 0, PAGE_SIZE);
- mfn_zero = virt_to_mfn((unsigned long) &_text);
+ _minios_mfn_zero = virt_to_mfn((unsigned long) &_text);
if ( (rc = HYPERVISOR_update_va_mapping(0, nullpte, UVMF_INVLPG)) )
- printk("Unable to unmap NULL page. rc=%d\n", rc);
+ minios_printk("Unable to unmap NULL page. rc=%d\n", rc);
}
void arch_init_p2m(unsigned long max_pfn)
unsigned long *l1_list = NULL, *l2_list = NULL, *l3_list;
unsigned long pfn;
- l3_list = (unsigned long *)alloc_page();
+ l3_list = (unsigned long *)minios_alloc_page();
for ( pfn=0; pfn<max_pfn; pfn++ )
{
if ( !(pfn % (L1_P2M_ENTRIES * L2_P2M_ENTRIES)) )
{
- l2_list = (unsigned long*)alloc_page();
+ l2_list = (unsigned long*)minios_alloc_page();
if ( (pfn >> L3_P2M_SHIFT) > 0 )
{
- printk("Error: Too many pfns.\n");
- do_exit();
+ minios_printk("Error: Too many pfns.\n");
+ minios_do_exit();
}
l3_list[(pfn >> L2_P2M_SHIFT)] = virt_to_mfn(l2_list);
}
if ( !(pfn % (L1_P2M_ENTRIES)) )
{
- l1_list = (unsigned long*)alloc_page();
+ l1_list = (unsigned long*)minios_alloc_page();
l2_list[(pfn >> L1_P2M_SHIFT) & L2_P2M_MASK] =
virt_to_mfn(l1_list);
}
{
unsigned long start_pfn, max_pfn;
- printk(" _text: %p(VA)\n", &_text);
- printk(" _etext: %p(VA)\n", &_etext);
- printk(" _erodata: %p(VA)\n", &_erodata);
- printk(" _edata: %p(VA)\n", &_edata);
- printk("stack start: %p(VA)\n", stack);
- printk(" _end: %p(VA)\n", &_end);
+ minios_printk(" _text: %p(VA)\n", &_text);
+ minios_printk(" _etext: %p(VA)\n", &_etext);
+ minios_printk(" _erodata: %p(VA)\n", &_erodata);
+ minios_printk(" _edata: %p(VA)\n", &_edata);
+ minios_printk("stack start: %p(VA)\n", _minios_stack);
+ minios_printk(" _end: %p(VA)\n", &_end);
/* First page follows page table pages and 3 more pages (store page etc) */
start_pfn = PFN_UP(to_phys(start_info.pt_base)) +
}
#endif
- printk(" start_pfn: %lx\n", start_pfn);
- printk(" max_pfn: %lx\n", max_pfn);
+ minios_printk(" start_pfn: %lx\n", start_pfn);
+ minios_printk(" max_pfn: %lx\n", max_pfn);
build_pagetable(&start_pfn, &max_pfn);
clear_bootstrap();
: "=r"(pointer));
#endif
}
- printk("The stack for \"%s\"\n", thread->name);
+ minios_printk("The stack for \"%s\"\n", thread->name);
for(count = 0; count < 25 && pointer < bottom; count ++)
{
- printk("[0x%lx] 0x%lx\n", pointer, *pointer);
+ minios_printk("[0x%lx] 0x%lx\n", pointer, *pointer);
pointer++;
}
- if(pointer < bottom) printk(" ... continues.\n");
+ if(pointer < bottom) minios_printk(" ... continues.\n");
}
/* Gets run when a new thread is scheduled the first time ever,
thread = xmalloc(struct thread);
/* We can't use lazy allocation here since the trap handler runs on the stack */
if (!stack) {
- thread->stack = (char *)alloc_pages(STACK_SIZE_PAGE_ORDER);
+ thread->stack = (char *)minios_alloc_pages(STACK_SIZE_PAGE_ORDER);
#if 0
- printk("Thread \"%s\": pointer: 0x%lx, stack: 0x%lx\n", name, thread,
+ minios_printk("Thread \"%s\": pointer: 0x%lx, stack: 0x%lx\n", name, thread,
thread->stack);
#endif
} else {
* This structure contains start-of-day info, such as pagetable base pointer,
* address of the shared_info structure, and things like that.
*/
-union start_info_union start_info_union;
+union start_info_union _minios_start_info_union;
/*
* Just allocate the kernel stack here. SS:ESP is set up to point here
* in head.S.
*/
-char stack[2*STACK_SIZE];
+char _minios_stack[2*STACK_SIZE];
extern char _minios_shared_info[PAGE_SIZE];
if ( (rc = HYPERVISOR_update_va_mapping(
(unsigned long)_minios_shared_info, __pte(pa | 7), UVMF_INVLPG)) )
{
- printk("Failed to map shared_info!! rc=%d\n", rc);
- do_exit();
+ minios_printk("Failed to map shared_info!! rc=%d\n", rc);
+ minios_do_exit();
}
return (shared_info_t *)_minios_shared_info;
}
memcpy(&start_info, si, sizeof(*si));
/* set up minimal memory infos */
- phys_to_machine_mapping = (unsigned long *)start_info.mfn_list;
+ _minios_phys_to_machine_mapping = (unsigned long *)start_info.mfn_list;
/* Grab the shared_info pointer and put it in a safe place. */
HYPERVISOR_shared_info = map_shared_info(start_info.shared_info);
void
arch_print_info(void)
{
- printk(" stack: %p-%p\n", stack, stack + sizeof(stack));
+ minios_printk(" stack: %p-%p\n", _minios_stack,
+ _minios_stack + sizeof(_minios_stack));
}
static evtchn_port_t port;
void init_time(void)
{
- printk("Initialising timer interface\n");
- port = bind_virq(VIRQ_TIMER, &timer_handler, NULL);
- unmask_evtchn(port);
+ minios_printk("Initialising timer interface\n");
+ port = minios_bind_virq(VIRQ_TIMER, &timer_handler, NULL);
+ minios_unmask_evtchn(port);
}
void fini_time(void)
{
/* Clear any pending timer */
HYPERVISOR_set_timer_op(0);
- unbind_evtchn(port);
+ minios_unbind_evtchn(port);
}
void dump_regs(struct pt_regs *regs)
{
- printk("Thread: %s\n", current->name);
+ minios_printk("Thread: %s\n", current->name);
#ifdef __i386__
- printk("EIP: %x, EFLAGS %x.\n", regs->eip, regs->eflags);
- printk("EBX: %08x ECX: %08x EDX: %08x\n",
+ minios_printk("EIP: %x, EFLAGS %x.\n", regs->eip, regs->eflags);
+ minios_printk("EBX: %08x ECX: %08x EDX: %08x\n",
regs->ebx, regs->ecx, regs->edx);
- printk("ESI: %08x EDI: %08x EBP: %08x EAX: %08x\n",
+ minios_printk("ESI: %08x EDI: %08x EBP: %08x EAX: %08x\n",
regs->esi, regs->edi, regs->ebp, regs->eax);
- printk("DS: %04x ES: %04x orig_eax: %08x, eip: %08x\n",
+ minios_printk("DS: %04x ES: %04x orig_eax: %08x, eip: %08x\n",
regs->xds, regs->xes, regs->orig_eax, regs->eip);
- printk("CS: %04x EFLAGS: %08x esp: %08x ss: %04x\n",
+ minios_printk("CS: %04x EFLAGS: %08x esp: %08x ss: %04x\n",
regs->xcs, regs->eflags, regs->esp, regs->xss);
#else
- printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip);
- printk("\nRSP: %04lx:%016lx EFLAGS: %08lx\n",
+ minios_printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip);
+ minios_printk("\nRSP: %04lx:%016lx EFLAGS: %08lx\n",
regs->ss, regs->rsp, regs->eflags);
- printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
+ minios_printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
regs->rax, regs->rbx, regs->rcx);
- printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
+ minios_printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
regs->rdx, regs->rsi, regs->rdi);
- printk("RBP: %016lx R08: %016lx R09: %016lx\n",
+ minios_printk("RBP: %016lx R08: %016lx R09: %016lx\n",
regs->rbp, regs->r8, regs->r9);
- printk("R10: %016lx R11: %016lx R12: %016lx\n",
+ minios_printk("R10: %016lx R11: %016lx R12: %016lx\n",
regs->r10, regs->r11, regs->r12);
- printk("R13: %016lx R14: %016lx R15: %016lx\n",
+ minios_printk("R13: %016lx R14: %016lx R15: %016lx\n",
regs->r13, regs->r14, regs->r15);
#endif
}
static void do_trap(int trapnr, char *str, struct pt_regs * regs, unsigned long error_code)
{
- printk("FATAL: Unhandled Trap %d (%s), error code=0x%lx\n", trapnr, str, error_code);
- printk("Regs address %p\n", regs);
+ minios_printk("FATAL: Unhandled Trap %d (%s), error code=0x%lx\n", trapnr, str, error_code);
+ minios_printk("Regs address %p\n", regs);
dump_regs(regs);
- do_exit();
+ minios_do_exit();
}
#define DO_ERROR(trapnr, str, name) \
{
pgentry_t *tab = (pgentry_t *)start_info.pt_base, page;
unsigned long addr = virt_address;
- printk("Pagetable walk from virt %lx, base %lx:\n", virt_address, start_info.pt_base);
+ minios_printk("Pagetable walk from virt %lx, base %lx:\n", virt_address, start_info.pt_base);
#if defined(__x86_64__)
page = tab[l4_table_offset(addr)];
tab = pte_to_virt(page);
- printk(" L4 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l4_table_offset(addr));
+ minios_printk(" L4 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l4_table_offset(addr));
#endif
page = tab[l3_table_offset(addr)];
tab = pte_to_virt(page);
- printk(" L3 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l3_table_offset(addr));
+ minios_printk(" L3 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l3_table_offset(addr));
page = tab[l2_table_offset(addr)];
tab = pte_to_virt(page);
- printk(" L2 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l2_table_offset(addr));
+ minios_printk(" L2 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l2_table_offset(addr));
page = tab[l1_table_offset(addr)];
- printk(" L1 = %"PRIpte" [offset = %lx]\n", page, l1_table_offset(addr));
+ minios_printk(" L1 = %"PRIpte" [offset = %lx]\n", page, l1_table_offset(addr));
}
if (!(page & _PAGE_PRESENT))
return 0;
/* Only support CoW for the zero page. */
- if (PHYS_PFN(page) != mfn_zero)
+ if (PHYS_PFN(page) != _minios_mfn_zero)
return 0;
- new_page = alloc_pages(0);
+ new_page = minios_alloc_pages(0);
memset((void*) new_page, 0, PAGE_SIZE);
rc = HYPERVISOR_update_va_mapping(addr & PAGE_MASK, __pte(virt_to_mach(new_page) | L1_PROT), UVMF_INVLPG);
if (!rc)
return 1;
- printk("Map zero page to %lx failed: %d.\n", addr, rc);
+ minios_printk("Map zero page to %lx failed: %d.\n", addr, rc);
return 0;
}
static void do_stack_walk(unsigned long frame_base)
{
unsigned long *frame = (void*) frame_base;
- printk("base is %#lx ", frame_base);
- printk("caller is %#lx\n", frame[1]);
+ minios_printk("base is %#lx ", frame_base);
+ minios_printk("caller is %#lx\n", frame[1]);
if (frame[0])
do_stack_walk(frame[0]);
}
for (i = ((addr)-16 ) & ~15; i < (((addr)+48 ) & ~15); i++)
{
if (!(i%16))
- printk("\n%lx:", i);
- printk(" %02x", *(unsigned char *)i);
+ minios_printk("\n%lx:", i);
+ minios_printk(" %02x", *(unsigned char *)i);
}
- printk("\n");
+ minios_printk("\n");
}
#define read_cr2() \
(HYPERVISOR_shared_info->vcpu_info[smp_processor_id()].arch.cr2)
a recursive fault */
if(handling_pg_fault == 1)
{
- printk("Page fault in pagetable walk (access to invalid memory?).\n");
+ minios_printk("Page fault in pagetable walk (access to invalid memory?).\n");
HYPERVISOR_sched_op(SCHEDOP_shutdown, &sched_shutdown);
}
handling_pg_fault++;
barrier();
#if defined(__x86_64__)
- printk("Page fault at linear address %p, rip %p, regs %p, sp %p, our_sp %p, code %lx\n",
+ minios_printk("Page fault at linear address %p, rip %p, regs %p, sp %p, our_sp %p, code %lx\n",
addr, regs->rip, regs, regs->rsp, &addr, error_code);
#else
- printk("Page fault at linear address %p, eip %p, regs %p, sp %p, our_sp %p, code %lx\n",
+ minios_printk("Page fault at linear address %p, eip %p, regs %p, sp %p, our_sp %p, code %lx\n",
addr, regs->eip, regs, regs->esp, &addr, error_code);
#endif
{
struct sched_shutdown sched_shutdown = { .reason = SHUTDOWN_crash };
#ifdef __i386__
- printk("GPF eip: %p, error_code=%lx\n", regs->eip, error_code);
+ minios_printk("GPF eip: %p, error_code=%lx\n", regs->eip, error_code);
#else
- printk("GPF rip: %p, error_code=%lx\n", regs->rip, error_code);
+ minios_printk("GPF rip: %p, error_code=%lx\n", regs->rip, error_code);
#endif
dump_regs(regs);
#if defined(__x86_64__)
void do_debug(struct pt_regs * regs)
{
- printk("Debug exception\n");
+ minios_printk("Debug exception\n");
#define TF_MASK 0x100
regs->eflags &= ~TF_MASK;
dump_regs(regs);
- do_exit();
+ minios_do_exit();
}
void do_coprocessor_error(struct pt_regs * regs)
{
- printk("Copro error\n");
+ minios_printk("Copro error\n");
dump_regs(regs);
- do_exit();
+ minios_do_exit();
}
void simd_math_error(void *eip)
{
- printk("SIMD error\n");
+ minios_printk("SIMD error\n");
}
void do_simd_coprocessor_error(struct pt_regs * regs)
{
- printk("SIMD copro error\n");
+ minios_printk("SIMD copro error\n");
}
void do_spurious_interrupt_bug(struct pt_regs * regs)
movq stack_start(%rip),%rsp
andq $(~(__STACK_SIZE-1)), %rsp
movq %rsi,%rdi
- call start_kernel
+ call _minios_start_kernel
stack_start:
- .quad stack+(2*__STACK_SIZE)
+ .quad _minios_stack+(2*__STACK_SIZE)
/* Unpleasant -- the PTE that maps this page is actually overwritten */
/* to map the real shared-info page! :-) */
testl $NMI_MASK,2*8(%rsp)
jnz 2f
- testb $1,(xen_features+XENFEAT_supervisor_mode_kernel)
+ testb $1,(_minios_xen_features+XENFEAT_supervisor_mode_kernel)
jnz 1f
/* Direct iret to kernel space. Correct CS and SS. */
incl %gs:0
cmovzq %rax,%rsp
pushq %rdi
- call do_hypervisor_callback
+ call _minios_do_hypervisor_callback
popq %rsp
decl %gs:0
jmp error_exit
pushq $0
xorq %rbp,%rbp
call *%rbx
- call exit_thread
+ call minios_exit_thread
ENTRY(arch_switch_threads)
void blkfront_handler(evtchn_port_t port, struct pt_regs *regs, void *data)
{
- wake_up(&blkfront_queue);
+ minios_wake_up(&blkfront_queue);
}
static void free_blkfront(struct blkfront_dev *dev)
{
- mask_evtchn(dev->evtchn);
+ minios_mask_evtchn(dev->evtchn);
free(dev->backend);
gnttab_end_access(dev->ring_ref);
- free_page(dev->ring.sring);
+ minios_free_page(dev->ring.sring);
- unbind_evtchn(dev->evtchn);
+ minios_unbind_evtchn(dev->evtchn);
free(dev->nodename);
free(dev);
}
-struct blkfront_dev *init_blkfront(char *_nodename, struct blkfront_info *info)
+struct blkfront_dev *blkfront_init(char *_nodename, struct blkfront_info *info)
{
xenbus_transaction_t xbt;
char* err;
snprintf(path, sizeof(path), "%s/backend-id", nodename);
dev->dom = xenbus_read_integer(path);
- evtchn_alloc_unbound(dev->dom, blkfront_handler, dev, &dev->evtchn);
+ minios_evtchn_alloc_unbound(dev->dom, blkfront_handler, dev, &dev->evtchn);
- s = (struct blkif_sring*) alloc_page();
+ s = (struct blkif_sring*) minios_alloc_page();
memset(s,0,PAGE_SIZE);
again:
err = xenbus_transaction_start(&xbt);
if (err) {
- printk("starting transaction\n");
+ minios_printk("starting transaction\n");
free(err);
}
if (err) free(err);
if (retry) {
goto again;
- printk("completing transaction\n");
+ minios_printk("completing transaction\n");
}
goto done;
abort_transaction:
free(err);
err = xenbus_transaction_end(xbt, 1, &retry);
- printk("Abort transaction %s\n", message);
+ minios_printk("Abort transaction %s\n", message);
goto error;
done:
snprintf(path, sizeof(path), "%s/backend", nodename);
msg = xenbus_read(XBT_NIL, path, &dev->backend);
if (msg) {
- printk("Error %s when reading the backend path %s\n", msg, path);
+ minios_printk("Error %s when reading the backend path %s\n", msg, path);
goto error;
}
- printk("blkfront: node=%s backend=%s\n", nodename, dev->backend);
+ minios_printk("blkfront: node=%s backend=%s\n", nodename, dev->backend);
dev->handle = strtoul(strrchr(nodename, '/')+1, NULL, 10);
snprintf(path, sizeof(path), "%s/mode", dev->backend);
msg = xenbus_read(XBT_NIL, path, &c);
if (msg) {
- printk("Error %s when reading the mode\n", msg);
+ minios_printk("Error %s when reading the mode\n", msg);
goto error;
}
if (*c == 'w')
while (msg == NULL && state < XenbusStateConnected)
msg = xenbus_wait_for_state_change(path, &state, &dev->events);
if (msg != NULL || state != XenbusStateConnected) {
- printk("backend not available, state=%d\n", state);
+ minios_printk("backend not available, state=%d\n", state);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
*info = dev->info;
}
- unmask_evtchn(dev->evtchn);
+ minios_unmask_evtchn(dev->evtchn);
- printk("blkfront: %u sectors\n", dev->info.sectors);
+ minios_printk("blkfront: %u sectors\n", dev->info.sectors);
return dev;
return NULL;
}
-void shutdown_blkfront(struct blkfront_dev *dev)
+void blkfront_shutdown(struct blkfront_dev *dev)
{
char* err = NULL;
XenbusState state;
blkfront_sync(dev);
- printk("blkfront detached: node=%s\n", dev->nodename);
+ minios_printk("blkfront detached: node=%s\n", dev->nodename);
snprintf(path, sizeof(path), "%s/state", dev->backend);
snprintf(nodename, sizeof(nodename), "%s/state", dev->nodename);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosing)) != NULL) {
- printk("shutdown_blkfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_blkfront: error changing state to %d: %s\n",
XenbusStateClosing, err);
goto close;
}
if (err) free(err);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosed)) != NULL) {
- printk("shutdown_blkfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_blkfront: error changing state to %d: %s\n",
XenbusStateClosed, err);
goto close;
}
}
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateInitialising)) != NULL) {
- printk("shutdown_blkfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_blkfront: error changing state to %d: %s\n",
XenbusStateInitialising, err);
goto close;
}
if (!RING_FULL(&dev->ring))
break;
/* Really no slot, go to sleep. */
- add_waiter(w, blkfront_queue);
+ minios_add_waiter(w, blkfront_queue);
local_irq_restore(flags);
- schedule();
+ minios_schedule();
local_irq_save(flags);
}
- remove_waiter(w, blkfront_queue);
+ minios_remove_waiter(w, blkfront_queue);
local_irq_restore(flags);
}
}
if (aiocbp->data)
break;
- add_waiter(w, blkfront_queue);
+ minios_add_waiter(w, blkfront_queue);
local_irq_restore(flags);
- schedule();
+ minios_schedule();
local_irq_save(flags);
}
- remove_waiter(w, blkfront_queue);
+ minios_remove_waiter(w, blkfront_queue);
local_irq_restore(flags);
}
if (RING_FREE_REQUESTS(&dev->ring) == RING_SIZE(&dev->ring))
break;
- add_waiter(w, blkfront_queue);
+ minios_add_waiter(w, blkfront_queue);
local_irq_restore(flags);
- schedule();
+ minios_schedule();
local_irq_save(flags);
}
- remove_waiter(w, blkfront_queue);
+ minios_remove_waiter(w, blkfront_queue);
local_irq_restore(flags);
}
status = rsp->status;
if (status != BLKIF_RSP_OKAY)
- printk("block error %d for op %d\n", status, rsp->operation);
+ minios_printk("block error %d for op %d\n", status, rsp->operation);
switch (rsp->operation) {
case BLKIF_OP_READ:
break;
default:
- printk("unrecognized block operation %d response\n", rsp->operation);
+ minios_printk("unrecognized block operation %d response\n", rsp->operation);
}
dev->ring.rsp_cons = ++cons;
{
/* Just repeat what's written */
buf[len] = '\0';
- printk("%s", buf);
+ minios_printk("%s", buf);
if(buf[len-1] == '\r')
- printk("\nNo console input handler.\n");
+ minios_printk("\nNo console input handler.\n");
}
}
}
-void console_print(struct consfront_dev *dev, char *data, int length)
+void minios_console_print(struct consfront_dev *dev, char *data, int length)
{
char *curr_char, saved_char;
char copied_str[length+1];
#endif
(void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf);
- console_print(NULL, buf, strlen(buf));
+ minios_console_print(NULL, buf, strlen(buf));
}
}
-void printk(const char *fmt, ...)
+void minios_printk(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
}
void init_console(void)
{
- printk("Initialising console ... ");
+ minios_printk("Initialising console ... ");
xencons_ring_init();
console_initialised = 1;
/* This is also required to notify the daemon */
- printk("done.\n");
+ minios_printk("done.\n");
}
snprintf(nodename, sizeof(nodename), "%s/state", dev->nodename);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosing)) != NULL) {
- printk("free_consfront: error changing state to %d: %s\n",
+ minios_printk("free_consfront: error changing state to %d: %s\n",
XenbusStateClosing, err);
goto close;
}
if (err) free(err);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosed)) != NULL) {
- printk("free_consfront: error changing state to %d: %s\n",
+ minios_printk("free_consfront: error changing state to %d: %s\n",
XenbusStateClosed, err);
goto close;
}
if (err) free(err);
xenbus_unwatch_path_token(XBT_NIL, path, path);
- mask_evtchn(dev->evtchn);
- unbind_evtchn(dev->evtchn);
+ minios_mask_evtchn(dev->evtchn);
+ minios_unbind_evtchn(dev->evtchn);
free(dev->backend);
free(dev->nodename);
gnttab_end_access(dev->ring_ref);
- free_page(dev->ring);
+ minios_free_page(dev->ring);
free(dev);
}
else
strncpy(nodename, _nodename, sizeof(nodename));
- printk("******************* CONSFRONT for %s **********\n\n\n", nodename);
+ minios_printk("******************* CONSFRONT for %s **********\n\n\n", nodename);
consfrontends++;
dev = malloc(sizeof(*dev));
return NULL;
else
dev->dom = res;
- evtchn_alloc_unbound(dev->dom, console_handle_input, dev, &dev->evtchn);
+ minios_evtchn_alloc_unbound(dev->dom, console_handle_input, dev, &dev->evtchn);
- dev->ring = (struct xencons_interface *) alloc_page();
+ dev->ring = (struct xencons_interface *) minios_alloc_page();
memset(dev->ring, 0, PAGE_SIZE);
dev->ring_ref = gnttab_grant_access(dev->dom, virt_to_mfn(dev->ring), 0);
again:
err = xenbus_transaction_start(&xbt);
if (err) {
- printk("starting transaction\n");
+ minios_printk("starting transaction\n");
free(err);
}
if (err) free(err);
if (retry) {
goto again;
- printk("completing transaction\n");
+ minios_printk("completing transaction\n");
}
goto done;
abort_transaction:
free(err);
err = xenbus_transaction_end(xbt, 1, &retry);
- printk("Abort transaction %s\n", message);
+ minios_printk("Abort transaction %s\n", message);
goto error;
done:
snprintf(path, sizeof(path), "%s/backend", nodename);
msg = xenbus_read(XBT_NIL, path, &dev->backend);
if (msg) {
- printk("Error %s when reading the backend path %s\n", msg, path);
+ minios_printk("Error %s when reading the backend path %s\n", msg, path);
goto error;
}
- printk("backend at %s\n", dev->backend);
+ minios_printk("backend at %s\n", dev->backend);
{
XenbusState state;
while (msg == NULL && state < XenbusStateConnected)
msg = xenbus_wait_for_state_change(path, &state, &dev->events);
if (msg != NULL || state != XenbusStateConnected) {
- printk("backend not available, state=%d\n", state);
+ minios_printk("backend not available, state=%d\n", state);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
}
- unmask_evtchn(dev->evtchn);
+ minios_unmask_evtchn(dev->evtchn);
- printk("**************************\n");
+ minios_printk("**************************\n");
return dev;
dev->evtchn = start_info.console.domU.evtchn;
dev->ring = (struct xencons_interface *) mfn_to_virt(start_info.console.domU.mfn);
- err = bind_evtchn(dev->evtchn, console_handle_input, dev);
+ err = minios_bind_evtchn(dev->evtchn, console_handle_input, dev);
if (err <= 0) {
- printk("XEN console request chn bind failed %i\n", err);
+ minios_printk("XEN console request chn bind failed %i\n", err);
free(dev);
return NULL;
}
- unmask_evtchn(dev->evtchn);
+ minios_unmask_evtchn(dev->evtchn);
/* In case we have in-flight data after save/restore... */
notify_daemon(dev);
if ( test_and_clear_bit(i, bound_ports) )
{
struct evtchn_close close;
- printk("port %d still bound!\n", i);
- mask_evtchn(i);
+ minios_printk("port %d still bound!\n", i);
+ minios_mask_evtchn(i);
close.port = i;
rc = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
if ( rc )
- printk("WARN: close_port %s failed rc=%d. ignored\n", i, rc);
- clear_evtchn(i);
+ minios_printk("WARN: close_port %s failed rc=%d. ignored\n", i, rc);
+ minios_clear_evtchn(i);
}
}
vcpu_info->evtchn_upcall_pending = 0;
{
ev_action_t *action;
- clear_evtchn(port);
+ minios_clear_evtchn(port);
if ( port >= NR_EVS )
{
- printk("WARN: do_event(): Port number too large: %d\n", port);
+ minios_printk("WARN: do_event(): Port number too large: %d\n", port);
return 1;
}
}
-evtchn_port_t bind_evtchn(evtchn_port_t port, evtchn_handler_t handler,
+evtchn_port_t minios_bind_evtchn(evtchn_port_t port, evtchn_handler_t handler,
void *data)
{
if ( ev_actions[port].handler != default_handler )
- printk("WARN: Handler for port %d already registered, replacing\n",
+ minios_printk("WARN: Handler for port %d already registered, replacing\n",
port);
ev_actions[port].data = data;
return port;
}
-void unbind_evtchn(evtchn_port_t port )
+void minios_unbind_evtchn(evtchn_port_t port )
{
struct evtchn_close close;
- int rc;
+ int rc;
if ( ev_actions[port].handler == default_handler )
- printk("WARN: No handler for port %d when unbinding\n", port);
- mask_evtchn(port);
- clear_evtchn(port);
+ minios_printk("WARN: No handler for port %d when unbinding\n", port);
+ minios_mask_evtchn(port);
+ minios_clear_evtchn(port);
ev_actions[port].handler = default_handler;
wmb();
close.port = port;
rc = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
- if ( rc )
- printk("WARN: close_port %s failed rc=%d. ignored\n", port, rc);
+ if ( rc )
+ minios_printk("WARN: close_port %s failed rc=%d. ignored\n", port, rc);
}
-evtchn_port_t bind_virq(uint32_t virq, evtchn_handler_t handler, void *data)
+evtchn_port_t minios_bind_virq(uint32_t virq, evtchn_handler_t handler, void *data)
{
evtchn_bind_virq_t op;
- int rc;
+ int rc;
/* Try to bind the virq to a port */
op.virq = virq;
if ( (rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq, &op)) != 0 )
{
- printk("Failed to bind virtual IRQ %d with rc=%d\n", virq, rc);
+ minios_printk("Failed to bind virtual IRQ %d with rc=%d\n", virq, rc);
return -1;
- }
- bind_evtchn(op.port, handler, data);
+ }
+ minios_bind_evtchn(op.port, handler, data);
return op.port;
}
-evtchn_port_t bind_pirq(uint32_t pirq, int will_share,
+evtchn_port_t minios_bind_pirq(uint32_t pirq, int will_share,
evtchn_handler_t handler, void *data)
{
evtchn_bind_pirq_t op;
- int rc;
+ int rc;
/* Try to bind the pirq to a port */
op.pirq = pirq;
if ( (rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_pirq, &op)) != 0 )
{
- printk("Failed to bind physical IRQ %d with rc=%d\n", pirq, rc);
+ minios_printk("Failed to bind physical IRQ %d with rc=%d\n", pirq, rc);
return -1;
}
- bind_evtchn(op.port, handler, data);
+ minios_bind_evtchn(op.port, handler, data);
return op.port;
}
#if defined(__x86_64__)
-char irqstack[2 * STACK_SIZE];
+static char irqstack[2 * STACK_SIZE];
static struct pda
{
for ( i = 0; i < NR_EVS; i++ )
{
ev_actions[i].handler = default_handler;
- mask_evtchn(i);
+ minios_mask_evtchn(i);
}
}
void default_handler(evtchn_port_t port, struct pt_regs *regs, void *ignore)
{
- printk("[Port %d] - event received\n", port);
+ minios_printk("[Port %d] - event received\n", port);
}
/* Create a port available to the pal for exchanging notifications.
as Xen is concerned, but we automatically bind a handler to it
from inside mini-os. */
-int evtchn_alloc_unbound(domid_t pal, evtchn_handler_t handler,
+int minios_evtchn_alloc_unbound(domid_t pal, evtchn_handler_t handler,
void *data, evtchn_port_t *port)
{
int rc;
rc = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, &op);
if ( rc )
{
- printk("ERROR: alloc_unbound failed with rc=%d", rc);
+ minios_printk("ERROR: alloc_unbound failed with rc=%d", rc);
return rc;
}
- *port = bind_evtchn(op.port, handler, data);
+ *port = minios_bind_evtchn(op.port, handler, data);
return rc;
}
/* Connect to a port so as to allow the exchange of notifications with
the pal. Returns the result of the hypervisor call. */
-int evtchn_bind_interdomain(domid_t pal, evtchn_port_t remote_port,
+int minios_evtchn_bind_interdomain(domid_t pal, evtchn_port_t remote_port,
evtchn_handler_t handler, void *data,
evtchn_port_t *local_port)
{
rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain, &op);
if ( rc )
{
- printk("ERROR: bind_interdomain failed with rc=%d", rc);
+ minios_printk("ERROR: bind_interdomain failed with rc=%d", rc);
return rc;
}
port = op.local_port;
- *local_port = bind_evtchn(port, handler, data);
+ *local_port = minios_bind_evtchn(port, handler, data);
return rc;
}
}
#ifdef GNTMAP_DEBUG
- printk("gntmap_find_free_entry(map=%p): all %d entries full\n",
+ minios_printk("gntmap_find_free_entry(map=%p): all %d entries full\n",
map, map->nentries);
#endif
return NULL;
gntmap_set_max_grants(struct gntmap *map, int count)
{
#ifdef GNTMAP_DEBUG
- printk("gntmap_set_max_grants(map=%p, count=%d)\n", map, count);
+ minios_printk("gntmap_set_max_grants(map=%p, count=%d)\n", map, count);
#endif
if (map->nentries != 0)
rc = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
if (rc != 0 || op.status != GNTST_okay) {
- printk("GNTTABOP_map_grant_ref failed: "
+ minios_printk("GNTTABOP_map_grant_ref failed: "
"returned %d, status %" PRId16 "\n",
rc, op.status);
return rc != 0 ? rc : op.status;
rc = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
if (rc != 0 || op.status != GNTST_okay) {
- printk("GNTTABOP_unmap_grant_ref failed: "
+ minios_printk("GNTTABOP_unmap_grant_ref failed: "
"returned %d, status %" PRId16 "\n",
rc, op.status);
return rc != 0 ? rc : op.status;
struct gntmap_entry *ent;
#ifdef GNTMAP_DEBUG
- printk("gntmap_munmap(map=%p, start_address=%lx, count=%d)\n",
+ minios_printk("gntmap_munmap(map=%p, start_address=%lx, count=%d)\n",
map, start_address, count);
#endif
for (i = 0; i < count; i++) {
ent = gntmap_find_entry(map, start_address + PAGE_SIZE * i);
if (ent == NULL) {
- printk("gntmap: tried to munmap unknown page\n");
+ minios_printk("gntmap: tried to munmap unknown page\n");
return -EINVAL;
}
int i;
#ifdef GNTMAP_DEBUG
- printk("gntmap_map_grant_refs(map=%p, count=%" PRIu32 ", "
+ minios_printk("gntmap_map_grant_refs(map=%p, count=%" PRIu32 ", "
"domids=%p [%" PRIu32 "...], domids_stride=%d, "
"refs=%p [%" PRIu32 "...], writable=%d)\n",
map, count,
gntmap_init(struct gntmap *map)
{
#ifdef GNTMAP_DEBUG
- printk("gntmap_init(map=%p)\n", map);
+ minios_printk("gntmap_init(map=%p)\n", map);
#endif
map->nentries = 0;
map->entries = NULL;
int i;
#ifdef GNTMAP_DEBUG
- printk("gntmap_fini(map=%p)\n", map);
+ minios_printk("gntmap_fini(map=%p)\n", map);
#endif
for (i = 0; i < map->nentries; i++) {
nflags = gnttab_table[ref].flags;
do {
if ((flags = nflags) & (GTF_reading|GTF_writing)) {
- printk("WARNING: g.e. still in use! (%x)\n", flags);
+ minios_printk("WARNING: g.e. still in use! (%x)\n", flags);
return 0;
}
} while ((nflags = synch_cmpxchg(&gnttab_table[ref].flags, flags, 0)) !=
while (!((flags = gnttab_table[ref].flags) & GTF_transfer_committed)) {
if (synch_cmpxchg(&gnttab_table[ref].flags, flags, 0) == flags) {
- printk("Release unused transfer grant.\n");
+ minios_printk("Release unused transfer grant.\n");
put_free_entry(ref);
return 0;
}
unsigned long mfn;
grant_ref_t gref;
- *map = (void *)alloc_page();
+ *map = (void *)minios_alloc_page();
mfn = virt_to_mfn(*map);
gref = gnttab_grant_access(0, mfn, 0);
return gref;
HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);
gnttab_table = map_frames(frames, NR_GRANT_FRAMES);
- printk("gnttab_table mapped at %p.\n", gnttab_table);
+ minios_printk("gnttab_table mapped at %p.\n", gnttab_table);
}
void
((sh)->evtchn_pending[idx] & \
~(sh)->evtchn_mask[idx])
-int in_callback;
+int _minios_in_hypervisor_callback;
-void do_hypervisor_callback(struct pt_regs *regs)
+void _minios_do_hypervisor_callback(struct pt_regs *regs)
{
unsigned long l1, l2, l1i, l2i;
unsigned int port;
shared_info_t *s = HYPERVISOR_shared_info;
vcpu_info_t *vcpu_info = &s->vcpu_info[cpu];
- in_callback = 1;
+ _minios_in_hypervisor_callback = 1;
vcpu_info->evtchn_upcall_pending = 0;
/* NB x86. No need for a barrier here -- XCHG is a barrier on x86. */
}
}
- in_callback = 0;
+ _minios_in_hypervisor_callback = 0;
}
-void force_evtchn_callback(void)
+void minios_force_evtchn_callback(void)
{
int save;
vcpu_info_t *vcpu;
while (vcpu->evtchn_upcall_pending) {
vcpu->evtchn_upcall_mask = 1;
barrier();
- do_hypervisor_callback(NULL);
+ _minios_do_hypervisor_callback(NULL);
barrier();
vcpu->evtchn_upcall_mask = save;
barrier();
};
}
-inline void mask_evtchn(uint32_t port)
+inline void minios_mask_evtchn(uint32_t port)
{
shared_info_t *s = HYPERVISOR_shared_info;
synch_set_bit(port, &s->evtchn_mask[0]);
}
-inline void unmask_evtchn(uint32_t port)
+inline void minios_unmask_evtchn(uint32_t port)
{
shared_info_t *s = HYPERVISOR_shared_info;
vcpu_info_t *vcpu_info = &s->vcpu_info[smp_processor_id()];
{
vcpu_info->evtchn_upcall_pending = 1;
if ( !vcpu_info->evtchn_upcall_mask )
- force_evtchn_callback();
+ minios_force_evtchn_callback();
}
}
-inline void clear_evtchn(uint32_t port)
+inline void minios_clear_evtchn(uint32_t port)
{
shared_info_t *s = HYPERVISOR_shared_info;
synch_clear_bit(port, &s->evtchn_pending[0]);
#include "netbsd_init.h"
-uint8_t xen_features[XENFEAT_NR_SUBMAPS * 32];
+uint8_t _minios_xen_features[XENFEAT_NR_SUBMAPS * 32];
void setup_xen_features(void)
{
break;
for (j=0; j<32; j++)
- xen_features[i*32+j] = !!(fi.submap & 1<<j);
+ _minios_xen_features[i*32+j] = !!(fi.submap & 1<<j);
}
}
/*
* INITIAL C ENTRY POINT.
*/
-void start_kernel(start_info_t *si)
+void _minios_start_kernel(start_info_t *si)
{
arch_init(si);
trap_init();
/* print out some useful information */
- printk(" start_info: %p(VA)\n", si);
- printk(" nr_pages: 0x%lx\n", si->nr_pages);
- printk(" shared_inf: 0x%08lx(MA)\n", si->shared_info);
- printk(" pt_base: %p(VA)\n", (void *)si->pt_base);
- printk("nr_pt_frames: 0x%lx\n", si->nr_pt_frames);
- printk(" mfn_list: %p(VA)\n", (void *)si->mfn_list);
- printk(" mod_start: 0x%lx(VA)\n", si->mod_start);
- printk(" mod_len: %lu\n", si->mod_len);
- printk(" flags: 0x%x\n", (unsigned int)si->flags);
- printk(" cmd_line: %s\n",
+ minios_printk(" start_info: %p(VA)\n", si);
+ minios_printk(" nr_pages: 0x%lx\n", si->nr_pages);
+ minios_printk(" shared_inf: 0x%08lx(MA)\n", si->shared_info);
+ minios_printk(" pt_base: %p(VA)\n", (void *)si->pt_base);
+ minios_printk("nr_pt_frames: 0x%lx\n", si->nr_pt_frames);
+ minios_printk(" mfn_list: %p(VA)\n", (void *)si->mfn_list);
+ minios_printk(" mod_start: 0x%lx(VA)\n", si->mod_start);
+ minios_printk(" mod_len: %lu\n", si->mod_len);
+ minios_printk(" flags: 0x%x\n", (unsigned int)si->flags);
+ minios_printk(" cmd_line: %s\n",
si->cmd_line ? (const char *)si->cmd_line : "NULL");
/* Set up events. */
init_xenbus();
/* Call (possibly overridden) app_main() */
- create_thread("main", NULL, _app_main, &start_info, NULL);
+ minios_create_thread("main", NULL, _app_main, &start_info, NULL);
/* Everything initialised, start idle thread */
run_idle_thread();
* Of course, minimal OS doesn't have applications :-)
*/
-void do_exit(void)
+void minios_do_exit(void)
{
- printk("Do_exit called!\n");
+ minios_printk("Do_exit called!\n");
stack_walk();
for( ;; )
{
#ifdef MM_DEBUG
#define DEBUG(_f, _a...) \
- printk("MINI_OS(file=mm.c, line=%d) " _f "\n", __LINE__, ## _a)
+ minios_printk("MINI_OS(file=mm.c, line=%d) " _f "\n", __LINE__, ## _a)
#else
#define DEBUG(_f, _a...) ((void)0)
#endif
unsigned long pfn_start = virt_to_pfn(start);
int count;
for(count = 0; count < nr_pages; count++)
- if(allocated_in_map(pfn_start + count)) printk("1");
- else printk("0");
+ if(allocated_in_map(pfn_start + count)) minios_printk("1");
+ else minios_printk("0");
- printk("\n");
+ minios_printk("\n");
}
/*
}
}
chunks[nr_pages] = '\0';
- printk("%s\n", chunks);
+ minios_printk("%s\n", chunks);
}
#endif
/* Allocate 2^@order contiguous pages. Returns a VIRTUAL address. */
-unsigned long alloc_pages(int order)
+unsigned long minios_alloc_pages(int order)
{
int i;
chunk_head_t *alloc_ch, *spare_ch;
no_memory:
- printk("Cannot handle page request order %d!\n", order);
+ minios_printk("Cannot handle page request order %d!\n", order);
return 0;
}
-void free_pages(void *pointer, int order)
+void minios_free_pages(void *pointer, int order)
{
chunk_head_t *freed_ch, *to_merge_ch;
chunk_tail_t *freed_ct;
unsigned long start_pfn, max_pfn;
- printk("MM: Init\n");
+ minios_printk("MM: Init\n");
arch_init_mm(&start_pfn, &max_pfn);
/*
* now we can initialise the page allocator
*/
- printk("MM: Initialise page allocator for %lx(%lx)-%lx(%lx)\n",
+ minios_printk("MM: Initialise page allocator for %lx(%lx)-%lx(%lx)\n",
(u_long)to_virt(PFN_PHYS(start_pfn)), PFN_PHYS(start_pfn),
(u_long)to_virt(PFN_PHYS(max_pfn)), PFN_PHYS(max_pfn));
init_page_allocator(PFN_PHYS(start_pfn), PFN_PHYS(max_pfn));
- printk("MM: done\n");
+ minios_printk("MM: done\n");
arch_init_p2m(max_pfn);
if (rx->flags & NETRXF_extra_info)
{
- printk("+++++++++++++++++++++ we have extras!\n");
+ minios_printk("+++++++++++++++++++++ we have extras!\n");
continue;
}
continue;
if (txrsp->status == NETIF_RSP_ERROR)
- printk("packet error\n");
+ minios_printk("packet error\n");
id = txrsp->id;
BUG_ON(id >= NET_TX_RING_SIZE);
for(i=0;i<NET_TX_RING_SIZE;i++)
down(&dev->tx_sem);
- mask_evtchn(dev->evtchn);
+ minios_mask_evtchn(dev->evtchn);
free(dev->mac);
free(dev->backend);
gnttab_end_access(dev->rx_ring_ref);
gnttab_end_access(dev->tx_ring_ref);
- free_page(dev->rx.sring);
- free_page(dev->tx.sring);
+ minios_free_page(dev->rx.sring);
+ minios_free_page(dev->tx.sring);
- unbind_evtchn(dev->evtchn);
+ minios_unbind_evtchn(dev->evtchn);
for(i=0;i<NET_RX_RING_SIZE;i++) {
gnttab_end_access(dev->rx_buffers[i].gref);
- free_page(dev->rx_buffers[i].page);
+ minios_free_page(dev->rx_buffers[i].page);
}
for(i=0;i<NET_TX_RING_SIZE;i++)
if (dev->tx_buffers[i].page)
- free_page(dev->tx_buffers[i].page);
+ minios_free_page(dev->tx_buffers[i].page);
free(dev->nodename);
free(dev);
}
-struct netfront_dev *init_netfront(char *_nodename, void (*thenetif_rx)(struct netfront_dev *, unsigned char* data, int len), unsigned char rawmac[6], char **ip, void *priv)
+struct netfront_dev *netfront_init(char *_nodename, void (*thenetif_rx)(struct netfront_dev *, unsigned char* data, int len), unsigned char rawmac[6], char **ip, void *priv)
{
xenbus_transaction_t xbt;
char* err;
dev->nodename = strdup(nodename);
dev->netfront_priv = priv;
- printk("net TX ring size %d\n", NET_TX_RING_SIZE);
- printk("net RX ring size %d\n", NET_RX_RING_SIZE);
+ minios_printk("net TX ring size %d\n", NET_TX_RING_SIZE);
+ minios_printk("net RX ring size %d\n", NET_RX_RING_SIZE);
init_SEMAPHORE(&dev->tx_sem, NET_TX_RING_SIZE);
for(i=0;i<NET_TX_RING_SIZE;i++)
{
for(i=0;i<NET_RX_RING_SIZE;i++)
{
/* TODO: that's a lot of memory */
- dev->rx_buffers[i].page = (char*)alloc_page();
+ dev->rx_buffers[i].page = (char*)minios_alloc_page();
}
snprintf(path, sizeof(path), "%s/backend-id", nodename);
dev->dom = xenbus_read_integer(path);
- evtchn_alloc_unbound(dev->dom, netfront_handler, dev, &dev->evtchn);
+ minios_evtchn_alloc_unbound(dev->dom, netfront_handler, dev, &dev->evtchn);
- txs = (struct netif_tx_sring *) alloc_page();
- rxs = (struct netif_rx_sring *) alloc_page();
+ txs = (struct netif_tx_sring *) minios_alloc_page();
+ rxs = (struct netif_rx_sring *) minios_alloc_page();
memset(txs,0,PAGE_SIZE);
memset(rxs,0,PAGE_SIZE);
again:
err = xenbus_transaction_start(&xbt);
if (err) {
- printk("starting transaction\n");
+ minios_printk("starting transaction\n");
free(err);
}
if (err) free(err);
if (retry) {
goto again;
- printk("completing transaction\n");
+ minios_printk("completing transaction\n");
}
goto done;
abort_transaction:
free(err);
err = xenbus_transaction_end(xbt, 1, &retry);
- printk("Abort transaction %s\n", message);
+ minios_printk("Abort transaction %s\n", message);
goto error;
done:
msg = xenbus_read(XBT_NIL, path, &dev->mac);
if ((dev->backend == NULL) || (dev->mac == NULL)) {
- printk("%s: backend/mac failed\n", __func__);
+ minios_printk("%s: backend/mac failed\n", __func__);
goto error;
}
- printk("netfront: node=%s backend=%s\n", nodename, dev->backend);
- printk("netfront: MAC %s\n", dev->mac);
+ minios_printk("netfront: node=%s backend=%s\n", nodename, dev->backend);
+ minios_printk("netfront: MAC %s\n", dev->mac);
{
XenbusState state;
while (err == NULL && state < XenbusStateConnected)
err = xenbus_wait_for_state_change(path, &state, &dev->events);
if (state != XenbusStateConnected) {
- printk("backend not avalable, state=%d\n", state);
+ minios_printk("backend not avalable, state=%d\n", state);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
}
}
- unmask_evtchn(dev->evtchn);
+ minios_unmask_evtchn(dev->evtchn);
if (rawmac) {
char *p;
v = strtoul(p, &ep, 16);
if (v > 255 || (*ep && *ep != ':')) {
- printk("invalid mac string %s\n", dev->mac);
- do_exit();
+ minios_printk("invalid mac string %s\n", dev->mac);
+ minios_do_exit();
}
rawmac[i] = v;
p = ep+1;
}
-void shutdown_netfront(struct netfront_dev *dev)
+void netfront_shutdown(struct netfront_dev *dev)
{
char* err = NULL;
XenbusState state;
char path[strlen(dev->backend) + 1 + 5 + 1];
char nodename[strlen(dev->nodename) + 1 + 5 + 1];
- printk("close network: backend at %s\n",dev->backend);
+ minios_printk("close network: backend at %s\n",dev->backend);
snprintf(path, sizeof(path), "%s/state", dev->backend);
snprintf(nodename, sizeof(nodename), "%s/state", dev->nodename);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosing)) != NULL) {
- printk("shutdown_netfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_netfront: error changing state to %d: %s\n",
XenbusStateClosing, err);
goto close;
}
if (err) free(err);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosed)) != NULL) {
- printk("shutdown_netfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_netfront: error changing state to %d: %s\n",
XenbusStateClosed, err);
goto close;
}
}
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateInitialising)) != NULL) {
- printk("shutdown_netfront: error changing state to %d: %s\n",
+ minios_printk("shutdown_netfront: error changing state to %d: %s\n",
XenbusStateInitialising, err);
goto close;
}
buf = &dev->tx_buffers[id];
page = buf->page;
if (!page)
- page = buf->page = (char*) alloc_page();
+ page = buf->page = (char*) minios_alloc_page();
i = dev->tx.req_prod_pvt;
tx = RING_GET_REQUEST(&dev->tx, i);
void pcifront_handler(evtchn_port_t port, struct pt_regs *regs, void *data)
{
- wake_up(&pcifront_queue);
+ minios_wake_up(&pcifront_queue);
}
static void free_pcifront(struct pcifront_dev *dev)
if (!dev)
dev = pcidev;
- mask_evtchn(dev->evtchn);
+ minios_mask_evtchn(dev->evtchn);
gnttab_end_access(dev->info_ref);
- free_page(dev->info);
+ minios_free_page(dev->info);
- unbind_evtchn(dev->evtchn);
+ minios_unbind_evtchn(dev->evtchn);
free(dev->backend);
free(dev->nodename);
snprintf(fe_state, sizeof(fe_state), "%s/state", nodename);
while (1) {
- printk("pcifront_watches: waiting for backend path to appear %s\n", path);
+ minios_printk("pcifront_watches: waiting for backend path to appear %s\n", path);
xenbus_watch_path_token(XBT_NIL, path, path, &events);
while ((err = xenbus_read(XBT_NIL, path, &be_path)) != NULL) {
free(err);
xenbus_wait_for_watch(&events);
}
xenbus_unwatch_path_token(XBT_NIL, path, path);
- printk("pcifront_watches: waiting for backend to get into the right state %s\n", be_path);
+ minios_printk("pcifront_watches: waiting for backend to get into the right state %s\n", be_path);
be_state = (char *) malloc(strlen(be_path) + 7);
snprintf(be_state, strlen(be_path) + 7, "%s/state", be_path);
xenbus_watch_path_token(XBT_NIL, be_state, be_state, &events);
}
xenbus_watch_path_token(XBT_NIL, be_state, be_state, &events);
state = XenbusStateConnected;
- printk("pcifront_watches: waiting for backend events %s\n", be_state);
+ minios_printk("pcifront_watches: waiting for backend events %s\n", be_state);
while ((err = xenbus_wait_for_state_change(be_state, &state, &events)) == NULL &&
(err = xenbus_read(XBT_NIL, pcidev->backend, &msg)) == NULL) {
free(msg);
- printk("pcifront_watches: backend state changed: %s %d\n", be_state, state);
+ minios_printk("pcifront_watches: backend state changed: %s %d\n", be_state, state);
if (state == XenbusStateReconfiguring) {
- printk("pcifront_watches: writing %s %d\n", fe_state, XenbusStateReconfiguring);
+ minios_printk("pcifront_watches: writing %s %d\n", fe_state, XenbusStateReconfiguring);
if ((err = xenbus_switch_state(XBT_NIL, fe_state, XenbusStateReconfiguring)) != NULL) {
- printk("pcifront_watches: error changing state to %d: %s\n",
+ minios_printk("pcifront_watches: error changing state to %d: %s\n",
XenbusStateReconfiguring, err);
if (!strcmp(err, "ENOENT")) {
xenbus_write(XBT_NIL, fe_state, "7");
}
}
} else if (state == XenbusStateReconfigured) {
- printk("pcifront_watches: writing %s %d\n", fe_state, XenbusStateConnected);
- printk("pcifront_watches: changing state to %d\n", XenbusStateConnected);
+ minios_printk("pcifront_watches: writing %s %d\n", fe_state, XenbusStateConnected);
+ minios_printk("pcifront_watches: changing state to %d\n", XenbusStateConnected);
if ((err = xenbus_switch_state(XBT_NIL, fe_state, XenbusStateConnected)) != NULL) {
- printk("pcifront_watches: error changing state to %d: %s\n",
+ minios_printk("pcifront_watches: error changing state to %d: %s\n",
XenbusStateConnected, err);
if (!strcmp(err, "ENOENT")) {
xenbus_write(XBT_NIL, fe_state, "4");
break;
}
if (err)
- printk("pcifront_watches: done waiting err=%s\n", err);
+ minios_printk("pcifront_watches: done waiting err=%s\n", err);
else
- printk("pcifront_watches: done waiting\n");
+ minios_printk("pcifront_watches: done waiting\n");
xenbus_unwatch_path_token(XBT_NIL, be_state, be_state);
shutdown_pcifront(pcidev);
free(be_state);
snprintf(path, sizeof(path), "%s/backend-id", nodename);
dom = xenbus_read_integer(path);
if (dom == -1) {
- printk("no backend\n");
+ minios_printk("no backend\n");
return NULL;
}
dev->nodename = strdup(nodename);
dev->dom = dom;
- evtchn_alloc_unbound(dev->dom, pcifront_handler, dev, &dev->evtchn);
+ minios_evtchn_alloc_unbound(dev->dom, pcifront_handler, dev, &dev->evtchn);
- dev->info = (struct xen_pci_sharedinfo*) alloc_page();
+ dev->info = (struct xen_pci_sharedinfo*) minios_alloc_page();
memset(dev->info,0,PAGE_SIZE);
dev->info_ref = gnttab_grant_access(dev->dom,virt_to_mfn(dev->info),0);
again:
err = xenbus_transaction_start(&xbt);
if (err) {
- printk("starting transaction\n");
+ minios_printk("starting transaction\n");
free(err);
}
if (err) free(err);
if (retry) {
goto again;
- printk("completing transaction\n");
+ minios_printk("completing transaction\n");
}
goto done;
abort_transaction:
free(err);
err = xenbus_transaction_end(xbt, 1, &retry);
- printk("Abort transaction %s\n", message);
+ minios_printk("Abort transaction %s\n", message);
goto error;
done:
snprintf(path, sizeof(path), "%s/backend", nodename);
msg = xenbus_read(XBT_NIL, path, &dev->backend);
if (msg) {
- printk("Error %s when reading the backend path %s\n", msg, path);
+ minios_printk("Error %s when reading the backend path %s\n", msg, path);
goto error;
}
- printk("pcifront: node=%s backend=%s\n", nodename, dev->backend);
+ minios_printk("pcifront: node=%s backend=%s\n", nodename, dev->backend);
{
char path[strlen(dev->backend) + 1 + 5 + 1];
while (err == NULL && state < XenbusStateConnected)
err = xenbus_wait_for_state_change(path, &state, &dev->events);
if (state != XenbusStateConnected) {
- printk("backend not avalable, state=%d\n", state);
+ minios_printk("backend not avalable, state=%d\n", state);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
snprintf(frontpath, sizeof(frontpath), "%s/state", nodename);
if ((err = xenbus_switch_state(XBT_NIL, frontpath, XenbusStateConnected))
!= NULL) {
- printk("error switching state %s\n", err);
+ minios_printk("error switching state %s\n", err);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
}
- unmask_evtchn(dev->evtchn);
+ minios_unmask_evtchn(dev->evtchn);
if (!_nodename)
pcidev = dev;
*domain = strtoul(s, &ep, 16);
if (*ep != ':') {
- printk("\"%s\" does not look like a PCI device address\n", s);
+ minios_printk("\"%s\" does not look like a PCI device address\n", s);
return 0;
}
*bus = strtoul(ep+1, &ep, 16);
if (*ep != ':') {
- printk("\"%s\" does not look like a PCI device address\n", s);
+ minios_printk("\"%s\" does not look like a PCI device address\n", s);
return 0;
}
*slot = strtoul(ep+1, &ep, 16);
if (*ep != '.') {
- printk("\"%s\" does not look like a PCI device address\n", s);
+ minios_printk("\"%s\" does not look like a PCI device address\n", s);
return 0;
}
*fun = strtoul(ep+1, &ep, 16);
if (*ep != '\0') {
- printk("\"%s\" does not look like a PCI device address\n", s);
+ minios_printk("\"%s\" does not look like a PCI device address\n", s);
return 0;
}
if (!dev)
dev = pcidev;
if (!dev) {
- printk("pcifront_scan: device or bus\n");
+ minios_printk("pcifront_scan: device or bus\n");
return;
}
snprintf(path, len, "%s/dev-%d", dev->backend, i);
msg = xenbus_read(XBT_NIL, path, &s);
if (msg) {
- printk("Error %s when reading the PCI root name at %s\n", msg, path);
+ minios_printk("Error %s when reading the PCI root name at %s\n", msg, path);
continue;
}
char path[strlen(dev->backend) + 1 + 5 + 1];
char nodename[strlen(dev->nodename) + 1 + 5 + 1];
- printk("close pci: backend at %s\n",dev->backend);
+ minios_printk("close pci: backend at %s\n",dev->backend);
snprintf(path, sizeof(path), "%s/state", dev->backend);
snprintf(nodename, sizeof(nodename), "%s/state", dev->nodename);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosing)) != NULL) {
- printk("shutdown_pcifront: error changing state to %d: %s\n",
+ minios_printk("shutdown_pcifront: error changing state to %d: %s\n",
XenbusStateClosing, err);
goto close_pcifront;
}
if (err) free(err);
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosed)) != NULL) {
- printk("shutdown_pcifront: error changing state to %d: %s\n",
+ minios_printk("shutdown_pcifront: error changing state to %d: %s\n",
XenbusStateClosed, err);
goto close_pcifront;
}
}
if ((err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateInitialising)) != NULL) {
- printk("shutdown_pcifront: error changing state to %d: %s\n",
+ minios_printk("shutdown_pcifront: error changing state to %d: %s\n",
XenbusStateInitialising, err);
goto close_pcifront;
}
snprintf(path, sizeof(path), "%s/dev-%d", dev->backend, i);
msg = xenbus_read(XBT_NIL, path, &s);
if (msg) {
- printk("Error %s when reading the PCI root name at %s\n", msg, path);
+ minios_printk("Error %s when reading the PCI root name at %s\n", msg, path);
continue;
}
snprintf(path, sizeof(path), "%s/vdev-%d", dev->backend, i);
msg = xenbus_read(XBT_NIL, path, &s);
if (msg) {
- printk("Error %s when reading the PCI root name at %s\n", msg, path);
+ minios_printk("Error %s when reading the PCI root name at %s\n", msg, path);
continue;
}
set_bit(_XEN_PCIF_active, (void*) &dev->info->flags);
notify_remote_via_evtchn(dev->evtchn);
- wait_event(pcifront_queue, !test_bit(_XEN_PCIF_active, (void*) &dev->info->flags));
+ minios_wait_event(pcifront_queue, !test_bit(_XEN_PCIF_active, (void*) &dev->info->flags));
/* Make sure flag is read before info */
rmb();
static struct thread_list thread_list = TAILQ_HEAD_INITIALIZER(thread_list);
static int threads_started;
-struct thread *main_thread;
-
void inline print_runqueue(void)
{
struct thread *th;
TAILQ_FOREACH(th, &thread_list, thread_list)
{
- printk(" Thread \"%s\", runnable=%d\n", th->name, is_runnable(th));
+ minios_printk(" Thread \"%s\", runnable=%d\n", th->name, is_runnable(th));
}
- printk("\n");
+ minios_printk("\n");
}
static void (*scheduler_hook)(void *, void *);
arch_switch_threads(prev, next);
}
-void schedule(void)
+void minios_schedule(void)
{
struct thread *prev, *next, *thread, *tmp;
unsigned long flags;
prev = current;
local_irq_save(flags);
- if (in_callback) {
- printk("Must not call schedule() from a callback\n");
+ if (_minios_in_hypervisor_callback) {
+ minios_printk("Must not call schedule() from a callback\n");
BUG();
}
if (flags) {
- printk("Must not call schedule() with IRQs disabled\n");
+ minios_printk("Must not call schedule() with IRQs disabled\n");
BUG();
}
{
if (thread->wakeup_time <= now) {
thread->flags |= THREAD_TIMEDOUT;
- wake(thread);
+ minios_wake(thread);
} else if (thread->wakeup_time < min_wakeup_time)
min_wakeup_time = thread->wakeup_time;
}
/* block until the next timeout expires, or for 10 secs, whichever comes first */
block_domain(min_wakeup_time);
/* handle pending events if any */
- force_evtchn_callback();
+ minios_force_evtchn_callback();
} while(1);
local_irq_restore(flags);
/* Interrupting the switch is equivalent to having the next thread
{
TAILQ_REMOVE(&exited_threads, thread, thread_list);
if ((thread->flags & THREAD_EXTSTACK) == 0)
- free_pages(thread->stack, STACK_SIZE_PAGE_ORDER);
+ minios_free_pages(thread->stack, STACK_SIZE_PAGE_ORDER);
xfree(thread);
}
}
}
struct thread *
-create_thread(const char *name, void *cookie,
+minios_create_thread(const char *name, void *cookie,
void (*function)(void *), void *data, void *stack)
{
struct thread *thread;
};
static TAILQ_HEAD(, join_waiter) joinwq = TAILQ_HEAD_INITIALIZER(joinwq);
-void exit_thread(void)
+void minios_exit_thread(void)
{
unsigned long flags;
struct thread *thread = current;
/* see if the joiner is already there */
TAILQ_FOREACH(jw_iter, &joinwq, jw_entries) {
if (jw_iter->jw_wanted == thread) {
- wake(jw_iter->jw_thread);
+ minios_wake(jw_iter->jw_thread);
break;
}
}
- block(thread);
- schedule();
+ minios_block(thread);
+ minios_schedule();
local_irq_save(flags);
}
/* Schedule will free the resources */
while(1)
{
- schedule();
- printk("schedule() returned! Trying again\n");
+ minios_schedule();
+ minios_printk("schedule() returned! Trying again\n");
}
}
/* hmm, all of the interfaces here are namespaced "backwards" ... */
-void join_thread(struct thread *joinable)
+void minios_join_thread(struct thread *joinable)
{
struct join_waiter jw;
struct thread *thread = get_current();
jw.jw_thread = thread;
jw.jw_wanted = joinable;
TAILQ_INSERT_TAIL(&joinwq, &jw, jw_entries);
- block(thread);
- schedule();
+ minios_block(thread);
+ minios_schedule();
TAILQ_REMOVE(&joinwq, &jw, jw_entries);
local_irq_save(flags);
joinable->flags &= ~THREAD_MUSTJOIN;
local_irq_restore(flags);
- wake(joinable);
+ minios_wake(joinable);
}
-void block(struct thread *thread)
+void minios_block(struct thread *thread)
{
thread->wakeup_time = 0LL;
clear_runnable(thread);
thread->wakeup_time = wakeuptime;
thread->flags &= ~THREAD_TIMEDOUT;
clear_runnable(thread);
- schedule();
+ minios_schedule();
rv = !!(thread->flags & THREAD_TIMEDOUT);
thread->flags &= ~THREAD_TIMEDOUT;
return rv;
}
-int msleep(uint32_t millisecs)
+int minios_msleep(uint32_t millisecs)
{
return dosleep(NOW() + MILLISECS(millisecs));
}
-int absmsleep(uint32_t millisecs)
+int minios_absmsleep(uint32_t millisecs)
{
return dosleep(MILLISECS(millisecs));
}
-void wake(struct thread *thread)
+void minios_wake(struct thread *thread)
{
thread->wakeup_time = 0LL;
set_runnable(thread);
{
threads_started = 1;
while (1) {
- block(current);
- schedule();
+ minios_block(current);
+ minios_schedule();
}
}
void init_sched(void)
{
- printk("Initialising scheduler\n");
+ minios_printk("Initialising scheduler\n");
- idle_thread = create_thread("Idle", NULL, idle_thread_fn, NULL, NULL);
+ idle_thread = minios_create_thread("Idle", NULL, idle_thread_fn, NULL, NULL);
}
-void set_sched_hook(void (*f)(void *, void *))
+void minios_set_sched_hook(void (*f)(void *, void *))
{
scheduler_hook = f;
}
-struct thread *init_mainlwp(void *cookie)
+struct thread *minios_init_mainlwp(void *cookie)
{
current->cookie = cookie;
#ifdef XENBUS_DEBUG
#define DEBUG(_f, _a...) \
- printk("MINI_OS(file=xenbus.c, line=%d) " _f , __LINE__, ## _a)
+ minios_printk("MINI_OS(file=xenbus.c, line=%d) " _f , __LINE__, ## _a)
#else
#define DEBUG(_f, _a...) ((void)0)
#endif
static void queue_wakeup(struct xenbus_event_queue *queue)
{
- wake_up(&queue->waitq);
+ minios_wake_up(&queue->waitq);
}
void xenbus_event_queue_init(struct xenbus_event_queue *queue)
{
MINIOS_STAILQ_INIT(&queue->events);
queue->wakeup = queue_wakeup;
- init_waitqueue_head(&queue->waitq);
+ minios_init_waitqueue_head(&queue->waitq);
}
static struct xenbus_event *remove_event(struct xenbus_event_queue *queue)
DEFINE_WAIT(w);
spin_lock(&xenbus_req_lock);
while (!(event = remove_event(queue))) {
- add_waiter(w, queue->waitq);
+ minios_add_waiter(w, queue->waitq);
spin_unlock(&xenbus_req_lock);
- schedule();
+ minios_schedule();
spin_lock(&xenbus_req_lock);
}
- remove_waiter(w, queue->waitq);
+ minios_remove_waiter(w, queue->waitq);
spin_unlock(&xenbus_req_lock);
return event;
}
if (ret)
free(ret);
else
- printk("unexpected path returned by watch\n");
+ minios_printk("unexpected path returned by watch\n");
}
char* xenbus_wait_for_value(const char* path, const char* value, struct xenbus_event_queue *queue)
for (;;)
{
- wait_event(xb_waitq, prod != xenstore_buf->rsp_prod);
+ minios_wait_event(xb_waitq, prod != xenstore_buf->rsp_prod);
while (1)
{
prod = xenstore_buf->rsp_prod;
if (events) {
queue_event(events, event);
} else {
- printk("unexpected watch token %s\n", event->token);
+ minios_printk("unexpected watch token %s\n", event->token);
free(event);
}
static void xenbus_evtchn_handler(evtchn_port_t port, struct pt_regs *regs,
void *ign)
{
- wake_up(&xb_waitq);
+ minios_wake_up(&xb_waitq);
}
static int nr_live_reqs;
req_info[id].reply_queue = 0;
nr_live_reqs--;
if (nr_live_reqs == NR_REQS - 1)
- wake_up(&req_wq);
+ minios_wake_up(&req_wq);
spin_unlock(&xenbus_req_lock);
}
if (nr_live_reqs < NR_REQS)
break;
spin_unlock(&xenbus_req_lock);
- wait_event(req_wq, (nr_live_reqs < NR_REQS));
+ minios_wait_event(req_wq, (nr_live_reqs < NR_REQS));
}
o_probe = probe;
DEBUG("init_xenbus called.\n");
xenbus_event_queue_init(&xenbus_default_watch_queue);
xenstore_buf = mfn_to_virt(start_info.store_mfn);
- create_thread("xenstore", NULL, xenbus_thread_func, NULL, NULL);
+ minios_create_thread("xenstore", NULL, xenbus_thread_func, NULL, NULL);
DEBUG("buf at %p.\n", xenstore_buf);
- err = bind_evtchn(start_info.store_evtchn,
+ err = minios_bind_evtchn(start_info.store_evtchn,
xenbus_evtchn_handler,
NULL);
- unmask_evtchn(start_info.store_evtchn);
- printk("xenbus initialised on irq %d mfn %#lx\n",
+ minios_unmask_evtchn(start_info.store_evtchn);
+ minios_printk("xenbus initialised on irq %d mfn %#lx\n",
err, start_info.store_mfn);
}
DEBUG("prod %d, len %d, cons %d, size %d; waiting.\n",
prod, len, xenstore_buf->req_cons, XENSTORE_RING_SIZE);
spin_unlock(&xb_lock);
- wait_event(xb_waitq,
+ minios_wait_event(xb_waitq,
xenstore_buf->req_prod + len - xenstore_buf->req_cons <=
XENSTORE_RING_SIZE);
spin_lock(&xb_lock);
struct xsd_sockmsg *reply;
reply = xenbus_msg_reply(XS_DEBUG, 0, req, ARRAY_SIZE(req));
- printk("Got a reply, type %d, id %d, len %d.\n",
+ minios_printk("Got a reply, type %d, id %d, len %d.\n",
reply->type, reply->req_id, reply->len);
}
res = xenbus_read(XBT_NIL, path, &buf);
if (res) {
- printk("Failed to read %s.\n", path);
+ minios_printk("Failed to read %s.\n", path);
free(res);
return -1;
}
char **dirs, *msg;
int x;
- printk("ls %s...\n", pre);
+ minios_printk("ls %s...\n", pre);
msg = xenbus_ls(XBT_NIL, pre, &dirs);
if (msg) {
- printk("Error in xenbus ls: %s\n", msg);
+ minios_printk("Error in xenbus ls: %s\n", msg);
free(msg);
return;
}
for (x = 0; dirs[x]; x++)
{
- printk("ls %s[%d] -> %s\n", pre, x, dirs[x]);
+ minios_printk("ls %s[%d] -> %s\n", pre, x, dirs[x]);
free(dirs[x]);
}
free(dirs);
static void do_read_test(const char *path)
{
char *res, *msg;
- printk("Read %s...\n", path);
+ minios_printk("Read %s...\n", path);
msg = xenbus_read(XBT_NIL, path, &res);
if (msg) {
- printk("Error in xenbus read: %s\n", msg);
+ minios_printk("Error in xenbus read: %s\n", msg);
free(msg);
return;
}
- printk("Read %s -> %s.\n", path, res);
+ minios_printk("Read %s -> %s.\n", path, res);
free(res);
}
static void do_write_test(const char *path, const char *val)
{
char *msg;
- printk("Write %s to %s...\n", val, path);
+ minios_printk("Write %s to %s...\n", val, path);
msg = xenbus_write(XBT_NIL, path, val);
if (msg) {
- printk("Result %s\n", msg);
+ minios_printk("Result %s\n", msg);
free(msg);
} else {
- printk("Success.\n");
+ minios_printk("Success.\n");
}
}
static void do_rm_test(const char *path)
{
char *msg;
- printk("rm %s...\n", path);
+ minios_printk("rm %s...\n", path);
msg = xenbus_rm(XBT_NIL, path);
if (msg) {
- printk("Result %s\n", msg);
+ minios_printk("Result %s\n", msg);
free(msg);
} else {
- printk("Success.\n");
+ minios_printk("Success.\n");
}
}
/* Simple testing thing */
void test_xenbus(void)
{
- printk("Doing xenbus test.\n");
+ minios_printk("Doing xenbus test.\n");
xenbus_debug_msg("Testing xenbus...\n");
- printk("Doing ls test.\n");
+ minios_printk("Doing ls test.\n");
do_ls_test("device");
do_ls_test("device/vif");
do_ls_test("device/vif/0");
- printk("Doing read test.\n");
+ minios_printk("Doing read test.\n");
do_read_test("device/vif/0/mac");
do_read_test("device/vif/0/backend");
- printk("Doing write test.\n");
+ minios_printk("Doing write test.\n");
do_write_test("device/vif/0/flibble", "flobble");
do_read_test("device/vif/0/flibble");
do_write_test("device/vif/0/flibble", "widget");
do_read_test("device/vif/0/flibble");
- printk("Doing rm test.\n");
+ minios_printk("Doing rm test.\n");
do_rm_test("device/vif/0/flibble");
do_read_test("device/vif/0/flibble");
- printk("(Should have said ENOENT)\n");
+ minios_printk("(Should have said ENOENT)\n");
}
/*
projects / rumpuser-xen.git / commitdiff