void task2(void *arg)
{
os_printf("task2 start....\n");
for (;;) {
#if msg_queue_test
memset(buffer, 0, 10);
msg_get(&my_queue, buffer);
os_printf("queue 0 read = %s\n", buffer);
memset(buffer, 0, 10);
msg_get(&my_queue1, buffer);
os_printf("queue 1 read = %s\n", buffer);
memset(buffer, 0, 10);
msg_get(&my_queue2, buffer);
os_printf("queue 2 read = %s\n", buffer);
#endif
#if sem_test
sem_get(&sem);
os_printf("task2 sem.count = %d\n", sem.count );
#endif
#if mutex_test
os_printf("task2 running\n" );
mutex_get(&mutex);
os_printf("task2 priority: %d\n", new_task->prio );
mutex_put(&mutex);
#endif
os_delay(100);
};
}
static void process_time_report() {
while(msg_available()) {
if (msg_get_16() != ATTR_TIMEANDZONE) return;
if (msg_get() != TYPE_OCTET_STRING) return;
if (msg_get() != 8) return; // Weird length
time_t t = msg_get_32()+ZIGBEE_TIME_OFFSET;
int32_t zone = msg_get_i32();
/* Setting time and zone must be done without WET
* macro because this function is only run in dry mode
* (no response generated, because it's a report) */
stime(&t);
set_timezone(zone);
}
}
int wlan_tx(txfifo_t *tx_fifo, msg_q_t *msg_q, int cnt)
{
int tx_cnt, i, ret;
tx_msg_t *msg;
tx_cnt = 0;
for (i = 0; i < cnt; i++) {
msg = msg_get(msg_q);
if (NULL == msg) {
break;
}
ret = tx_fifo_in(tx_fifo, msg);
if (TX_FIFO_FULL == ret) {
ret = TX_FIFO_FULL;
break;
}
trans_up();
if (HOST_SC2331_CMD == msg->hdr.type) {
if ((msg->slice[0].len > 0)
&& (NULL != msg->slice[0].data))
kfree(msg->slice[0].data);
} else if (HOST_SC2331_PKT == msg->hdr.type) {
if ((NULL != msg->p))
dev_kfree_skb((struct sk_buff *)(msg->p));
} else {
}
memset((unsigned char *)msg, 0, sizeof(tx_msg_t));
msg_free(msg_q, msg);
tx_cnt++;
}
return tx_cnt ? tx_cnt : ret;
}
static void
req_forward_remote_dc(struct context *ctx, struct conn *c_conn, struct msg *msg,
struct mbuf *orig_mbuf, uint8_t *key, uint32_t keylen,
struct datacenter *dc)
{
uint32_t rack_cnt = array_n(&dc->racks);
if (rack_cnt == 0)
return;
struct rack *rack = dc->preselected_rack_for_replication;
if (rack == NULL)
rack = array_get(&dc->racks, 0);
struct msg *rack_msg = msg_get(c_conn, msg->request, __FUNCTION__);
if (rack_msg == NULL) {
log_debug(LOG_VERB, "whelp, looks like yer screwed now, buddy. no inter-rack messages for you!");
msg_put(rack_msg);
return;
}
msg_clone(msg, orig_mbuf, rack_msg);
log_info("msg (%d:%d) clone to remote rack msg (%d:%d)",
msg->id, msg->parent_id, rack_msg->id, rack_msg->parent_id);
rack_msg->swallow = true;
if (log_loggable(LOG_DEBUG)) {
log_debug(LOG_DEBUG, "forwarding request to conn '%s' on rack '%.*s'",
dn_unresolve_peer_desc(c_conn->sd), rack->name->len, rack->name->data);
}
remote_req_forward(ctx, c_conn, rack_msg, rack, key, keylen);
}
static void *transmit_start(void *arg)
{
int fd = (unsigned long)arg;
struct msg *msg;
ssize_t res;
while (1) {
msg = opt_master ? msg_gen(-opt_msglen) : msg_get();
if (opt_verbose)
msg_dump(msg);
res = write(fd, msg->buf, msg->len);
if (res < 0) {
pr_error("Write error %d\n", errno);
exit(-1);
}
if (res < msg->len) {
pr_error("Short write %zd < %u\n", res, msg->len);
exit(-1);
}
tx_bytes += res;
if (opt_master && opt_chain)
msg_add(msg);
else
free(msg);
}
return NULL;
}
static void
req_forward_error(struct context *ctx, struct conn *conn, struct msg *msg,
err_t err)
{
if (log_loggable(LOG_INFO)) {
log_debug(LOG_INFO, "forward req %"PRIu64" len %"PRIu32" type %d from "
"c %d failed: %s", msg->id, msg->mlen, msg->type, conn->sd,
strerror(err));
}
if (!msg->expect_datastore_reply) {
req_put(msg);
return;
}
// Create an appropriate response for the request so its propagated up;
// This response gets dropped in rsp_make_error anyways. But since this is
// an error path its ok with the overhead.
struct msg *rsp = msg_get(conn, false, __FUNCTION__);
rsp->peer = msg;
rsp->error = 1;
rsp->err = err;
rstatus_t status = conn_handle_response(conn, msg->id, rsp);
IGNORE_RET_VAL(status);
}
int msg_get_plain_text(int age, char *buffer, int max)
{
int ct = 0, i;
doc_token_t token;
msg_ptr msg = msg_get(age);
cptr pos = string_buffer(msg->msg);
bool done = FALSE;
while (!done)
{
pos = doc_lex(pos, &token);
if (token.type == DOC_TOKEN_EOF) break;
if (token.type == DOC_TOKEN_TAG) continue; /* assume only color tags */
for (i = 0; i < token.size; i++)
{
if (ct >= max - 4)
{
buffer[ct++] = '.';
buffer[ct++] = '.';
buffer[ct++] = '.';
done = TRUE;
break;
}
buffer[ct++] = token.pos[i];
}
}
buffer[ct] = '\0';
return ct;
}
void kernel_footprint(void)
{
init();
// generate code for process
struct Process *p =
proc_new(proc1_main, 0, sizeof(proc1_stack), proc1_stack);
proc_setPri(p, 5);
proc_yield();
// generate code for msg
Msg msg;
msg_initPort(&in_port, event_createSignal(p, SIG_USER1));
msg_put(&in_port, &msg);
msg_peek(&in_port);
Msg *msg_re = msg_get(&in_port);
msg_reply(msg_re);
// generate code for signals
sig_send(p, SIG_USER0);
// generate code for msg
Semaphore sem;
sem_init(&sem);
sem_obtain(&sem);
sem_release(&sem);
sig_wait(SIG_USER0);
}
int tea_thread_msg_push(int tid, INET_ADDR *addr, void *msg, int msg_size)
{
TEA_MSG *tmsg;
int r = 0;
pthreadex_lock_get_shared(&ttable_lock);
if(ttable[tid])
{
if(ttable[tid]->mqueue)
{
tmsg = msg_get();
if(addr)
msg_set_addr(tmsg, addr);
msg_fill(tmsg, msg, msg_size);
mqueue_push(ttable[tid]->mqueue, tmsg);
pthreadex_flag_up(&(ttable[tid]->mwaiting));
} else
DBG("[tea] network message ignored by %d", tid);
} else
r = -1;
pthreadex_lock_release();
return r;
}
int main()
{
int msg_id = msg_get();//cli
if(msg_id < 0)
return 1;
char buf[G_SIZE];
while(1)
{
memset(buf,'\0',sizeof(buf));
printf("Please Input\n: ");
fflush(stdout);
char *ar = fgets(buf,sizeof(buf)-1,stdin);
if(strncasecmp(ar,"quit",4) == 0)
break;
msg_send(msg_id,buf,DATA_TYPE_CLI);
int ret =msg_recv(msg_id,buf,\
sizeof(buf)-1,DATA_TYPE_SER);
printf("ser:>%s\n",buf);
fflush(stdout);
memset(buf,'\0',sizeof(buf));
}
// sleep(10);
// int ret = msg_destroy(msg_id);
// printf("destroy code is:> %d\n",ret);
return 0;
}
struct msg *
req_fake(struct context *ctx, struct conn *conn)
{
rstatus_t status;
struct msg *msg;
/* the fake req don't have client conn */
msg = msg_get(NULL, true, conn->redis);
if (msg == NULL) {
log_error("get msg for fake req failed");
return NULL;
}
/* the fake req don't have client conn to reply.
* we know the response order, so we don't need the peer request.
* mark it noreply to release it when sent or socket error.
*/
msg->noreply = 1;
/* enqueue the message (request) into server inq */
if (TAILQ_EMPTY(&conn->imsg_q)) {
status = event_add_out(ctx->evb, conn);
if (status != NC_OK) {
conn->err = errno;
req_put(msg);
return NULL;
}
}
conn->enqueue_inq(ctx, conn, msg);
return msg;
}
int processline(io *s)
{
int code;
int m;
ssize_t sz;
char line[512], msgid[512];
sz = parse_response_line(s, &code, line);
if(sz == -1)
msg_fail("parse_response_line: %s", msg_get());
switch(code) {
case 223:
break;
case 422:
exit(EXIT_SUCCESS);
default:
msg_fail("Received unexpected response code %d", code);
}
m = sscanf(line, "%*d %*d %s", msgid);
if(m == 0)
msg_fail("Failed to parse message-id from response");
printf("%s\n", msgid);
return 0;
}
void MsgStorage::invoke(const string& method,
const AmArg& args, AmArg& ret) {
if(method == "msg_new"){
MessageDataFile* f =
dynamic_cast<MessageDataFile*>(args.get(3).asObject());
if (NULL == f) {
throw(string("message data is not a file ptr."));
}
ret.push(msg_new(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
f->fp));
} else if(method == "msg_get"){
msg_get(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
ret);
} else if(method == "msg_markread"){
ret.push(msg_markread(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr()));
} else if(method == "msg_delete"){
ret.push(msg_delete(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr()));
} else if(method == "userdir_open"){
userdir_open(args.get(0).asCStr(),
args.get(1).asCStr(),
ret);
} else if(method == "userdir_close"){
ret.push(userdir_close(args.get(0).asCStr(),
args.get(1).asCStr()));
} else if(method == "userdir_getcount"){
userdir_getcount(args.get(0).asCStr(),
args.get(1).asCStr(),
ret);
} else if(method == "events_subscribe"){
events_subscribe(args.get(0).asDynInv(),
args.get(1).asCStr());
} else if(method == "events_unsubscribe"){
events_unsubscribe(args.get(0).asDynInv());
} else if(method == "_list"){
ret.push("msg_new");
ret.push("msg_get");
ret.push("msg_markread");
ret.push("msg_delete");
ret.push("userdir_open");
ret.push("userdir_close");
ret.push("userdir_getcount");
ret.push("events_subscribe");
ret.push("events_unsubscribe");
}
else
throw AmDynInvoke::NotImplemented(method);
}
void initconn(io *s)
{
int c;
c = tcp_dial(server, port);
if(c == -1)
msg_fail("tcp_dial: %s", msg_get());
io_set_fd(s, c, tcp_write, tcp_read);
}
struct msg *
req_get(struct conn *conn)
{
struct msg *msg;
msg = msg_get(conn, true);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
int client_subrun(client_state_t *state) {
if (!(state->connection) &&
(state->log)
) {
state->thread_state = THREAD_STATE_ERROR;
return CON_ERROR_UNKNOWN;
}
int msgget = msg_get(state);
if ((msgget) && (msgget != -1)) return CON_ERROR_UNKNOWN;
return CON_ERROR_NONE;
}
struct msg *
req_get(struct conn *conn)
{
struct msg *msg;
ASSERT(conn->client && !conn->proxy);
msg = msg_get(conn, true, conn->redis);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
struct msg *
req_get(struct conn *conn, struct msg_base *msgb)
{
struct msg *msg;
ASSERT(conn->client && !conn->proxy);
msg = msg_get(conn, true, conn->source_type, msgb);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
static void *receive_start(void *arg)
{
int fd = (unsigned long)arg;
struct msg *msg;
ssize_t res;
unsigned int avail = 0;
static unsigned char buf[MAX_MAX_MSG_LEN];
unsigned long long delay;
while (1) {
msg = opt_master ? msg_get() : msg_gen(-opt_msglen);
while (avail < msg->len) {
res = read(fd, buf + avail, sizeof(buf) - avail);
if (res < 0) {
pr_error("Read error %d\n", errno);
exit(-1);
}
avail += res;
rx_bytes += res;
}
if (!msg_verify(msg, buf)) {
pr_error("Data mismatch\n");
cmp_buffer(buf, msg->buf, msg->len);
print_stats();
exit(-1);
}
delay = get_timestamp() - msg->stamp;
if (!delay)
delay = 1;
pr_debug(ESC_GREEN "OK %u bytes in %llu us (%llu bps)\n",
msg->len, delay, msg->len * 8000000 / delay);
avail -= msg->len;
if (avail > 0) {
pr_debug("Keeping %u bytes\n", avail);
memmove(buf, buf + msg->len, avail);
}
if (!opt_master && opt_chain) {
msg_inc(msg);
msg_add(msg);
} else {
free(msg);
}
}
return NULL;
}
struct msg *
dnode_rsp_get(struct conn *conn)
{
struct msg *msg;
ASSERT(!conn->dnode_client && !conn->dnode_server);
msg = msg_get(conn, false, conn->redis);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
struct msg *
rsp_get(struct conn *conn)
{
struct msg *msg;
ASSERT(!conn->client && !conn->proxy);
msg = msg_get(conn, false);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
void main()
{
queue_create(&my_queue, 1000, "first", 0);
MSG msg1;
MSG msg2;
MSG msg3;
msg1.buff = "abcd";
msg2.buff = "abce";
msg3.buff = "abcf";
printf("test read = %s\n", msg1.buff);
U8 *buffer = (U8 *)malloc(10);
memset(buffer, 0, 10);
msg_put(&my_queue, &msg1, 0);
msg_put(&my_queue, &msg2, 0);
msg_put(&my_queue, &msg3, 0);
msg_get(&my_queue, buffer);
printf("first read = %s\n", buffer);
msg_get(&my_queue, buffer);
printf("second read = %s\n", buffer);
msg_get(&my_queue, buffer);
printf("three read = %s\n", buffer);
}
struct msg *
rsp_get(struct conn *conn)
{
struct msg *msg;
ASSERT((conn->type == CONN_DNODE_PEER_SERVER) ||
(conn->type == CONN_SERVER));
msg = msg_get(conn, false, __FUNCTION__);
if (msg == NULL) {
conn->err = errno;
}
return msg;
}
static void
server_ack_err(struct context *ctx, struct conn *conn, struct msg *req)
{
// I want to make sure we do not have swallow here.
//ASSERT_LOG(!req->swallow, "req %d:%d has swallow set??", req->id, req->parent_id);
if ((req->swallow && req->noreply) ||
(req->swallow && (req->consistency == DC_ONE)) ||
(req->swallow && (req->consistency == DC_QUORUM)
&& (!conn->same_dc))) {
log_debug(LOG_INFO, "dyn: close s %d swallow req %"PRIu64" len %"PRIu32
" type %d", conn->sd, req->id, req->mlen, req->type);
req_put(req);
return;
}
struct conn *c_conn = req->owner;
// At other connections, these responses would be swallowed.
ASSERT_LOG((c_conn->type == CONN_CLIENT) ||
(c_conn->type == CONN_DNODE_PEER_CLIENT), "c_conn type %s",
conn_get_type_string(c_conn));
// Create an appropriate response for the request so its propagated up;
// This response gets dropped in rsp_make_error anyways. But since this is
// an error path its ok with the overhead.
struct msg *rsp = msg_get(conn, false, conn->data_store);
if (rsp == NULL) {
log_warn("Could not allocate msg.");
return;
}
req->done = 1;
req->peer = rsp;
rsp->peer = req;
rsp->error = req->error = 1;
rsp->err = req->err = conn->err;
rsp->dyn_error = req->dyn_error = STORAGE_CONNECTION_REFUSE;
rsp->dmsg = NULL;
log_warn("%d:%d <-> %d:%d", req->id, req->parent_id, rsp->id, rsp->parent_id);
log_warn("dyn: close s %d schedule error for req %u:%u "
"len %"PRIu32" type %d from c %d%c %s", conn->sd, req->id, req->parent_id,
req->mlen, req->type, c_conn->sd, conn->err ? ':' : ' ',
conn->err ? strerror(conn->err): " ");
rstatus_t status =
conn_handle_response(c_conn, req->parent_id ? req->parent_id : req->id,
rsp);
IGNORE_RET_VAL(status);
if (req->swallow)
req_put(req);
}
void msg_on_save(savefile_ptr file)
{
int i;
int count = msg_count();
if (compress_savefile && count > 40) count = 40;
savefile_write_u16b(file, count);
for (i = count - 1; i >= 0; i--)
{
msg_ptr m = msg_get(i);
savefile_write_cptr(file, string_buffer(m->msg));
savefile_write_s32b(file, m->turn);
savefile_write_s32b(file, m->count);
savefile_write_byte(file, m->color);
}
}
/*---------------------------------------------------------------------------*/
static void task1 (void)
{
usys stat, src_id, size ;
u8 msg [32] ;
while (1)
{
if ((stat = msg_get (&src_id, &size, msg, 15)) == GOOD)
{
printf ("Task1: Got Msg \"%s\" from taskId %d of size %d\n",
msg, src_id, size) ;
} else {
printf ("ERR: Task 1 sem_get(). Stat %d\n", stat) ;
}
}
} /* End of Function task1() */
void greeting(io *s)
{
size_t sz;
int code;
sz = parse_response_line(s, &code, NULL);
if(sz == -1)
msg_fail("parse_response_line: %s", msg_get());
switch(code) {
case 200:
case 201:
break;
default:
msg_fail("Received unexpected response code %d", code);
}
}
static void
req_forward_all_local_racks(struct context *ctx, struct conn *c_conn,
struct msg *msg, struct mbuf *orig_mbuf,
uint8_t *key, uint32_t keylen, struct datacenter *dc)
{
//log_debug(LOG_DEBUG, "dc name '%.*s'",
// dc->name->len, dc->name->data);
uint8_t rack_cnt = (uint8_t)array_n(&dc->racks);
uint8_t rack_index;
msg->rsp_handler = msg_get_rsp_handler(msg);
init_response_mgr(&msg->rspmgr, msg, msg->is_read, rack_cnt, c_conn);
log_info("msg %d:%d same DC racks:%d expect replies %d",
msg->id, msg->parent_id, rack_cnt, msg->rspmgr.max_responses);
for(rack_index = 0; rack_index < rack_cnt; rack_index++) {
struct rack *rack = array_get(&dc->racks, rack_index);
//log_debug(LOG_DEBUG, "rack name '%.*s'",
// rack->name->len, rack->name->data);
struct msg *rack_msg;
// clone message even for local node
struct server_pool *pool = c_conn->owner;
if (string_compare(rack->name, &pool->rack) == 0 ) {
rack_msg = msg;
} else {
rack_msg = msg_get(c_conn, msg->request, __FUNCTION__);
if (rack_msg == NULL) {
log_debug(LOG_VERB, "whelp, looks like yer screwed "
"now, buddy. no inter-rack messages for "
"you!");
continue;
}
msg_clone(msg, orig_mbuf, rack_msg);
log_info("msg (%d:%d) clone to rack msg (%d:%d)",
msg->id, msg->parent_id, rack_msg->id, rack_msg->parent_id);
rack_msg->swallow = true;
}
if (log_loggable(LOG_DEBUG)) {
log_debug(LOG_DEBUG, "forwarding request to conn '%s' on rack '%.*s'",
dn_unresolve_peer_desc(c_conn->sd), rack->name->len, rack->name->data);
}
log_debug(LOG_VERB, "c_conn: %p forwarding (%d:%d)",
c_conn, rack_msg->id, rack_msg->parent_id);
remote_req_forward(ctx, c_conn, rack_msg, rack, key, keylen);
}
}
static rstatus_t
req_make_reply(struct context *ctx, struct conn *conn, struct msg *req)
{
struct msg *msg;
msg = msg_get(conn, false, conn->redis); /* replay */
if (msg == NULL) {
conn->err = errno;
return NC_ENOMEM;
}
req->peer = msg;
msg->peer = req;
msg->request = 0;
req->done = 1;
conn->enqueue_outq(ctx, conn, req);
return NC_OK;
}
static int wlan_tx_msg_q_free(wlan_vif_t *vif)
{
int q_id, num, i;
msg_q_t *msg_q;
tx_msg_t *msg;
for (q_id = 0; q_id < 2; q_id++) {
msg_q = &(vif->msg_q[q_id]);
num = msg_num(msg_q);
for (i = 0; i < num; i++) {
msg = msg_get(msg_q);
if (NULL == msg)
break;
msg_free(msg_q, msg);
}
msg_q_free(msg_q);
}
tx_fifo_free(&(vif->txfifo));
return OK;
}
