SRS之SrsRtmpConn::publishing详解

1. SrsRtmpConn::publishing

int SrsRtmpConn::publishing(SrsSource* source)
{
    int ret = ERROR_SUCCESS;
    
    /* 在配置文件中配置了 refer_publish 配置项才会进行 refer check */
    if ((ret = refer->check(req->pageUrl, _srs_config->get_refer_pubish(req->vhost))) 
        != ERROR_SUCCESS) {
        srs_error("check publish_refer failed. ret=%d", ret);
        return ret;
    }
    srs_verbose("check publish_refer success.");
    
    /* 若配置文件中使能了 http_hooks 配置项，则调用该函数，否则忽略 */
    if ((ret = http_hooks_on_publish()) != ERROR_SUCCESS) {
        srs_error("http hook on_publish failed. ret=%d", ret);
        return ret;
    }
    
    /* 若配置文件中没有配置 mode 配置项，则返回 false */
    bool vhost_is_edge = _srs_config->get_vhost_is_edge(req->vhost);
    if ((ret = acquire_publish(source, vhost_is_edge)) == ERROR_SUCCESS) {
        // use isolate thread to recv,
        // @see: https://github.com/ossrs/srs/issues/237
        SrsPublishRecvThread trd(rtmp, req, 
            st_netfd_fileno(stfd), 0, this, source, 
            client_type != SrsRtmpConnFlashPublish,
            vhost_is_edge);
        
        srs_info("start to publish stream %s success", req->stream.c_str());
        /* 该函数会启动接收推流数据的线程 recv，然后当前线程会循环进入休眠，并在醒来
         * 后更新状态信息 */
        ret = do_publishing(source, &trd);
        
        // stop isolate recv thread
        trd.stop();
    }
    
    if (ret != ERROR_SYSTEM_STREAM_BUSY) {
        release_publish(source, vhost_is_edge);
    }
    
    /* whatever the acquire publish, always release publish.
     * when the acquire error in the middle-way, the publish state changed,
     * but failed, so we must cleanup it.
     * @see https://github.com/ossrs/srs/issues/474: srs_librtmp推送后返回错误码1009
     * @remark when stream is busy, should never release it. */
    http_hooks_on_unpublish();
    
    return ret;
}

2. SrsRtmpConn::acquire_publish

int SrsRtmpConn::acquire_publish(SrsSource* source, bool is_edge)
{
    int ret = ERROR_SUCCESS;
    
    /* 检测是否可以进行 publish */
    if (!source->can_publish(is_edge)) {
        ret = ERROR_SYSTEM_STREAM_BUSY;
        srs_warn("stream %s is already publishing. ret=%d", 
            req->get_stream_url().c_str(), ret);
        return ret;
    }
    
    // when edge, ignore the publish event, directly proxy it.
    if (is_edge) {
        if ((ret = source->on_edge_start_publish()) != ERROR_SUCCESS) {
            srs_error("notice edge start publish stream failed. ret=%d", ret);
            return ret;
        }
    } else {
        /* 通知可以进行 publish */
        if ((ret = source->on_publish()) != ERROR_SUCCESS) {
            srs_error("notify publish failed. ret=%d", ret);
            return ret;
        }
    }
    
    return ret;
}

2.1 SrsSource::can_publish

bool SrsSource::can_publish(bool is_edge)
{
    /* 当为 edge 时，检测当前 edge 的状态，只要不为 SrsEdgeStatePublish，即可进行 publish */
    if (is_edge) {
        return publish_edge->can_publish();
    }
    
    /* 默认初始化时为 true */
    return _can_publish;
}

2.2 SrsSource::on_publish

/**
 * publish stream event notify.
 * @param _req the request from client, the source will deep copy it,
 *        for when reload the request of client maybe invalid.
 */
