static xmlrpc_value * start_flows(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
int start_timestamp;
struct _request_start_flows *request = 0;
DEBUG_MSG(LOG_WARNING, "Method start_flows called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array, "({s:i,*})",
/* general settings */
"start_timestamp", &start_timestamp);
if (env->fault_occurred)
goto cleanup;
request = malloc(sizeof(struct _request_start_flows));
request->start_timestamp = start_timestamp;
rc = dispatch_request((struct _request*)request, REQUEST_START_FLOWS);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "i", 0);
cleanup:
if (request)
free_all(request->r.error, request);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method start_flows failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method start_flows successful");
}
return ret;
}
static xmlrpc_value * method_stop_flow(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
int flow_id;
struct _request_stop_flow *request = 0;
DEBUG_MSG(LOG_WARNING, "Method stop_flow called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array, "({s:i,*})",
/* flow id */
"flow_id", &flow_id);
if (env->fault_occurred)
goto cleanup;
request = malloc(sizeof(struct _request_stop_flow));
request->flow_id = flow_id;
rc = dispatch_request((struct _request*)request, REQUEST_STOP_FLOW);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "()");
cleanup:
if (request)
free_all(request->r.error, request);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method stop_flow failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method stop_flow successful");
}
return ret;
}
/*
* Reselect task to execute
* Set 'schedtsk' to the head task at the ready queue.
*/
Inline void reschedule( void )
{
TCB *toptsk;
toptsk = ready_queue_top(&ready_queue);
if ( schedtsk != toptsk ) {
/*
* When the state becomes RUN to READY,
* execute the time slice scheduling.
*/
if ( schedtsk == ctxtsk ) {
time_slice_schedule(schedtsk);
}
schedtsk = toptsk;
dispatch_request();
}
}
ER
imact_tsk(ID tskid, ID prcid)
{
TCB *p_tcb;
ER ercd;
PCB *t_p_pcb;
PCB *f_p_pcb;
LOG_IMACT_TSK_ENTER(tskid, prcid);
CHECK_INTCTX_UNL();
CHECK_TSKID(tskid);
CHECK_PRCID_INI(prcid);
p_tcb = get_tcb(tskid);
prcid = (prcid == TPRC_INI)? p_tcb->p_tinib->iaffinity : prcid;
CHECK_MIG(p_tcb->p_tinib->affinity_mask, prcid);
i_lock_cpu();
/* 現在割り付けられているプロセッサと移動先のプロセッサのタスクロックを取得 */
i_acquire_dual_tsk_lock(p_tcb, prcid, &f_p_pcb, &t_p_pcb);
if (TSTAT_DORMANT(p_tcb->tstat)) {
LOG_TSKMIG(p_tcb, f_p_pcb->prcid, prcid);
p_tcb->p_pcb = t_p_pcb;
if (make_active(p_tcb)) {
if (dispatch_request(t_p_pcb)) {
t_p_pcb->reqflg = true;
}
}
ercd = E_OK;
}
else if (!(p_tcb->actque)) {
p_tcb->actque = true;
p_tcb->actprc = prcid;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
release_dual_tsk_lock(f_p_pcb, t_p_pcb);
i_unlock_cpu();
error_exit:
LOG_IMACT_TSK_LEAVE(ercd);
return(ercd);
}
/* This method returns the number of flows and if actual test has started */
static xmlrpc_value * method_get_status(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(param_array);
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
struct _request_get_status *request = 0;
DEBUG_MSG(LOG_WARNING, "Method get_status called");
request = malloc(sizeof(struct _request_get_status));
rc = dispatch_request((struct _request*)request, REQUEST_GET_STATUS);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "{s:i,s:i}",
"started", request->started,
"num_flows", request->num_flows);
cleanup:
if (request) {
free(request->r.error);
free(request);
}
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method get_status failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method get_status successful");
}
return ret;
}
int main() {
// load routes
routes_init();
int sockfd, newsockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
hyfy_error("ERROR opening socket");
int portno = 8080;
struct sockaddr_in serv_addr, cli_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
hyfy_error("ERROR on binding");
printf("hyfy now online on port 8080 \n");
listen(sockfd,5);
socklen_t clilen;
clilen = sizeof(cli_addr);
while(1) {
newsockfd = accept(sockfd,(struct sockaddr *) &cli_addr,&clilen);
if (newsockfd < 0)
hyfy_error("ERROR on accept");
// handle new connection
dispatch_request(newsockfd);
}
close(sockfd);
return 0;
}
void dispatch(Router *r)
{
Message m = { { 0 } };
const static int CIRCULARITY_THRESHOLD=50;
static int circularity_count=0;
if(CIRCULARITY_THRESHOLD == ++circularity_count)
{
fprintf(stderr,"ERROR: CIRCULARITY_THRESHOLD reached. Message neglected.\n");
mqueue_pophead(&r->mqueue,&m);
circularity_count--;
return;
}
while (!mqueue_empty(&r->mqueue))
{
if (1 == mqueue_pophead(&r->mqueue,&m))
{
fprintf(stderr,"ERROR: message_router.c:dispatch\n");
return;
}
switch (m.type)
{
case NOTIFICATION:
dispatch_notification(r, &m);
break;
case REQUEST:
dispatch_request(r, &m);
break;
case REPLY:
dispatch_reply(r, &m);
break;
}
if (SYNC_MODE == m.mode)
*m.sync_message_status=PROCESSED;
(*m.mdfptr)(&m); // destroy the CONTENTS of the message.
}
circularity_count--;
}
ER
act_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
bool_t dspreq = false;
PCB *p_pcb;
LOG_ACT_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
t_lock_cpu();
p_tcb = get_tcb_self(tskid, get_my_p_pcb());
p_pcb = t_acquire_tsk_lock(p_tcb);
if (TSTAT_DORMANT(p_tcb->tstat)) {
if (make_active(p_tcb)) {
dspreq = dispatch_request(p_pcb);
}
ercd = E_OK;
}
else if (!(p_tcb->actque)) {
p_tcb->actque = true;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
release_tsk_lock(p_pcb);
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_ACT_TSK_LEAVE(ercd);
return(ercd);
}
ER
iact_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
PCB *p_pcb;
LOG_IACT_TSK_ENTER(tskid);
CHECK_INTCTX_UNL();
CHECK_TSKID(tskid);
p_tcb = get_tcb(tskid);
i_lock_cpu();
p_pcb = i_acquire_tsk_lock(p_tcb);
if (TSTAT_DORMANT(p_tcb->tstat)) {
if (make_active(p_tcb)) {
if (dispatch_request(p_pcb)) {
p_pcb->reqflg = true;
}
}
ercd = E_OK;
}
else if (!(p_tcb->actque)) {
p_tcb->actque = true;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
release_tsk_lock(p_pcb);
i_unlock_cpu();
error_exit:
LOG_IACT_TSK_LEAVE(ercd);
return(ercd);
}
ER
chg_pri(ID tskid, PRI tskpri)
{
TCB *p_tcb;
uint_t newpri;
ER ercd;
bool_t dspreq = false;
PCB *p_pcb;
LOG_CHG_PRI_ENTER(tskid, tskpri);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
CHECK_TPRI_INI(tskpri);
t_lock_cpu();
p_tcb = get_tcb_self(tskid, get_my_p_pcb());
newpri = (tskpri == TPRI_INI) ? p_tcb->p_tinib->ipriority
: INT_PRIORITY(tskpri);
p_pcb = t_acquire_tsk_lock(p_tcb);
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else {
#if TTYPE_KLOCK == G_KLOCK
if (change_priority(p_tcb, newpri)) {
dspreq = dispatch_request(p_pcb);
}
#else /* TTYPE_KLOCK != G_KLOCK */
if (!(TSTAT_WAITING(p_tcb->tstat) && TSTAT_WAIT_WOBJ(p_tcb->tstat))) {
/* オブジェクト待ち以外の状態の場合 */
if (change_priority(p_tcb, newpri)) {
dspreq = dispatch_request(p_pcb);
}
}
else {
/*
* オブジェクト待ちの場合
* デッドロック回避のため，ロックを取得し直す
*/
WOBJCB *p_wobjcb = p_tcb->p_wobjcb;
p_tcb->pend_chgpri = true;
p_tcb->pend_newpri = newpri;
release_tsk_lock(p_pcb);
/*
* あらためて
* オブジェクトロック -> タスクロック
* の順でロックを取得
*/
TEST_G_LABEL("_test_chg_pri");
retry:
t_acquire_obj_lock(&GET_OBJLOCK(p_wobjcb));
if ((p_pcb = t_acquire_nested_tsk_lock(p_tcb, &GET_OBJLOCK(p_wobjcb))) == NULL){
goto retry;
}
/* タスクの状態が変化していないかチェック */
if (!(p_tcb->pend_chgpri)) {
/* 既に他の箇所で優先度変更処理がなされた */
release_nested_tsk_lock(p_pcb);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
t_unlock_cpu();
ercd = E_OK;
goto error_exit;
}
p_tcb->priority = p_tcb->pend_newpri;
p_tcb->pend_chgpri = false;
change_priority(p_tcb, newpri);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
}
#endif /* TTYPE_KLOCK != G_KLOCK */
ercd = E_OK;
}
release_tsk_lock(p_pcb);
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_CHG_PRI_LEAVE(ercd);
return(ercd);
}
ER
ter_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd = E_OK;
bool_t dspreq = false;
PCB *f_p_pcb;
PCB *t_p_pcb;
PCB *my_p_pcb;
PCB *p_pcb;
LOG_TER_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID(tskid);
p_tcb = get_tcb(tskid);
t_lock_cpu();
retry:
p_pcb = t_acquire_tsk_lock(p_tcb);
my_p_pcb = get_my_p_pcb();
/* 自タスクを指定するとエラー */
if ((p_tcb) == my_p_pcb->p_runtsk) {
ercd = E_ILUSE;
release_tsk_lock(p_pcb);
}
/* 異なるプロセッサに割り付けられているタスクならエラーとする */
else if (p_pcb != my_p_pcb) {
ercd = E_OBJ;
release_tsk_lock(p_pcb);
}
else if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
release_tsk_lock(p_pcb);
}
else {
if (!(TSTAT_WAITING(p_tcb->tstat) && TSTAT_WAIT_WOBJ(p_tcb->tstat))) {
/* オブジェクト待ち以外の状態の場合 */
if ((p_tcb->actprc == TPRC_NONE) || (p_tcb->actprc == p_pcb->prcid)) {
/* 再起動時のマイグレーションなし */
if (TSTAT_RUNNABLE(p_tcb->tstat)) {
/*
* 対象タスクが他プロセッサ上のタスクかつRUNNABLEの場合，
* RUN状態の可能性があるため，ディスパッチ要求を出す必要があるが，
* 本システムコールは同じプロセッサに割り付けられているタスクのみ
* に発行可能であるので，ディスパッチ要求を出す必要はない．
*/
(void)make_non_runnable(p_tcb);
}
else if (TSTAT_WAITING(p_tcb->tstat)) {
/* オブジェクト待ち以外の待ち状態の場合 */
wait_dequeue_tmevtb(p_tcb);
}
make_dormant(p_tcb);
if (p_tcb->actque) {
p_tcb->actque = false;
p_tcb->actprc = TPRC_NONE;
if (make_active(p_tcb)) {
dspreq = dispatch_request(p_pcb);
}
}
release_tsk_lock(p_pcb);
if (dspreq) {
dispatch();
}
}
else {
/* 起動要求キューイングあり & 他プロセッサにマイグレーションあり */
/* 移動先のプロセッサのPCBを取得 */
t_p_pcb = get_mp_p_pcb(p_tcb->actprc);
/* 一旦タスクロックを離す */
release_tsk_lock(p_pcb);
/*
* 現在割り付けられているプロセッサと移動先のプロセッサのタスク
* ロックを取得
*/
t_acquire_dual_tsk_lock(p_tcb, p_tcb->actprc, &p_pcb, &t_p_pcb);
/*
* マイグレーション先のプロセッサが変更された場合はリトライ
* 対象タスクと自タスクが所属するプロセッサが異なる場合も
* リトライする．
*/
if ((p_tcb->actprc != t_p_pcb->prcid) || (p_pcb != my_p_pcb)) {
release_dual_tsk_lock(p_pcb, t_p_pcb);
goto retry;
}
if (TSTAT_RUNNABLE(p_tcb->tstat)) {
/*
* 対象タスクが他プロセッサ上のタスクかつRUNNABLEの場合，
* RUN状態の可能性があるため，ディスパッチ要求を出す必要があるが，
* 本システムコールは同じプロセッサに割り付けられているタスクのみ
* に発行可能であるので，ディスパッチ要求を出す必要はない．
*/
(void)make_non_runnable(p_tcb);
}
else if (TSTAT_WAITING(p_tcb->tstat)) {
/* オブジェクト待ち以外の待ち状態の場合 */
wait_dequeue_tmevtb(p_tcb);
}
make_dormant(p_tcb);
p_tcb->actque = false;
p_tcb->actprc = TPRC_NONE;
f_p_pcb = p_pcb;
p_tcb->p_pcb = t_p_pcb;
if (make_active(p_tcb)) {
/*
* 現在所属するプロセッサと同じプロセッサにマイグレー
* ションする場合はここに来ないため，dispatch_request()
* 戻り値はチェックしない．
*/
(void)dispatch_request(t_p_pcb);
}
release_dual_tsk_lock(f_p_pcb, t_p_pcb);
}
}
else {
/* オブジェクト待ち状態の場合 */
if ((p_tcb->actprc == TPRC_NONE) || (p_tcb->actprc == p_pcb->prcid)) {
/* 再起動時のマイグレーションなし */
/*
* デッドロック回避のため，ロックを取得し直す
*/
WOBJCB *p_wobjcb = p_tcb->p_wobjcb;
release_tsk_lock(p_pcb);
/*
* あらためて
* オブジェクトロック -> タスクロック
* の順でロックを取得
*/
TEST_G_LABEL("_test_ter_tsk_01");
t_acquire_obj_lock(&GET_OBJLOCK(p_wobjcb));
if ((p_pcb = t_acquire_nested_tsk_lock(p_tcb, &GET_OBJLOCK(p_wobjcb))) == NULL){
goto retry;
}
/*
* オブジェクト待ち状態以外ないし，異なるオブジェクトに対する待ち
* になっていないかチェック．
*/
if ((TSTAT_WAITING(p_tcb->tstat) && !TSTAT_WAIT_WOBJ(p_tcb->tstat))
|| p_wobjcb != p_tcb->p_wobjcb) {
release_nested_tsk_lock(p_pcb);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
goto retry;
}
wait_dequeue_wobj(p_tcb);
wait_dequeue_tmevtb(p_tcb);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
make_dormant(p_tcb);
if (p_tcb->actque) {
p_tcb->actque = false;
p_tcb->actprc = TPRC_NONE;
if (make_active(p_tcb)) {
dspreq = dispatch_request(p_pcb);
}
}
release_tsk_lock(p_pcb);
if (dspreq) {
dispatch();
}
}
else {
/* 起動要求キューイングあり & 他プロセッサへのマイグレーション */
/* 移動先のプロセッサのPCBを取得 */
t_p_pcb = get_mp_p_pcb(p_tcb->actprc);
/*
* デッドロック回避のため，ロックを取得し直す
*/
WOBJCB *p_wobjcb = p_tcb->p_wobjcb;
release_tsk_lock(p_pcb);
/*
* あらためて
* オブジェクトロック -> タスクロック
* の順でロックを取得
*/
TEST_G_LABEL("_test_ter_tsk_02");
t_acquire_obj_lock(&GET_OBJLOCK(p_wobjcb));
if (t_acquire_nested_dual_tsk_lock(p_tcb, p_tcb->actprc, &GET_OBJLOCK(p_wobjcb),
&p_pcb, &t_p_pcb)) {
goto retry;
}
/*
* 異なるオブジェクトに対する待ちないし，オブジェクト待ち状態以外に
* になっていない，異なるプロセッサへのマイグレーション，対象タスク
* がマイグレートしているならリトライ．
*/
if ((p_wobjcb != p_tcb->p_wobjcb) ||
(TSTAT_WAITING(p_tcb->tstat) && !TSTAT_WAIT_WOBJ(p_tcb->tstat)) ||
(get_mp_p_pcb(p_tcb->actprc) != t_p_pcb) ||
(p_pcb != my_p_pcb)) {
release_dual_tsk_lock(p_pcb, t_p_pcb);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
goto retry;
}
wait_dequeue_wobj(p_tcb);
wait_dequeue_tmevtb(p_tcb);
release_obj_lock(&GET_OBJLOCK(p_wobjcb));
make_dormant(p_tcb);
p_tcb->actque = false;
p_tcb->actprc = TPRC_NONE;
f_p_pcb = p_pcb;
p_tcb->p_pcb = t_p_pcb;
if (make_active(p_tcb)) {
/*
* 現在所属するプロセッサと同じプロセッサにマイグレー
* ションする場合はここに来ないため，dispatch_request()
* 戻り値はチェックしない．
*/
(void)dispatch_request(t_p_pcb);
}
release_dual_tsk_lock(f_p_pcb, t_p_pcb);
}
}
}
t_unlock_cpu();
error_exit:
LOG_TER_TSK_LEAVE(ercd);
return(ercd);
}
ER
ter_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
bool_t dspreq = false;
PCB *p_pcb;
PCB *my_p_pcb;
LOG_TER_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID(tskid);
p_tcb = get_tcb(tskid);
t_lock_cpu();
p_pcb = t_acquire_tsk_lock(p_tcb);
my_p_pcb = get_my_p_pcb();
/* 自タスクを指定するとエラー */
if ((p_tcb) == my_p_pcb->p_runtsk) {
ercd = E_ILUSE;
}
/* 異なるプロセッサに割り付けられているタスクならエラーとする */
else if (p_pcb != my_p_pcb) {
ercd = E_OBJ;
}
else if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else {
if (TSTAT_RUNNABLE(p_tcb->tstat)) {
/*
* 対象タスクが他プロセッサ上のタスクかつRUNNABLEの場合，
* RUN状態の可能性があるため，ディスパッチ要求を出す必要があるが，
* 本システムコールは同じプロセッサに割り付けられているタスクのみ
* に発行可能であるので，ディスパッチ要求を出す必要はない．
*/
(void)make_non_runnable(p_tcb);
}
else if (TSTAT_WAITING(p_tcb->tstat)) {
wait_dequeue_wobj(p_tcb);
wait_dequeue_tmevtb(p_tcb);
}
make_dormant(p_tcb);
if (p_tcb->actque) {
p_tcb->actque = false;
/*
* マイグレーション要求がキューイングしている場合は，
* マイグレーション処理を行う．
*/
if ((p_tcb->actprc != TPRC_NONE) && (p_tcb->actprc != my_p_pcb->prcid)) {
p_tcb->p_pcb = get_mp_p_pcb(p_tcb->actprc);
}
p_tcb->actprc = TPRC_NONE;
if (make_active(p_tcb)) {
dspreq = dispatch_request(p_tcb->p_pcb);
}
}
ercd = E_OK;
}
release_tsk_lock(p_pcb);
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_TER_TSK_LEAVE(ercd);
return(ercd);
}
/**
* @brief
* issue a batch request to another server or to a MOM
* or even to ourself!
*
* If the request is meant for this every server, then
* Set up work-task of type WORK_Deferred_Local with a dummy
* connection handle (PBS_LOCAL_CONNECTION).
*
* Dispatch the request to be processed. [reply_send() will
* dispatch the reply via the work task entry.]
*
* If the request is to another server/MOM, then
* Set up work-task of type WORK_Deferred_Reply with the
* connection handle as the event.
*
* Encode and send the request.
*
* When the reply is ready, process_reply() will decode it and
* dispatch the work task.
*
* @note
* IT IS UP TO THE FUNCTION DISPATCHED BY THE WORK TASK TO CLOSE THE
* CONNECTION (connection handle not socket) and FREE THE REQUEST
* STRUCTURE. The connection (non-negative if open) is in wt_event
* and the pointer to the request structure is in wt_parm1.
*
* @param[in] conn - connection index
* @param[in] request - batch request to send
* @param[in] func - The callback function to invoke to handle the batch reply
* @param[out] ppwt - Return work task to be maintained by server to handle
* deferred replies
* @param[in] rpp - conn is over tcp or rpp?
*
* @return Error code
* @retval 0 - Success
* @retval -1 - Failure
*
*/
int
issue_Drequest(int conn,
struct batch_request *request,
void (*func)(),
struct work_task **ppwt,
int rpp)
{
struct attropl *patrl;
struct work_task *ptask;
struct svrattrl *psvratl;
int rc;
int sock = -1;
enum work_type wt;
char *msgid = NULL;
request->rppcmd_msgid = NULL;
if (conn == PBS_LOCAL_CONNECTION) {
wt = WORK_Deferred_Local;
request->rq_conn = PBS_LOCAL_CONNECTION;
} else if (rpp) {
sock = conn;
request->rq_conn = conn;
wt = WORK_Deferred_Reply;
} else {
sock = connection[conn].ch_socket;
request->rq_conn = sock;
wt = WORK_Deferred_Reply;
DIS_tcp_setup(sock);
}
ptask = set_task(wt, (long) conn, func, (void *) request);
if (ptask == NULL) {
log_err(errno, __func__, "could not set_task");
if (ppwt != 0)
*ppwt = 0;
return (-1);
}
if (conn == PBS_LOCAL_CONNECTION) {
/* the request should be issued to ourself */
dispatch_request(PBS_LOCAL_CONNECTION, request);
if (ppwt != 0)
*ppwt = ptask;
return (0);
}
/* the request is bound to another server, encode/send the request */
switch (request->rq_type) {
#ifndef PBS_MOM
case PBS_BATCH_DeleteJob:
rc = PBSD_mgr_put(conn,
PBS_BATCH_DeleteJob,
MGR_CMD_DELETE,
MGR_OBJ_JOB,
request->rq_ind.rq_delete.rq_objname,
NULL,
request->rq_extend,
rpp,
&msgid);
break;
case PBS_BATCH_HoldJob:
attrl_fixlink(&request->rq_ind.rq_hold.rq_orig.rq_attr);
psvratl = (struct svrattrl *)GET_NEXT(
request->rq_ind.rq_hold.rq_orig.rq_attr);
patrl = &psvratl->al_atopl;
rc = PBSD_mgr_put(conn,
PBS_BATCH_HoldJob,
MGR_CMD_SET,
MGR_OBJ_JOB,
request->rq_ind.rq_hold.rq_orig.rq_objname,
patrl,
NULL,
rpp,
&msgid);
break;
case PBS_BATCH_MessJob:
rc = PBSD_msg_put(conn,
request->rq_ind.rq_message.rq_jid,
request->rq_ind.rq_message.rq_file,
request->rq_ind.rq_message.rq_text,
NULL,
rpp,
&msgid);
break;
case PBS_BATCH_RelnodesJob:
rc = PBSD_relnodes_put(conn,
request->rq_ind.rq_relnodes.rq_jid,
request->rq_ind.rq_relnodes.rq_node_list,
NULL,
rpp,
&msgid);
break;
case PBS_BATCH_PySpawn:
rc = PBSD_py_spawn_put(conn,
request->rq_ind.rq_py_spawn.rq_jid,
request->rq_ind.rq_py_spawn.rq_argv,
request->rq_ind.rq_py_spawn.rq_envp,
rpp,
&msgid);
break;
case PBS_BATCH_ModifyJob:
attrl_fixlink(&request->rq_ind.rq_modify.rq_attr);
patrl = (struct attropl *)&((struct svrattrl *)GET_NEXT(
request->rq_ind.rq_modify.rq_attr))->al_atopl;
rc = PBSD_mgr_put(conn,
PBS_BATCH_ModifyJob,
MGR_CMD_SET,
MGR_OBJ_JOB,
request->rq_ind.rq_modify.rq_objname,
patrl,
NULL,
rpp,
&msgid);
break;
case PBS_BATCH_Rerun:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock, PBS_BATCH_Rerun, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_JobId(sock, request->rq_ind.rq_rerun);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_RegistDep:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock,
PBS_BATCH_RegistDep, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_Register(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_SignalJob:
rc = PBSD_sig_put(conn,
request->rq_ind.rq_signal.rq_jid,
request->rq_ind.rq_signal.rq_signame,
NULL,
rpp,
&msgid);
break;
case PBS_BATCH_StatusJob:
rc = PBSD_status_put(conn,
PBS_BATCH_StatusJob,
request->rq_ind.rq_status.rq_id,
NULL, NULL,
rpp,
&msgid);
break;
case PBS_BATCH_TrackJob:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock, PBS_BATCH_TrackJob, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_TrackJob(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, request->rq_extend);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_CopyFiles:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock,
PBS_BATCH_CopyFiles, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_CopyFiles(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_CopyFiles_Cred:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock,
PBS_BATCH_CopyFiles_Cred, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_CopyFiles_Cred(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_DelFiles:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock,
PBS_BATCH_DelFiles, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_CopyFiles(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_DelFiles_Cred:
if (rpp) {
rc = is_compose_cmd(sock, IS_CMD, &msgid);
if (rc != 0)
break;
}
rc=encode_DIS_ReqHdr(sock,
PBS_BATCH_DelFiles_Cred, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_CopyFiles_Cred(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
case PBS_BATCH_FailOver:
rc = put_failover(sock, request); /* we should never do rpp for this one */
break;
#else /* PBS_MOM */
case PBS_BATCH_JobObit:
rc=encode_DIS_ReqHdr(sock, PBS_BATCH_JobObit, pbs_current_user);
if (rc != 0)
break;
rc=encode_DIS_JobObit(sock, request);
if (rc != 0)
break;
rc=encode_DIS_ReqExtend(sock, 0);
if (rc != 0)
break;
rc = DIS_wflush(sock, rpp);
break;
#endif /* PBS_MOM */
default:
(void)sprintf(log_buffer, msg_issuebad, request->rq_type);
log_err(-1, __func__, log_buffer);
delete_task(ptask);
rc = -1;
break;
}
if (rc) {
sprintf(log_buffer,
"issue_Drequest failed, error=%d on request %d",
rc, request->rq_type);
log_err(-1, __func__, log_buffer);
if (msgid)
free(msgid);
delete_task(ptask);
} else if (ppwt != 0) {
if (rpp) {
rpp_add_close_func(sock, process_DreplyRPP); /* register a close handler */
ptask->wt_event2 = msgid;
/*
* since its an rpp delayed task, remove it from the task_event list
* caller will add to moms deferred cmd list
*/
delete_link(&ptask->wt_linkall);
}
ptask->wt_aux2 = rpp; /* 0 in case of non-TPP */
*ppwt = ptask;
}
return (rc);
}
int issue_Drequest(
int conn,
struct batch_request *request,
void (*func) (struct work_task *),
struct work_task **ppwt)
{
struct attropl *patrl;
struct work_task *ptask;
struct svrattrl *psvratl;
int rc;
int sock = 0;
enum work_type wt;
char *id = "issue_Drequest";
if (conn == PBS_LOCAL_CONNECTION)
{
wt = WORK_Deferred_Local;
request->rq_conn = PBS_LOCAL_CONNECTION;
}
else
{
sock = connection[conn].ch_socket;
request->rq_conn = sock;
wt = WORK_Deferred_Reply;
DIS_tcp_setup(sock);
}
ptask = set_task(wt, (long)conn, func, (void *)request);
if (ptask == NULL)
{
log_err(errno, id, "could not set_task");
if (ppwt != NULL)
*ppwt = 0;
return(-1);
}
if (conn == PBS_LOCAL_CONNECTION)
{
/* the request should be issued to ourself */
dispatch_request(PBS_LOCAL_CONNECTION, request);
if (ppwt != NULL)
*ppwt = ptask;
return(0);
}
/* the request is bound to another server, encode/send the request */
switch (request->rq_type)
{
#ifndef PBS_MOM
case PBS_BATCH_DeleteJob:
rc = PBSD_mgr_put(
conn,
PBS_BATCH_DeleteJob,
MGR_CMD_DELETE,
MGR_OBJ_JOB,
request->rq_ind.rq_delete.rq_objname,
NULL,
NULL);
break;
case PBS_BATCH_HoldJob:
attrl_fixlink(&request->rq_ind.rq_hold.rq_orig.rq_attr);
psvratl = (struct svrattrl *)GET_NEXT(request->rq_ind.rq_hold.rq_orig.rq_attr);
patrl = &psvratl->al_atopl;
rc = PBSD_mgr_put(
conn,
PBS_BATCH_HoldJob,
MGR_CMD_SET,
MGR_OBJ_JOB,
request->rq_ind.rq_hold.rq_orig.rq_objname,
patrl,
NULL);
break;
case PBS_BATCH_CheckpointJob:
rc = PBSD_mgr_put(
conn,
PBS_BATCH_CheckpointJob,
MGR_CMD_SET,
MGR_OBJ_JOB,
request->rq_ind.rq_hold.rq_orig.rq_objname,
NULL,
NULL);
break;
case PBS_BATCH_GpuCtrl:
rc = PBSD_gpu_put(
conn,
request->rq_ind.rq_gpuctrl.rq_momnode,
request->rq_ind.rq_gpuctrl.rq_gpuid,
request->rq_ind.rq_gpuctrl.rq_gpumode,
request->rq_ind.rq_gpuctrl.rq_reset_perm,
request->rq_ind.rq_gpuctrl.rq_reset_vol,
NULL);
break;
case PBS_BATCH_MessJob:
rc = PBSD_msg_put(
conn,
request->rq_ind.rq_message.rq_jid,
request->rq_ind.rq_message.rq_file,
request->rq_ind.rq_message.rq_text,
NULL);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
attrl_fixlink(&request->rq_ind.rq_modify.rq_attr);
patrl = (struct attropl *) & ((struct svrattrl *)GET_NEXT(
request->rq_ind.rq_modify.rq_attr))->al_atopl;
rc = PBSD_mgr_put(
conn,
request->rq_type,
MGR_CMD_SET,
MGR_OBJ_JOB,
request->rq_ind.rq_modify.rq_objname,
patrl,
NULL);
break;
case PBS_BATCH_Rerun:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_Rerun, msg_daemonname)))
break;
if ((rc = encode_DIS_JobId(sock, request->rq_ind.rq_rerun)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
case PBS_BATCH_RegistDep:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_RegistDep, msg_daemonname)))
break;
if ((rc = encode_DIS_Register(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
case PBS_BATCH_AsySignalJob:
case PBS_BATCH_SignalJob:
rc = PBSD_sig_put(
conn,
request->rq_ind.rq_signal.rq_jid,
request->rq_ind.rq_signal.rq_signame,
request->rq_extra);
break;
case PBS_BATCH_StatusJob:
rc = PBSD_status_put(
conn,
PBS_BATCH_StatusJob,
request->rq_ind.rq_status.rq_id,
NULL,
NULL);
break;
case PBS_BATCH_TrackJob:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_TrackJob, msg_daemonname)))
break;
if ((rc = encode_DIS_TrackJob(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
case PBS_BATCH_ReturnFiles:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_ReturnFiles, msg_daemonname)))
break;
if ((rc = encode_DIS_ReturnFiles(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
case PBS_BATCH_CopyFiles:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_CopyFiles, msg_daemonname)))
break;
if ((rc = encode_DIS_CopyFiles(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
case PBS_BATCH_DelFiles:
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_DelFiles, msg_daemonname)))
break;
if ((rc = encode_DIS_CopyFiles(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
#else /* PBS_MOM */
case PBS_BATCH_JobObit:
/* who is sending obit request? */
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_JobObit, msg_daemonname)))
break;
if ((rc = encode_DIS_JobObit(sock, request)))
break;
if ((rc = encode_DIS_ReqExtend(sock, 0)))
break;
rc = DIS_tcp_wflush(sock);
break;
#endif /* PBS_MOM */
default:
sprintf(log_buffer, msg_issuebad,
request->rq_type);
log_err(-1, id, log_buffer);
delete_task(ptask);
rc = -1;
break;
} /* END switch (request->rq_type) */
if (ppwt != NULL)
*ppwt = ptask;
return(rc);
} /* END issue_Drequest() */
void
process_request(int sfds)
{
int rc;
struct batch_request *request;
conn_t *conn;
time_now = time(NULL);
conn = get_conn(sfds);
if (!conn) {
log_event(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST, LOG_ERR,
"process_request", "did not find socket in connection table");
#ifdef WIN32
(void)closesocket(sfds);
#else
(void)close(sfds);
#endif
return;
}
if ((request = alloc_br(0)) == NULL) {
log_event(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST, LOG_ERR,
"process_request", "Unable to allocate request structure");
close_conn(sfds);
return;
}
request->rq_conn = sfds;
/*
* Read in the request and decode it to the internal request structure.
*/
if (get_connecthost(sfds, request->rq_host, PBS_MAXHOSTNAME)) {
(void)sprintf(log_buffer, "%s: %lu", msg_reqbadhost,
get_connectaddr(sfds));
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_REQUEST, LOG_DEBUG,
"", log_buffer);
req_reject(PBSE_BADHOST, 0, request);
return;
}
#ifndef PBS_MOM
if (conn->cn_active == FromClientDIS) {
rc = dis_request_read(sfds, request);
} else {
log_event(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST, LOG_ERR,
"process_req", "request on invalid type of connection");
close_conn(sfds);
free_br(request);
return;
}
#else /* PBS_MOM */
rc = dis_request_read(sfds, request);
#endif /* PBS_MOM */
if (rc == -1) { /* End of file */
close_client(sfds);
free_br(request);
return;
} else if ((rc == PBSE_SYSTEM) || (rc == PBSE_INTERNAL)) {
/* read error, likely cannot send reply so just disconnect */
/* ??? not sure about this ??? */
close_client(sfds);
free_br(request);
return;
} else if (rc > 0) {
/*
* request didn't decode, either garbage or unknown
* request type, in ether case, return reject-reply
*/
req_reject(rc, 0, request);
close_client(sfds);
return;
}
#ifndef PBS_MOM
/* If the request is coming on the socket we opened to the */
/* scheduler, change the "user" from "root" to "Scheduler" */
if (find_sched_from_sock(request->rq_conn) != NULL) {
strncpy(request->rq_user, PBS_SCHED_DAEMON_NAME, PBS_MAXUSER);
request->rq_user[PBS_MAXUSER] = '\0';
}
#endif /* PBS_MOM */
(void)sprintf(log_buffer, msg_request, request->rq_type,
request->rq_user, request->rq_host, sfds);
log_event(PBSEVENT_DEBUG2, PBS_EVENTCLASS_REQUEST, LOG_DEBUG,
"", log_buffer);
/* is the request from a host acceptable to the server */
if (request->rq_type == PBS_BATCH_AuthExternal) {
rc = authenticate_external(conn, request);
if (rc == 0)
reply_ack(request);
else if (rc == -2)
req_reject(PBSE_NOSUP, 0, request);
else
req_reject(PBSE_BADCRED, 0, request);
return;
}
#ifndef PBS_MOM
if (server.sv_attr[(int)SRV_ATR_acl_host_enable].at_val.at_long) {
/* acl enabled, check it; always allow myself */
struct pbsnode *isanode = NULL;
if ((server.sv_attr[SRV_ATR_acl_host_moms_enable].at_flags & ATR_VFLAG_SET) &&
(server.sv_attr[(int)SRV_ATR_acl_host_moms_enable].at_val.at_long == 1)) {
isanode = find_nodebyaddr(get_connectaddr(sfds));
if ((isanode != NULL) && (isanode->nd_state & INUSE_DELETED))
isanode = NULL;
}
if (isanode == NULL) {
if ((acl_check(&server.sv_attr[(int)SRV_ATR_acl_hosts],
request->rq_host, ACL_Host) == 0) &&
(strcasecmp(server_host, request->rq_host) != 0)) {
req_reject(PBSE_BADHOST, 0, request);
close_client(sfds);
return;
}
}
}
/*
* determine source (user client or another server) of request.
* set the permissions granted to the client
*/
if (conn->cn_authen & PBS_NET_CONN_FROM_PRIVIL) {
/* request came from another server */
request->rq_fromsvr = 1;
request->rq_perm = ATR_DFLAG_USRD | ATR_DFLAG_USWR |
ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR |
ATR_DFLAG_SvWR;
} else {
/* request not from another server */
request->rq_fromsvr = 0;
/*
* Client must be authenticated by a Authenticate User Request,
* if not, reject request and close connection.
* -- The following is retained for compat with old cmds --
* The exception to this is of course the Connect Request which
* cannot have been authenticated, because it contains the
* needed ticket; so trap it here. Of course, there is no
* prior authentication on the Authenticate User request either,
* but it comes over a reserved port and appears from another
* server, hence is automatically granted authorization.
*/
if (request->rq_type == PBS_BATCH_Connect) {
req_connect(request);
return;
}
if ((conn->cn_authen & PBS_NET_CONN_AUTHENTICATED) ==0) {
rc = PBSE_BADCRED;
} else {
rc = authenticate_user(request, conn);
}
if (rc != 0) {
req_reject(rc, 0, request);
if (rc == PBSE_BADCRED)
close_client(sfds);
return;
}
request->rq_perm =
svr_get_privilege(request->rq_user, request->rq_host);
}
/* if server shutting down, disallow new jobs and new running */
if (server.sv_attr[(int)SRV_ATR_State].at_val.at_long > SV_STATE_RUN) {
switch (request->rq_type) {
case PBS_BATCH_AsyrunJob:
case PBS_BATCH_JobCred:
case PBS_BATCH_UserCred:
case PBS_BATCH_UserMigrate:
case PBS_BATCH_MoveJob:
case PBS_BATCH_QueueJob:
case PBS_BATCH_RunJob:
case PBS_BATCH_StageIn:
case PBS_BATCH_jobscript:
req_reject(PBSE_SVRDOWN, 0, request);
return;
}
}
#else /* THIS CODE FOR MOM ONLY */
/* check connecting host against allowed list of ok clients */
if (!addrfind(conn->cn_addr)) {
req_reject(PBSE_BADHOST, 0, request);
close_client(sfds);
return;
}
request->rq_fromsvr = 1;
request->rq_perm = ATR_DFLAG_USRD | ATR_DFLAG_USWR |
ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR |
ATR_DFLAG_SvWR | ATR_DFLAG_MOM;
#endif
/*
* dispatch the request to the correct processing function.
* The processing function must call reply_send() to free
* the request struture.
*/
dispatch_request(sfds, request);
return;
}
int process_request(
struct tcp_chan *chan) /* file descriptor (socket) to get request */
{
int rc = PBSE_NONE;
struct batch_request *request = NULL;
char log_buf[LOCAL_LOG_BUF_SIZE];
long acl_enable = FALSE;
long state = SV_STATE_DOWN;
time_t time_now = time(NULL);
int free_request = TRUE;
char tmpLine[MAXLINE];
char *auth_err = NULL;
enum conn_type conn_active;
unsigned short conn_socktype;
unsigned short conn_authen;
unsigned long conn_addr;
int sfds = chan->sock;
pthread_mutex_lock(svr_conn[sfds].cn_mutex);
conn_active = svr_conn[sfds].cn_active;
conn_socktype = svr_conn[sfds].cn_socktype;
conn_authen = svr_conn[sfds].cn_authen;
conn_addr = svr_conn[sfds].cn_addr;
svr_conn[sfds].cn_lasttime = time_now;
pthread_mutex_unlock(svr_conn[sfds].cn_mutex);
if ((request = alloc_br(0)) == NULL)
{
snprintf(tmpLine, sizeof(tmpLine),
"cannot allocate memory for request from %lu",
conn_addr);
req_reject(PBSE_MEM_MALLOC, 0, request, NULL, tmpLine);
free_request = FALSE;
rc = PBSE_SYSTEM;
goto process_request_cleanup;
}
request->rq_conn = sfds;
/*
* Read in the request and decode it to the internal request structure.
*/
if (conn_active == FromClientDIS || conn_active == ToServerDIS)
{
#ifdef ENABLE_UNIX_SOCKETS
if ((conn_socktype & PBS_SOCK_UNIX) &&
(conn_authen != PBS_NET_CONN_AUTHENTICATED))
{
/* get_creds interestingly always returns 0 */
get_creds(sfds, conn_credent[sfds].username, conn_credent[sfds].hostname);
}
#endif /* END ENABLE_UNIX_SOCKETS */
rc = dis_request_read(chan, request);
}
else
{
char out[80];
snprintf(tmpLine, MAXLINE, "request on invalid type of connection: %d, sock type: %d, from address %s",
conn_active,conn_socktype, netaddr_long(conn_addr, out));
log_event(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST,
"process_req", tmpLine);
snprintf(tmpLine, sizeof(tmpLine),
"request on invalid type of connection (%d) from %s",
conn_active,
netaddr_long(conn_addr, out));
req_reject(PBSE_BADHOST, 0, request, NULL, tmpLine);
free_request = FALSE;
rc = PBSE_BADHOST;
goto process_request_cleanup;
}
if (rc == -1)
{
/* FAILURE */
/* premature end of file */
rc = PBSE_PREMATURE_EOF;
goto process_request_cleanup;
}
if ((rc == PBSE_SYSTEM) || (rc == PBSE_INTERNAL) || (rc == PBSE_SOCKET_CLOSE))
{
/* FAILURE */
/* read error, likely cannot send reply so just disconnect */
/* ??? not sure about this ??? */
goto process_request_cleanup;
}
if (rc > 0)
{
/* FAILURE */
/*
* request didn't decode, either garbage or unknown
* request type, in either case, return reject-reply
*/
req_reject(rc, 0, request, NULL, "cannot decode message");
free_request = FALSE;
goto process_request_cleanup;
}
if (get_connecthost(sfds, request->rq_host, PBS_MAXHOSTNAME) != 0)
{
sprintf(log_buf, "%s: %lu",
pbse_to_txt(PBSE_BADHOST),
conn_addr);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_REQUEST, "", log_buf);
snprintf(tmpLine, sizeof(tmpLine),
"cannot determine hostname for connection from %lu",
conn_addr);
req_reject(PBSE_BADHOST, 0, request, NULL, tmpLine);
free_request = FALSE;
rc = PBSE_BADHOST;
goto process_request_cleanup;
}
if (LOGLEVEL >= 1)
{
sprintf(log_buf,
msg_request,
reqtype_to_txt(request->rq_type),
request->rq_user,
request->rq_host,
sfds);
log_event(PBSEVENT_DEBUG2, PBS_EVENTCLASS_REQUEST, "", log_buf);
}
/* is the request from a host acceptable to the server */
if (conn_socktype & PBS_SOCK_UNIX)
{
strcpy(request->rq_host, server_name);
}
get_svr_attr_l(SRV_ATR_acl_host_enable, &acl_enable);
if (acl_enable)
{
/* acl enabled, check it; always allow myself and nodes */
struct array_strings *pas = NULL;
struct pbsnode *isanode;
get_svr_attr_arst(SRV_ATR_acl_hosts, &pas);
isanode = PGetNodeFromAddr(conn_addr);
if ((isanode == NULL) &&
(strcmp(server_host, request->rq_host) != 0) &&
(acl_check_my_array_string(pas, request->rq_host, ACL_Host) == 0))
{
char tmpLine[MAXLINE];
snprintf(tmpLine, sizeof(tmpLine), "request not authorized from host %s",
request->rq_host);
req_reject(PBSE_BADHOST, 0, request, NULL, tmpLine);
free_request = FALSE;
rc = PBSE_BADHOST;
goto process_request_cleanup;
}
if (isanode != NULL)
unlock_node(isanode, "process_request", NULL, LOGLEVEL);
}
/*
* determine source (user client or another server) of request.
* set the permissions granted to the client
*/
if (conn_authen == PBS_NET_CONN_FROM_PRIVIL)
{
/* request came from another server */
request->rq_fromsvr = 1;
request->rq_perm =
ATR_DFLAG_USRD | ATR_DFLAG_USWR |
ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR |
ATR_DFLAG_SvWR;
}
else
{
/* request not from another server */
conn_credent[sfds].timestamp = time_now;
request->rq_fromsvr = 0;
/*
* Client must be authenticated by an Authenticate User Request, if not,
* reject request and close connection. -- The following is retained for
* compat with old cmds -- The exception to this is of course the Connect
* Request which cannot have been authenticated, because it contains the
* needed ticket; so trap it here. Of course, there is no prior
* authentication on the Authenticate User request either, but it comes
* over a reserved port and appears from another server, hence is
* automatically granted authentication.
*
* The above is only true with inet sockets. With unix domain sockets, the
* user creds were read before the first dis_request_read call above.
* We automatically granted authentication because we can trust the socket
* creds. Authorization is still granted in svr_get_privilege below
*/
if (request->rq_type == PBS_BATCH_Connect)
{
req_connect(request);
if (conn_socktype == PBS_SOCK_INET)
{
rc = PBSE_IVALREQ;
req_reject(rc, 0, request, NULL, NULL);
free_request = FALSE;
goto process_request_cleanup;
}
}
if (conn_socktype & PBS_SOCK_UNIX)
{
pthread_mutex_lock(svr_conn[sfds].cn_mutex);
svr_conn[sfds].cn_authen = PBS_NET_CONN_AUTHENTICATED;
pthread_mutex_unlock(svr_conn[sfds].cn_mutex);
}
if (ENABLE_TRUSTED_AUTH == TRUE )
rc = PBSE_NONE; /* bypass the authentication of the user--trust the client completely */
else if (munge_on)
{
/* If munge_on is true we will validate the connection now */
if (request->rq_type == PBS_BATCH_AltAuthenUser)
{
rc = req_altauthenuser(request);
free_request = FALSE;
goto process_request_cleanup;
}
else
{
rc = authenticate_user(request, &conn_credent[sfds], &auth_err);
}
}
else if (conn_authen != PBS_NET_CONN_AUTHENTICATED)
/* skip checking user if we did not get an authenticated credential */
rc = PBSE_BADCRED;
else
rc = authenticate_user(request, &conn_credent[sfds], &auth_err);
if (rc != 0)
{
req_reject(rc, 0, request, NULL, auth_err);
if (auth_err != NULL)
free(auth_err);
free_request = FALSE;
goto process_request_cleanup;
}
/*
* pbs_mom and checkpoint restart scripts both need the authority to do
* alters and releases on checkpointable jobs. Allow manager permission
* for root on the jobs execution node.
*/
if (((request->rq_type == PBS_BATCH_ModifyJob) ||
(request->rq_type == PBS_BATCH_ReleaseJob)) &&
(strcmp(request->rq_user, PBS_DEFAULT_ADMIN) == 0))
{
job *pjob;
char *dptr;
int skip = FALSE;
char short_host[PBS_MAXHOSTNAME+1];
/* make short host name */
strcpy(short_host, request->rq_host);
if ((dptr = strchr(short_host, '.')) != NULL)
{
*dptr = '\0';
}
if ((pjob = svr_find_job(request->rq_ind.rq_modify.rq_objname, FALSE)) != (job *)0)
{
if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING)
{
if ((pjob->ji_wattr[JOB_ATR_checkpoint].at_flags & ATR_VFLAG_SET) &&
((csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "s") != NULL) ||
(csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "c") != NULL) ||
(csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "enabled") != NULL)) &&
(strstr(pjob->ji_wattr[JOB_ATR_exec_host].at_val.at_str, short_host) != NULL))
{
request->rq_perm = svr_get_privilege(request->rq_user, server_host);
skip = TRUE;
}
}
unlock_ji_mutex(pjob, __func__, "1", LOGLEVEL);
}
if (!skip)
{
request->rq_perm = svr_get_privilege(request->rq_user, request->rq_host);
}
}
else
{
request->rq_perm = svr_get_privilege(request->rq_user, request->rq_host);
}
} /* END else (conn_authen == PBS_NET_CONN_FROM_PRIVIL) */
/* if server shutting down, disallow new jobs and new running */
get_svr_attr_l(SRV_ATR_State, &state);
if (state > SV_STATE_RUN)
{
switch (request->rq_type)
{
case PBS_BATCH_AsyrunJob:
case PBS_BATCH_JobCred:
case PBS_BATCH_MoveJob:
case PBS_BATCH_QueueJob:
case PBS_BATCH_RunJob:
case PBS_BATCH_StageIn:
case PBS_BATCH_jobscript:
req_reject(PBSE_SVRDOWN, 0, request, NULL, NULL);
rc = PBSE_SVRDOWN;
free_request = FALSE;
goto process_request_cleanup;
/*NOTREACHED*/
break;
}
}
/*
* dispatch the request to the correct processing function.
* The processing function must call reply_send() to free
* the request struture.
*/
rc = dispatch_request(sfds, request);
return(rc);
process_request_cleanup:
if (free_request == TRUE)
free_br(request);
return(rc);
} /* END process_request() */
void process_request(
int sfds) /* file descriptor (socket) to get request */
{
#ifdef PBS_MOM
char *id = "process_request";
#endif
int rc;
struct batch_request *request = NULL;
#ifndef PBS_MOM
char *auth_err = NULL;
#endif
time_now = time(NULL);
request = alloc_br(0);
request->rq_conn = sfds;
/*
* Read in the request and decode it to the internal request structure.
*/
#ifndef PBS_MOM
if (svr_conn[sfds].cn_active == FromClientDIS)
{
#ifdef ENABLE_UNIX_SOCKETS
if ((svr_conn[sfds].cn_socktype & PBS_SOCK_UNIX) &&
(svr_conn[sfds].cn_authen != PBS_NET_CONN_AUTHENTICATED))
{
get_creds(sfds, conn_credent[sfds].username, conn_credent[sfds].hostname);
}
#endif /* END ENABLE_UNIX_SOCKETS */
rc = dis_request_read(sfds, request);
}
else
{
LOG_EVENT(
PBSEVENT_SYSTEM,
PBS_EVENTCLASS_REQUEST,
"process_req",
"request on invalid type of connection");
close_conn(sfds);
free_br(request);
return;
}
#else /* PBS_MOM */
rc = dis_request_read(sfds, request);
#endif /* PBS_MOM */
if (rc == -1)
{
/* FAILURE */
/* premature end of file */
close_client(sfds);
free_br(request);
return;
}
if ((rc == PBSE_SYSTEM) || (rc == PBSE_INTERNAL))
{
/* FAILURE */
/* read error, likely cannot send reply so just disconnect */
/* ??? not sure about this ??? */
close_client(sfds);
free_br(request);
return;
}
if (rc > 0)
{
/* FAILURE */
/*
* request didn't decode, either garbage or unknown
* request type, in either case, return reject-reply
*/
req_reject(rc, 0, request, NULL, "cannot decode message");
close_client(sfds);
return;
}
if (get_connecthost(sfds, request->rq_host, PBS_MAXHOSTNAME) != 0)
{
char tmpLine[1024];
sprintf(log_buffer, "%s: %lu",
pbse_to_txt(PBSE_BADHOST),
get_connectaddr(sfds));
LOG_EVENT(PBSEVENT_DEBUG, PBS_EVENTCLASS_REQUEST, "", log_buffer);
snprintf(tmpLine, sizeof(tmpLine), "cannot determine hostname for connection from %lu",
get_connectaddr(sfds));
req_reject(PBSE_BADHOST, 0, request, NULL, tmpLine);
return;
}
if (LOGLEVEL >= 1)
{
sprintf(
log_buffer,
msg_request,
reqtype_to_txt(request->rq_type),
request->rq_user,
request->rq_host,
sfds);
LOG_EVENT(PBSEVENT_DEBUG2, PBS_EVENTCLASS_REQUEST, "", log_buffer);
}
/* is the request from a host acceptable to the server */
#ifndef PBS_MOM
if (svr_conn[sfds].cn_socktype & PBS_SOCK_UNIX)
{
strcpy(request->rq_host, server_name);
}
if (server.sv_attr[SRV_ATR_acl_host_enable].at_val.at_long)
{
/* acl enabled, check it; always allow myself and nodes */
struct pbsnode *isanode;
isanode = PGetNodeFromAddr(get_connectaddr(sfds));
if ((isanode == NULL) &&
(strcmp(server_host, request->rq_host) != 0) &&
(acl_check(
&server.sv_attr[SRV_ATR_acl_hosts],
request->rq_host,
ACL_Host) == 0))
{
char tmpLine[1024];
snprintf(tmpLine, sizeof(tmpLine), "request not authorized from host %s",
request->rq_host);
req_reject(PBSE_BADHOST, 0, request, NULL, tmpLine);
close_client(sfds);
return;
}
}
/*
* determine source (user client or another server) of request.
* set the permissions granted to the client
*/
if (svr_conn[sfds].cn_authen == PBS_NET_CONN_FROM_PRIVIL)
{
/* request came from another server */
request->rq_fromsvr = 1;
request->rq_perm =
ATR_DFLAG_USRD | ATR_DFLAG_USWR |
ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR |
ATR_DFLAG_SvWR;
}
else
{
/* request not from another server */
request->rq_fromsvr = 0;
/*
* Client must be authenticated by an Authenticate User Request, if not,
* reject request and close connection. -- The following is retained for
* compat with old cmds -- The exception to this is of course the Connect
* Request which cannot have been authenticated, because it contains the
* needed ticket; so trap it here. Of course, there is no prior
* authentication on the Authenticate User request either, but it comes
* over a reserved port and appears from another server, hence is
* automatically granted authentication.
*
* The above is only true with inet sockets. With unix domain sockets, the
* user creds were read before the first dis_request_read call above.
* We automatically granted authentication because we can trust the socket
* creds. Authorization is still granted in svr_get_privilege below
*/
if (request->rq_type == PBS_BATCH_Connect)
{
req_connect(request);
if (svr_conn[sfds].cn_socktype == PBS_SOCK_INET)
return;
}
if (svr_conn[sfds].cn_socktype & PBS_SOCK_UNIX)
{
conn_credent[sfds].timestamp = time_now;
svr_conn[sfds].cn_authen = PBS_NET_CONN_AUTHENTICATED;
}
if (ENABLE_TRUSTED_AUTH == TRUE )
rc = 0; /* bypass the authentication of the user--trust the client completely */
else if (munge_on)
{
/* If munge_on is true we will validate the connection now */
if ( request->rq_type == PBS_BATCH_AltAuthenUser)
{
rc = req_altauthenuser(request);
if (rc == PBSE_NONE)
{
conn_credent[sfds].timestamp = time_now;
svr_conn[sfds].cn_authen = PBS_NET_CONN_AUTHENTICATED;
}
return;
}
else if (svr_conn[sfds].cn_authen != PBS_NET_CONN_AUTHENTICATED)
/* skip checking user if we did not get an authenticated credential */
rc = PBSE_BADCRED;
else
{
rc = authenticate_user(request, &conn_credent[sfds], &auth_err);
}
}
else if (svr_conn[sfds].cn_authen != PBS_NET_CONN_AUTHENTICATED)
rc = PBSE_BADCRED;
else
rc = authenticate_user(request, &conn_credent[sfds], &auth_err);
if (rc != 0)
{
req_reject(rc, 0, request, NULL, auth_err);
if (auth_err != NULL)
free(auth_err);
close_client(sfds);
return;
}
/*
* pbs_mom and checkpoint restart scripts both need the authority to do
* alters and releases on checkpointable jobs. Allow manager permission
* for root on the jobs execution node.
*/
if (((request->rq_type == PBS_BATCH_ModifyJob) ||
(request->rq_type == PBS_BATCH_ReleaseJob)) &&
(strcmp(request->rq_user, PBS_DEFAULT_ADMIN) == 0))
{
job *pjob;
char *dptr;
int skip = FALSE;
char short_host[PBS_MAXHOSTNAME+1];
/* make short host name */
strcpy(short_host, request->rq_host);
if ((dptr = strchr(short_host, '.')) != NULL)
{
*dptr = '\0';
}
if (((pjob = find_job(request->rq_ind.rq_modify.rq_objname)) != (job *)0) &&
(pjob->ji_qs.ji_state == JOB_STATE_RUNNING))
{
if ((pjob->ji_wattr[JOB_ATR_checkpoint].at_flags & ATR_VFLAG_SET) &&
((csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "s") != NULL) ||
(csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "c") != NULL) ||
(csv_find_string(pjob->ji_wattr[JOB_ATR_checkpoint].at_val.at_str, "enabled") != NULL)) &&
(strstr(pjob->ji_wattr[JOB_ATR_exec_host].at_val.at_str, short_host) != NULL))
{
request->rq_perm = svr_get_privilege(request->rq_user, server_host);
skip = TRUE;
}
}
if (!skip)
{
request->rq_perm = svr_get_privilege(request->rq_user, request->rq_host);
}
}
else
{
request->rq_perm = svr_get_privilege(request->rq_user, request->rq_host);
}
} /* END else (svr_conn[sfds].cn_authen == PBS_NET_CONN_FROM_PRIVIL) */
/* if server shutting down, disallow new jobs and new running */
if (server.sv_attr[SRV_ATR_State].at_val.at_long > SV_STATE_RUN)
{
switch (request->rq_type)
{
case PBS_BATCH_AsyrunJob:
case PBS_BATCH_JobCred:
case PBS_BATCH_MoveJob:
case PBS_BATCH_QueueJob:
case PBS_BATCH_RunJob:
case PBS_BATCH_StageIn:
case PBS_BATCH_jobscript:
req_reject(PBSE_SVRDOWN, 0, request, NULL, NULL);
return;
/*NOTREACHED*/
break;
}
}
#else /* THIS CODE FOR MOM ONLY */
{
/*extern tree *okclients; */
extern void mom_server_update_receive_time_by_ip(u_long ipaddr, const char *cmd);
/* check connecting host against allowed list of ok clients */
if (LOGLEVEL >= 6)
{
sprintf(log_buffer, "request type %s from host %s received",
reqtype_to_txt(request->rq_type),
request->rq_host);
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
log_buffer);
}
/* if (!tfind(svr_conn[sfds].cn_addr, &okclients)) */
if (!AVL_is_in_tree(svr_conn[sfds].cn_addr, 0, okclients))
{
sprintf(log_buffer, "request type %s from host %s rejected (host not authorized)",
reqtype_to_txt(request->rq_type),
request->rq_host);
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
log_buffer);
req_reject(PBSE_BADHOST, 0, request, NULL, "request not authorized");
close_client(sfds);
return;
}
if (LOGLEVEL >= 3)
{
sprintf(log_buffer, "request type %s from host %s allowed",
reqtype_to_txt(request->rq_type),
request->rq_host);
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
log_buffer);
}
mom_server_update_receive_time_by_ip(svr_conn[sfds].cn_addr, reqtype_to_txt(request->rq_type));
} /* END BLOCK */
request->rq_fromsvr = 1;
request->rq_perm =
ATR_DFLAG_USRD | ATR_DFLAG_USWR |
ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR |
ATR_DFLAG_SvWR | ATR_DFLAG_MOM;
#endif /* END else !PBS_MOM */
/*
* dispatch the request to the correct processing function.
* The processing function must call reply_send() to free
* the request struture.
*/
dispatch_request(sfds, request);
return;
} /* END process_request() */
static xmlrpc_value * add_flow_destination(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc, i;
xmlrpc_value *ret = 0;
char* cc_alg = 0;
char* bind_address = 0;
xmlrpc_value* extra_options = 0;
struct _flow_settings settings;
struct _request_add_flow_destination* request = 0;
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array,
"("
"{s:s,*}"
"{s:d,s:d,s:d,s:d,s:d,*}"
"{s:i,s:i,*}"
"{s:i,*}"
"{s:b,s:b,s:b,s:b,s:b,*}"
"{s:i,s:i,*}"
"{s:i,s:d,s:d,*}" /* request */
"{s:i,s:d,s:d,*}" /* response */
"{s:i,s:d,s:d,*}" /* interpacket_gap */
"{s:b,s:b,s:i,s:i,*}"
"{s:s,*}"
"{s:i,s:i,s:i,s:i,s:i,*}"
#ifdef HAVE_LIBPCAP
"{s:s,*}"
#endif /* HAVE_LIBPCAP */
"{s:i,s:A,*}"
")",
/* general settings */
"bind_address", &bind_address,
"write_delay", &settings.delay[WRITE],
"write_duration", &settings.duration[WRITE],
"read_delay", &settings.delay[READ],
"read_duration", &settings.duration[READ],
"reporting_interval", &settings.reporting_interval,
"requested_send_buffer_size", &settings.requested_send_buffer_size,
"requested_read_buffer_size", &settings.requested_read_buffer_size,
"maximum_block_size", &settings.maximum_block_size,
"traffic_dump", &settings.traffic_dump,
"so_debug", &settings.so_debug,
"route_record", &settings.route_record,
"pushy", &settings.pushy,
"shutdown", &settings.shutdown,
"write_rate", &settings.write_rate,
"random_seed",&settings.random_seed,
"traffic_generation_request_distribution", &settings.request_trafgen_options.distribution,
"traffic_generation_request_param_one", &settings.request_trafgen_options.param_one,
"traffic_generation_request_param_two", &settings.request_trafgen_options.param_two,
"traffic_generation_response_distribution", &settings.response_trafgen_options.distribution,
"traffic_generation_response_param_one", &settings.response_trafgen_options.param_one,
"traffic_generation_response_param_two", &settings.response_trafgen_options.param_two,
"traffic_generation_gap_distribution", &settings.interpacket_gap_trafgen_options.distribution,
"traffic_generation_gap_param_one", &settings.interpacket_gap_trafgen_options.param_one,
"traffic_generation_gap_param_two", &settings.interpacket_gap_trafgen_options.param_two,
"flow_control", &settings.flow_control,
"byte_counting", &settings.byte_counting,
"cork", &settings.cork,
"nonagle", &settings.nonagle,
"cc_alg", &cc_alg,
"elcn", &settings.elcn,
"lcd", &settings.lcd,
"mtcp", &settings.mtcp,
"dscp", &settings.dscp,
"ipmtudiscover", &settings.ipmtudiscover,
#ifdef HAVE_LIBPCAP
"dump_prefix", &dump_prefix,
#endif /* HAVE_LIBPCAP */
"num_extra_socket_options", &settings.num_extra_socket_options,
"extra_socket_options", &extra_options);
if (env->fault_occurred)
goto cleanup;
/* Check for sanity */
if (strlen(bind_address) >= sizeof(settings.bind_address) - 1 ||
settings.delay[WRITE] < 0 || settings.duration[WRITE] < 0 ||
settings.delay[READ] < 0 || settings.duration[READ] < 0 ||
settings.requested_send_buffer_size < 0 || settings.requested_read_buffer_size < 0 ||
settings.maximum_block_size < MIN_BLOCK_SIZE ||
settings.write_rate < 0 ||
strlen(cc_alg) > TCP_CA_NAME_MAX ||
settings.num_extra_socket_options < 0 || settings.num_extra_socket_options > MAX_EXTRA_SOCKET_OPTIONS ||
xmlrpc_array_size(env, extra_options) != settings.num_extra_socket_options) {
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Flow settings incorrect");
}
/* Parse extra socket options */
for (i = 0; i < settings.num_extra_socket_options; i++) {
const unsigned char* buffer = 0;
size_t len;
xmlrpc_value *option, *level = 0, *optname = 0, *value = 0;
xmlrpc_array_read_item(env, extra_options, i, &option);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "level", &level);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "optname", &optname);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "value", &value);
if (!env->fault_occurred)
xmlrpc_read_int(env, level, &settings.extra_socket_options[i].level);
if (!env->fault_occurred)
xmlrpc_read_int(env, optname, &settings.extra_socket_options[i].optname);
if (!env->fault_occurred)
xmlrpc_read_base64(env, value, &len, &buffer);
if (level)
xmlrpc_DECREF(level);
if (optname)
xmlrpc_DECREF(optname);
if (value)
xmlrpc_DECREF(value);
if (!env->fault_occurred) {
if (len > MAX_EXTRA_SOCKET_OPTION_VALUE_LENGTH) {
free((void *)buffer);
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Too long extra socket option length");
}
settings.extra_socket_options[i].optlen = len;
memcpy(settings.extra_socket_options[i].optval, buffer, len);
free((void *)buffer);
}
if (env->fault_occurred)
goto cleanup;
}
strcpy(settings.cc_alg, cc_alg);
strcpy(settings.bind_address, bind_address);
DEBUG_MSG(LOG_WARNING, "bind_address=%s", bind_address);
request = malloc(sizeof(struct _request_add_flow_destination));
request->settings = settings;
rc = dispatch_request((struct _request*)request, REQUEST_ADD_DESTINATION);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "{s:i,s:i,s:i,s:i}",
"flow_id", request->flow_id,
"listen_data_port", request->listen_data_port,
"real_listen_send_buffer_size", request->real_listen_send_buffer_size,
"real_listen_read_buffer_size", request->real_listen_read_buffer_size);
cleanup:
if (request)
free_all(request->r.error, request);
free_all(cc_alg, bind_address);
if (extra_options)
xmlrpc_DECREF(extra_options);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method add_flow_destination failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination successful");
}
return ret;
}
ER
mig_tsk(ID tskid, ID prcid)
{
TCB *p_tcb;
ER ercd = E_OK;
PCB *t_p_pcb;
PCB *f_p_pcb;
bool_t dspreq = false;
PCB *my_p_pcb;
#ifdef TOPPERS_SYSTIM_LOCAL
EVTTIM left_time;
#endif /* TOPPERS_SYSTIM_LOCAL */
LOG_MIG_TSK_ENTER(tskid, prcid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
CHECK_PRCID_INI(prcid);
t_lock_cpu();
p_tcb = get_tcb_self(tskid, get_my_p_pcb());
prcid = (prcid == TPRC_INI)? p_tcb->p_tinib->iaffinity : prcid;
T_CHECK_MIG(p_tcb->p_tinib->affinity_mask, prcid);
/* 現在割り付けられているプロセッサと移動先のプロセッサのタスクロックを取得 */
t_acquire_dual_tsk_lock(p_tcb, prcid, &f_p_pcb, &t_p_pcb);
my_p_pcb = get_my_p_pcb();
if (f_p_pcb != my_p_pcb) {
/*
* 自タスクと同じプロセッサに割り付けられているタスクでなけれ
* ばエラー． mig_tsk を呼び出したタスクがシステムコール呼出し後，
* マイグレートされた場合にも，ここでエラーとなる
*/
ercd = E_OBJ;
}
else if (TSTAT_RUNNABLE(p_tcb->tstat)){
/* 実行可能状態 */
if(p_tcb == my_p_pcb->p_runtsk) {
/* 自タスクに対して発行 */
if (!(my_p_pcb->dspflg)) {
/* ディスパッチ禁止中ならエラー */
ercd = E_CTX;
}
else if (t_p_pcb == my_p_pcb) {
/* 同一プロセッサを指定 */
/* 優先順位を同一優先度のタスクの中で最低とする */
dspreq = set_lowest_precedence(p_tcb, my_p_pcb);
ercd = E_OK;
}
else {
/* マイグレーション要求を処理 */
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
dispatch_and_migrate(prcid);
/* ここに戻ってくる時にはロックは解放されている */
ercd = E_OK;
t_unlock_cpu();
goto error_exit;
}
}
else {
/* 他タスクの場合 */
if (t_p_pcb == my_p_pcb) {
/* 同一プロセッサを指定 */
/*
* 優先順位を同一優先度のタスクの中で最低とする．
* 対象のタスクは最高優先順位のタスクでないため，タ
* スク切り替えは発生しない
*/
(void)set_lowest_precedence(p_tcb, my_p_pcb);
ercd = E_OK;
}
else {
/* 異なるプロセッサを指定 */
/* レディーキューから外す */
make_non_runnable(p_tcb);
/* pcb の書き換え */
p_tcb->p_pcb = t_p_pcb;
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
/* 移行先のプロセッサでmake_runnable する*/
if (make_runnable(p_tcb)) {
dispatch_request(t_p_pcb);
}
ercd = E_OK;
}
}
}
else if (TSTAT_DORMANT(p_tcb->tstat)) {
/* 休止状態 */
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
p_tcb->p_pcb = t_p_pcb;
ercd = E_OK;
}
else {
/* 待ち状態 */
if ((p_tcb->tmevtb).callback == NULL) {
/* 時間待ちでない場合 */
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
p_tcb->p_pcb = t_p_pcb;
ercd = E_OK;
}
else {
/*
* 時間待ちの場合 グローバルタイマ方式 なら必要なし
*/
#ifdef TOPPERS_SYSTIM_LOCAL
/* キューから削除 */
left_time = tmevtb_dequeue(f_p_pcb->p_tevtcb, &(p_tcb->tmevtb));
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
/* 移動先のプロセッサのキューに挿入 */
tmevtb_insert(t_p_pcb->p_tevtcb, &(p_tcb->tmevtb), base_time(t_p_pcb->p_tevtcb) + left_time);
#else /* TOPPERS_SYSTIM_GLOBAL */
LOG_TSKMIG(p_tcb, my_p_pcb->prcid, prcid);
#endif /* TOPPERS_SYSTIM_GLOBAL */
p_tcb->p_pcb = t_p_pcb;
ercd = E_OK;
}
}
release_dual_tsk_lock(f_p_pcb, t_p_pcb);
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_MIG_TSK_LEAVE(ercd);
return(ercd);
}