bool_t
xdr_chunkStatusReq (XDR *xdrs, struct chunkStatusReq *chunkStatusReq,
struct LSFHeader *hdr)
{
static char fname[] = "xdr_chunkStatusReq";
int i;
if (xdrs->x_op == XDR_DECODE) {
chunkStatusReq->numStatusReqs = 0;
chunkStatusReq->statusReqs = NULL;
}
if (xdrs->x_op == XDR_FREE) {
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
xdr_lsffree(xdr_statusReq,
(char *)chunkStatusReq->statusReqs[i], hdr);
FREEUP(chunkStatusReq->statusReqs[i]);
}
FREEUP(chunkStatusReq->statusReqs);
return(TRUE);
}
if (!xdr_int(xdrs, &chunkStatusReq->numStatusReqs)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int",
"numStatusReqs");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE && chunkStatusReq->numStatusReqs) {
chunkStatusReq->statusReqs = (struct statusReq **)
my_calloc(chunkStatusReq->numStatusReqs,
sizeof (struct statusReq *), fname);
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
chunkStatusReq->statusReqs[i] = (struct statusReq *) my_calloc(1,
sizeof (struct statusReq), fname);
}
}
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
xdr_statusReq(xdrs, chunkStatusReq->statusReqs[i], hdr);
}
return(TRUE);
}
struct queueInfoEnt *
lsb_queueinfo (char **queues,
int *numQueues,
char *hosts,
char *users,
int options)
{
mbdReqType mbdReqtype;
static struct infoReq queueInfoReq;
static struct queueInfoReply reply;
static struct queueInfoEnt **qInfo = NULL;
struct queueInfoEnt **qTmp;
XDR xdrs;
XDR xdrs2;
char *request_buf;
char *reply_buf;
int cc;
int i;
static struct LSFHeader hdr;
char *clusterName = NULL;
if (qInfo != NULL) {
for (i = 0; i < reply.numQueues; i++) {
xdr_lsffree(xdr_queueInfoEnt,
(char*)qInfo[i],
&hdr);
}
}
if (numQueues == NULL) {
lsberrno = LSBE_BAD_ARG;
return NULL;
}
if ((queues == NULL && *numQueues > 1) || (*numQueues < 0)) {
lsberrno = LSBE_BAD_ARG;
return NULL;
}
queueInfoReq.options = 0;
if (queueInfoReq.names) {
FREEUP (queueInfoReq.names);
}
if (numQueues == NULL || *numQueues == 0)
queueInfoReq.options |= ALL_QUEUE;
else if (queues == NULL && *numQueues == 1)
queueInfoReq.options |= DFT_QUEUE;
if ((queueInfoReq.options & ALL_QUEUE)
|| (queueInfoReq.options & DFT_QUEUE)) {
if ((queueInfoReq.names = malloc(3 * sizeof(char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
queueInfoReq.names[0] = "";
queueInfoReq.numNames = 1;
cc = 1;
} else {
if ((queueInfoReq.names = calloc(*numQueues + 2,
sizeof(char*))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
queueInfoReq.numNames = *numQueues;
for (i = 0; i < *numQueues; i++) {
if (queues[i] && strlen(queues[i]) + 1 < MAXHOSTNAMELEN) {
queueInfoReq.names[i] = queues[i];
} else {
free (queueInfoReq.names);
queueInfoReq.names = NULL;
lsberrno = LSBE_BAD_QUEUE;
*numQueues = i;
return NULL;
}
}
cc = queueInfoReq.numNames;
}
if (users != NULL) {
if (strlen(users) + 1 < MAX_LSB_NAME_LEN) {
queueInfoReq.options |= CHECK_USER;
queueInfoReq.names[cc] = users;
cc++;
} else {
lsberrno = LSBE_BAD_USER;
*numQueues = 0;
return NULL;
}
}
if (hosts != NULL) {
if (ls_isclustername(hosts) <= 0) {
if (strlen (hosts) + 1 < MAXHOSTNAMELEN) {
queueInfoReq.options |= CHECK_HOST;
queueInfoReq.names[cc] = hosts;
cc++;
} else {
lsberrno = LSBE_BAD_HOST;
*numQueues = 0;
return NULL;
}
} else
clusterName = hosts;
}
queueInfoReq.resReq = "";
mbdReqtype = BATCH_QUE_INFO;
cc = sizeof(struct infoReq) + cc * MAXHOSTNAMELEN + cc + 128;
if ((request_buf = malloc (cc)) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs,
(char *)&queueInfoReq,
&hdr,
xdr_infoReq,
0,
NULL)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
free (request_buf);
return NULL;
}
if ((cc = callmbd(clusterName,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&hdr,
NULL,
NULL,
NULL)) == -1) {
xdr_destroy(&xdrs);
free (request_buf);
return NULL;
}
xdr_destroy(&xdrs);
free (request_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR
|| lsberrno == LSBE_BAD_QUEUE) {
xdrmem_create(&xdrs2, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (!xdr_queueInfoReply(&xdrs2, &reply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
*numQueues = 0;
return NULL;
}
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
if (lsberrno == LSBE_BAD_QUEUE) {
*numQueues = reply.badQueue;
return NULL;
}
if ((qTmp = myrealloc(qInfo,
reply.numQueues
* sizeof(struct queueInfoEnt *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
qInfo = qTmp;
for (i = 0; i < reply.numQueues; i++)
qInfo[i] = &(reply.queues[i]);
*numQueues = reply.numQueues;
return qInfo[0];
}
if (cc)
free(reply_buf);
*numQueues = 0;
return NULL;
}
void
do_probe(XDR * xdrs, int chfd, struct LSFHeader * reqHdr)
{
static char fname[] = "do_probe()";
char reply_buf[MSGSIZE];
XDR xdrs2;
struct LSFHeader replyHdr;
struct sbdPackage sbdPackage;
struct jobSpecs *jobSpecs;
int i;
struct lsfAuth *auth = NULL;
if (reqHdr->length == 0)
return;
initLSFHeader_(&replyHdr);
replyHdr.opCode = ERR_NO_ERROR;
jobSpecs = NULL;
if (!xdr_sbdPackage(xdrs, &sbdPackage, reqHdr)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_sbdPackage");
relife();
} else {
if (sbdPackage.numJobs) {
jobSpecs = my_calloc(sbdPackage.numJobs,
sizeof(struct jobSpecs), fname);
for (i = 0; i < sbdPackage.numJobs; i++) {
if (!xdr_arrayElement(xdrs, (char *) &(jobSpecs[i]),
reqHdr, xdr_jobSpecs)) {
replyHdr.opCode = ERR_BAD_REQ;
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5815,
"%s: %s(%d) failed for %d jobs"), /* catgets 5815 */
fname, "xdr_arrayElement", i, sbdPackage.numJobs);
break;
}
refreshJob(&(jobSpecs[i]));
xdr_lsffree(xdr_jobSpecs, (char *)&jobSpecs[i], reqHdr);
}
}
}
if (replyHdr.opCode == ERR_NO_ERROR)
if (!xdr_sbdPackage1(xdrs, &sbdPackage, reqHdr)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_sbdPackage1");
relife();
}
if (replyHdr.opCode == ERR_NO_ERROR) {
if (myStatus & NO_LIM) {
replyHdr.opCode = ERR_NO_LIM;
}
}
xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE);
if (!xdr_encodeMsg(&xdrs2, NULL, &replyHdr, NULL, 0, auth)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_encodeMsg");
relife();
}
if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "chanWrite_");
}
xdr_destroy(&xdrs2);
if (jobSpecs != NULL)
free(jobSpecs);
getManagerId(&sbdPackage);
mbdPid = sbdPackage.mbdPid;
sbdSleepTime = sbdPackage.sbdSleepTime;
retryIntvl = sbdPackage.retryIntvl;
preemPeriod = sbdPackage.preemPeriod;
pgSuspIdleT = sbdPackage.pgSuspIdleT;
maxJobs = sbdPackage.maxJobs;
uJobLimit = sbdPackage.uJobLimit;
rusageUpdateRate = sbdPackage.rusageUpdateRate;
rusageUpdatePercent = sbdPackage.rusageUpdatePercent;
jobTerminateInterval = sbdPackage.jobTerminateInterval;
for (i = 0; i < sbdPackage.nAdmins; i++)
FREEUP(sbdPackage.admins[i]);
FREEUP(sbdPackage.admins);
return;
}
static int
sendGrpReq (char *clusterName, int options, struct infoReq *groupInfo,
struct groupInfoReply *reply)
{
XDR xdrs;
char request_buf[MSGSIZE];
char * reply_buf;
struct LSFHeader hdr;
mbdReqType mbdReqtype;
int cc;
xdr_lsffree(xdr_groupInfoReply, (char *)reply, &hdr);
mbdReqtype = BATCH_GRP_INFO;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs,
(char *)groupInfo,
&hdr,
xdr_infoReq,
0,
NULL)){
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return -1;
}
if ((cc = callmbd (clusterName,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&hdr,
NULL,
NULL,
NULL)) == -1) {
xdr_destroy(&xdrs);
return -1;
}
xdr_destroy(&xdrs);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR || lsberrno == LSBE_BAD_GROUP ) {
xdrmem_create(&xdrs,
reply_buf,
XDR_DECODE_SIZE_(cc),
XDR_DECODE);
if (!xdr_groupInfoReply(&xdrs, reply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return -1;
}
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return 0;
}
if (cc)
free(reply_buf);
return -1;
}
void
do_modifyjob(XDR * xdrs, int chfd, struct LSFHeader * reqHdr)
{
static char fname[] = "do_switchjob()";
char reply_buf[MSGSIZE];
XDR xdrs2;
struct jobSpecs jobSpecs;
struct jobReply jobReply;
sbdReplyType reply;
char found = FALSE;
struct LSFHeader replyHdr;
char *replyStruct;
struct jobCard *jp;
struct lsfAuth *auth = NULL;
memset(&jobReply, 0, sizeof(struct jobReply));
if (!xdr_jobSpecs(xdrs, &jobSpecs, reqHdr)) {
reply = ERR_BAD_REQ;
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobSpecs");
goto sendReply;
}
for (jp = jobQueHead->back; jp != jobQueHead; jp = jp->back)
if (jp->jobSpecs.jobId == jobSpecs.jobId) {
found = TRUE;
break;
}
if (!found) {
reply = ERR_NO_JOB;
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5808,
"%s: mbatchd trying to modify a non-existent job <%s>"), fname, lsb_jobid2str(jobSpecs.jobId)); /* catgets 5808 */
goto sendReply;
}
if (jp->jobSpecs.jStatus & (JOB_STAT_DONE | JOB_STAT_EXIT)) {
reply = ERR_JOB_FINISH;
goto sendReply;
}
if ((lsbJobCpuLimit != 1) &&
((jp->jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_maxl
!= jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_maxl) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_maxh
!= jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_maxh) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_curl
!= jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_curl) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_curh
!= jobSpecs.lsfLimits[LSF_RLIMIT_CPU].rlim_curh)
)) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd, NL_SETN, 5809, "%s, LSB_JOB_CPULIMIT is not set for the host, job <%s>, CPU limit not modified"), fname, lsb_jobid2str(jobSpecs.jobId));
} else {
memcpy((char *) &jp->jobSpecs.lsfLimits[LSF_RLIMIT_CPU],
(char *) &jobSpecs.lsfLimits[LSF_RLIMIT_CPU],
sizeof(struct lsfLimit));
}
if ((lsbJobMemLimit != 1) &&
((jp->jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_maxl
!= jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_maxl) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_maxh
!= jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_maxh) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_curl
!= jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_curl) ||
(jp->jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_curh
!= jobSpecs.lsfLimits[LSF_RLIMIT_RSS].rlim_curh)
)) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd, NL_SETN, 5810, "%s, LSB_JOB_MEMLIMIT is not set for the host, job <%s>, memory limit not modified"), fname, lsb_jobid2str(jobSpecs.jobId));
} else {
memcpy((char *) &jp->jobSpecs.lsfLimits[LSF_RLIMIT_RSS],
(char *) &jobSpecs.lsfLimits[LSF_RLIMIT_RSS],
sizeof(struct lsfLimit));
}
memcpy((char *) &jp->jobSpecs.lsfLimits[LSF_RLIMIT_RUN],
(char *) &jobSpecs.lsfLimits[LSF_RLIMIT_RUN],
sizeof(struct lsfLimit));
setRunLimit(jp, FALSE);
if (strcmp(jp->jobSpecs.outFile, jobSpecs.outFile) ||
!(strcmp(jobSpecs.outFile, "/dev/null")))
{
strcpy(jp->jobSpecs.outFile, jobSpecs.outFile);
if (strcmp(jobSpecs.outFile, "/dev/null") ||
(jobSpecs.options & SUB_OUT_FILE)) {
jp->jobSpecs.options |= SUB_OUT_FILE;
}
else {
jp->jobSpecs.options &= ~SUB_OUT_FILE;
}
}
if (strcmp(jp->jobSpecs.errFile, jobSpecs.errFile))
{
strcpy(jp->jobSpecs.errFile, jobSpecs.errFile);
if (!strcmp(jp->jobSpecs.errFile, "/dev/null")
&& !(jobSpecs.options & SUB_ERR_FILE)) {
jp->jobSpecs.options &= ~SUB_ERR_FILE;
}
}
if (jobSpecs.options & SUB_RERUNNABLE) {
jp->jobSpecs.options |= SUB_RERUNNABLE;
} else {
jp->jobSpecs.options &= ~SUB_RERUNNABLE;
}
sendReply:
xdr_lsffree(xdr_jobSpecs, (char *)&jobSpecs, reqHdr);
xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&replyHdr);
replyHdr.opCode = reply;
if (reply == ERR_NO_ERROR)
replyStruct = (char *) &jobReply;
else {
replyStruct = (char *) 0;
}
if (!xdr_encodeMsg(&xdrs2, replyStruct, &replyHdr, xdr_jobReply, 0, auth)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_M, fname,
lsb_jobid2str(jp->jobSpecs.jobId),
"xdr_jobReply");
relife();
}
if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_M, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "chanWrite_");
}
xdr_destroy(&xdrs2);
return;
}
void
do_newjob(XDR *xdrs, int chfd, struct LSFHeader *reqHdr)
{
static char fname[] = "do_newjob()";
char reply_buf[MSGSIZE];
XDR xdrs2;
struct jobSpecs jobSpecs;
struct jobReply jobReply;
struct jobCard *jp;
sbdReplyType reply;
struct LSFHeader replyHdr;
char *replyStruct;
struct lsfAuth *auth = NULL;
memset(&jobReply, 0, sizeof(struct jobReply));
if (!xdr_jobSpecs(xdrs, &jobSpecs, reqHdr)) {
reply = ERR_BAD_REQ;
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobSpecs");
goto sendReply;
}
for (jp = jobQueHead->forw; (jp != jobQueHead); jp = jp->forw) {
if (jp->jobSpecs.jobId == jobSpecs.jobId) {
jobReply.jobId = jp->jobSpecs.jobId;
jobReply.jobPid = jp->jobSpecs.jobPid;
jobReply.jobPGid = jp->jobSpecs.jobPGid;
jobReply.jStatus = jp->jobSpecs.jStatus;
reply = ERR_NO_ERROR;
goto sendReply;
}
}
jp = calloc(1, sizeof(struct jobCard));
if (jp == NULL) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_M, fname,
lsb_jobid2str(jobSpecs.jobId), "calloc");
reply = ERR_MEM;
goto sendReply;
}
memcpy((char *) &jp->jobSpecs, (char *) &jobSpecs,
sizeof(struct jobSpecs));
jp->jobSpecs.jStatus &= ~JOB_STAT_MIG;
jp->jobSpecs.startTime = now;
jp->jobSpecs.reasons = 0;
jp->jobSpecs.subreasons = 0;
/* Initialize the core number
*/
jp->core_num = -1;
if (jp->jobSpecs.jAttrib & Q_ATTRIB_EXCLUSIVE) {
if (lockHosts (jp) < 0) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "lockHosts");
unlockHosts (jp, jp->jobSpecs.numToHosts);
reply = ERR_LOCK_FAIL;
freeWeek(jp->week);
FREEUP(jp);
goto sendReply;
}
}
jp->runTime = 0;
if (initJobCard(jp, &jobSpecs, (int *)&reply) < 0) {
if (jp->jobSpecs.jAttrib & Q_ATTRIB_EXCLUSIVE) {
unlockHosts (jp, jp->jobSpecs.numToHosts);
}
FREEUP(jp);
goto sendReply;
}
jp->execJobFlag = 0;
if (jp->runTime < 0) {
jp->runTime = 0;
}
jp->execGid = 0;
jp->execUsername[0] = '\0';
jp->jobSpecs.execUid = -1;
jp->jobSpecs.execUsername[0] = '\0';
if (jp->jobSpecs.jobSpoolDir[0] != '\0') {
char *tmp;
if ((tmp = getUnixSpoolDir (jp->jobSpecs.jobSpoolDir)) == NULL) {
jp->jobSpecs.jobSpoolDir[0] = '\0';
}
}
if ((logclass & LC_TRACE) && jp->jobSpecs.jobSpoolDir[0] != 0) {
ls_syslog(LOG_DEBUG,
"%s: the SpoolDir for job <%s> is %s \n",
fname, lsb_jobid2str(jp->jobSpecs.jobId),
jp->jobSpecs.jobSpoolDir);
}
if (jp->jobSpecs.options & SUB_PRE_EXEC)
SBD_SET_STATE(jp, (JOB_STAT_RUN | JOB_STAT_PRE_EXEC))
else
SBD_SET_STATE(jp, JOB_STAT_RUN);
reply = job_exec(jp, chfd);
if (reply != ERR_NO_ERROR) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "job_exec");
if (jp->jobSpecs.jAttrib & Q_ATTRIB_EXCLUSIVE) {
unlockHosts (jp, jp->jobSpecs.numToHosts);
}
deallocJobCard(jp);
} else {
jobReply.jobId = jp->jobSpecs.jobId;
jobReply.jobPid = jp->jobSpecs.jobPid;
jobReply.jobPGid = jp->jobSpecs.jobPGid;
jobReply.jStatus = jp->jobSpecs.jStatus;
}
sendReply:
xdr_lsffree(xdr_jobSpecs, (char *)&jobSpecs, reqHdr);
xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&replyHdr);
replyHdr.opCode = reply;
replyStruct = (reply == ERR_NO_ERROR) ? (char *) &jobReply : (char *) NULL;
if (!xdr_encodeMsg(&xdrs2, replyStruct, &replyHdr, xdr_jobReply, 0, auth)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobReply");
lsb_merr(_i18n_msg_get(ls_catd , NL_SETN, 5804,
"Fatal error: xdr_jobReply() failed; sbatchd relifing")); /* catgets 5804 */
relife();
}
if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5805,
"%s: Sending jobReply (len=%d) to master failed: %m"), /* catgets 5805 */
fname, XDR_GETPOS(&xdrs2));
}
xdr_destroy(&xdrs2);
if (reply == ERR_NO_ERROR && !daemonParams[LSB_BSUBI_OLD].paramValue &&
PURE_INTERACTIVE(&jp->jobSpecs)) {
if (status_job (BATCH_STATUS_JOB, jp, jp->jobSpecs.jStatus,
ERR_NO_ERROR) < 0) {
jp->notReported++;
}
}
}
void
do_switchjob(XDR * xdrs, int chfd, struct LSFHeader * reqHdr)
{
static char fname[] = "do_switchjob()";
char reply_buf[MSGSIZE];
XDR xdrs2;
struct jobSpecs jobSpecs;
struct jobReply jobReply;
int i;
sbdReplyType reply;
char *cp;
char *word;
char found = FALSE;
struct LSFHeader replyHdr;
char *replyStruct;
struct jobCard *jp;
struct lsfAuth *auth = NULL;
memset(&jobReply, 0, sizeof(struct jobReply));
if (!xdr_jobSpecs(xdrs, &jobSpecs, reqHdr)) {
reply = ERR_BAD_REQ;
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobSpecs");
goto sendReply;
}
for (jp = jobQueHead->back; jp != jobQueHead; jp = jp->back) {
if (jp->jobSpecs.jobId == jobSpecs.jobId) {
found = TRUE;
break;
}
}
if (!found) {
reply = ERR_NO_JOB;
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5807,
"%s: mbatchd trying to switch a non-existent job <%s>"), fname, lsb_jobid2str(jobSpecs.jobId)); /* catgets 5807 */
goto sendReply;
}
if (jp->jobSpecs.jStatus & (JOB_STAT_DONE | JOB_STAT_EXIT)) {
reply = ERR_JOB_FINISH;
goto sendReply;
}
cp = jobSpecs.windows;
freeWeek(jp->week);
while ((word = getNextWord_(&cp)) != NULL) {
if (addWindow(word, jp->week, "switchJob jobSpecs") < 0) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S_M, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "addWindow", word);
freeWeek(jp->week);
reply = ERR_BAD_REQ;
goto sendReply;
}
}
jp->windEdge = now;
if ((jp->jobSpecs.jAttrib & Q_ATTRIB_EXCLUSIVE)
&& !(jobSpecs.jAttrib & Q_ATTRIB_EXCLUSIVE))
for (i = 0; i < jp->jobSpecs.numToHosts; i++)
if (unlockHost_(jp->jobSpecs.toHosts[i]) < 0
&& lserrno != LSE_LIM_NLOCKED)
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S_MM, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "unlockHost_", jp->jobSpecs.toHosts[i]);
strcpy(jp->jobSpecs.queue, jobSpecs.queue);
strcpy(jp->jobSpecs.windows, jobSpecs.windows);
jp->jobSpecs.priority = jobSpecs.priority;
jp->jobSpecs.nice = jobSpecs.nice;
jp->jobSpecs.jAttrib = jobSpecs.jAttrib;
freeThresholds (&jp->jobSpecs.thresholds);
saveThresholds (&jp->jobSpecs, &jobSpecs.thresholds);
memcpy((char *) &jp->jobSpecs.lsfLimits[LSF_RLIMIT_RUN],
(char *) &jobSpecs.lsfLimits[LSF_RLIMIT_RUN],
sizeof(struct lsfLimit));
strcpy (jp->jobSpecs.requeueEValues, jobSpecs.requeueEValues);
strcpy (jp->jobSpecs.resumeCond, jobSpecs.resumeCond);
strcpy (jp->jobSpecs.stopCond, jobSpecs.stopCond);
lsbFreeResVal (&jp->resumeCondVal);
if (jobSpecs.resumeCond && jobSpecs.resumeCond[0] != '\0') {
if ((jp->resumeCondVal = checkThresholdCond (jobSpecs.resumeCond))
== NULL)
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(jp->jobSpecs.jobId),
"checkThresholdCond", jobSpecs.resumeCond);
}
lsbFreeResVal (&jp->stopCondVal);
if (jobSpecs.stopCond && jobSpecs.stopCond[0] != '\0') {
if ((jp->stopCondVal = checkThresholdCond (jobSpecs.stopCond))
== NULL)
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(jp->jobSpecs.jobId),
"checkThresholdCond", jobSpecs.stopCond);
}
if (jobSpecs.options & SUB_LOGIN_SHELL) {
FREEUP (jp->jobSpecs.loginShell);
jp->jobSpecs.loginShell = safeSave (jobSpecs.loginShell);
}
strcpy (jp->jobSpecs.suspendActCmd, jobSpecs.suspendActCmd);
strcpy (jp->jobSpecs.resumeActCmd, jobSpecs.resumeActCmd);
strcpy (jp->jobSpecs.terminateActCmd, jobSpecs.terminateActCmd);
setRunLimit (jp, FALSE);
offList ((struct listEntry *)jp);
inJobLink (jp);
if (reniceJob(jp) < 0)
ls_syslog(LOG_DEBUG, "%s: renice job <%s> failed",
fname, lsb_jobid2str(jp->jobSpecs.jobId));
reply = ERR_NO_ERROR;
jobReply.jobId = jp->jobSpecs.jobId;
jobReply.jobPid = jp->jobSpecs.jobPid;
jobReply.jobPGid = jp->jobSpecs.jobPGid;
jobReply.jStatus = jp->jobSpecs.jStatus;
sendReply:
xdr_lsffree(xdr_jobSpecs, (char *)&jobSpecs, reqHdr);
xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&replyHdr);
replyHdr.opCode = reply;
if (reply == ERR_NO_ERROR)
replyStruct = (char *) &jobReply;
else {
replyStruct = (char *) 0;
}
if (!xdr_encodeMsg(&xdrs2, replyStruct, &replyHdr, xdr_jobReply, 0, auth)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_M, fname,
lsb_jobid2str(jp->jobSpecs.jobId),
"xdr_jobReply");
relife();
}
if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_M, fname,
lsb_jobid2str(jp->jobSpecs.jobId), "chanWrite_");
}
xdr_destroy(&xdrs2);
return;
}
struct lsSharedResourceInfo *
ls_sharedresourceinfo (char **resources, int *numResources, char *hostName,
int options)
{
static char fname[] = "ls_sharedresourceinfo";
static struct resourceInfoReq resourceInfoReq;
int cc, i;
static struct resourceInfoReply resourceInfoReply;
static struct LSFHeader replyHdr;
static int first = TRUE;
if (logclass & (LC_TRACE))
ls_syslog (LOG_DEBUG1, "%s: Entering this routine...", fname);
if (first == TRUE)
{
resourceInfoReply.numResources = 0;
resourceInfoReq.resourceNames = NULL;
resourceInfoReq.numResourceNames = 0;
resourceInfoReq.hostName = NULL;
first = FALSE;
}
if (resourceInfoReply.numResources > 0)
xdr_lsffree (xdr_resourceInfoReply, (char *) &resourceInfoReply,
&replyHdr);
FREEUP (resourceInfoReq.resourceNames);
FREEUP (resourceInfoReq.hostName);
if (numResources == NULL || *numResources < 0
|| (resources == NULL && *numResources > 0))
{
lserrno = LSE_BAD_ARGS;
return (NULL);
}
if (*numResources == 0 && resources == NULL)
{
if ((resourceInfoReq.resourceNames =
(char **) malloc (sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (NULL);
}
resourceInfoReq.resourceNames[0] = "";
resourceInfoReq.numResourceNames = 1;
}
else
{
if ((resourceInfoReq.resourceNames =
(char **) malloc (*numResources * sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (NULL);
}
for (i = 0; i < *numResources; i++)
{
if (resources[i] && strlen (resources[i]) + 1 < MAXLSFNAMELEN)
resourceInfoReq.resourceNames[i] = resources[i];
else
{
FREEUP (resourceInfoReq.resourceNames);
lserrno = LSE_BAD_RESOURCE;
*numResources = i;
return (NULL);
}
resourceInfoReq.numResourceNames = *numResources;
}
}
if (hostName != NULL)
{
if (strlen (hostName) > MAXHOSTNAMELEN - 1
|| Gethostbyname_ (hostName) == NULL)
{
lserrno = LSE_BAD_HOST;
return (NULL);
}
resourceInfoReq.hostName = putstr_ (hostName);
}
else
resourceInfoReq.hostName = putstr_ (" ");
if (resourceInfoReq.hostName == NULL)
{
lserrno = LSE_MALLOC;
return (NULL);
}
cc = callLim_ (LIM_GET_RESOUINFO, &resourceInfoReq, xdr_resourceInfoReq,
&resourceInfoReply, xdr_resourceInfoReply, NULL, _USE_TCP_,
&replyHdr);
if (cc < 0)
{
return NULL;
}
*numResources = resourceInfoReply.numResources;
return (resourceInfoReply.resources);
}
struct lsbSharedResourceInfo *
lsb_sharedresourceinfo(char **resources, int *numResources, char *hostName, int options)
{
static char fname[] = "lsb_sharedresourceinfo";
static struct lsbShareResourceInfoReply lsbResourceInfoReply;
struct resourceInfoReq resourceInfoReq;
int cc = 0, i;
char *clusterName = NULL;
static struct LSFHeader hdr;
char *request_buf;
char *reply_buf;
mbdReqType mbdReqtype;
XDR xdrs, xdrs2;
#define FREE_MEMORY \
{ \
free(request_buf); \
free(resourceInfoReq.resourceNames); \
}
#define FREE_REPLY_BUFFER \
{ \
if (cc) \
free(reply_buf); \
}
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG1, "%s: Entering this routine...", fname);
if (lsbResourceInfoReply.numResources > 0)
xdr_lsffree(xdr_lsbShareResourceInfoReply, (char *)&lsbResourceInfoReply, &hdr);
if (numResources == NULL ||
*numResources < 0 ||
(resources == NULL && *numResources != 0) ||
(resources != NULL && *numResources == 0)) {
lsberrno = LSBE_BAD_ARG;
return (NULL);
}
resourceInfoReq.options = 0;
if (*numResources == 0) {
if ((resourceInfoReq.resourceNames =
(char **) malloc(sizeof (char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return (NULL);
}
resourceInfoReq.resourceNames[0] = "";
resourceInfoReq.numResourceNames = 1;
cc += 2;
} else {
if ((resourceInfoReq.resourceNames =
(char **) malloc (*numResources * sizeof(char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return(NULL);
}
for (i = 0; i < *numResources; i++) {
if (resources[i] && strlen (resources[i]) + 1 < MAXLSFNAMELEN) {
resourceInfoReq.resourceNames[i] = resources[i];
cc += MAXLSFNAMELEN;
} else {
free (resourceInfoReq.resourceNames);
lserrno = LSBE_BAD_RESOURCE;
return (NULL);
}
}
resourceInfoReq.numResourceNames = *numResources;
}
if (hostName != NULL) {
if (ls_isclustername(hostName) <= 0) {
if (strlen (hostName) + 1 < MAXHOSTNAMELEN) {
resourceInfoReq.hostName = hostName;
} else {
lsberrno = LSBE_BAD_HOST;
return (NULL);
}
} else {
clusterName = hostName;
cc += MAXHOSTNAMELEN;
}
} else
resourceInfoReq.hostName = " ";
mbdReqtype = BATCH_RESOURCE_INFO;
cc = sizeof(struct resourceInfoReq) + cc + 100;
if ((request_buf = malloc (cc)) == NULL) {
lsberrno = LSBE_NO_MEM;
return(NULL);
}
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs, (char*)&resourceInfoReq, &hdr, xdr_resourceInfoReq,
0, NULL)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
FREE_MEMORY;
return(NULL);
}
if ((cc = callmbd(clusterName, request_buf, XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1)
{
xdr_destroy(&xdrs);
FREE_MEMORY;
return (NULL);
}
FREE_MEMORY;
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR) {
xdrmem_create(&xdrs2, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (!xdr_lsbShareResourceInfoReply(&xdrs2, &lsbResourceInfoReply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs2);
FREE_REPLY_BUFFER;
return(NULL);
}
xdr_destroy(&xdrs2);
FREE_REPLY_BUFFER;
*numResources = lsbResourceInfoReply.numResources;
return (lsbResourceInfoReply.resources);
}
FREE_REPLY_BUFFER;
return (NULL);
}