int SrsSource::on_publish()
{
    int ret = ERROR_SUCCESS;
    
    // update the request object.
    srs_assert(_req);
    
    /* 若当前线程上下文的id与_source_id不一致，表明id改变了，需要更新_source_id，
     * 并通知所有的 consumers */
    /* whatever, the publish thread is the source or edge source, 
     * save its id to source id */
    on_source_id_changed(_srs_context->get_id);
    
    /* the mix queue to correct the timestamp for mix_correct algorithm */
    /* reset the mix queue. */
    mix_queue->clear();
    
    /* detect the monotonically again. */
    is_monotonically_increase = true;
    last_packet_time = 0;
    
    /* create forwarders： 需要配置文件中配置 forward 配置项，否则忽略该函数 */
    if ((ret = create_forwarders()) != ERROR_SUCCESS) {
        srs_error("create forwarders failed. ret=%d", ret);
        return ret;
    }
    
    // TODO: FIXME: use initialize to set req.
#ifdef SRS_AUTO_TRANSCODE
    if ((ret = encoder->on_publish(_req)) != ERROR_SUCCESS) {
        srs_error("start encoder failed. ret=%d", ret);
        return ret;
    }
#endif

    // TODO: FIXME: use initialize to set req.
#ifdef SRS_AUTO_HLS
    if ((ret = hls->on_publish(_req, false)) != ERROR_SUCCESS) {
        srs_error("start hls failed. ret=%d", ret);
        return ret;
    }
#endif
    
    // TODO: FIXME: use initialize to set req.
#ifdef SRS_AUTO_DVR
    if ((ret = dvr->on_publish(_req)) != ERROR_SUCCESS) {
        srs_error("start dvr failed. ret=%d", ret);
        return ret;
    }
#endif

#ifdef SRS_AUTO_HDS
    if ((ret = hds->on_publish(_req)) != ERROR_SUCCESS) {
        srs_error("start hds failed. ret=%d", ret);
        return ret;
    }
#endif

    // notify the handler.
    srs_assert(handler);
    /* handler 指向子类 SrsServer，因此调用子类实现的 on_publish */
    if ((ret = handler->on_publish(this, _req)) != ERROR_SUCCESS) {
        srs_error("handle on publish failed. ret=%d", ret);
        return ret;
    }
    /* 更新 stat 中的值 */
    SrsStatistic* stat = SrsStatistic::instance();
    stat->on_stream_publish(_req, _source_id);
    
    return ret;
}

2.2.1 SrsSource::on_source_id_changed

/**
 * source id changed
 * @id: 当前线程的 id
 */
int SrsSource::on_source_id_changed(int id)
{
    int ret = ERROR_SUCCESS;
    
    if (_source_id == id) {
        return ret;
    }
    
    if (_pre_source_id == -1) {
        _pre_source_id = id;
    } else if (_pre_source_id != _source_id) {
        _pre_source_id = _source_id;
    }
    
    /* source id, 
     * for publish, it's the publish client id.
     * for edge, it's the edge ingest id.
     * when source id changed, for example, the edge reconnect,
     * invoke the on_source_id_changed() to let all clients know.
     */
    _source_id = id;
    
    /* SrsConsumer: the consumer for SrsSource, that is a play client. */
    /* notice all consumer */
    std::vector<SrsConsumer*>::iterator it;
    for (it = consumers.begin(); it != consumers.end(); ++it) {
        SrsConsumer* consumer = *it;
        consumer->update_source_id();
    }
    
    retrn ret;
}

2.2.2 SrsServer::on_publish

int SrsServer::on_publish(SrsSource* s, SrsRequest* r)
{
    int ret = ERROR_SUCCESS;
    
    /* 暂时忽略，没有启用 */
#ifdef SRS_AUTO_HTTP_SERVER
    if ((ret = http_server->http_mount(s, r)) != ERROR_SUCCESS) {
        return ret;
    }
#endif

    return ret;
}

3. SrsPublishRecvThread 构造

/**
 * the publish recv thread got message and callback the souorce method 
 * to process message.
 */
SrsPublishRecvThread::SrsPublishRecvThread(
    SrsRtmpServer* rtmp_sdk, 
    SrsRequest* _req, int mr_sock_fd, int timeout_ms, 
    SrsRtmpConn* conn, SrsSource* source, bool is_fmle, bool is_edge
): trd(this, rtmp_sdk, timeout_ms)
{
    rtmp = rtmp_sdk;
    
    _conn = conn;
    /* the params for conn callback. */
    _source = source;
    _is_fmle = is_fmle;
    _is_edge = is_edge;
    
    /* the recv thread error code. */
    recv_error_code = ERROR_SUCCESS;
    /* the msgs already got. */
    _nb_msgs = 0;
    /* The video frames we got. */
    video_frames = 0;
    /* the error timeout cond
     * @see https://github.com/ossrs/srs/issues/244 */
    error = st_cond_new();
    /* merged context id. */
    ncid = cid = 0;
    
    req = _req;
    mr_fd = mr_sock_fd;
    
    // the mr settings,
    // @see https://github.com/ossrs/srs/issues/241
    mr = _srs_config->get_mr_enabled(req->vhost);
    mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);
    
    realtime = _srs_config->get_realtime_enabled(req->vhost);
    
    /* for reload handler to register itself,
     * when config service do the reload, callback the handler. */
    _srs_config->subscribe(this);
}

