sp<Message> Message::obtain(const sp<Handler>& handler, int32_t what)
{
sp<Message> message = obtain();
message->target = handler;
message->what = what;
return message;
}
sp<Message> Message::obtain(const sp<Handler>& handler, int32_t what, const sp<Object>& obj) {
sp<Message> message = obtain();
message->target = handler;
message->what = what;
message->obj = obj;
return message;
}
static void test(void)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
ctx->tasks[M] = rtems_task_self();
start_task(ctx, A_1, worker, 1);
start_task(ctx, A_2_0, worker, 2);
start_task(ctx, A_2_1, worker, 2);
start_task(ctx, H, helper, 3);
sc = rtems_semaphore_create(
rtems_build_name(' ', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0,
&ctx->mtx
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
obtain(ctx);
request(ctx, A_1, REQ_MTX_OBTAIN);
check_generations(ctx, NONE, NONE);
assert_prio(ctx, M, 1);
release(ctx);
check_generations(ctx, A_1, NONE);
assert_prio(ctx, M, 3);
request(ctx, A_1, REQ_MTX_RELEASE);
check_generations(ctx, A_1, NONE);
obtain(ctx);
request(ctx, A_2_0, REQ_MTX_OBTAIN);
request(ctx, A_1, REQ_MTX_OBTAIN);
request(ctx, A_2_1, REQ_MTX_OBTAIN);
check_generations(ctx, NONE, NONE);
assert_prio(ctx, M, 1);
release(ctx);
check_generations(ctx, A_1, NONE);
assert_prio(ctx, M, 3);
assert_prio(ctx, A_1, 1);
request(ctx, A_1, REQ_MTX_RELEASE);
check_generations(ctx, A_1, A_2_0);
request(ctx, A_2_0, REQ_MTX_RELEASE);
check_generations(ctx, A_2_0, A_2_1);
request(ctx, A_2_1, REQ_MTX_RELEASE);
check_generations(ctx, A_2_1, NONE);
}
sp<Message> Message::obtain(const sp<Handler>& handler,
const sp<Runnable>& callback)
{
sp<Message> message = obtain();
message->target = handler;
message->callback = callback;
return message;
}
sp<Message> Message::obtain(const sp<Handler>& handler, int32_t what, int32_t arg1, int32_t arg2) {
sp<Message> message = obtain();
message->mHandler = handler;
message->what = what;
message->arg1 = arg1;
message->arg2 = arg2;
return message;
}
Mailbox * Mailbox::find( const UString &name, bool deleted )
{
Mailbox * m = obtain( name, false );
if ( !m )
return 0;
if ( m->deleted() && !deleted )
return 0;
return m;
}
bool LuceneLock::obtain(int64_t lockWaitTimeout) {
bool locked = obtain();
if ( lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER ) {
_CLTHROWA(CL_ERR_IllegalArgument,"lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number");
}
int64_t maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
int64_t sleepCount = 0;
while (!locked) {
if ( lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ == maxSleepCount ) {
_CLTHROWA(CL_ERR_IO,"Lock obtain timed out");
}
_LUCENE_SLEEP(LOCK_POLL_INTERVAL);
locked = obtain();
}
return locked;
}
bool player::disassemble()
{
auto loc = game_menus::inv::disassemble( *this );
if( !loc ) {
add_msg( _( "Never mind." ) );
return false;
}
return disassemble( loc.obtain( *this ) );
}
void *start_client (void *data) {
int a;
char key[20];
char *value = calloc(1, 1204);
char *dir = calloc(1, 1204);
while (1) {
printf("*** A simple DHT for you ***\n");
printf("*** Select one operation ***\n");
printf("*** Enter 1 for inserting an entry ***\n");
printf("*** Enter 2 for searching peers ***\n");
printf("*** Enter 3 for obtaining an entry ***\n");
printf("*** Enter 4 to exit ***\n");
scanf("%d", &a);
switch (a) {
case 1:
printf("Enter the file name\n");
scanf("%s", key);
printf("Enter your index [1-8]\n");
scanf("%s", value);
printf("Enter the file directory\n");
scanf("%s", dir);
put (key, value, dir, servers);
break;
case 2:
printf("Enter the file name\n");
scanf("%s", key);
printf("Enter your index [1-8]\n");
scanf("%s", value);
value = get (key, value, servers);
if (value == NULL) {
printf("ULL");
} else {
printf("Extracted value %s\n", value);
}
break;
case 3:
printf("Enter the peer ID\n");
scanf("%s", key);
printf("Enter the file name\n");
scanf("%s", value);
printf("Obtaining file %s from %d", value, atoi(key));
value = obtain(atoi(key), value, servers);
break;
case 4: goto exit;
default: printf("No such option.. Try Again !");
break;
}
}
exit:
printf("*** Exiting ***\n");
return 0;
}
sp<Message> Message::obtain(const Message* message) {
sp<Message> dupMessage = obtain();
dupMessage->what = message->what;
dupMessage->arg1 = message->arg1;
dupMessage->arg2 = message->arg2;
dupMessage->obj = message->obj;
dupMessage->mExecTimestamp = 0;
dupMessage->mHandler = message->mHandler;
dupMessage->mCallback = message->mCallback;
dupMessage->mMetaData = message->mMetaData;
dupMessage->mNextMessage = NULL;
return dupMessage;
}
sp<Message> Message::obtain(const sp<Message>& origMessage) {
sp<Message> message = obtain();
message->what = origMessage->what;
message->arg1 = origMessage->arg1;
message->arg2 = origMessage->arg2;
message->obj = origMessage->obj;
if (origMessage->data != nullptr) {
message->data = new Bundle(origMessage->data);
}
message->target = origMessage->target;
message->callback = origMessage->callback;
return message;
}
FileLock::~FileLock( void )
{
#ifndef WIN32 // let's only do that for non-Windows for now
if (m_delete == 1) {
int deleted = -1;
if (m_state != WRITE_LOCK) {
bool result = obtain(WRITE_LOCK);
if (!result) {
dprintf(D_ALWAYS, "Lock file %s cannot be deleted upon lock file object destruction. \n", m_path);
goto finish;
}
}
// this path is only called for the literal case by preen -- still want to clean up all two levels.
deleted = rec_clean_up(m_path, 2) ;
if (deleted == 0){
dprintf(D_FULLDEBUG, "Lock file %s has been deleted. \n", m_path);
} else{
dprintf(D_FULLDEBUG, "Lock file %s cannot be deleted. \n", m_path);
}
}
finish:
#endif
if( m_state != UN_LOCK ) {
release();
}
m_use_kernel_mutex = -1;
#ifdef WIN32
if (m_debug_win32_mutex) {
::CloseHandle(m_debug_win32_mutex);
m_debug_win32_mutex = NULL;
}
#endif
SetPath(NULL);
SetPath(NULL, true);
if (m_delete == 1) {
close(m_fd);
}
Reset();
}
static void worker(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
task_id id = arg;
while (true) {
rtems_event_set events = wait_for_events();
if ((events & REQ_MTX_OBTAIN) != 0) {
obtain(ctx);
++ctx->generation[id];
}
if ((events & REQ_MTX_RELEASE) != 0) {
release(ctx);
++ctx->generation[id];
}
}
}
/*
* 从目标handler的消息池中获取到一个MSG
* 参数:
* handler - 当前handler
* what - 消息代码
* data - 该消息携带的数据
* data_size - 数据大小
* 返回值:
* 得到信息，返回获取到的 msg 指针
* 失败则返回 NULL
*/
MSG* obtain_message(HANDLER* handler, int what, void* data, int data_size)
{
MSG* msg = NULL;
ENTER_LOG();
if (handler==NULL) {
LEAVE_LOG();
return NULL;
}
msg = obtain(handler);
if (msg)
{
msg->what = what;
if (data_size>0)
{
msg->data = malloc(data_size+2);
if (msg->data) {
memset(msg->data, 0, data_size+2);
memcpy(msg->data, data, data_size);
msg->data_size = data_size;
} else {
upil_error("malloc error: %d", errno);
remove_message(msg);
msg = NULL;
}
}
if (msg)
dump_msg("obtain new message:", msg);
} else {
upil_dbg("no msg cant be obtain.");
}
upil_printf(MSG_MSGDUMP, "now msg count: %d", handler->msg_count);
LEAVE_LOG();
return msg;
}
Mailbox * Mailbox::closestParent( const UString & name )
{
if ( name[0] != '/' )
return 0;
UString n = name;
do {
uint i = n.length() - 1;
if ( !i )
return root();
while ( i > 0 && n[i] != '/' )
i--;
if ( i < 2 )
return root();
n.truncate( i );
Mailbox * m = obtain( n );
if ( m->isHome() )
return m;
if ( !m->deleted() )
return m;
} while ( true );
return 0;
}
bool
FileLock::release(void)
{
return obtain( UN_LOCK );
}
MutexLock(pthread_mutex_t & rmutex) : mutex(&rmutex), locked(false)
{
obtain();
}
sp<Message> Message::obtain(const sp<Handler>& handler)
{
sp<Message> message = obtain();
message->target = handler;
return message;
}
