int syscall_handler(int num, struct syscall_arguments *args)
{
interrupt_unmask();
switch (num)
{
case ADDPROCESS:
interrupt_mask();
process_add((void (*)())args->arg1);
interrupt_unmask();
break;
case YIELD:
interrupt_sleepinsyscall();
break;
case UDPSEND:
return udp_output(args->arg1, (struct sockaddr*)args->arg2,
(char *)args->arg3, args->arg4);
break;
case UDPRECV:
return udp_recvfrom(args->arg1, (struct sockaddr*)args->arg2,
(char *)args->arg3, args->arg4);
break;
case UDPSOCKET:
return udp_socket();
break;
case UDPBIND:
return udp_bind(args->arg1, (struct sockaddr*)args->arg2);
break;
case UDPCLOSE:
return udp_close(args->arg1);
break;
case TCPCONNECT:
return tcp_connect(args->arg1, (struct sockaddr*)args->arg2);
break;
case TCPSEND:
return tcp_send(args->arg1, (char *)args->arg2, args->arg3);
break;
case TCPRECV:
return tcp_recv(args->arg1, (char *)args->arg2, args->arg3);
break;
case TCPSOCKET:
return tcp_socket();
break;
case TCPBIND:
return tcp_bind(args->arg1, (struct sockaddr*)args->arg2);
break;
case TCPCLOSE:
return tcp_close(args->arg1);
break;
case TCPLISTEN:
return tcp_listen(args->arg1);
break;
}
return 0;
}
/**
* Close CMRC connection
*
* @v cmrc Communication-Managed Reliable Connection
* @v rc Reason for close
*/
static void ib_cmrc_close ( struct ib_cmrc_connection *cmrc, int rc ) {
/* Close data transfer interface */
intf_shutdown ( &cmrc->xfer, rc );
/* Schedule shutdown process */
process_add ( &cmrc->shutdown );
}
void server_connect(t_server *server,int port)
{
t_context *C=ctx_get();
t_process *process=process_add(C,"server",__server);
process->clock->limit=1;
process_launch(process);
}
void clock_init(void)
{
T1CON = 0x8010;
IPC0bits.T1IP = 1;
IEC0bits.T1IE = 1;
IFS0bits.T1IF = 0;
/* period = 1 / (70000000 / 8) * 8750 = 1ms */
PR1 = 8750;
process_add(clock_process);
}
app * process_bv_app(func_decl * f, unsigned num, expr * const * args) {
SASSERT(f->get_family_id() == m_bv_util.get_family_id());
switch (f->get_decl_kind()) {
case OP_BADD:
return process_add(f->get_family_id(), OP_BADD, OP_BSUB, num, args);
case OP_BMUL:
return process_bv_mul(f, num, args);
case OP_BSDIV:
case OP_BUDIV:
case OP_BSDIV_I:
case OP_BUDIV_I:
SASSERT(num == 2);
return process_bv_div(f, args[0], args[1]);
case OP_SLEQ:
SASSERT(num == 2);
return process_bv_le(f, args[0], args[1], true);
case OP_ULEQ:
SASSERT(num == 2);
return process_bv_le(f, args[0], args[1], false);
case OP_CONCAT:
return process_concat(f, num, args);
case OP_EXTRACT:
SASSERT(num == 1);
return process_extract(f, args[0]);
case OP_BNOT:
SASSERT(num == 1);
if (uncnstr(args[0])) {
app * r;
if (!mk_fresh_uncnstr_var_for(f, num, args, r))
return r;
if (m_mc)
add_def(args[0], m().mk_app(f, r));
return r;
}
return nullptr;
case OP_BOR:
if (num > 0 && uncnstr(num, args)) {
sort * s = m().get_sort(args[0]);
app * r;
if (!mk_fresh_uncnstr_var_for(f, num, args, r))
return r;
if (m_mc)
add_defs(num, args, r, m_bv_util.mk_numeral(rational(0), s));
return r;
}
return nullptr;
default:
return nullptr;
}
}
/**
* Create ELS request
*
* @v job Parent job-control interface
* @v port Fibre Channel port
* @v peer_port_id Peer port ID
* @v handler ELS handler
* @ret rc Return status code
*/
int fc_els_request ( struct interface *job, struct fc_port *port,
struct fc_port_id *peer_port_id,
struct fc_els_handler *handler ) {
struct fc_els *els;
/* Allocate and initialise structure */
els = fc_els_create ( port, &port->port_id, peer_port_id );
if ( ! els )
return -ENOMEM;
els->handler = handler;
els->flags = FC_ELS_REQUEST;
process_add ( &els->process );
/* Attach to parent job interface, mortalise self, and return */
intf_plug_plug ( &els->job, job );
ref_put ( &els->refcnt );
return 0;
}
app * process_arith_app(func_decl * f, unsigned num, expr * const * args) {
SASSERT(f->get_family_id() == m_a_util.get_family_id());
switch (f->get_decl_kind()) {
case OP_ADD:
return process_add(f->get_family_id(), OP_ADD, OP_SUB, num, args);
case OP_MUL:
return process_arith_mul(f, num, args);
case OP_LE:
SASSERT(num == 2);
return process_le_ge(f, args[0], args[1], true);
case OP_GE:
SASSERT(num == 2);
return process_le_ge(f, args[0], args[1], false);
default:
return nullptr;
}
}
subpaving::var process_arith_app(app * t, unsigned depth, mpz & n, mpz & d) {
SASSERT(m_autil.is_arith_expr(t));
switch (t->get_decl_kind()) {
case OP_NUM:
return process_num(t, depth, n, d);
case OP_ADD:
return process_add(t, depth, n, d);
case OP_MUL:
return process_mul(t, depth, n, d);
case OP_POWER:
return process_power(t, depth, n, d);
case OP_TO_REAL:
return process(t->get_arg(0), depth+1, n, d);
case OP_SUB:
case OP_UMINUS:
found_non_simplified();
break;
case OP_TO_INT:
case OP_DIV:
case OP_IDIV:
case OP_MOD:
case OP_REM:
case OP_IRRATIONAL_ALGEBRAIC_NUM:
throw default_exception("you must apply arithmetic purifier before internalizing expressions into the subpaving module.");
case OP_SIN:
case OP_COS:
case OP_TAN:
case OP_ASIN:
case OP_ACOS:
case OP_ATAN:
case OP_SINH:
case OP_COSH:
case OP_TANH:
case OP_ASINH:
case OP_ACOSH:
case OP_ATANH:
// TODO
throw default_exception("transcendental and hyperbolic functions are not supported yet.");
default:
UNREACHABLE();
}
return subpaving::null_var;
}
int parse_options(int argc, char **argv) {
static struct option opts[] = {
{"command", required_argument, 0, 'c'},
{"help", no_argument, 0, '?'},
{"stderr", required_argument, 0, '2'},
{"stdin", required_argument, 0, '0'},
{"stdout", required_argument, 0, '1'},
{0, 0, 0, 0},
};
assert(argv0 == NULL);
argv0 = strdup(argv[0]);
if (argv0 == NULL) {
return -1;
}
process_t *current = NULL;
while (1) {
int opt_ind, c = getopt_long(argc, argv, "0:1:2:c:?", opts, &opt_ind);
if (c == -1) {
break;
}
switch (c) {
case 0: {
if (opts[opt_ind].flag != 0) {
continue;
}
fprintf(stderr, "Unexpected option %s\n", opts[opt_ind].name);
break;
} case '?': {
usage(stdout);
exit(0);
} case 'c': {
if (current != NULL) {
process_add(current);
}
current = new_process(optarg);
if (current == NULL) {
goto fail;
}
break;
} case '0': {
set(current ? ¤t->in : &plumb_in, optarg);
break;
} case '1': {
set(current ? ¤t->out : &plumb_out, optarg);
break;
} case '2': {
set(current ? ¤t->err : &plumb_err, optarg);
break;
} default: {
fprintf(stderr, "Getopt failure\n");
exit(1);
}
}
}
if (current != NULL) {
process_add(current);
}
return 0;
fail:
perror("Failed to parse arguments");
exit(1);
}