该 SrsPublishRecvThread 类中同时有一个 SrsRecvThread 类的成员 trd，因此会同时构造 SrsRecvThread 类。

3.1 SrsRecvThread 构造函数

/**
 * the recv thread, use message handler to handle each received message.
 */
SrsRecvThread::SrsRecvThread(ISrsMessageHandler* msg_handler, 
    SrsRtmpServer* rtmp_sdk, int timeout_ms)
{
    
    timeout = timeout_ms;
    /* handler 指向子类 SrsPublishRecvThread 的指针对象 */
    handler = msg_handler;
    rtmp = rtmp_sdk;
    /* 构造一个可重复使用的线程：recv */
    trd = new SrsReusableThread2("recv", this);
}

3.2 SrsReusableThread2 构造函数

SrsReusableThread2::SrsReusableThread2(const char* n, ISrsReusableThread2Handler* h, 
    int64_t interval_us)
{
    /* 指向子类 SrsRecvThread 的指针对象 */
    handler = h;
    /* 构造一个 SrsThread 类，该类代表一个线程 */
    pthread = new internal::SrsThread(n, this, interval_us, true);
}

4. SrsRtmpConn::do_publishing

int SrsRtmpConn::do_publishing(SrsSource* source, SrsPublishRecvThread* trd)
{
    int ret = ERROR_SUCCESS;
    
    /**
     * SrsPithyPrint:
     * the stage is used for a collection of object to do print,
     * the print time in a stage is constant and not changed,
     * that is, we always got one message to print every specified time.
     *
     * for example, stage #1 for all play clients, print time is 3s,
     * if there is 1client, it will print every 3s.
     * if there is 10clients, random select one to print every 3s.
     * Usage:
     *     SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_play();
     *     SrsAutoFree(SrsPithyPrint, pprint);
     *     while (true) {
     *         pprint->elapse();
     *         if (pprint->can_print()) {
     *             // print pithy message.
     *             // user can get the elapse time by: pprint->age()
     *         }
     *         // read and write RTMP messages.
     *     }
     */
    SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_publish();
    SrsAutoFree(SrsPithyPrint, pprint);
    
    /* 构建并启动一个专门用于接收客户端推流数据的 recv 线程 */
    // start isolate recv thread.
    if ((ret = trd->start()) != ERROR_SUCCESS) {
        srs_error("start isolate recv thread failed. ret=%d", ret);
        return ret;
    }
    
    // change the isolate recv thread context id,
    // merge its log to current thread.
    int receive_thread_cid = trd->get_cid();
    trd->set_cid(_srs_context->get_cid());
    
    // initialize the publish timeout.
    /* 若没有配置 publish_1stpkt_timeout，则当没有收到消息时使用默认超时时间 20000ms */
    publish_1stpkt_timeout = _srs_config->get_publish_1stpkt_timeout(req->vhost);
    /* 若没有配置 publish_normal_timeout，则当已经收到过消息时使用默认超时时间 5000ms */
    publish_normal_timeout = _srs_config->get_publish_normal_timeout(req->vhost);
    
    // set the sock options.
    set_sock_options();
    
    if (true) {
        /* vhost{} 中是否启用了 mr 功能，否返回 false */
        bool mr = _srs_config->get_mr_enabled(req->vhost);
        int mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);
        srs_trace("start publish mr=%d/%d, p1stpt=%d, pnt=%d, tcp_nodelay=%d, rtcid=%d",
                  mr, mr_sleep, publish_1stpkt_timeout, publish_normal_timeout, 
                  tcp_nodelay, receive_thread_cid);
    }
    
    int64_t nb_msgd = 0;
    uint64_t nb_frames = 0;
    while (!disposed) {
        /* 自动计算经过的时间 */
        pprint->elapse();
        
        // when source is set to expired, disconnect it.
        if (expired) {
            ret = ERROR_USER_DISCONNECT;
            srs_error("connection expired. ret=%d", ret);
            return ret;
        }
        
        // cond wait for timeout.
        if (nb_msgs == 0) {
            // when not got msgs, wait for a larger timeout.
            // @see https://github.com/ossrs/srs/issues/441
            trd->wait(publish_1stpkt_timeout);
        } else {
            trd->wait(publish_normal_timeout);
        }
        
        // check the thread error code.
        if ((ret = trd->error_code()) != ERROR_SUCCESS) {
            if (!srs_is_system_control_error(ret) && !srs_is_client_gracefully_close(ret)) 
            {
                srs_error("recv thread failed. ret=%d", ret);
            }
            return ret;
        }
        
        // when not got any messages, timeout.
        if (trd->nb_msgs() <= nb_msgs) {
            ret = ERROR_SOCKET_TIMEOUT;
            srs_warn("publish timeout %dms, nb_msgs=%"PRId64", ret=%d",
                nb_msgs? publish_normal_timeout : publish_1stpkt_timeout, nb_msgs, ret);
            break;
        }
        nb_msgs = trd->nb_msgs();
        
        // Update the stat for video fps.
        // @remark https://github.com/ossrs/srs/issues/851
        SrsStatistic* stat = SrsStatistic::instance();
        if ((ret = stat->on_video_frames(req, (int)(trd->nb_video_frames() - nb_frames))) 
            != ERROR_SUCCESS) {
            return ret;
        }
        nb_frames = trd->nb_video_frames();
        
        // reportable
        if (pprint->can_print()) {
            kbps->sample();
            bool mr = _srs_config->get_mr_enabled(req->vhost);
            int mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);
            srs_trace("<- "SRS_CONSTS_LOG_CLIENT_PUBLISH
                " time=%"PRId64", okbps=%d,%d,%d, ikbps=%d,%d,%d, "
                "mr=%d/%d, p1stpt=%d, pnt=%d", 
                pprint->age(),
                kbps->get_send_kbps(), kbps->get_send_kbps_30s(), kbps->get_send_kbps_5m(),
                kbps->get_recv_kbps(), kbps->get_recv_kbps_30s(), kbps->get_recv_kbps_5m(),
                mr, mr_sleep, publish_1stpkt_timeout, publish_normal_timeout
            );
        }
    }
    
    return ret;
}

