void pvm_restart_connection( pvm_object_t o )
{
struct data_area_4_connection *da = pvm_object_da( o, connection );
printf("restarting connection");
da->kernel = 0;
#warning restart!
}
void pvm_backtrace(struct data_area_4_thread *tda)
{
struct pvm_code_handler *code = &tda->code;
if(code->IP > code->IP_max)
{
printf("pvm_backtrace IP > IP_Max!\n");
return;
}
printf("pvm_backtrace thread IP %d\n", code->IP);
printf("pvm_backtrace thread this:\n");
pvm_object_dump(tda->_this_object);
printf("\n\n");
pvm_object_t sframe = tda->call_frame;
while( !pvm_is_null(sframe) )
{
//if( !pvm_object_class_is(sframe, pvm_get_stack_frame_class()) ) ??!
struct data_area_4_call_frame *fda = pvm_object_da(sframe,call_frame);
printf("pvm_backtrace frame:\n");
pvm_object_dump(sframe);
printf("\n");
printf("pvm_backtrace frame this:\n");
pvm_object_t thiso = fda->this_object;
pvm_object_dump(thiso);
printf("\n");
printf("pvm_backtrace frame IP: %d\n", fda->IP);
pvm_object_t tclass = thiso.data->_class;
int ord = fda->ordinal;
int lineno = pvm_ip_to_linenum(tclass, ord, fda->IP);
if( lineno >= 0 )
{
pvm_object_t mname = pvm_get_method_name( tclass, ord );
pvm_object_print(mname);
printf(":%d\n", lineno);
}
printf("\n\n");
sframe = fda->prev;
}
}
static void start_new_vm_thread(struct pvm_object new_thread)
{
args_used++;
//int tid = hal_start_thread(thread_run_func, &new_thread, THREAD_FLAG_VM|THREAD_FLAG_USER);
int tid = hal_start_thread(thread_run_func, &new_thread, THREAD_FLAG_VM);
struct data_area_4_thread *tda = pvm_object_da( new_thread, thread );
tda->tid = tid;
t_set_owner( tid, new_thread.data );
//phantom_thread_t *t = get_thread(tid);
//t->owner = new_thread.data;
while(args_used > 0)
hal_sleep_msec(1);
if(tda->sleep_flag)
{
//timedcall_t *e = &(tda->timer);
net_timer_event *e = &(tda->timer);
int didit = 0;
if( e->pending )
{
bigtime_t msecMore = e->sched_time - hal_system_time();
msecMore /= 1000;
if( msecMore > 0 )
{
// Thread is sleeping on timer, reactivate wakeup
phantom_wakeup_after_msec( msecMore, tda );
}
else
{
// Sleep time is passed, just wake
SYSCALL_WAKE_THREAD_UP(tda);
}
didit = 1;
}
if(!didit)
{
SHOW_ERROR( 0, "Sleeping VM thread has no means to wakeup (%p)", new_thread.data );
}
}
}
void pvm_gc_iter_directory(gc_iterator_call_t func, struct pvm_object_storage * os, void *arg)
{
struct data_area_4_directory *da = (struct data_area_4_directory *)os->da;
struct data_area_4_binary *bin = pvm_object_da( da->container, binary );
void *bp = bin->data;
int i;
for( i = 0; i < da->nEntries; i++, bp += da->elSize )
{
gc_fcall( func, arg, *((pvm_object_t*)bp) );
}
gc_fcall( func, arg, da->container );
}
void pvm_restart_window( pvm_object_t o )
{
struct data_area_4_window *da = pvm_object_da( o, window );
printf("restart WIN\n");
da->w.title = da->title; // must be correct in snap? don't reset?
queue_init(&(da->w.events));
da->w.events_count = 0;
drv_video_window_enter_allwq( &da->w );
//event_q_put_win( 0, 0, UI_EVENT_WIN_REPAINT, &da->w );
ev_q_put_win( 0, 0, UI_EVENT_WIN_REDECORATE, &da->w );
}
void pvm_restart_tty( pvm_object_t o )
{
struct data_area_4_tty *tty = pvm_object_da( o, tty );
printf( "restart TTY %p\n", tty );
tty->w.title = tty->title; // need? must be correct in snap
// BUG! How do we fill owner? We must have object ref here
tty->w.inKernelEventProcess = 0;
tty->w.owner = -1;
queue_init(&(tty->w.events));
tty->w.events_count = 0;
drv_video_window_enter_allwq( &tty->w );
//event_q_put_win( 0, 0, UI_EVENT_WIN_REPAINT, &tty->w );
//event_q_put_win( 0, 0, UI_EVENT_WIN_REDECORATE, &tty->w );
}
struct pvm_object pvm_weakref_get_object(struct pvm_object wr )
{
struct data_area_4_weakref *da = pvm_object_da( wr, weakref );
struct pvm_object out;
// still crashes :(
// HACK HACK HACK BUG - wiring target too. TODO need wire size parameter for page cross situations!
wire_page_for_addr( &(da->object) );
wire_page_for_addr( da->object.data );
// All we do is return new reference to our object,
// incrementing refcount before
#if WEAKREF_SPIN
wire_page_for_addr( &da->lock );
int ie = hal_save_cli();
hal_spin_lock( &da->lock );
#else
hal_mutex_lock( &da->mutex );
#endif
// TODO should we check refcount before and return null if zero?
if( 0 == da->object.data->_ah.refCount )
printf("zero object in pvm_weakref_get_object\n");
out = ref_inc_o( da->object );
#if WEAKREF_SPIN
hal_spin_unlock( &da->lock );
if( ie ) hal_sti();
unwire_page_for_addr( &da->lock );
#else
hal_mutex_unlock( &da->mutex );
#endif
unwire_page_for_addr( da->object.data );
unwire_page_for_addr( &(da->object) );
return out;
}
static pvm_object_t cn_url_blocking_syscall_worker( pvm_object_t conn, struct data_area_4_thread *tc, int nmethod, pvm_object_t arg )
{
(void) conn;
(void) tc;
(void) arg;
struct data_area_4_connection *c = pvm_object_da( conn, connection );
//struct cn_url_volatile *vp = c->v_kernel_state;
struct cn_url_persistent *pp = c->p_kernel_state;
char buf[4096];
errno_t e = 0;
switch( nmethod )
{
default:
case CONN_OP_READ:
e = net_curl( pp->url, buf, sizeof(buf) );
break;
case CONN_OP_WRITE:
case CONN_OP_BIND:
e = ENOSYS;
break;
}
//ret:
if( e )
{
SHOW_ERROR( 1, "err %d", e );
// err_ret:
return pvm_create_string_object("");
}
char *bp = buf;
// Skip HTTP headers
for( ; *bp ; bp++ )
{
if( (bp[0] == '\r') && (bp[1] == '\n') && (bp[2] == '\r') && (bp[3] == '\n') )
{
bp += 4;
goto done;
}
if( (bp[0] == '\n') && (bp[1] == '\n') )
{
bp += 2;
goto done;
}
}
// fall through if no headers, ignore?
SHOW_ERROR( 1, "no headers in '%s'", buf );
// goto err_ret;
done:
return pvm_create_string_object(bp);
}
static pvm_object_t cn_udp_blocking_syscall_worker( pvm_object_t conn, struct data_area_4_thread *tc, int nmethod, pvm_object_t arg )
{
(void) conn;
(void) tc;
(void) arg;
struct data_area_4_connection *c = pvm_object_da( conn, connection );
struct cn_udp_volatile *vp = c->v_kernel_state;
errno_t e = ENOSYS;
int ret = 0;
if( !vp->udp_endpoint )
{
e = ENOTCONN;
goto ret;
}
switch( nmethod )
{
default:
case CONN_OP_READ:
case CONN_OP_WRITE:
e = ENOSYS;
break;
#if HAVE_NET
case CONN_OP_BIND:
{
if(!IS_PHANTOM_INT(arg))
{
SHOW_ERROR0( 1, "bind arg not int" );
e = EINVAL;
break;
}
i4sockaddr a;
a.port = pvm_get_int(arg);
if( udp_bind(vp->udp_endpoint, &a) )
e = EISCONN;
else
e = 0;
break;
}
#endif // HAVE_NET
}
ret:
if( e )
{
SHOW_ERROR( 1, "err %d", e );
return pvm_create_int_object(-e);
}
return pvm_create_int_object(ret);
}
