static int
cdemu_read(struct disk_op_s *op)
{
struct drive_s *drive_g;
drive_g = GLOBALFLAT2GLOBAL(GET_LOW(CDEmu.emulated_drive_gf));
struct disk_op_s dop;
dop.drive_g = drive_g;
dop.command = op->command;
dop.lba = GET_LOW(CDEmu.ilba) + op->lba / 4;
int count = op->count;
op->count = 0;
u8 *cdbuf_fl = GET_GLOBAL(bounce_buf_fl);
if (op->lba & 3) {
// Partial read of first block.
dop.count = 1;
dop.buf_fl = cdbuf_fl;
int ret = process_op(&dop);
if (ret)
return ret;
u8 thiscount = 4 - (op->lba & 3);
if (thiscount > count)
thiscount = count;
count -= thiscount;
memcpy_fl(op->buf_fl, cdbuf_fl + (op->lba & 3) * 512, thiscount * 512);
op->buf_fl += thiscount * 512;
op->count += thiscount;
dop.lba++;
}
if (count > 3) {
// Read n number of regular blocks.
dop.count = count / 4;
dop.buf_fl = op->buf_fl;
int ret = process_op(&dop);
op->count += dop.count * 4;
if (ret)
return ret;
u8 thiscount = count & ~3;
count &= 3;
op->buf_fl += thiscount * 512;
dop.lba += thiscount / 4;
}
if (count) {
// Partial read on last block.
dop.count = 1;
dop.buf_fl = cdbuf_fl;
int ret = process_op(&dop);
if (ret)
return ret;
u8 thiscount = count;
memcpy_fl(op->buf_fl, cdbuf_fl, thiscount * 512);
op->count += thiscount;
}
return DISK_RET_SUCCESS;
}
void run_processes(void)
{
t_proc *process;
int opcode;
int offset;
int i;
i = g_corewar.process_count;
while (--i >= 0)
{
process = &g_corewar.process[i];
if (process->wait < 0)
{
opcode = (int)read_byte(process->pc) - 1;
if (opcode < OP_COUNT && opcode >= 0)
{
process->op = &g_op_tab[opcode];
process->wait = g_op_tab[opcode].cycles;
}
}
if (--process->wait <= 0)
{
offset = process_op(process);
process_move(&g_corewar.process[i], offset);
}
}
}
// Must be threadsafe
void
process_tile(MyPaintTiledSurface *self, int tx, int ty)
{
TileIndex tile_index = {tx, ty};
OperationDataDrawDab *op = operation_queue_pop(self->operation_queue, tile_index);
if (!op) {
return;
}
MyPaintTileRequest request_data;
const int mipmap_level = 0;
mypaint_tile_request_init(&request_data, mipmap_level, tx, ty, FALSE);
mypaint_tiled_surface_tile_request_start(self, &request_data);
uint16_t * rgba_p = request_data.buffer;
if (!rgba_p) {
printf("Warning: Unable to get tile!\n");
return;
}
uint16_t mask[MYPAINT_TILE_SIZE*MYPAINT_TILE_SIZE+2*MYPAINT_TILE_SIZE];
while (op) {
process_op(rgba_p, mask, tile_index.x, tile_index.y, op);
free(op);
op = operation_queue_pop(self->operation_queue, tile_index);
}
mypaint_tiled_surface_tile_request_end(self, &request_data);
}
/*
* Decode, process and encode a COMPOUND
*/
static int nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
{
struct cb_compound_hdr_arg hdr_arg;
struct cb_compound_hdr_res hdr_res;
struct xdr_stream xdr_in, xdr_out;
uint32_t *p;
unsigned int status;
unsigned int nops = 1;
dprintk("%s: start\n", __FUNCTION__);
xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
p = (uint32_t*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
decode_compound_hdr_arg(&xdr_in, &hdr_arg);
hdr_res.taglen = hdr_arg.taglen;
hdr_res.tag = hdr_arg.tag;
hdr_res.nops = NULL;
encode_compound_hdr_res(&xdr_out, &hdr_res);
for (;;) {
status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp);
if (status != 0)
break;
if (nops == hdr_arg.nops)
break;
nops++;
}
*hdr_res.status = status;
*hdr_res.nops = htonl(nops);
dprintk("%s: done, status = %u\n", __FUNCTION__, status);
return rpc_success;
}
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
{
struct cb_compound_hdr_arg hdr_arg = { 0 };
struct cb_compound_hdr_res hdr_res = { NULL };
struct xdr_stream xdr_in, xdr_out;
__be32 *p, status;
struct cb_process_state cps = {
.drc_status = 0,
.clp = NULL,
.slotid = NFS4_NO_SLOT,
.net = rqstp->rq_xprt->xpt_net,
};
unsigned int nops = 0;
dprintk("%s: start\n", __func__);
xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
if (status == __constant_htonl(NFS4ERR_RESOURCE))
return rpc_garbage_args;
if (hdr_arg.minorversion == 0) {
cps.clp = nfs4_find_client_ident(rqstp->rq_xprt->xpt_net, hdr_arg.cb_ident);
if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp))
return rpc_drop_reply;
}
hdr_res.taglen = hdr_arg.taglen;
hdr_res.tag = hdr_arg.tag;
if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
return rpc_system_err;
while (status == 0 && nops != hdr_arg.nops) {
status = process_op(hdr_arg.minorversion, nops, rqstp,
&xdr_in, argp, &xdr_out, resp, &cps);
nops++;
}
if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
status = htonl(NFS4ERR_RESOURCE);
nops--;
}
*hdr_res.status = status;
*hdr_res.nops = htonl(nops);
nfs4_cb_free_slot(&cps);
nfs_put_client(cps.clp);
dprintk("%s: done, status = %u\n", __func__, ntohl(status));
return rpc_success;
}
static struct callback_op callback_ops[] = {
[0] = {
.res_maxsize = CB_OP_HDR_RES_MAXSZ,
},
// Execute a "disk_op_s" request (using the extra 16bit stack).
static int
send_disk_op(struct disk_op_s *op)
{
ASSERT16();
if (! CONFIG_DRIVES)
return -1;
if (!CONFIG_ENTRY_EXTRASTACK)
// Jump on to extra stack
return stack_hop(__send_disk_op, op, GET_SEG(SS));
return process_op(op);
}
// Execute a "disk_op_s" request after jumping to the extra stack.
static int
__send_disk_op(struct disk_op_s *op_far, u16 op_seg)
{
struct disk_op_s dop;
memcpy_far(GET_SEG(SS), &dop, op_seg, op_far, sizeof(dop));
int status = process_op(&dop);
// Update count with total sectors transferred.
SET_FARVAR(op_seg, op_far->count, dop.count);
return status;
}
// Test unit ready
static int
cdb_test_unit_ready(struct disk_op_s *op)
{
struct cdb_request_sense cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_TEST_UNIT_READY;
op->command = CMD_SCSI;
op->count = 0;
op->buf_fl = NULL;
op->cdbcmd = &cmd;
op->blocksize = 0;
return process_op(op);
}
// Request capacity
static int
cdb_read_capacity(struct disk_op_s *op, struct cdbres_read_capacity *data)
{
struct cdb_read_capacity cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_READ_CAPACITY;
op->command = CMD_SCSI;
op->count = 1;
op->buf_fl = data;
op->cdbcmd = &cmd;
op->blocksize = sizeof(*data);
return process_op(op);
}
void add_op(op_rec * rec)
{
token tok = next_token();
/* <addop> ::= PLUSOP | MINUSOP*/
if (tok == PLUSOP || tok == MINUSOP){
match(tok);
//op_rec x = process_op();
*rec = process_op();
}
else{
syntax_error(tok);
}
}
// Request SENSE
static int
cdb_get_sense(struct disk_op_s *op, struct cdbres_request_sense *data)
{
struct cdb_request_sense cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_REQUEST_SENSE;
cmd.length = sizeof(*data);
op->command = CMD_SCSI;
op->count = 1;
op->buf_fl = data;
op->cdbcmd = &cmd;
op->blocksize = sizeof(*data);
return process_op(op);
}
// Mode sense, geometry page.
static int
cdb_mode_sense_geom(struct disk_op_s *op, struct cdbres_mode_sense_geom *data)
{
struct cdb_mode_sense cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_MODE_SENSE;
cmd.flags = 8; /* DBD */
cmd.page = MODE_PAGE_HD_GEOMETRY;
cmd.count = cpu_to_be16(sizeof(*data));
op->command = CMD_SCSI;
op->count = 1;
op->buf_fl = data;
op->cdbcmd = &cmd;
op->blocksize = sizeof(*data);
return process_op(op);
}
/*
* Decode, process and encode a COMPOUND
*/
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
{
struct cb_compound_hdr_arg hdr_arg = { 0 };
struct cb_compound_hdr_res hdr_res = { NULL };
struct xdr_stream xdr_in, xdr_out;
__be32 *p;
__be32 status, drc_status = 0;
unsigned int nops = 0;
dprintk("%s: start\n", __func__);
xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
if (status == __constant_htonl(NFS4ERR_RESOURCE))
return rpc_garbage_args;
hdr_res.taglen = hdr_arg.taglen;
hdr_res.tag = hdr_arg.tag;
if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
return rpc_system_err;
while (status == 0 && nops != hdr_arg.nops) {
status = process_op(hdr_arg.minorversion, nops, rqstp,
&xdr_in, argp, &xdr_out, resp, &drc_status);
nops++;
}
/* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
* resource error in cb_compound status without returning op */
if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
status = htonl(NFS4ERR_RESOURCE);
nops--;
}
*hdr_res.status = status;
*hdr_res.nops = htonl(nops);
dprintk("%s: done, status = %u\n", __func__, ntohl(status));
return rpc_success;
}
expression_ptr cpp_from_isl::process_expr(isl_ast_expr * ast_expr)
{
expression_ptr expr;
auto type = isl_ast_expr_get_type(ast_expr);
switch(type)
{
case isl_ast_expr_op:
{
expr = process_op(ast_expr);
break;
}
case isl_ast_expr_id:
{
auto id = isl_ast_expr_get_id(ast_expr);
string name(isl_id_get_name(id));
isl_id_free(id);
if (m_id_func)
expr = m_id_func(name);
if (!expr)
expr = make_shared<id_expression>(name);
break;
}
case isl_ast_expr_int:
{
auto val = isl_ast_expr_get_val(ast_expr);
if (isl_val_is_int(val) != isl_bool_true)
throw error("Value is not an integer.");
int ival = isl_val_get_num_si(val);
isl_val_free(val);
expr = literal(ival);
break;
}
default:
throw error("Unexpected AST expression type.");
}
return expr;
}
codelist_entry *process_line(){
eat_whitespace();
codelist_entry *ret = NULL;
printf("Processing line: %s -- len: %d\n", input_file_stack->line_buffer, (int)strlen(input_file_stack->line_buffer));
if(!is_line_blank() && !is_line_comment()){
if(is_line_label()){
printf("Line is label\n");
return process_label();
}else if(is_line_dat()){
printf("Line is data\n");
return process_dat();
}else if(is_line_include()){
printf("Line is include\n");
open_input_m4(get_include_filename());
return NULL;
}else{
printf("Processing code line\n");
return process_op();
}
}else{
printf("Line comment/empty/blank\n");
}
return ret;
}
/* PUBLIC */
Term read_commands(FILE *fin, FILE *fout, BOOL echo, int unknown_action)
{
Term t = read_term(fin, fout);
BOOL go = (t != NULL);
while (go) {
BOOL already_echoed = FALSE;
/************************************************************ set, clear */
if (is_term(t, "set", 1) || is_term(t, "clear", 1)) {
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
flag_handler(fout, t, unknown_action);
}
else if (is_term(t, "assign", 2)) {
/************************************************************** assign */
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
parm_handler(fout, t, unknown_action);
}
else if (is_term(t, "assoc_comm", 1) ||
is_term(t, "commutative", 1)) {
/************************************************************ AC, etc. */
Term f = ARG(t,0);
if (!CONSTANT(f)) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("argument must be symbol only");
}
else {
if (is_term(t, "assoc_comm", 1))
set_assoc_comm(sn_to_str(SYMNUM(f)), TRUE);
else
set_commutative(sn_to_str(SYMNUM(f)), TRUE);
}
}
else if (is_term(t, "op", 3)) {
/****************************************************************** op */
/* e.g., op(300, infix, +); */
Term prec_term = ARG(t,0);
Term type_term = ARG(t,1);
Term symb_term = ARG(t,2);
int prec;
BOOL ok = term_to_int(prec_term, &prec);
if (!ok || prec < MIN_PRECEDENCE || prec > MAX_PRECEDENCE) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("bad precedence in op command");
}
else if (proper_listterm(symb_term)) {
while (cons_term(symb_term)) {
process_op(fout, t, prec, type_term, ARG(symb_term, 0));
symb_term = ARG(symb_term, 1);
}
}
else
process_op(fout, t, prec, type_term, symb_term);
}
else if (is_term(t, "lex", 1)) {
/***************************************************************** lex */
Plist p = listterm_to_tlist(ARG(t,0));
if (p == NULL) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("lex command must contain a proper list, e.g., [a,b,c]");
}
else {
preliminary_precedence(p);
zap_plist(p);
}
}
else {
/******************************************************** unrecognized */
/* return this unknown term */
go = FALSE;
}
if (go) {
if (echo && !already_echoed)
fwrite_term_nl(fout, t);
zap_term(t);
t = read_term(fin, fout);
go = (t != NULL);
}
}
return t;
} /* read_commands */
static int
process_filter(struct event_format *event, struct filter_arg **parg,
char **error_str, int not)
{
enum event_type type;
char *token = NULL;
struct filter_arg *current_op = NULL;
struct filter_arg *current_exp = NULL;
struct filter_arg *left_item = NULL;
struct filter_arg *arg = NULL;
enum op_type op_type;
enum filter_op_type btype;
enum filter_exp_type etype;
enum filter_cmp_type ctype;
int ret;
*parg = NULL;
do {
free(token);
type = read_token(&token);
switch (type) {
case EVENT_SQUOTE:
case EVENT_DQUOTE:
case EVENT_ITEM:
arg = create_arg_item(event, token, type, error_str);
if (!arg)
goto fail;
if (!left_item)
left_item = arg;
else if (current_exp) {
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
left_item = NULL;
/* Not's only one one expression */
if (not) {
arg = NULL;
if (current_op)
goto fail_print;
free(token);
*parg = current_exp;
return 0;
}
} else
goto fail_print;
arg = NULL;
break;
case EVENT_DELIM:
if (*token == ',') {
show_error(error_str,
"Illegal token ','");
goto fail;
}
if (*token == '(') {
if (left_item) {
show_error(error_str,
"Open paren can not come after item");
goto fail;
}
if (current_exp) {
show_error(error_str,
"Open paren can not come after expression");
goto fail;
}
ret = process_filter(event, &arg, error_str, 0);
if (ret != 1) {
if (ret == 0)
show_error(error_str,
"Unbalanced number of '('");
goto fail;
}
ret = 0;
/* A not wants just one expression */
if (not) {
if (current_op)
goto fail_print;
*parg = arg;
return 0;
}
if (current_op)
ret = add_right(current_op, arg, error_str);
else
current_exp = arg;
if (ret < 0)
goto fail;
} else { /* ')' */
if (!current_op && !current_exp)
goto fail_print;
/* Make sure everything is finished at this level */
if (current_exp && !check_op_done(current_exp))
goto fail_print;
if (current_op && !check_op_done(current_op))
goto fail_print;
if (current_op)
*parg = current_op;
else
*parg = current_exp;
return 1;
}
break;
case EVENT_OP:
op_type = process_op(token, &btype, &ctype, &etype);
/* All expect a left arg except for NOT */
switch (op_type) {
case OP_BOOL:
/* Logic ops need a left expression */
if (!current_exp && !current_op)
goto fail_print;
/* fall through */
case OP_NOT:
/* logic only processes ops and exp */
if (left_item)
goto fail_print;
break;
case OP_EXP:
case OP_CMP:
if (!left_item)
goto fail_print;
break;
case OP_NONE:
show_error(error_str,
"Unknown op token %s", token);
goto fail;
}
ret = 0;
switch (op_type) {
case OP_BOOL:
arg = create_arg_op(btype);
if (current_op)
ret = add_left(arg, current_op);
else
ret = add_left(arg, current_exp);
current_op = arg;
current_exp = NULL;
break;
case OP_NOT:
arg = create_arg_op(btype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
current_exp = arg;
ret = process_filter(event, &arg, error_str, 1);
if (ret < 0)
goto fail;
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
break;
case OP_EXP:
case OP_CMP:
if (op_type == OP_EXP)
arg = create_arg_exp(etype);
else
arg = create_arg_cmp(ctype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
ret = add_left(arg, left_item);
if (ret < 0) {
arg = NULL;
goto fail_print;
}
current_exp = arg;
break;
default:
break;
}
arg = NULL;
if (ret < 0)
goto fail_print;
break;
case EVENT_NONE:
break;
default:
goto fail_print;
}
} while (type != EVENT_NONE);
if (!current_op && !current_exp)
goto fail_print;
if (!current_op)
current_op = current_exp;
current_op = collapse_tree(current_op);
*parg = current_op;
return 0;
fail_print:
show_error(error_str, "Syntax error");
fail:
free_arg(current_op);
free_arg(current_exp);
free_arg(arg);
free(token);
return -1;
}
/*
* Decode, process and encode a COMPOUND
*/
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
{
struct cb_compound_hdr_arg hdr_arg = { 0 };
struct cb_compound_hdr_res hdr_res = { NULL };
struct xdr_stream xdr_in, xdr_out;
__be32 *p, status;
struct cb_process_state cps = {
.drc_status = 0,
.clp = NULL,
.net = SVC_NET(rqstp),
};
unsigned int nops = 0;
dprintk("%s: start\n", __func__);
xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
if (status == htonl(NFS4ERR_RESOURCE))
return rpc_garbage_args;
if (hdr_arg.minorversion == 0) {
cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident);
if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp))
goto out_invalidcred;
}
cps.minorversion = hdr_arg.minorversion;
hdr_res.taglen = hdr_arg.taglen;
hdr_res.tag = hdr_arg.tag;
if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
return rpc_system_err;
while (status == 0 && nops != hdr_arg.nops) {
status = process_op(nops, rqstp, &xdr_in,
argp, &xdr_out, resp, &cps);
nops++;
}
/* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
* resource error in cb_compound status without returning op */
if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
status = htonl(NFS4ERR_RESOURCE);
nops--;
}
*hdr_res.status = status;
*hdr_res.nops = htonl(nops);
nfs4_cb_free_slot(&cps);
nfs_put_client(cps.clp);
dprintk("%s: done, status = %u\n", __func__, ntohl(status));
return rpc_success;
out_invalidcred:
pr_warn_ratelimited("NFS: NFSv4 callback contains invalid cred\n");
return rpc_autherr_badcred;
}
/*
* Define NFS4 callback COMPOUND ops.
*/
static struct callback_op callback_ops[] = {
[0] = {
.res_maxsize = CB_OP_HDR_RES_MAXSZ,
},