4.1 SrsPithyPrint::create_rtmp_publish

为 rtmp publish 构造一个 SrsPithyPrint 类。

SrsPithyPrint* SrsPithyPrint::create_rtmp_publish()
{
    return new SrsPithyPrint(SRS_CONSTS_STAGE_PUBLISH_USER);
}

4.1.1 SrsPithyPrint 构造函数

SrsPithyPrint::SrsPithyPrint(int _stage_id)
{
    stage_id = _stage_id;
    client_id = enter_stage();
    previous_tick = srs_get_system_time_ms();
    _age = 0;
}

4.1.2 SrsPithyPrint::enter_stage

int SrsPithyPrint::enter_stage()
{
    SrsStageInfo* stage = NULL;
    
    std::map<int, SrsStageInfo*>::iterator it = _srs_stages.find(stage_id);
    if (it == _srs_stages.end()) {
        stage = new SrsStageInfo(stage_id);
        _srs_stages[stage_id] = stage;
    } else {
        stage = it->second;
    }
    
    srs_assert(stage != NULL);
    client_id = stage->nb_clients++;
    
    srs_verbose("enter stage, stage_id=%d, client_id=%d, nb_clients=%d, time_ms=%d",
        stage->stage_id, client_id, stage->nb_clients, stage->pithy_print_time_ms);
        
    return client_id;
}

4.2 SrsPublishRecvThread::start: 启动线程

int SrsPublishRecvThread::start()
{
    /* 调用 SrsRecvThread::start()  */
    int ret = trd.start();
    ncid = cid = trd.cid();
    return ret;
}

4.2.1 SrsRecvThread::start

int SrsRecvThread::start()
{
    /* 接着调用 SrsReusableThread2::start() */
    return trd->start();
}

4.2.2 SrsReusableThread2::start

/* for the reusable thread, start and stop by user. */
int SrsReusableThread2::start()
{
    /* 调用 SrsThread::start() */
    return pthread->start();
}

4.2.3 SrsThread::start

int SrsThread::start()
{
    int ret = ERROR_SUCCESS;
    
    if (tid) {
        srs_info("thread %s already running.", _name);
        return ret;
    }
    
    if ((tid = st_thread_create(thread_fun, this, (joinable? 1:0), 0)) == NULL) {
        ret = ERROR_ST_CREATE_CYCLE_THREAD;
        srs_error("st_thread_create failed. ret=%d", ret);
        return ret;
    }
    
    disposed = false;
    // we set to loop to true for thread to run.
    loop = true;
    
    // wait for cid to ready, for parent thread to get the cid.
    while (_cid < 0) {
        st_usleep(10 * 1000);
    }
    
    // now, cycle thread can run.
    can_run = true;
    
    return ret;
}

以上 Thread 类之间的关系图

4.3 SrsRtmpConn::set_sock_options

void SrsRtmpConn::set_sock_options()
{
    /* 若配置文件中的 vhost{} 没有配置 tcp_nodelay 配置项，默认返回 false */
    bool nvalue = _srs_config->get_tcp_nodelay(req->vhost);
    if (nvalue != tcp_nodelay) {
        tcp_nodelay = nvalue;
#ifdef SRS_PERF_TCP_NODELAY
        int fd = st_netfd_fileno(stfd);
        
        socklen_t nb_v = sizeof(int);
        
        int ov = 0;
        getsocket(fd, IPPROTO_TCP, TCP_NODELAY, &ov, &nb_v);
        
        int v = tcp_nodelay;
        // set the socket send buffer when required larger buffer
        if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &v, nb_v) < 0) {
            srs_warn("set sock TCP_NODELAY=%d failed.", v);
        }
        getsocket(fd, IPPROTO_TCP, TCP_NODELAY, &v, &nb_v);
        
        srs_trace("set TCP_NODELAY %d=>%d", ov, v);
#else
        srs_warn("SRS_PERF_TCP_NODELAY is disabled but tcp_nodelay configed.");
#endif
    }
}

4.4 SrsPithyPrint::elapse

/* auto calc the elapse time */
void SrsPithyPrint::elapse()
{
    SrsStageInfo* stage = _srs_stages[stage_id];
    srs_assert(stage != NULL);
    
    int64_t diff = srs_get_system_time_ms() - previous_tick;
    diff = srs_max(0, diff);
    
    stage->elapse(diff);
    _age += diff;
    previous_tick = srs_get_system_time_ms();
}

void SrsStageInfo::elapse(int64_t diff)
{
    age += diff;
}

4.5 SrsPublishRecvThread::wait

int SrsPublishRecvThread::wait(int timeout_ms)
{
    /* 若已经发生错误，则直接返回错误码 */
    if (recv_error_code != ERROR_SUCCESS) {
        return recv_error_code;
    }
    
    // ignore any return of cond wait.
    st_cond_timedwait(error, timeout_ms * 1000);
    
    return ERROR_SUCCESS;
}

4.5.1 st_cond_timedwait

int st_cond_timedwait(_st_cond_t* cvar, st_utime_t timeout)
{
    _st_thread_t *me = _ST_CURRENT_THREAD();
    int rv;
    
    if (me->flags & _ST_FL_INTERRUPT) {
        me->flags &= ~_ST_FL_INTERRUPT;
        errno = EINTR;
        return -1;
    }
    
    /* Put caller thread on the condition variable's wait queue */
    me->state = _ST_ST_COND_WAIT;
    ST_APPEND_LINK(&me->wait_links, &cvar->wait_q);
    
    /* 当超时时间不为 -1 时，将当前线程添加到 sleep 队列中 */
    if (timeout != ST_UTIME_NO_TIMEOUT) 
        _ST_ADD_SLEEPQ(me, timeout);
    
    /* 然后切换上下文环境，直到被条件变量唤醒或是超时事件到了而醒来 */
    _ST_SWITCH_CONTEXT(me);
    
    ST_REMOVE_LINK(&me->wait_links);
    rv = 0;
    
    if (me->flags & _ST_FL_TIMEDOUT) {
        me->flags &= ~_ST_FL_TIMEDOUT;
        errno = ETIME;
        rv = -1;
    }
    if (me->flags & _ST_FL_INTERRUPT) {
        me->flags &= ~_ST_FL_INTERRUPT;
        errno = EINTR;
        rv = -1;
    }
    
    return rv;
}

4.5.2 ST_APPEND_LINK

/* Insert an element "_e" at the end of the list "_l" */
#define ST_APPEND_LINK(_e, _l) ST_INSERT_BEFORE(_e, _l)

/* Insert element "_e" into the list, before "_l" */
#define ST_INSERT_BEFORE(_e, _l) 
    ST_BEGIN_MACRO  
    (_e)->next = (_l); 
    (_e)->prev = (_l)->prev; 
    (-l)->prev->next = (_e); 
    (-l)->prev = (_e); 
    ST_END_MACRO

