void reply_sid(
struct batch_request *preq, /* M */
long sid, /* I */
int which) /* I */
{
char sid_text[MAXLINE];
if (preq->rq_reply.brp_choice != BATCH_REPLY_CHOICE_NULL)
{
/* in case another reply was being built up, clean it out */
reply_free(&preq->rq_reply);
}
sprintf(sid_text,"%lu",sid);
preq->rq_reply.brp_choice = which;
preq->rq_reply.brp_un.brp_txt.brp_str = strdup(sid_text);
preq->rq_reply.brp_un.brp_txt.brp_txtlen = strlen(sid_text);
preq->rq_reply.brp_code = 0;
preq->rq_reply.brp_auxcode = 0;
reply_send_mom(preq);
} /* END reply_text() */
void reply_text(
batch_request *preq,
int code,
const char *text) /* I */
{
if (preq->rq_reply.brp_choice != BATCH_REPLY_CHOICE_NULL)
{
/* in case another reply was being built up, clean it out */
reply_free(&preq->rq_reply);
}
preq->rq_reply.brp_code = code;
preq->rq_reply.brp_auxcode = 0;
if ((text != NULL) && (text[0] != '\0'))
{
preq->rq_reply.brp_choice = BATCH_REPLY_CHOICE_Text;
preq->rq_reply.brp_un.brp_txt.brp_str = strdup(text);
preq->rq_reply.brp_un.brp_txt.brp_txtlen = strlen(text);
}
else
{
preq->rq_reply.brp_choice = BATCH_REPLY_CHOICE_NULL;
}
reply_send(preq);
return;
} /* END reply_text() */
void
req_stat_que(struct batch_request *preq)
{
char *name;
pbs_queue *pque;
struct batch_reply *preply;
int rc = 0;
int type = 0;
/*
* first, validate the name of the requested object, either
* a queue, or null for all queues
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name =='@'))
type = 1;
else {
pque = find_queuebyname(name);
#ifdef NAS /* localmod 075 */
if (pque == NULL)
pque = find_resvqueuebyname(name);
#endif /* localmod 075 */
if (pque == NULL) {
req_reject(PBSE_UNKQUE, 0, preq);
return;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0) { /* get status of the one named queue */
rc = status_que(pque, preq, &preply->brp_un.brp_status);
} else { /* get status of queues */
pque = (pbs_queue *)GET_NEXT(svr_queues);
while (pque) {
rc = status_que(pque, preq, &preply->brp_un.brp_status);
if (rc != 0) {
if (rc == PBSE_PERM)
rc = 0;
else
break;
}
pque = (pbs_queue *)GET_NEXT(pque->qu_link);
}
}
if (rc) {
(void)reply_free(preply);
req_reject(rc, bad, preq);
} else {
(void)reply_send(preq);
}
}
void
req_stat_svr(struct batch_request *preq)
{
svrattrl *pal;
struct batch_reply *preply;
struct brp_status *pstat;
/* update count and state counts from sv_numjobs and sv_jobstates */
server.sv_attr[(int)SRV_ATR_TotalJobs].at_val.at_long = server.sv_qs.sv_numjobs;
server.sv_attr[(int)SRV_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;
update_state_ct(&server.sv_attr[(int)SRV_ATR_JobsByState],
server.sv_jobstates,
server.sv_jobstbuf);
update_license_ct(&server.sv_attr[(int)SRV_ATR_license_count],
server.sv_license_ct_buf);
/* allocate a reply structure and a status sub-structure */
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
pstat = (struct brp_status *)malloc(sizeof(struct brp_status));
if (pstat == NULL) {
reply_free(preply);
req_reject(PBSE_SYSTEM, 0, preq);
return;
}
CLEAR_LINK(pstat->brp_stlink);
(void)strcpy(pstat->brp_objname, server_name);
pstat->brp_objtype = MGR_OBJ_SERVER;
CLEAR_HEAD(pstat->brp_attr);
append_link(&preply->brp_un.brp_status, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
bad = 0;
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(pal, svr_attr_def, server.sv_attr, SRV_ATR_LAST,
preq->rq_perm, &pstat->brp_attr, &bad))
reply_badattr(PBSE_NOATTR, bad, pal, preq);
else
(void)reply_send(preq);
}
static void connection_free_link (struct connection *c)
{
PacketPassFifoQueue_PrepareFree(&c->send_queue);
LinkedList0Node *ln;
while (ln = LinkedList0_GetFirst(&c->replies_list)) {
struct reply *r = UPPER_OBJECT(ln, struct reply, replies_list_node);
ASSERT(r->con == c)
reply_free(r);
}
PacketPassFifoQueue_Free(&c->send_queue);
PacketStreamSender_Free(&c->send_pss);
PacketProtoDecoder_Free(&c->recv_decoder);
PacketPassInterface_Free(&c->recv_if);
BConnection_RecvAsync_Free(&c->con);
BConnection_SendAsync_Free(&c->con);
BConnection_Free(&c->con);
}
int req_stat_svr(
struct batch_request *preq) /* ptr to the decoded request */
{
svrattrl *pal;
struct batch_reply *preply;
struct brp_status *pstat;
int bad = 0;
char nc_buf[128];
int numjobs;
int netrates[3];
memset(netrates, 0, sizeof(netrates));
/* update count and state counts from sv_numjobs and sv_jobstates */
lock_sv_qs_mutex(server.sv_qs_mutex, __func__);
numjobs = server.sv_qs.sv_numjobs;
unlock_sv_qs_mutex(server.sv_qs_mutex, __func__);
pthread_mutex_lock(server.sv_attr_mutex);
server.sv_attr[SRV_ATR_TotalJobs].at_val.at_long = numjobs;
server.sv_attr[SRV_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET;
pthread_mutex_lock(server.sv_jobstates_mutex);
update_state_ct(
&server.sv_attr[SRV_ATR_JobsByState],
server.sv_jobstates,
server.sv_jobstbuf);
pthread_mutex_unlock(server.sv_jobstates_mutex);
netcounter_get(netrates);
snprintf(nc_buf, 127, "%d %d %d", netrates[0], netrates[1], netrates[2]);
if (server.sv_attr[SRV_ATR_NetCounter].at_val.at_str != NULL)
free(server.sv_attr[SRV_ATR_NetCounter].at_val.at_str);
server.sv_attr[SRV_ATR_NetCounter].at_val.at_str = strdup(nc_buf);
if (server.sv_attr[SRV_ATR_NetCounter].at_val.at_str != NULL)
server.sv_attr[SRV_ATR_NetCounter].at_flags |= ATR_VFLAG_SET;
pthread_mutex_unlock(server.sv_attr_mutex);
/* allocate a reply structure and a status sub-structure */
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
pstat = (struct brp_status *)calloc(1, sizeof(struct brp_status));
if (pstat == NULL)
{
reply_free(preply);
req_reject(PBSE_SYSTEM, 0, preq, NULL, NULL);
pthread_mutex_unlock(server.sv_attr_mutex);
return(PBSE_SYSTEM);
}
CLEAR_LINK(pstat->brp_stlink);
strcpy(pstat->brp_objname, server_name);
pstat->brp_objtype = MGR_OBJ_SERVER;
CLEAR_HEAD(pstat->brp_attr);
append_link(&preply->brp_un.brp_status, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(
pal,
svr_attr_def,
server.sv_attr,
SRV_ATR_LAST,
preq->rq_perm,
&pstat->brp_attr,
&bad,
1)) /* IsOwner == TRUE */
{
reply_badattr(PBSE_NOATTR, bad, pal, preq);
}
else
{
reply_send_svr(preq);
}
return(PBSE_NONE);
} /* END req_stat_svr() */
int req_stat_que(
batch_request *preq)
{
char *name;
pbs_queue *pque = NULL;
struct batch_reply *preply;
int rc = 0;
int type = 0;
char log_buf[LOCAL_LOG_BUF_SIZE+1];
/*
* first, validate the name of the requested object, either
* a queue, or null for all queues
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name == '@'))
{
type = 1;
}
else
{
pque = find_queuebyname(name);
if (pque == NULL)
{
rc = PBSE_UNKQUE;
snprintf(log_buf, LOCAL_LOG_BUF_SIZE, "cannot locate queue %s", name);
req_reject(rc, 0, preq, NULL, log_buf);
return rc;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0)
{
/* get status of the named queue */
mutex_mgr pque_mutex = mutex_mgr(pque->qu_mutex, true);
rc = status_que(pque, preq, &preply->brp_un.brp_status);
/* pque_qu_mutex will be unlocked in the destructor when we leave this scope */
}
else
{
/* pque == NULL before next_queue */
svr_queues.lock();
all_queues_iterator *iter = svr_queues.get_iterator();
svr_queues.unlock();
/* get status of all queues */
while ((pque = next_queue(&svr_queues,iter)) != NULL)
{
mutex_mgr pque_mutex = mutex_mgr(pque->qu_mutex, true);
rc = status_que(pque, preq, &preply->brp_un.brp_status);
if (rc != 0)
{
if (rc != PBSE_PERM)
{
break;
}
rc = 0;
}
}
delete iter;
}
if (rc != PBSE_NONE)
{
reply_free(preply);
req_reject(PBSE_NOATTR, rc, preq, NULL, "status_queue failed");
}
else
{
reply_send_svr(preq);
}
return rc;
} /* END req_stat_que() */
void
free_br(struct batch_request *preq)
{
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_parentbr) {
/*
* have a parent who has the original info, so we cannot
* free any data malloc-ed outside of the basic structure;
* decrement the reference count in the parent and when it
* goes to zero, reply_send() it
*/
if (preq->rq_parentbr->rq_refct > 0) {
if (--preq->rq_parentbr->rq_refct == 0)
reply_send(preq->rq_parentbr);
}
if (preq->rppcmd_msgid)
free(preq->rppcmd_msgid);
(void)free(preq);
return;
}
/*
* IMPORTANT - free any data that is malloc-ed outside of the
* basic batch_request structure below here so it is not freed
* when a copy of the structure (for a Array subjob) is freed
*/
if (preq->rq_extend)
(void)free(preq->rq_extend);
switch (preq->rq_type) {
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
(void)free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_UserCred:
if (preq->rq_ind.rq_usercred.rq_data)
(void)free(preq->rq_ind.rq_usercred.rq_data);
break;
case PBS_BATCH_GSS_Context:
if (preq->rq_ind.rq_gssdata.rq_data)
free(preq->rq_ind.rq_gssdata.rq_data);
break;
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
(void)free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_CopyHookFile:
if (preq->rq_ind.rq_hookfile.rq_data)
(void)free(preq->rq_ind.rq_hookfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
(void)free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_RelnodesJob:
if (preq->rq_ind.rq_relnodes.rq_node_list)
(void)free(preq->rq_ind.rq_relnodes.rq_node_list);
break;
case PBS_BATCH_PySpawn:
arrayfree(preq->rq_ind.rq_py_spawn.rq_argv);
arrayfree(preq->rq_ind.rq_py_spawn.rq_envp);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_ModifyResv:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
case PBS_BATCH_StageIn:
case PBS_BATCH_ConfirmResv:
if (preq->rq_ind.rq_run.rq_destin)
(void)free(preq->rq_ind.rq_run.rq_destin);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
case PBS_BATCH_StatusSched:
case PBS_BATCH_StatusHook:
case PBS_BATCH_StatusRsc:
case PBS_BATCH_StatusResv:
if (preq->rq_ind.rq_status.rq_id)
free(preq->rq_ind.rq_status.rq_id);
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
case PBS_BATCH_CopyFiles_Cred:
case PBS_BATCH_DelFiles_Cred:
freebr_cpyfile_cred(&preq->rq_ind.rq_cpyfile_cred);
break;
case PBS_BATCH_MvJobFile:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
#ifndef PBS_MOM /* Server Only */
case PBS_BATCH_SubmitResv:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
case PBS_BATCH_ReserveResc:
case PBS_BATCH_ReleaseResc:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_DefSchReply:
free(preq->rq_ind.rq_defrpy.rq_id);
free(preq->rq_ind.rq_defrpy.rq_txt);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select.rq_selattr);
free_attrlist(&preq->rq_ind.rq_select.rq_rtnattr);
break;
#endif /* PBS_MOM */
}
if (preq->rppcmd_msgid)
free(preq->rppcmd_msgid);
(void)free(preq);
}
static void req_stat_job_step2(
struct stat_cntl *cntl) /* I/O (free'd on return) */
{
svrattrl *pal;
job *pjob = NULL;
struct batch_request *preq;
struct batch_reply *preply;
int rc = 0;
enum TJobStatTypeEnum type;
pbs_queue *pque = NULL;
int exec_only = 0;
int bad = 0;
long DTime; /* delta time - only report full pbs_attribute list if J->MTime > DTime */
static svrattrl *dpal = NULL;
int job_array_index = 0;
job_array *pa = NULL;
char log_buf[LOCAL_LOG_BUF_SIZE];
int iter;
time_t time_now = time(NULL);
long poll_jobs = 0;
char job_id[PBS_MAXSVRJOBID+1];
int job_substate = -1;
time_t job_momstattime = -1;
preq = cntl->sc_origrq;
type = (enum TJobStatTypeEnum)cntl->sc_type;
preply = &preq->rq_reply;
/* See pbs_server_attributes(1B) for details on "poll_jobs" behaviour */
if (dpal == NULL)
{
/* build 'delta' pbs_attribute list */
svrattrl *tpal;
tlist_head dalist;
int aindex;
int atrlist[] =
{
JOB_ATR_jobname,
JOB_ATR_resc_used,
JOB_ATR_LAST
};
CLEAR_LINK(dalist);
for (aindex = 0;atrlist[aindex] != JOB_ATR_LAST;aindex++)
{
if ((tpal = attrlist_create("", "", 23)) == NULL)
{
return;
}
tpal->al_valln = atrlist[aindex];
if (dpal == NULL)
dpal = tpal;
append_link(&dalist, &tpal->al_link, tpal);
}
} /* END if (dpal == NULL) */
if (type == tjstArray)
{
pa = get_array(preq->rq_ind.rq_status.rq_id);
if (pa == NULL)
{
req_reject(PBSE_UNKARRAYID, 0, preq, NULL, "unable to find array");
return;
}
}
iter = -1;
get_svr_attr_l(SRV_ATR_PollJobs, &poll_jobs);
if (!poll_jobs)
{
/* polljobs not set - indicates we may need to obtain fresh data from
MOM */
if (cntl->sc_jobid[0] == '\0')
pjob = NULL;
else
pjob = svr_find_job(cntl->sc_jobid, FALSE);
while (1)
{
if (pjob == NULL)
{
/* start from the first job */
if (type == tjstJob)
{
pjob = svr_find_job(preq->rq_ind.rq_status.rq_id, FALSE);
}
else if (type == tjstQueue)
{
pjob = next_job(cntl->sc_pque->qu_jobs,&iter);
}
else if (type == tjstArray)
{
job_array_index = 0;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (job_array_index < pa->ai_qs.array_size)
{
if (pa->job_ids[job_array_index] != NULL)
{
if ((pjob = svr_find_job(pa->job_ids[job_array_index], FALSE)) != NULL)
{
unlock_ji_mutex(pjob, __func__, "2", LOGLEVEL);
break;
}
}
job_array_index++;
}
}
else
{
pjob = next_job(&alljobs,&iter);
}
} /* END if (pjob == NULL) */
else
{
strcpy(job_id, pjob->ji_qs.ji_jobid);
unlock_ji_mutex(pjob, __func__, "3", LOGLEVEL);
if (type == tjstJob)
break;
if (type == tjstQueue)
pjob = next_job(cntl->sc_pque->qu_jobs,&iter);
else if (type == tjstArray)
{
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (++job_array_index < pa->ai_qs.array_size)
{
if (pa->job_ids[job_array_index] != NULL)
{
if ((pjob = svr_find_job(pa->job_ids[job_array_index], FALSE)) != NULL)
{
unlock_ji_mutex(pjob, __func__, "3", LOGLEVEL);
break;
}
}
}
}
else
pjob = next_job(&alljobs,&iter);
}
if (pjob == NULL)
break;
strcpy(job_id, pjob->ji_qs.ji_jobid);
job_substate = pjob->ji_qs.ji_substate;
job_momstattime = pjob->ji_momstat;
strcpy(cntl->sc_jobid, job_id);
unlock_ji_mutex(pjob, __func__, "4", LOGLEVEL);
pjob = NULL;
/* PBS_RESTAT_JOB defaults to 30 seconds */
if ((job_substate == JOB_SUBSTATE_RUNNING) &&
((time_now - job_momstattime) > JobStatRate))
{
/* go to MOM for status */
if ((rc = stat_to_mom(job_id, cntl)) == PBSE_MEM_MALLOC)
break;
if (rc != 0)
{
pjob = svr_find_job(job_id, FALSE);
rc = 0;
continue;
}
if (pa != NULL)
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
return; /* will pick up after mom replies */
}
} /* END while(1) */
if (rc != 0)
{
if (pa != NULL)
unlock_ai_mutex(pa, __func__, "2", LOGLEVEL);
reply_free(preply);
req_reject(rc, 0, preq, NULL, "cannot get update from mom");
return;
}
} /* END if (!server.sv_attr[SRV_ATR_PollJobs].at_val.at_long) */
/*
* now ready for part 3, building the status reply,
* loop through again
*/
if ((type == tjstSummarizeArraysQueue) ||
(type == tjstSummarizeArraysServer))
{
/* No array can be owned for these options */
update_array_statuses();
}
if (type == tjstJob)
pjob = svr_find_job(preq->rq_ind.rq_status.rq_id, FALSE);
else if (type == tjstQueue)
pjob = next_job(cntl->sc_pque->qu_jobs,&iter);
else if (type == tjstSummarizeArraysQueue)
pjob = next_job(cntl->sc_pque->qu_jobs_array_sum,&iter);
else if (type == tjstSummarizeArraysServer)
pjob = next_job(&array_summary,&iter);
else if (type == tjstArray)
{
job_array_index = -1;
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (++job_array_index < pa->ai_qs.array_size)
{
if (pa->job_ids[job_array_index] != NULL)
{
if ((pjob = svr_find_job(pa->job_ids[job_array_index], FALSE)) != NULL)
{
break;
}
}
}
}
else
pjob = next_job(&alljobs,&iter);
DTime = 0;
if (preq->rq_extend != NULL)
{
char *ptr;
/* FORMAT: { EXECQONLY | DELTA:<EPOCHTIME> } */
if (strstr(preq->rq_extend, EXECQUEONLY))
exec_only = 1;
ptr = strstr(preq->rq_extend, "DELTA:");
if (ptr != NULL)
{
ptr += strlen("delta:");
DTime = strtol(ptr, NULL, 10);
}
}
if ((type == tjstTruncatedServer) ||
(type == tjstTruncatedQueue))
{
long sentJobCounter;
long qjcounter;
long qmaxreport;
int iter = -1;
/* loop through all queues */
while ((pque = next_queue(&svr_queues,&iter)) != NULL)
{
qjcounter = 0;
if ((exec_only == 1) &&
(pque->qu_qs.qu_type != QTYPE_Execution))
{
/* ignore routing queues */
unlock_queue(pque, __func__, "ignore queue", LOGLEVEL);
continue;
}
if (((pque->qu_attr[QA_ATR_MaxReport].at_flags & ATR_VFLAG_SET) != 0) &&
(pque->qu_attr[QA_ATR_MaxReport].at_val.at_long >= 0))
{
qmaxreport = pque->qu_attr[QA_ATR_MaxReport].at_val.at_long;
}
else
{
qmaxreport = TMAX_JOB;
}
if (LOGLEVEL >= 5)
{
sprintf(log_buf,"giving scheduler up to %ld idle jobs in queue %s\n",
qmaxreport,
pque->qu_qs.qu_name);
log_event(PBSEVENT_SYSTEM,PBS_EVENTCLASS_QUEUE,pque->qu_qs.qu_name,log_buf);
}
sentJobCounter = 0;
/* loop through jobs in queue */
if (pjob != NULL)
unlock_ji_mutex(pjob, __func__, "5", LOGLEVEL);
iter = -1;
while ((pjob = next_job(pque->qu_jobs,&iter)) != NULL)
{
if ((qjcounter >= qmaxreport) &&
(pjob->ji_qs.ji_state == JOB_STATE_QUEUED))
{
/* max_report of queued jobs reached for queue */
unlock_ji_mutex(pjob, __func__, "6", LOGLEVEL);
continue;
}
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
rc = status_job(
pjob,
preq,
(pjob->ji_wattr[JOB_ATR_mtime].at_val.at_long >= DTime) ? pal : dpal,
&preply->brp_un.brp_status,
&bad);
if ((rc != 0) && (rc != PBSE_PERM))
{
req_reject(rc, bad, preq, NULL, NULL);
if (pa != NULL)
{
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
}
unlock_ji_mutex(pjob, __func__, "7", LOGLEVEL);
unlock_queue(pque, __func__, "perm", LOGLEVEL);
return;
}
sentJobCounter++;
if (pjob->ji_qs.ji_state == JOB_STATE_QUEUED)
qjcounter++;
unlock_ji_mutex(pjob, __func__, "8", LOGLEVEL);
} /* END foreach (pjob from pque) */
if (LOGLEVEL >= 5)
{
sprintf(log_buf,"sent scheduler %ld total jobs for queue %s\n",
sentJobCounter,
pque->qu_qs.qu_name);
log_event(PBSEVENT_SYSTEM,PBS_EVENTCLASS_QUEUE,pque->qu_qs.qu_name,log_buf);
}
unlock_queue(pque, __func__, "end while", LOGLEVEL);
} /* END for (pque) */
if (pa != NULL)
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
reply_send_svr(preq);
return;
} /* END if ((type == tjstTruncatedServer) || ...) */
while (pjob != NULL)
{
/* go ahead and build the status reply for this job */
if (exec_only)
{
if (cntl->sc_pque != NULL)
{
if (cntl->sc_pque->qu_qs.qu_type != QTYPE_Execution)
goto nextjob;
}
else
{
if (pa != NULL)
pthread_mutex_unlock(pa->ai_mutex);
pque = get_jobs_queue(&pjob);
if (pa != NULL)
pthread_mutex_lock(pa->ai_mutex);
if ((pjob == NULL) ||
(pque == NULL))
goto nextjob;
if (pque->qu_qs.qu_type != QTYPE_Execution)
{
unlock_queue(pque, __func__, "not exec", LOGLEVEL);
goto nextjob;
}
unlock_queue(pque, __func__, "exec", LOGLEVEL);
}
}
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
rc = status_job(
pjob,
preq,
pal,
&preply->brp_un.brp_status,
&bad);
if ((rc != 0) &&
(rc != PBSE_PERM))
{
if (pa != NULL)
{
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
}
unlock_ji_mutex(pjob, __func__, "9", LOGLEVEL);
req_reject(rc, bad, preq, NULL, NULL);
return;
}
/* get next job */
nextjob:
if (pjob != NULL)
unlock_ji_mutex(pjob, __func__, "10", LOGLEVEL);
if (type == tjstJob)
break;
if (type == tjstQueue)
pjob = next_job(cntl->sc_pque->qu_jobs,&iter);
else if (type == tjstSummarizeArraysQueue)
pjob = next_job(cntl->sc_pque->qu_jobs_array_sum,&iter);
else if (type == tjstSummarizeArraysServer)
pjob = next_job(&array_summary,&iter);
else if (type == tjstArray)
{
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (++job_array_index < pa->ai_qs.array_size)
{
if (pa->job_ids[job_array_index] != NULL)
{
if ((pjob = svr_find_job(pa->job_ids[job_array_index], FALSE)) != NULL)
{
break;
}
}
}
}
else
pjob = next_job(&alljobs,&iter);
rc = 0;
} /* END while (pjob != NULL) */
if (pa != NULL)
{
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
}
reply_send_svr(preq);
if (LOGLEVEL >= 7)
{
log_event(PBSEVENT_SYSTEM,
PBS_EVENTCLASS_JOB,
"req_statjob",
"Successfully returned the status of queued jobs\n");
}
return;
} /* END req_stat_job_step2() */
int req_stat_que(
struct batch_request *preq)
{
char *name;
pbs_queue *pque = NULL;
struct batch_reply *preply;
int rc = 0;
int type = 0;
char log_buf[LOCAL_LOG_BUF_SIZE+1];
/*
* first, validate the name of the requested object, either
* a queue, or null for all queues
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name == '@'))
{
type = 1;
}
else
{
pque = find_queuebyname(name);
if (pque == NULL)
{
rc = PBSE_UNKQUE;
snprintf(log_buf, LOCAL_LOG_BUF_SIZE, "can not locate queue %s", name);
req_reject(rc, 0, preq, NULL, log_buf);
return rc;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0)
{
/* get status of the named queue */
rc = status_que(pque, preq, &preply->brp_un.brp_status);
unlock_queue(pque, "req_stat_que", "type == 0", LOGLEVEL);
}
else
{
/* pque == NULL before next_queue */
int iter = -1;
/* get status of all queues */
while ((pque = next_queue(&svr_queues,&iter)) != NULL)
{
rc = status_que(pque, preq, &preply->brp_un.brp_status);
if (rc != 0)
{
if (rc != PBSE_PERM)
{
unlock_queue(pque, "req_stat_que", "break", LOGLEVEL);
break;
}
rc = 0;
}
unlock_queue(pque, "req_stat_que", "end while", LOGLEVEL);
}
}
if (rc != PBSE_NONE)
{
reply_free(preply);
req_reject(PBSE_NOATTR, rc, preq, NULL, "status_queue failed");
}
else
{
reply_send_svr(preq);
}
return rc;
} /* END req_stat_que() */
void free_br(
struct batch_request *preq)
{
if (preq->rq_id != NULL)
{
remove_batch_request(preq->rq_id);
free(preq->rq_id);
preq->rq_id = NULL;
}
reply_free(&preq->rq_reply);
if (preq->rq_extend)
{
free(preq->rq_extend);
preq->rq_extend = NULL;
}
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
{
free(preq->rq_ind.rq_jobcred.rq_data);
preq->rq_ind.rq_jobcred.rq_data = NULL;
}
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
{
free(preq->rq_ind.rq_jobfile.rq_data);
preq->rq_ind.rq_jobfile.rq_data = NULL;
}
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
{
free(preq->rq_ind.rq_message.rq_text);
preq->rq_ind.rq_message.rq_text = NULL;
}
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
if (preq->rq_ind.rq_run.rq_destin)
{
free(preq->rq_ind.rq_run.rq_destin);
preq->rq_ind.rq_run.rq_destin = NULL;
}
break;
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */
void free_br(
struct batch_request *preq)
{
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_extend)
free(preq->rq_extend);
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
#ifndef PBS_MOM /* Server Only */
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
if (preq->rq_ind.rq_run.rq_destin)
free(preq->rq_ind.rq_run.rq_destin);
break;
#endif /* !PBS_MOM */
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */
static void req_stat_job_step2(
struct stat_cntl *cntl) /* I/O (freed on return) */
{
svrattrl *pal;
job *pjob = NULL;
struct batch_request *preq;
struct batch_reply *preply;
int rc = 0;
enum TJobStatTypeEnum type;
pbs_queue *pque = NULL;
int exec_only = 0;
int IsTruncated = 0;
long DTime; /* delta time - only report full attribute list if J->MTime > DTime */
static svrattrl *dpal = NULL;
int job_array_index = 0;
job_array *pa = NULL;
preq = cntl->sc_origrq;
type = (enum TJobStatTypeEnum)cntl->sc_type;
preply = &preq->rq_reply;
/* See pbs_server_attributes(1B) for details on "poll_jobs" behaviour */
/* NOTE: If IsTruncated is true, should walk all queues and walk jobs in each queue
until max_reported is reached (NYI) */
if (dpal == NULL)
{
/* build 'delta' attribute list */
svrattrl *tpal;
tlist_head dalist;
int aindex;
int atrlist[] =
{
JOB_ATR_jobname,
JOB_ATR_resc_used,
JOB_ATR_LAST
};
CLEAR_LINK(dalist);
for (aindex = 0;atrlist[aindex] != JOB_ATR_LAST;aindex++)
{
if ((tpal = attrlist_create("", "", 23)) == NULL)
{
return;
}
tpal->al_valln = atrlist[aindex];
if (dpal == NULL)
dpal = tpal;
append_link(&dalist, &tpal->al_link, tpal);
}
} /* END if (dpal == NULL) */
if (type == tjstArray)
{
pa = get_array(preq->rq_ind.rq_status.rq_id);
}
if (!server.sv_attr[(int)SRV_ATR_PollJobs].at_val.at_long)
{
/* polljobs not set - indicates we may need to obtain fresh data from
MOM */
if (cntl->sc_jobid[0] == '\0')
pjob = NULL;
else
pjob = find_job(cntl->sc_jobid);
while (1)
{
if (pjob == NULL)
{
/* start from the first job */
if (type == tjstJob)
{
pjob = find_job(preq->rq_ind.rq_status.rq_id);
}
else if (type == tjstQueue)
{
pjob = (job *)GET_NEXT(cntl->sc_pque->qu_jobs);
}
else if (type == tjstArray)
{
job_array_index = 0;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (job_array_index < pa->ai_qs.array_size && (pjob = pa->jobs[job_array_index]) == NULL)
job_array_index++;
}
else
{
if ((type == tjstTruncatedServer) || (type == tjstTruncatedQueue))
IsTruncated = TRUE;
pjob = (job *)GET_NEXT(svr_alljobs);
}
} /* END if (pjob == NULL) */
else
{
/* get next job */
if (type == tjstJob)
break;
if (type == tjstQueue)
pjob = (job *)GET_NEXT(pjob->ji_jobque);
else
pjob = (job *)GET_NEXT(pjob->ji_alljobs);
if (type == tjstArray)
{
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (++job_array_index < pa->ai_qs.array_size && (pjob = pa->jobs[job_array_index]) == NULL)
;
}
}
if (pjob == NULL)
break;
/* PBS_RESTAT_JOB defaults to 30 seconds */
if ((pjob->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING) &&
((time_now - pjob->ji_momstat) > JobStatRate))
{
/* go to MOM for status */
strcpy(cntl->sc_jobid, pjob->ji_qs.ji_jobid);
if ((rc = stat_to_mom(pjob, cntl)) == PBSE_SYSTEM)
{
break;
}
if (rc != 0)
{
rc = 0;
continue;
}
return; /* will pick up after mom replies */
}
} /* END while(1) */
if (cntl->sc_conn >= 0)
svr_disconnect(cntl->sc_conn); /* close connection to MOM */
if (rc != 0)
{
free(cntl);
reply_free(preply);
req_reject(rc, 0, preq, NULL, "cannot get update from mom");
return;
}
} /* END if (!server.sv_attr[(int)SRV_ATR_PollJobs].at_val.at_long) */
/*
* now ready for part 3, building the status reply,
* loop through again
*/
if (type == tjstSummarizeArraysQueue || type == tjstSummarizeArraysServer)
{
update_array_statuses();
}
if (type == tjstJob)
pjob = find_job(preq->rq_ind.rq_status.rq_id);
else if (type == tjstQueue)
pjob = (job *)GET_NEXT(cntl->sc_pque->qu_jobs);
else if (type == tjstSummarizeArraysQueue)
pjob = (job *)GET_NEXT(cntl->sc_pque->qu_jobs_array_sum);
else if (type == tjstSummarizeArraysServer)
pjob = (job *)GET_NEXT(svr_jobs_array_sum);
else if (type == tjstArray)
{
job_array_index = 0;
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (job_array_index < pa->ai_qs.array_size && (pjob = pa->jobs[job_array_index]) == NULL)
job_array_index++;
}
else
pjob = (job *)GET_NEXT(svr_alljobs);
DTime = 0;
if (preq->rq_extend != NULL)
{
char *ptr;
/* FORMAT: { EXECQONLY | DELTA:<EPOCHTIME> } */
if (strstr(preq->rq_extend, EXECQUEONLY))
exec_only = 1;
ptr = strstr(preq->rq_extend, "DELTA:");
if (ptr != NULL)
{
ptr += strlen("delta:");
DTime = strtol(ptr, NULL, 10);
}
}
free(cntl);
if ((type == tjstTruncatedServer) || (type == tjstTruncatedQueue))
{
long sentJobCounter;
long qjcounter;
long qmaxreport;
/* loop through all queues */
for (pque = (pbs_queue *)GET_NEXT(svr_queues);
pque != NULL;
pque = (pbs_queue *)GET_NEXT(pque->qu_link))
{
qjcounter = 0;
if ((exec_only == 1) &&
(pque->qu_qs.qu_type != QTYPE_Execution))
{
/* ignore routing queues */
continue;
}
if (((pque->qu_attr[QA_ATR_MaxReport].at_flags & ATR_VFLAG_SET) != 0) &&
(pque->qu_attr[QA_ATR_MaxReport].at_val.at_long >= 0))
{
qmaxreport = pque->qu_attr[QA_ATR_MaxReport].at_val.at_long;
}
else
{
qmaxreport = TMAX_JOB;
}
if (LOGLEVEL >= 5)
{
sprintf(log_buffer,"giving scheduler up to %ld idle jobs in queue %s\n",
qmaxreport,
pque->qu_qs.qu_name);
log_event(
PBSEVENT_SYSTEM,
PBS_EVENTCLASS_QUEUE,
pque->qu_qs.qu_name,
log_buffer);
}
sentJobCounter = 0;
/* loop through jobs in queue */
for (pjob = (job *)GET_NEXT(pque->qu_jobs);
pjob != NULL;
pjob = (job *)GET_NEXT(pjob->ji_jobque))
{
if ((qjcounter >= qmaxreport) &&
(pjob->ji_qs.ji_state == JOB_STATE_QUEUED))
{
/* max_report of queued jobs reached for queue */
continue;
}
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
rc = status_job(
pjob,
preq,
(pjob->ji_wattr[(int)JOB_ATR_mtime].at_val.at_long >= DTime) ? pal : dpal,
&preply->brp_un.brp_status,
&bad);
if ((rc != 0) && (rc != PBSE_PERM))
{
req_reject(rc, bad, preq, NULL, NULL);
return;
}
sentJobCounter++;
if (pjob->ji_qs.ji_state == JOB_STATE_QUEUED)
qjcounter++;
} /* END for (pjob) */
if (LOGLEVEL >= 5)
{
sprintf(log_buffer,"sent scheduler %ld total jobs for queue %s\n",
sentJobCounter,
pque->qu_qs.qu_name);
log_event(
PBSEVENT_SYSTEM,
PBS_EVENTCLASS_QUEUE,
pque->qu_qs.qu_name,
log_buffer);
}
} /* END for (pque) */
reply_send(preq);
return;
} /* END if ((type == tjstTruncatedServer) || ...) */
while (pjob != NULL)
{
/* go ahead and build the status reply for this job */
if (exec_only)
{
pque = find_queuebyname(pjob->ji_qs.ji_queue);
if (pque->qu_qs.qu_type != QTYPE_Execution)
goto nextjob;
}
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
rc = status_job(
pjob,
preq,
pal,
&preply->brp_un.brp_status,
&bad);
if ((rc != 0) && (rc != PBSE_PERM))
{
req_reject(rc, bad, preq, NULL, NULL);
return;
}
/* get next job */
nextjob:
if (type == tjstJob)
break;
if (type == tjstQueue)
pjob = (job *)GET_NEXT(pjob->ji_jobque);
else if (type == tjstSummarizeArraysQueue)
pjob = (job *)GET_NEXT(pjob->ji_jobque_array_sum);
else if (type == tjstSummarizeArraysServer)
pjob = (job *)GET_NEXT(pjob->ji_jobs_array_sum);
else if (type == tjstArray)
{
pjob = NULL;
/* increment job_array_index until we find a non-null pointer or hit the end */
while (++job_array_index < pa->ai_qs.array_size && (pjob = pa->jobs[job_array_index]) == NULL)
;
}
else
pjob = (job *)GET_NEXT(pjob->ji_alljobs);
rc = 0;
} /* END while (pjob != NULL) */
reply_send(preq);
if (LOGLEVEL >= 7)
{
log_event(PBSEVENT_SYSTEM,
PBS_EVENTCLASS_JOB,
"req_statjob",
"Successfully returned the status of queued jobs\n");
}
return;
} /* END req_stat_job_step2() */
void req_stat_svr(
struct batch_request *preq) /* ptr to the decoded request */
{
svrattrl *pal;
struct batch_reply *preply;
struct brp_status *pstat;
int *nc;
static char nc_buf[128];
/* update count and state counts from sv_numjobs and sv_jobstates */
server.sv_attr[(int)SRV_ATR_TotalJobs].at_val.at_long = server.sv_qs.sv_numjobs;
server.sv_attr[(int)SRV_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET;
update_state_ct(
&server.sv_attr[(int)SRV_ATR_JobsByState],
server.sv_jobstates,
server.sv_jobstbuf);
nc = netcounter_get();
sprintf(nc_buf, "%d %d %d", *nc, *(nc + 1), *(nc + 2));
server.sv_attr[(int)SRV_ATR_NetCounter].at_val.at_str = nc_buf;
server.sv_attr[(int)SRV_ATR_NetCounter].at_flags |= ATR_VFLAG_SET;
/* allocate a reply structure and a status sub-structure */
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
pstat = (struct brp_status *)malloc(sizeof(struct brp_status));
if (pstat == NULL)
{
reply_free(preply);
req_reject(PBSE_SYSTEM, 0, preq, NULL, NULL);
return;
}
CLEAR_LINK(pstat->brp_stlink);
strcpy(pstat->brp_objname, server_name);
pstat->brp_objtype = MGR_OBJ_SERVER;
CLEAR_HEAD(pstat->brp_attr);
append_link(&preply->brp_un.brp_status, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
bad = 0;
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(
pal,
svr_attr_def,
server.sv_attr,
SRV_ATR_LAST,
preq->rq_perm,
&pstat->brp_attr,
&bad,
1)) /* IsOwner == TRUE */
{
reply_badattr(PBSE_NOATTR, bad, pal, preq);
}
else
{
reply_send(preq);
}
return;
} /* END req_stat_svr() */
void req_stat_que(
struct batch_request *preq) /* ptr to the decoded request */
{
char *name;
pbs_queue *pque = NULL;
struct batch_reply *preply;
int rc = 0;
int type = 0;
/*
* first, validate the name of the requested object, either
* a queue, or null for all queues
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name == '@'))
{
type = 1;
}
else
{
pque = find_queuebyname(name);
if (pque == NULL)
{
req_reject(PBSE_UNKQUE, 0, preq, NULL, "cannot locate queue");
return;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0)
{
/* get status of the named queue */
rc = status_que(pque, preq, &preply->brp_un.brp_status);
}
else
{
/* get status of all queues */
pque = (pbs_queue *)GET_NEXT(svr_queues);
while (pque != NULL)
{
rc = status_que(pque, preq, &preply->brp_un.brp_status);
if (rc != 0)
{
if (rc != PBSE_PERM)
break;
rc = 0;
}
pque = (pbs_queue *)GET_NEXT(pque->qu_link);
}
}
if (rc != 0)
{
reply_free(preply);
req_reject(rc, bad, preq, NULL, "status_queue failed");
}
else
{
reply_send(preq);
}
return;
} /* END req_stat_que() */
void free_br(
batch_request *preq)
{
if (preq == NULL)
return;
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_extend)
free(preq->rq_extend);
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */