示例#1
0
void *read_thread(void *_context)
{
    struct read_args *context = (struct read_args*)_context;

    int num_threads = context->num_threads;

    encrypter_context *encrypters = context->encrypters;
    sender_context *sender_info = context->sender_info;

    while (true) {
        for (int i = 0; i < num_threads; i++) {

            log_print(LOG_DEBUG, "Read: preparing enc: %d \n", i);

            safe_wait(&sender_info[i].done, &sender_info[i].done_mutex,
                &sender_info[i].writable);

            encrypters[i].bytes_read = read(context->fd, encrypters[i].plain,
                max_block_size);

            log_print(LOG_DEBUG, "Bytes read: %d\n", encrypters[i].bytes_read);

            encrypters[i].ready_to_encrypt = true;
            pthread_cond_signal(&encrypters[i].encrypt_wait);

            if (encrypters[i].bytes_read <= 0) {

                *(encrypters[i].readable) = true;
                pthread_cond_signal(encrypters[i].send_wait);

                // we are done so lets cleanup
                for (int j = 0; j < num_threads; j++) {
                    if (j == i)
                        continue;

                    safe_wait(&sender_info[j].done, &sender_info[j].done_mutex,
                        &sender_info[j].writable);

                    log_print(LOG_DEBUG,
                        "cleaning up thread %d becuase thrd %d\n",
                        j, i);

                    encrypters[j].bytes_read = 0;
                    encrypters[j].ready_to_encrypt = true;
                    pthread_cond_signal(&encrypters[j].encrypt_wait);
                }
                return NULL;
            }
        }
    }
}
示例#2
0
void *send_thread(void *_context)
{
    struct send_args *context = (struct send_args*)_context;
    sender_context *sender_info = context->sender_info;

    while (true) {

        for (int i = 0; i < context->num_threads; i++) {
            int ss;
            int ssize = 0;

            safe_wait(&sender_info[i].wait, &sender_info[i].wait_mutex,
                &sender_info[i].readable);

            int bytes_read = *sender_info[i].bytes_read;

            log_print(LOG_DEBUG, "got %d bytes in sender \n", bytes_read);

            log_print(LOG_DEBUG, "sender enc %s \n", sender_info[i].outdata);

            if (bytes_read <= 0)
                return NULL;

            while (ssize < bytes_read) {
                if (UDT::ERROR == (ss = UDT::send(*context->udt_socket,
                    sender_info[i].outdata + ssize, bytes_read - ssize, 0)))
                    return NULL;
                ssize += ss;
            }

            sender_info[i].writable = true;
            pthread_cond_signal(&sender_info[i].done);
        }
    }
}
示例#3
0
void *encrypt_thread(void *_context)
{
    struct encrypter_context* context = (struct encrypter_context*)_context;

    while (true) {

        safe_wait(&context->encrypt_wait, &context->mutex,
            &context->ready_to_encrypt);

        if (context->bytes_read <= 0) {
            log_print(LOG_DEBUG, "going to die %d\n", context->plain);
            return NULL;
        }

        log_print(LOG_DEBUG, "encrypter bytes read %d in %d\n",
            context->bytes_read, context->plain);

        //context->crypt->encrypt(context->plain, context->encrypted,
        //    context->bytes_read);
        memcpy(context->encrypted, context->plain, context->bytes_read);

        log_print(LOG_DEBUG, "enc enc %d %s \n", context->encrypted,
            context->encrypted);

        log_print(LOG_DEBUG, "encryption completed in %d for %d\n",
            context->plain, context->encrypted);

        *(context->readable) = true;
        pthread_cond_signal(context->send_wait);
    }
}
示例#4
0
/// Blocks to wait for completion of any subprocess.
///
/// \return The termination status of the child process that terminated.
///
/// \throw process::system_error If the call to wait(2) fails.
process::status
process::wait_any(void)
{
    const process::status status = safe_wait();
    {
        signals::interrupts_inhibiter inhibiter;
        signals::remove_pid_to_kill(status.dead_pid());
    }
    return status;
}
示例#5
0
文件: child.cpp 项目: Bhudipta/minix
/// Blocks to wait for completion.
///
/// \return The termination status of the child process.
///
/// \throw process::system_error If the call to waitpid(2) fails.
process::status
process::child::wait(void)
{
    const process::status status = safe_wait(_pimpl->_pid);
    {
        signals::interrupts_inhibiter inhibiter;
        signals::remove_pid_to_kill(_pimpl->_pid);
    }
    return status;
}
示例#6
0
文件: safe.cpp 项目: Karlan88/xray
OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID/* = kInvalidID*/)
{
    if(pCriticalRegionCriticalRegionID != kInvalidID)
    {
        if(at_mp())
        {
        // enter the critical region's critical region
            OSStatus lStatus = noErr;
            AbsoluteTime sExpiration;
            if(lDuration != kDurationImmediate && lDuration != kDurationForever)
            {
                sExpiration = AddDurationToAbsolute(lDuration, UpTime());
            }
            lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, lDuration);
            assert(lStatus == noErr || lStatus == kMPTimeoutErr);
            if(lStatus == noErr)
            {
            // calculate a new duration
                if(lDuration != kDurationImmediate && lDuration != kDurationForever)
                {
                // check if we have any time left
                    AbsoluteTime sUpTime(UpTime());
                    if(force_cast<uint64_t>(sExpiration) > force_cast<uint64_t>(sUpTime))
                    {
                    // reset our duration to our remaining time
                        lDuration = AbsoluteDeltaToDuration(sExpiration, sUpTime);
                    }
                    else
                    {
                    // no time left
                        lDuration = kDurationImmediate;
                    }
                }
            // if we entered the critical region, exit it again
                lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
                assert(lStatus == noErr);
            }
            else
            {
            // otherwise, give up
                return(lStatus);
            }
        }
        else
        {
        // if we're at system task time, try to enter the critical region's critical
        //    region until we succeed.  MP tasks will block on this until we let it go.
            OSStatus lStatus;
            do
            {
                lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, kDurationImmediate);
            } while(lStatus == kMPTimeoutErr);
            assert(lStatus == noErr);
        }
    }

// try to enter the critical region
    function<OSStatus, Duration> oEnterCriticalRegion;
    oEnterCriticalRegion = bind(MPEnterCriticalRegion, pCriticalRegionID, _1);
    OSStatus lStatus = safe_wait(oEnterCriticalRegion, lDuration);

// if we entered the critical region's critical region to get the critical region,
//    exit the critical region's critical region.
    if(pCriticalRegionCriticalRegionID != kInvalidID && at_mp() == false)
    {
        lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
        assert(lStatus == noErr);
    }
    return(lStatus);
}
示例#7
0
文件: safe.cpp 项目: Karlan88/xray
OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration)
{
    function<OSStatus, Duration> oWaitOnSemaphore;
    oWaitOnSemaphore = bind(MPWaitOnSemaphore, pSemaphoreID, _1);
    return(safe_wait(oWaitOnSemaphore, lDuration));
}
示例#8
0
文件: safe.cpp 项目: Karlan88/xray
OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration)
{
    function<OSStatus, Duration> oWaitOnQueue;
    oWaitOnQueue = bind(MPWaitOnQueue, pQueueID, pParam1, pParam2, pParam3, _1);
    return(safe_wait(oWaitOnQueue, lDuration));
}