static struct hostInfoEnt *
getHostList(int *numHosts, char **inputHosts)
{
static struct hostInfoEnt *hostInfo = NULL;
int i;
char *localHost;
FREEUP(hostInfo);
if ((hostInfo = (struct hostInfoEnt *) calloc(*numHosts + 1,
sizeof(struct hostInfoEnt)))
== NULL) {
perror("calloc");
return NULL;
}
if (inputHosts) {
for (i = 0; i < *numHosts; i++)
hostInfo[i].host = inputHosts[i];
} else {
if ((localHost = ls_getmyhostname()) == NULL)
hostInfo[0].host = "localhost";
else
hostInfo[0].host = localHost;
}
return hostInfo;
}
char *ls_getmnthost(char *file)
{
struct stat statb;
if (stat(file, &statb) < 0) {
return (NULL);
}
return (ls_getmyhostname());
}
int
parseXferArg(char *arg, char **userName, char **hostName, char **fName)
{
char *tmp_arg, *tmp_ptr;
char *user_arg = NULL, *host_arg;
char *freeup_tmp;
char szOfficialName[MAXHOSTNAMELEN];
freeup_tmp = tmp_arg = putstr_(arg);
tmp_ptr = strchr(tmp_arg, '@');
if (tmp_ptr) {
*tmp_ptr = '\0';
user_arg = tmp_arg;
tmp_arg = ++tmp_ptr;
}
if (!tmp_ptr || *user_arg == '\0') {
char lsfUserName[MAXLSFNAMELEN];
if (getUser(lsfUserName, sizeof(lsfUserName)) != 0) {
free(freeup_tmp);
return -1;
}
*userName = putstr_(lsfUserName);
} else
*userName = putstr_(user_arg);
tmp_ptr = strchr(tmp_arg, ':');
if (tmp_ptr) {
*tmp_ptr = '\0';
host_arg = tmp_arg;
tmp_arg = ++tmp_ptr;
}
if (!tmp_ptr || *host_arg == '\0') {
*hostName = putstr_(ls_getmyhostname());
} else {
strcpy(szOfficialName, host_arg);
*hostName = putstr_(szOfficialName);
}
if (tmp_arg) {
*fName = putstr_(tmp_arg);
} else {
free(freeup_tmp);
return -1;
}
free(freeup_tmp);
return 0;
}
int
getElock(void)
{
static char fname[] = "getElock";
int force = 0;
int retry;
char *myhostnm, *mastername;
struct stat statbuf;
time_t lastmodtime;
char first = TRUE;
char buf[MAXHOSTNAMELEN+8];
int lock_fd = -1;
if (lsb_CheckMode)
return 0;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
return MASTER_FATAL;
}
sprintf(lockfile, "%s/logdir/%s",
daemonParams[LSB_SHAREDIR].paramValue,
EVENT_LOCK_FILE);
access:
chuser(managerId);
if (force)
lock_fd = open(lockfile, O_RDWR | O_CREAT | O_TRUNC, 0644);
else
lock_fd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0644);
if (lock_fd >= 0) {
sprintf(buf, "%s:%d", myhostnm, (int)getpid());
write(lock_fd, buf, strlen(buf));
close(lock_fd);
chuser(batchId);
ls_syslog(LOG_INFO, "%s: Got lock file", fname);
gotLock = TRUE;
return 0;
} else if (errno == EEXIST) {
int fd,cc,i,pid;
fd = open(lockfile, O_RDONLY, 0444);
chuser(batchId);
if (fd < 0) {
ls_syslog(LOG_ERR, "\
%s: Can't open existing lock file <%s>: %m", fname, lockfile);
return MASTER_FATAL;
}
static void
setdefaults (void)
{
int n;
char *confpath, *localHost;
struct config_param acctdir[] = { {"LSF_RES_ACCTDIR", NULL},
{NULL, NULL}
};
struct stat statBuf;
char lsfUserName[MAX_LOGIN + 1];
details = 0;
if ((confpath = getenv ("LSF_ENVDIR")) == NULL)
confpath = "/etc";
ls_readconfenv (acctdir, confpath);
if (acctdir[0].paramValue == NULL
|| stat (acctdir[0].paramValue, &statBuf) == -1)
acctdir[0].paramValue = "/tmp";
strcpy (logfile, acctdir[0].paramValue);
n = strlen (logfile);
strncat (logfile, "/lsf.acct.", MAX_PATH - n);
if ((localHost = ls_getmyhostname ()) == NULL)
{
ls_perror ("ls_getmyhostname");
return;
}
n = strlen (logfile);
strncat (logfile, localHost, MAX_PATH - n);
if (getLSFUser_ (lsfUserName, MAX_LOGIN + 1) != 0)
{
ls_perror ("getLSFUser_");
return;
}
strcpy (mylogin, lsfUserName);
users[0] = mylogin;
users[1] = NULL;
hosts[0] = NULL;
eternity = mkinterval (mktime (&creation), mktime (&destruction));
start = complete = eternity;
}
int
copyFile(lsRcpXfer *lsXfer, char* buf, int option )
{
char szThisHost[MAXHOSTNAMELEN];
struct stat sLstat, sRstat;
int iRetVal = 0, len = 0;
int lfd, rfd;
int file_no_exist = FALSE;
int ret = 0;
mode_t mode;
char fname[]="copyFile";
static struct hostent pheHostBuf, pheDestBuf;
struct hostent *hp1, *hp2;
static int first = 1;
if (first) {
memset(&pheHostBuf, 0, sizeof(struct hostent));
memset(&pheDestBuf, 0, sizeof(struct hostent));
first = 0;
}
if (pheHostBuf.h_name != NULL) {
free(pheHostBuf.h_name);
}
if (pheDestBuf.h_name != NULL) {
free(pheDestBuf.h_name);
}
strcpy(szThisHost, ls_getmyhostname());
lserrno = LSE_FILE_SYS;
if (strcmp(lsXfer->szHostUser, lsXfer->szDestUser) != 0) {
ls_syslog(LOG_ERR,
I18N(6050,"%s: %s does not support account mapping using rcp"), /* catgets 6050*/
fname,"RES");
return -1;
}
if ((hp1 = Gethostbyname_(lsXfer->szHost)) == NULL) {
ls_syslog(LOG_ERR, "\
%s gethostbyname() failed for %s", __func__, lsXfer->szHost);
return -1;
}
void
lsb_merr(char *s)
{
char fname[] = "lsb_merr";
FILE *mail;
char *myhostnm;
if (lsb_CheckMode)
return;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
if (masterme)
die(MASTER_FATAL);
else
die (SLAVE_FATAL);
}
if (lsbManager == NULL || (getpwnam(lsbManager)) == NULL) {
if (lsbManager == NULL)
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8601,
"%s: LSF administrator name is NULL"), /* catgets 8601 */
fname);
else
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8602,
"%s: Bad LSF administrator name <%s>"), /* catgets 8602 */
fname,
lsbManager);
if (masterme)
die (MASTER_FATAL);
else
die (SLAVE_FATAL);
}
mail = smail(lsbManager, myhostnm);
if (masterme)
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3201,
"Subject: mbatchd on %s: %s\n"), /* catgets 3201 */
myhostnm, s);
else
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3202,
"Subject: sbatchd on %s: %s\n"), /* catgets 3202 */
myhostnm, s);
mclose(mail);
}
char *
ls_gethostmodel (char *hostname)
{
struct hostInfo *hostinfo;
static char hostModel[MAXLSFNAMELEN];
if (hostname == NULL)
if ((hostname = ls_getmyhostname ()) == NULL)
return (NULL);
hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0);
if (hostinfo == NULL)
return (NULL);
strcpy (hostModel, hostinfo[0].hostModel);
return hostModel;
}
char *
ls_gethosttype (char *hostname)
{
struct hostInfo *hostinfo;
static char hostType[MAXLSFNAMELEN];
if (hostname == NULL)
if ((hostname = ls_getmyhostname ()) == NULL)
return (NULL);
hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0);
if (hostinfo == NULL)
return (NULL);
strcpy (hostType, hostinfo[0].hostType);
return (hostType);
}
float *
ls_gethostfactor (char *hostname)
{
struct hostInfo *hostinfo;
static float cpufactor;
if (hostname == NULL)
if ((hostname = ls_getmyhostname ()) == NULL)
return (NULL);
hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0);
if (hostinfo == NULL)
return (NULL);
cpufactor = hostinfo->cpuFactor;
return (&cpufactor);
}
static void
initChildRes (char *envdir)
{
static char fname[] = "initChildRes";
int i, maxfds;
getLogClass_ (resParams[LSF_DEBUG_RES].paramValue,
resParams[LSF_TIME_RES].paramValue);
openChildLog ("res", resParams[LSF_LOGDIR].paramValue,
(debug > 1), &(resParams[LSF_LOG_MASK].paramValue));
if ((Myhost = ls_getmyhostname ()) == NULL)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "ls_getmyhostname");
resExit_ (-1);
}
client_cnt = child_cnt = 0;
for (i = 0; i < MAXCLIENTS_HIGHWATER_MARK + 1; i++)
{
clients[i] = NULL;
}
children = calloc (sysconf (_SC_OPEN_MAX), sizeof (struct children *));
if (!children)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "calloc");
resExit_ (-1);
}
maxfds = sysconf (_SC_OPEN_MAX);
for (i = 0; i < maxfds; i++)
{
children[i] = NULL;
}
initConn2NIOS ();
resNotifyList = listCreate ("resNotifyList");
if (!resNotifyList)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "listCreate");
resExit_ (-1);
}
}
void
getJobsState(struct sbdPackage *sbdPackage)
{
mbdReqType mbdReqtype;
char request_buf[MSGSIZE/8];
char *reply_buf;
char *myhostnm;
XDR xdrs;
struct LSFHeader hdr;
int reply;
int i;
int cc;
int numJobs;
struct jobSpecs jobSpecs;
struct jobCard *job = NULL;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, "\
%s: Ohmygosh failed to get my hostname... %M", __func__);
die(SLAVE_FATAL);
}
int
hostValue(void)
{
static unsigned char value;
char *sp;
if (value)
return value;
sp = ls_getmyhostname();
if (sp == NULL)
return 50;
while (*sp != '\0') {
value = value + *sp;
sp++;
}
return (int) value;
}
int
setLockOnOff_(int on, time_t duration, char *hname)
{
struct limLock lockReq;
char *host = hname;
if (initenv_(NULL, NULL) <0)
return -1;
lockReq.on = on;
lockReq.uid = getuid();
if (getLSFUser_(lockReq.lsfUserName, sizeof(lockReq.lsfUserName)) < 0) {
return -1;
}
if (duration == 0)
lockReq.time = 77760000;
else
lockReq.time = duration;
if (host == NULL)
host = ls_getmyhostname();
if (callLim_(LIM_LOCK_HOST,
&lockReq,
xdr_limLock,
NULL,
NULL,
host,
0,
NULL) < 0)
return -1;
return 0;
}
char *
chDisplay_(char *disp)
{
char *sp;
char *hostName;
static char dspbuf[MAXHOSTNAMELEN+10];
sp = disp +8;
if (strncmp("unix:", sp, 5) == 0)
sp += 4;
else if (strncmp("localhost:", sp, 10) == 0)
sp += 9;
if (sp[0] == ':') {
if ((hostName = ls_getmyhostname()) == NULL)
return(disp);
sprintf(dspbuf, "%s=%s%s", "DISPLAY", hostName, sp);
return dspbuf;
}
return disp;
}
void
merr_user(char *user, char *host, char *msg, char *type)
{
char fname[] = "merr_user";
FILE *mail;
char *myhostnm;
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
die(MASTER_FATAL);
}
mail = smail(user, host);
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3203,
"Subject: job %s report from %s\n"), /* catgets 3203 */
type,
myhostnm);
fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3204,
"\n\nDear %s,\n\n%s\n\n"), /* catgets 3204 */
user,
msg);
mclose(mail);
}
int
ls_servavail(int servId, int nonblock)
{
int options = 0;
if (nonblock)
options |= _NON_BLOCK_;
if (initenv_(NULL, NULL) < 0)
return -1;
if (callLim_(LIM_SERV_AVAIL,
&servId,
xdr_int,
NULL,
NULL,
ls_getmyhostname(),
options,
NULL) < 0)
return -1;
return 0;
}
void
ls_openlog(const char *ident,
const char *path,
int use_stderr,
char *logMask)
{
char *msg = NULL;
strncpy(logident, ident, 9);
logident[9] = '\0';
logmask = getLogMask(&msg, logMask);
if (use_stderr) {
log_dest = LOGTO_STDERR;
return;
}
if (path && *path) {
char *myname;
FILE *lfp;
struct stat st;
if ((myname = ls_getmyhostname()) == NULL)
goto syslog;
sprintf(logfile, "%s/%s.log.%s", path, ident, myname);
if (lstat(logfile, &st) < 0) {
if (errno == ENOENT) {
if (openLogFile(ident, myname) == 0) {
if (msg != NULL)
ls_syslog(LOG_ERR, "%s", msg);
return;
}
} else {
sprintf(logfile, "%s/%s.log.%s", lsTmpDir_, ident, myname);
if (lstat(logfile, &st) < 0) {
if (errno == ENOENT) {
if ((lfp = fopen(logfile, "a")) != NULL) {
fclose(lfp);
if (!strcmp(ident, "res")
|| (logmask >= LOG_UPTO(LOG_DEBUG)
&& logmask <= LOG_UPTO(LOG_DEBUG3)))
chmod(logfile, 0666);
else
chmod(logfile, 0644);
log_dest = LOGTO_FILE;
if (msg != NULL)
ls_syslog(LOG_ERR, "%s", msg);
return;
}
}
} else if (S_ISREG(st.st_mode) && st.st_nlink == 1) {
if ((lfp = fopen(logfile, "a")) != NULL) {
fclose(lfp);
if (!strcmp(ident, "res")
|| (logmask >= LOG_UPTO(LOG_DEBUG)
&& logmask <= LOG_UPTO(LOG_DEBUG3)))
chmod(logfile, 0666);
else
chmod(logfile, 0644);
log_dest = LOGTO_FILE;
if (msg != NULL)
ls_syslog(LOG_ERR, "%s", msg);
return;
}
}
}
} else if (S_ISREG(st.st_mode) && st.st_nlink == 1) {
if (openLogFile(ident, myname) == 0) {
if (msg != NULL)
ls_syslog(LOG_ERR, "%s", msg);
return;
}
}
}
syslog:
log_dest = LOGTO_SYS;
logfile[0] = '\0';
openlog((char *) ident, LOG_PID, LOG_DAEMON);
setlogmask(logmask);
if (msg != NULL)
ls_syslog(LOG_ERR, "%s", msg);
}
void
init_res (void)
{
static char fname[] = "init_res";
int i, maxfds;
if (logclass & (LC_TRACE | LC_HANG))
ls_syslog (LOG_DEBUG, "%s: Entering this routine...", fname);
if (!sbdMode)
{
if (!debug)
{
if (geteuid () || getuid ())
{
fprintf (stderr, "RES should be run as root.\n");
fflush (stderr);
resExit_ (1);
}
chdir ("/tmp");
}
if (debug <= 1)
{
daemonize_ ();
ls_openlog ("res", resParams[LSF_LOGDIR].paramValue, 0,
resParams[LSF_LOG_MASK].paramValue);
umask (0);
nice (NICE_LEAST);
}
}
if ((Myhost = ls_getmyhostname ()) == NULL)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
resExit_ (-1);
}
if (isatty (0))
{
tcgetattr (0, &defaultTty.attr);
defaultTty.ws.ws_row = 24;
defaultTty.ws.ws_col = 80;
defaultTty.ws.ws_xpixel = defaultTty.ws.ws_ypixel = 0;
}
else
{
defaultTty.ws.ws_row = 24;
defaultTty.ws.ws_col = 80;
defaultTty.ws.ws_xpixel = defaultTty.ws.ws_ypixel = 0;
}
if (!sbdMode)
{
init_AcceptSock ();
}
client_cnt = child_cnt = 0;
for (i = 0; i < MAXCLIENTS_HIGHWATER_MARK + 1; i++)
{
clients[i] = NULL;
}
children =
(struct child **) calloc (sysconf (_SC_OPEN_MAX),
sizeof (struct children *));
if (!children)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "calloc");
resExit_ (-1);
}
maxfds = sysconf (_SC_OPEN_MAX);
for (i = 0; i < maxfds; i++)
{
children[i] = NULL;
}
initConn2NIOS ();
resNotifyList = listCreate ("resNotifyList");
if (!resNotifyList)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "listCreate");
resExit_ (-1);
}
ls_syslog (LOG_INFO, (_i18n_msg_get (ls_catd, NL_SETN, 5346, "Daemon started"))); /* catgets 5346 */
initResLog ();
}
void
job_checking (void)
{
static char fname[] = "job_checking";
struct jobCard *jobCard, *nextJob;
struct hostLoad *myload, savedLoad;
char *myhostnm;
static time_t last_check;
char preempted = FALSE;
int i;
if (last_check == 0)
last_check = now;
if (jobcnt <= 0) {
last_check = now;
return;
}
checkFinish ();
for (jobCard = jobQueHead->forw; (jobCard != jobQueHead);
jobCard = nextJob) {
nextJob = jobCard->forw;
if (IS_FINISH(jobCard->jobSpecs.jStatus)
|| (jobCard->jobSpecs.jStatus & JOB_STAT_PEND))
continue;
ruLimits(jobCard);
if (IS_RUN_JOB_CMD(jobCard->jobSpecs.jStatus)) {
jobCard->runTime += (int) (now - last_check);
}
if (jobCard->runTime >
jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl) {
if ((jobCard->jobSpecs.terminateActCmd == NULL)
|| (jobCard->jobSpecs.terminateActCmd[0] == '\0')) {
if (jobCard->runTime >
jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl
+ WARN_TIME && jobCard->timeExpire) {
if ((IS_SUSP (jobCard->jobSpecs.jStatus))
&& (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT)
&& (jobCard->jobSpecs.subreasons & SUB_REASON_RUNLIMIT))
continue;
else if (jobCard->jobSpecs.jStatus & JOB_STAT_KILL)
continue;
else {
ls_syslog(LOG_INFO, \
"%s: warning period expired killing the job=%d",
fname, jobCard->jobSpecs.jobId);
jobSigStart (jobCard, SIG_TERM_RUNLIMIT, 0, 0, SIGLOG);
sbdlog_newstatus(jobCard);
jobCard->jobSpecs.jStatus |= JOB_STAT_KILL;
}
} else if (!jobCard->timeExpire) {
ls_syslog(LOG_INFO, I18N(5704,
"%s: sending warning signal to job=%d"), /* catgets 5704 */
fname, jobCard->jobSpecs.jobId);
jobsig(jobCard, SIGUSR2, FALSE);
jobCard->timeExpire = TRUE;
}
} else {
if (jobCard->runTime >
jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl) {
if ((IS_SUSP (jobCard->jobSpecs.jStatus))
&& (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT)
&& (jobCard->jobSpecs.subreasons & SUB_REASON_RUNLIMIT))
continue;
else {
jobSigStart (jobCard, SIG_TERM_RUNLIMIT, 0, 0, SIGLOG);
sbdlog_newstatus(jobCard);
}
}
}
continue;
}
if (jobCard->jobSpecs.termTime && now > jobCard->jobSpecs.termTime
&& !(jobCard->jobSpecs.jAttrib & JOB_FORCE_KILL)) {
if ((jobCard->jobSpecs.terminateActCmd == NULL)
|| (jobCard->jobSpecs.terminateActCmd[0] == '\0')) {
if (now > jobCard->jobSpecs.termTime + WARN_TIME
&& jobCard->timeExpire) {
if ((IS_SUSP (jobCard->jobSpecs.jStatus))
&& (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT)
&& (jobCard->jobSpecs.subreasons & SUB_REASON_DEADLINE))
continue;
else if (jobCard->jobSpecs.jStatus & JOB_STAT_KILL)
continue;
else {
jobSigStart (jobCard, SIG_TERM_DEADLINE, 0, 0, SIGLOG);
sbdlog_newstatus(jobCard);
jobCard->jobSpecs.jStatus |= JOB_STAT_KILL;
}
} else
if (!jobCard->timeExpire) {
jobsig(jobCard, SIGUSR2, FALSE);
jobCard->timeExpire = TRUE;
}
} else {
if (now > jobCard->jobSpecs.termTime) {
if ((IS_SUSP (jobCard->jobSpecs.jStatus))
&& (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT)
&& (jobCard->jobSpecs.subreasons & SUB_REASON_DEADLINE))
continue;
else {
jobSigStart (jobCard, SIG_TERM_DEADLINE, 0, 0, SIGLOG);
sbdlog_newstatus(jobCard);
}
}
}
continue;
}
if (! window_ok (jobCard)
&& !(jobCard->jobSpecs.jAttrib & JOB_URGENT_NOSTOP)) {
if (! (jobCard->jobSpecs.options & SUB_WINDOW_SIG)
|| ((jobCard->jobSpecs.options & SUB_WINDOW_SIG)
&& now - jobCard->windWarnTime >= WARN_TIME)) {
jobSuspendAction(jobCard, SIG_SUSP_WINDOW, SUSP_QUEUE_WINDOW, 0);
continue;
}
} else {
jobResumeAction(jobCard, SIG_RESUME_WINDOW, SUSP_QUEUE_WINDOW);
continue;
}
}
if ((myhostnm = ls_getmyhostname()) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname");
die(SLAVE_FATAL);
}
myload = ls_loadofhosts (NULL, 0, EXACT|EFFECTIVE, 0, &myhostnm, 1);
if (myload == NULL) {
if (myStatus != NO_LIM)
ls_syslog(LOG_INFO, I18N_FUNC_FAIL_MM, fname, "ls_loadofhosts");
if (lserrno == LSE_LIM_BADHOST)
relife();
if (lserrno == LSE_BAD_XDR)
relife();
if (lserrno == LSE_LIM_DOWN || lserrno == LSE_TIME_OUT) {
myStatus |= NO_LIM;
tryChkpntMig();
}
last_check = now;
return;
} else
myStatus = 0;
memcpy ((char *)&savedLoad, (char *)myload, sizeof (struct hostLoad));
savedLoad.li = (float *) my_malloc (allLsInfo->numIndx * sizeof (float),
"job_checking");
savedLoad.status = (int *) my_malloc
((1 + GET_INTNUM(allLsInfo->numIndx)) * sizeof (int), "job_checking");
for (i = 0; i < allLsInfo->numIndx; i++)
savedLoad.li[i] = myload->li[i];
for (i = 0; i < 1 + GET_INTNUM(allLsInfo->numIndx); i++)
savedLoad.status[i] = myload->status[i];
tryResume (&savedLoad);
if (!preempted)
tryStop (myhostnm, &savedLoad);
tryChkpntMig();
FREEUP(savedLoad.li);
FREEUP(savedLoad.status);
last_check = now;
return;
}
int
limCtrl(int argc, char **argv, int opCode)
{
char *optName;
char *localHost;
int vFlag = 0;
int config = 0, checkReply;
fFlag = 0;
if (strcmp(argv[optind-1], "reconfig") == 0) {
config = 1;
}
while ((optName = myGetOpt(argc, argv, "f|v|")) != NULL) {
switch (optName[0]) {
case 'v':
if (opCode == LIM_CMD_SHUTDOWN)
return(-2);
vFlag = 1;
break;
case 'f':
fFlag = 1;
break;
default:
return(-2);
}
}
exitrc = 0;
if (config && optind != argc)
return -2;
switch (checkReply) {
case EXIT_FATAL_ERROR:
return -1;
case EXIT_WARNING_ERROR:
if (fFlag)
break;
if (!getConfirm(I18N(250, "Do you want to reconfigure? [y/n] "))) /* catgets 250 */ {
fprintf(stderr, I18N(251, "Reconfiguration aborted.\n")); /* catgets 251 */
return(-1);
}
break;
default:
break;
}
if (config) {
doAllHosts(opCode);
return(exitrc);
}
if (optind == argc) {
if ((localHost = ls_getmyhostname()) == NULL) {
ls_perror("ls_getmyhostname");
return -1;
}
operateHost(localHost, opCode, 0);
}
else
{
doHosts(argc, argv, opCode);
}
return(exitrc);
}
struct hostInfo *
ls_gethostinfo (char *resReq, int *numhosts, char **hostlist, int listsize,
int options)
{
static char fname[] = "ls_gethostinfo";
struct decisionReq hostInfoReq;
static struct hostInfoReply hostInfoReply;
struct shortLsInfo lsInfo;
char *hname;
int cc, i;
if (logclass & (LC_TRACE))
ls_syslog (LOG_DEBUG1, "%s: Entering this routine...", fname);
if ((hname = ls_getmyhostname ()) == NULL)
return (NULL);
if (listsize)
{
if (hostlist == NULL)
{
lserrno = LSE_BAD_ARGS;
return NULL;
}
hostInfoReq.preferredHosts = (char **)
calloc (listsize + 1, sizeof (char *));
if (hostInfoReq.preferredHosts == NULL)
{
lserrno = LSE_MALLOC;
return NULL;
}
for (i = 0; i < listsize; i++)
{
if (hostlist[i] == NULL)
{
lserrno = LSE_BAD_ARGS;
break;
}
cc = ls_isclustername (hostlist[i]);
if (cc <= 0)
{
if (cc < 0)
break;
if (Gethostbyname_ (hostlist[i]) == NULL)
{
lserrno = LSE_BAD_HOST;
break;
}
hostInfoReq.preferredHosts[i + 1] = putstr_ (hostlist[i]);
}
else
hostInfoReq.preferredHosts[i + 1] = putstr_ (hostlist[i]);
if (!hostInfoReq.preferredHosts[i + 1])
{
lserrno = LSE_MALLOC;
break;
}
}
if (i < listsize)
{
int j;
for (j = 1; j < i + 1; j++)
free (hostInfoReq.preferredHosts[j]);
free (hostInfoReq.preferredHosts);
return (NULL);
}
hostInfoReq.ofWhat = OF_HOSTS;
}
else
{
hostInfoReq.preferredHosts = (char **) calloc (1, sizeof (char *));
if (hostInfoReq.preferredHosts == NULL)
{
lserrno = LSE_MALLOC;
return NULL;
}
hostInfoReq.ofWhat = OF_ANY;
}
hostInfoReq.options = options;
strcpy (hostInfoReq.hostType, " ");
hostInfoReq.preferredHosts[0] = putstr_ (hname);
hostInfoReq.numPrefs = listsize + 1;
if (resReq != NULL)
strcpy (hostInfoReq.resReq, resReq);
else
strcpy (hostInfoReq.resReq, " ");
hostInfoReply.shortLsInfo = &lsInfo;
hostInfoReq.numHosts = 0;
cc = callLim_ (LIM_GET_HOSTINFO,
&hostInfoReq,
xdr_decisionReq,
&hostInfoReply, xdr_hostInfoReply, NULL, _USE_TCP_, NULL);
for (i = 0; i < hostInfoReq.numPrefs; i++)
free (hostInfoReq.preferredHosts[i]);
free (hostInfoReq.preferredHosts);
if (cc < 0)
return NULL;
if (numhosts != NULL)
*numhosts = hostInfoReply.nHost;
return (expandSHinfo (&hostInfoReply));
}
int
lsb_hostcontrol (char *host, int opCode)
{
XDR xdrs;
char request_buf[MSGSIZE];
char *reply_buf, *contactHost = NULL;
static struct controlReq hostControlReq;
int cc;
struct LSFHeader hdr;
struct lsfAuth auth;
if (hostControlReq.name == NULL) {
hostControlReq.name = (char *) malloc (MAXHOSTNAMELEN);
if (hostControlReq.name == NULL) {
lsberrno = LSBE_NO_MEM;
return(-1);
}
}
if (opCode != HOST_OPEN && opCode != HOST_CLOSE &&
opCode != HOST_REBOOT && opCode != HOST_SHUTDOWN) {
lsberrno = LSBE_BAD_ARG;
return (-1);
}
if (host)
if (strlen (host) >= MAXHOSTNAMELEN - 1) {
lsberrno = LSBE_BAD_ARG;
return (-1);
}
hostControlReq.opCode = opCode;
if (host)
strcpy(hostControlReq.name, host);
else {
char *h;
if ((h = ls_getmyhostname()) == NULL) {
lsberrno = LSBE_LSLIB;
return(-1);
}
strcpy(hostControlReq.name, h);
}
switch (opCode) {
case HOST_REBOOT:
hdr.opCode = CMD_SBD_REBOOT;
contactHost = host;
break;
case HOST_SHUTDOWN:
hdr.opCode = CMD_SBD_SHUTDOWN;
contactHost = host;
break;
default:
hdr.opCode = BATCH_HOST_CTRL;
break;
}
if (authTicketTokens_(&auth, contactHost) == -1)
return (-1);
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
if (!xdr_encodeMsg(&xdrs, (char*) &hostControlReq, &hdr,
xdr_controlReq, 0, &auth)) {
lsberrno = LSBE_XDR;
return(-1);
}
if (opCode == HOST_REBOOT || opCode == HOST_SHUTDOWN) {
if ((cc = cmdCallSBD_(hostControlReq.name, request_buf,
XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL)) == -1)
return (-1);
} else {
if ((cc = callmbd (NULL, request_buf, XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1)
return (-1);
}
lsberrno = hdr.opCode;
if (cc)
free(reply_buf);
if (lsberrno == LSBE_NO_ERROR)
return(0);
else
return(-1);
}
struct hostLoad *
loadinfo_(char *resReq, struct decisionReq *loadReqPtr, char *fromhost, int *numHosts, char ***outnlist)
{
static char fname[] = "loadinfo_";
static struct loadReply loadReply;
int i;
char *hname;
int options = 0;
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: Entering this routine...", fname);
if (loadReqPtr->numHosts <=0) {
lserrno = LSE_BAD_ARGS;
goto error;
}
if (!fromhost) {
if ((hname = ls_getmyhostname()) == NULL)
goto error;
loadReqPtr->preferredHosts[0] = putstr_(hname);
} else
loadReqPtr->preferredHosts[0] = putstr_(fromhost);
if (loadReqPtr->preferredHosts[0] == NULL) {
lserrno = LSE_MALLOC;
goto error;
}
if (resReq) {
strncpy(loadReqPtr->resReq, resReq, MAXLINELEN);
} else
strcpy(loadReqPtr->resReq, " ");
loadReqPtr->resReq[MAXLINELEN-1] = '\0';
if (loadReqPtr->ofWhat == OF_HOSTS && loadReqPtr->numPrefs == 2
&& loadReqPtr->numHosts == 1
&& equalHost_(loadReqPtr->preferredHosts[1],
loadReqPtr->preferredHosts[0]))
options |= _LOCAL_;
else
options |= _USE_TCP_;
if (callLim_(LIM_LOAD_REQ, loadReqPtr, xdr_decisionReq,
&loadReply, xdr_loadReply, NULL, options, NULL) < 0)
goto error;
if (loadReply.flags & LOAD_REPLY_SHARED_RESOURCE) {
sharedResConfigured_ = TRUE;
}
for (i=0; i<loadReqPtr->numPrefs; i++)
FREEUP(loadReqPtr->preferredHosts[i]);
FREEUP (loadReqPtr->preferredHosts);
*numHosts = loadReply.nEntry;
*outnlist = loadReply.indicies;
return (loadReply.loadMatrix);
error:
for (i=0; i<loadReqPtr->numPrefs; i++)
FREEUP(loadReqPtr->preferredHosts[i]);
FREEUP (loadReqPtr->preferredHosts);
return (NULL);
}
struct jRusage *getJInfo_(int npgid, int *pgid, int options, int cpgid)
{
static char fname[] = "lib.pim.c/getJInfo_()";
struct jRusage *jru;
static char pfile[MAXFILENAMELEN];
char *myHost;
static struct sockaddr_in pimAddr;
struct LSFHeader sendHdr, recvHdr, hdrBuf;
int s, cc;
struct timeval timeOut;
static time_t lastTime = 0, lastUpdateNow = 0;
time_t now;
static time_t pimSleepTime = PIM_SLEEP_TIME;
static bool_t periodicUpdateOnly = FALSE;
now = time(0);
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG3,"now = %ld, lastTime = %ld, sleepTime = %ld",
now, lastUpdateNow, pimSleepTime);
argOptions = options;
if (lastTime == 0) {
struct hostent *hp;
struct config_param *plp;
for (plp = pimParams; plp->paramName != NULL; plp++) {
if (plp->paramValue != NULL) {
FREEUP (plp->paramValue);
}
}
if (initenv_(pimParams, NULL) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: initenv_() failed: %M", fname);
return NULL;
}
if ((myHost = ls_getmyhostname()) == NULL) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG,
"%s: ls_getmyhostname() failed: %m", fname);
return (NULL);
}
if (pimParams[LSF_PIM_INFODIR].paramValue)
sprintf(pfile, "%s/pim.info.%s",
pimParams[LSF_PIM_INFODIR].paramValue, myHost);
else {
if (pimParams[LSF_LIM_DEBUG].paramValue) {
if (pimParams[LSF_LOGDIR].paramValue)
sprintf(pfile, "%s/pim.info.%s",
pimParams[LSF_LOGDIR].paramValue, myHost);
else
sprintf(pfile, "/tmp/pim.info.%s.%d", myHost, (int)getuid());
} else {
sprintf(pfile, "/tmp/pim.info.%s", myHost);
}
}
if (pimParams[LSF_PIM_SLEEPTIME].paramValue) {
if ((pimSleepTime =
atoi(pimParams[LSF_PIM_SLEEPTIME].paramValue)) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "LSF_PIM_SLEEPTIME value <%s> must be a positive integer, defaulting to %d", pimParams[LSF_PIM_SLEEPTIME].paramValue, PIM_SLEEP_TIME);
pimSleepTime = PIM_SLEEP_TIME;
}
}
if (pimParams[LSF_PIM_SLEEPTIME_UPDATE].paramValue != NULL
&& strcasecmp(pimParams[LSF_PIM_SLEEPTIME_UPDATE].paramValue, "y") == 0) {
periodicUpdateOnly = TRUE;
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: Only to call pim each PIM_SLEEP_TIME interval", fname);
}
if ((hp = Gethostbyname_(myHost)) == NULL) {
return NULL;
}
memset((char *) &pimAddr, 0, sizeof(pimAddr));
memcpy((char *) &pimAddr.sin_addr, (char *) hp->h_addr,
(int)hp->h_length);
pimAddr.sin_family = AF_INET;
}
if (now - lastUpdateNow >= pimSleepTime || (options & PIM_API_UPDATE_NOW)) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG,"%s: update now", fname);
lastUpdateNow = now;
if ((s = TcpCreate_(FALSE, 0)) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: tcpCreate failed: %m", fname);
return (NULL);
}
if (pimPort(&pimAddr, pfile) == -1) {
close(s);
return (NULL);
}
if (b_connect_(s, (struct sockaddr *) &pimAddr, sizeof(pimAddr), 0)
== -1) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: b_connect() failed: %m", fname);
lserrno = LSE_CONN_SYS;
close(s);
return (NULL);
}
initLSFHeader_(&sendHdr);
initLSFHeader_(&recvHdr);
sendHdr.opCode = options;
sendHdr.refCode = (short) now & 0xffff;
sendHdr.reserved = cpgid;
if ((cc = writeEncodeHdr_(s, &sendHdr, b_write_fix)) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG,
"%s: writeEncodeHdr failed cc=%d: %M", fname, cc);
close(s);
return (NULL);
}
timeOut.tv_sec = 10;
timeOut.tv_usec = 0;
if ((cc = rd_select_(s, &timeOut)) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: rd_select_ cc=%d: %m", fname, cc);
close(s);
return (NULL);
}
if ((cc = lsRecvMsg_(s, (char *) &hdrBuf, sizeof(hdrBuf), &recvHdr,
NULL, NULL, b_read_fix)) < 0) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG, "%s: lsRecvMsg_ failed cc=%d: %M",
fname, cc);
close(s);
return (NULL);
}
close(s);
if (recvHdr.refCode != sendHdr.refCode) {
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG,
"%s: recv refCode=%d not equal to send refCode=%d, server is not PIM",
fname, (int) recvHdr.refCode, (int) sendHdr.refCode);
return (NULL);
}
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG,"%s updated now",fname);
if (!readPIMFile(pfile)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "readPIMFile");
return(NULL);
}
}
lastTime = now;
if ((jru = readPIMInfo(npgid, pgid)) == NULL &&
!(options & PIM_API_UPDATE_NOW)
&& (periodicUpdateOnly == FALSE
|| (periodicUpdateOnly == TRUE
&& now - lastUpdateNow >= pimSleepTime))) {
if (hitPGid > 0) {
jru = getJInfo_(npgid, pgid, options | PIM_API_UPDATE_NOW, hitPGid);
hitPGid = 0;
return jru;
}
else {
return (getJInfo_(npgid, pgid, options | PIM_API_UPDATE_NOW, cpgid));
}
}
return jru;
}