4.6 SrsStatistic::on_video_frames

/* When got videos, update the frames.
 * We only stat the total number of video frames. */
int SrsStatistic::on_video_frames(SrsRequest* req, int nb_frames)
{
    int ret = ERROR_SUCCESS;
    
    SrsStatisticVhost* vhost = create_vhost(req);
    SrsStatisticStream* stream = create_stream(vhost, req);
    
    stream->nb_frames += nb_frames;
    
    return ret;
}

5. SrsPublishRecvThread::stop

当从 do_publishing 函数返回时，终止接收推流数据的 recv 线程。

void SrsPublishRecvThread::stop()
{
    trd.stop();
}

5.1 SrsRecvThread::stop

void SrsRecvThread::stop()
{
    trd->stop();
}

5.2 SrsReusableThread2::stop

void SrsReusableThread2::stop()
{
    pthread->stop();
}

5.3 SrsThread::stop

void SrsThread::stop()
{
    if (!tid) {
        return;
    }
    
    /* 设置线程循环标志，退出循环 */
    loop = false;
    
    dispose();
    
    _cid = -1;
    can_run = false;
    tid = NULL; 
}

5.4 SrsThread::dispose

void SrsThread::dispose()
{
    if (disposed) {
        return;
    }
    
    // the interrupt will cause the socket to read/write error,
    // which will terminate the cycle thread.
    st_thread_interrupt(tid);
    
    // when joinable, wait util quit.
    if (_joinable) {
        // wait the thread to exit.
        int ret = st_thread_join(tid, NULL);
        if (ret) {
            srs_warn("core: ignore join thread failed.");
        }
    }
    
    // wait the thread actually terminated.
    // sometimes the thread join return -1, for example,
    // when thread use st_recvfrom, the thread join return -1.
    // so here, we use a variable to ensure the thread stopped.
    // @remark event the thread not joinable, we must ensure the thread stopped when stop.
    while (!really_terminated) {
        st_usleep(10 * 1000);
        
        if (really_terminated) {
            break;
        }
        srs_warn("core: wait thread to actually terminated");
    }
    
    disposed = true;
}

5.4.1 st_thread_interrupt

void st_thread_interrupt(_st_thread_t *thread)
{
    /* If thread is already dead */
    if (thread->state == _ST_ST_ZOMEBIE) 
        return;
    
    /* 设置线程标志为 interrupt */
    thread->flags |= _ST_FL_INTERRUPT;
    
    /* 若线程当前正在运行或已在 run 队列中，则直接返回，在线程函数会检测
     * 线程的 flags，若发现是 interrput，则会终止线程函数的执行 */
    if (thread->state == _ST_ST_RUNNING || thread->state == _ST_ST_RUNNABLE) 
        return;
    
    /* 否则，若线程当前处于 sleep 队列中，即休眠状态，则将该线程从
     * 休眠队列中移除 */
    if (thread->flags & _ST_FL_ON_SLEEPQ) 
        _ST_DEL_SLEEPQ(thread);
    
    /* Make thread runnable */
    thread->state = _ST_ST_RUNNABLE;
    _ST_ADD_RUNQ(thread);
}

5.4.2 st_thread_join

int st_thread_join(_st_thread_t *thread, void **retvalp)
{
    _st_cond_t *term = thread_term;
    
    /* Can't join a non-joinable thread */
    if (term == NULL) {
        errno = EINVAL;
        return -1;
    }
    if (_ST_CURRENT_THREAD() == thread) {
        errno = EDEADLK;
        return -1;
    }
    
    /* Multiple threads can't wait on the same joinable thread */
    if (term->wait_q.next != &term->wait_q) {
        errno = EINVAL;
        return -1;
    }
    
    while (thread->state != _ST_ST_ZOMBIE) {
        if (st_cond_timedwait(term, ST_UTIME_NO_TIMEOUT) != 0) 
            return -1;
    }
    
    if (retvalp) 
        *retvalp = thread->retval;
        
    /*
     * Remove target thread from the zombie queue and make it runnable.
     * When it gets scheduled later, it will do the clean up.
     */
    thread->state = _ST_ST_RUNNABLE;
    _ST_DEL_ZOMBIEQ(thread);
    _ST_ADD_RUNQ(thread);
    
    return 0;
}