struct clusterInfo *
ls_clusterinfo (char *resReq, int *numclusters, char **clusterList,
int listsize, int options)
{
struct clusterInfoReq clusterInfoReq;
static struct clusterInfoReply clusterInfoReply;
struct shortLsInfo shortlsInfo;
int count, ret_val;
if (listsize != 0 && clusterList == NULL)
{
lserrno = LSE_BAD_ARGS;
return NULL;
}
if (initenv_ (NULL, NULL) < 0)
return (NULL);
for (count = 0; count < listsize; count++)
{
ret_val = ls_isclustername (clusterList[count]);
if (ret_val <= 0)
{
if (ret_val < 0)
{
return (NULL);
}
lserrno = LSE_BAD_CLUSTER;
return (NULL);
}
}
if (resReq)
clusterInfoReq.resReq = resReq;
else
clusterInfoReq.resReq = "";
clusterInfoReq.clusters = clusterList;
clusterInfoReq.listsize = listsize;
clusterInfoReq.options = options;
clusterInfoReply.shortLsInfo = &shortlsInfo;
if (callLim_ (LIM_GET_CLUSINFO, &clusterInfoReq, xdr_clusterInfoReq,
&clusterInfoReply, xdr_clusterInfoReply, NULL, 0, NULL) < 0)
return (NULL);
if (numclusters != NULL)
*numclusters = clusterInfoReply.nClus;
return (expandSCinfo (&clusterInfoReply));
}
struct lsInfo *
ls_info (void)
{
static struct lsInfo lsInfo;
if (initenv_ (NULL, NULL) < 0)
return NULL;
if (callLim_ (LIM_GET_INFO,
NULL, NULL, &lsInfo, xdr_lsInfo, NULL, _USE_TCP_, NULL) < 0)
return NULL;
return &lsInfo;
}
static int
getname_ (enum limReqCode limReqCode, char *name, int namesize)
{
int options;
if (initenv_ (NULL, NULL) < 0)
return (-1);
if (limReqCode == LIM_GET_CLUSNAME)
{
struct stringLen str;
str.name = name;
str.len = namesize;
if (callLim_ (limReqCode,
NULL, NULL, &str, xdr_stringLen, NULL, _LOCAL_, NULL) < 0)
return -1;
return 0;
}
/* Force the library not to call _LOCAL_ LIM since
* it may not know the master yet, this is the
* case of LIM_ADD_HOST.
*/
if (limReqCode == LIM_GET_MASTINFO2)
options = _SERVER_HOSTS_ONLY_;
else
options = _LOCAL_;
if (callLim_ (limReqCode, NULL, /* no data to send */
NULL, &masterInfo_, xdr_masterInfo, NULL, /* host LSF_SERVER_HOSTS */
options, NULL) < 0)
return (-1);
if (memcmp (&sockIds_[MASTER].sin_addr,
&masterInfo_.addr, sizeof (in_addr_t)))
{
CLOSECD (limchans_[MASTER]);
CLOSECD (limchans_[TCP]);
}
memcpy (&sockIds_[MASTER].sin_addr, &masterInfo_.addr, sizeof (in_addr_t));
memcpy (&sockIds_[TCP].sin_addr, &masterInfo_.addr, sizeof (in_addr_t));
sockIds_[TCP].sin_port = masterInfo_.portno;
masterknown_ = TRUE;
strncpy (name, masterInfo_.hostName, namesize);
name[namesize - 1] = '\0';
return 0;
}
int
expSyntax_ (char *resReq)
{
struct stringLen str;
if (initenv_ (NULL, NULL) < 0)
return (-1);
if (!resReq)
resReq = " ";
str.name = resReq;
str.len = MAXLINELEN;
if (callLim_ (LIM_CHK_RESREQ, &str, xdr_stringLen,
NULL, NULL, NULL, 0, NULL) < 0)
return (-1);
return 0;
}
float *
ls_getmodelfactor (char *modelname)
{
static float cpuf;
struct stringLen str;
if (!modelname)
return (ls_gethostfactor (NULL));
if (initenv_ (NULL, NULL) < 0)
return (NULL);
str.name = modelname;
str.len = MAXLSFNAMELEN;
if (callLim_ (LIM_GET_CPUF, &str, xdr_stringLen, &cpuf, xdr_float,
NULL, 0, NULL) < 0)
return (NULL);
return (&cpuf);
}
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;
}
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;
}
/* This is PIM process information manager.
* This is the interface to the machine /proc and
* based on its process table openlava implements
* the getJInfo_() API that returns runtime
* resource usage.
*/
int
main(int argc, char **argv)
{
char *sp;
char *traceVal;
char *myHost;
char *env_dir=NULL;
int cc;
myHost = "localhost";
while ((cc = getopt(argc, argv, "12Vd:")) != EOF) {
switch (cc) {
case 'd':
env_dir = optarg;
break;
case '1':
pim_debug = 1;
break;
case '2':
pim_debug = 2;
break;
case 'V':
fputs(_LS_VERSION_, stderr);
return 0;
case '?':
default:
usage(argv[0]);
return -1;
}
}
if (env_dir == NULL) {
if ((env_dir = getenv("LSF_ENVDIR")) == NULL) {
env_dir = "/etc";
}
}
if (initenv_(pimParams, env_dir) < 0) {
sp = getenv("LSF_LOGDIR");
if (sp != NULL)
pimParams[LSF_LOGDIR].paramValue = sp;
ls_openlog("pim",
pimParams[LSF_LOGDIR].paramValue, (pim_debug == 2),
pimParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, "%s: initenv_() failed %s.", __func__, env_dir);
return -1;
}
if (!pim_debug && pimParams[LSF_LIM_DEBUG].paramValue) {
pim_debug = atoi(pimParams[LSF_LIM_DEBUG].paramValue);
if (pim_debug <= 0)
pim_debug = 1;
}
traceVal = NULL;
if (pimParams[LSF_PIM_TRACE].paramValue) {
traceVal = pimParams[LSF_PIM_TRACE].paramValue;
} else if (pimParams[LSF_DEBUG_PIM].paramValue) {
traceVal = pimParams[LSF_DEBUG_PIM].paramValue;
}
getLogClass_(traceVal, pimParams[LSF_TIME_PIM].paramValue);
if (pim_debug > 1)
ls_openlog("pim", pimParams[LSF_LOGDIR].paramValue, TRUE, "LOG_DEBUG");
else
ls_openlog("pim", pimParams[LSF_LOGDIR].paramValue, FALSE,
pimParams[LSF_LOG_MASK].paramValue);
if ((sp = pimParams[LSF_PIM_SLEEPTIME].paramValue)) {
if ((sleepTime = atoi(sp) < 0)) {
ls_syslog(LOG_ERR, "\
%s: LSF_PIM_SLEEPTIME value %s must be a positive integer, set to %d",
__func__, sp, PIM_SLEEP_TIME);
sleepTime = PIM_SLEEP_TIME;
}
}
int
ls_rexecve (char *host, char **argv, int options, char **envp)
{
int d;
int retsock;
struct timeval timeout;
socklen_t len;
struct sockaddr_in sin;
int max;
char sock_buf[20];
char *new_argv[5];
char pathbuf[MAXPATHLEN];
int s;
int descriptor[2];
struct resCmdBill cmdmsg;
int resTimeout;
if (genParams_[LSF_RES_TIMEOUT].paramValue)
resTimeout = atoi (genParams_[LSF_RES_TIMEOUT].paramValue);
else
resTimeout = RES_TIMEOUT;
if (_isconnected_ (host, descriptor))
s = descriptor[0];
else if ((s = ls_connect (host)) < 0)
return (-1);
if (!FD_ISSET (s, &connection_ok_))
{
FD_SET (s, &connection_ok_);
if (ackReturnCode_ (s) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
}
cmdmsg.options = options & ~REXF_TASKPORT;
if (cmdmsg.options & REXF_SHMODE)
cmdmsg.options |= REXF_USEPTY;
if (!isatty (0) && !isatty (1))
cmdmsg.options &= ~REXF_USEPTY;
else if (cmdmsg.options & REXF_USEPTY)
{
if (rstty_ (host) < 0)
{
_lostconnection_ (host);
return (-1);
}
}
if ((genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
&& (strcasecmp (genParams_[LSF_INTERACTIVE_STDERR].paramValue,
"y") == 0))
{
cmdmsg.options |= REXF_STDERR;
}
if (mygetwd_ (cmdmsg.cwd) == 0)
{
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_WDIR;
return (-1);
}
if (envp)
{
if (ls_rsetenv (host, envp) < 0)
{
_lostconnection_ (host);
return (-1);
}
}
if ((retsock = TcpCreate_ (TRUE, 0)) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
len = sizeof (sin);
if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
{
(void) closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_SOCK_SYS;
return (-1);
}
cmdmsg.retport = sin.sin_port;
cmdmsg.rpid = 0;
cmdmsg.argv = argv;
cmdmsg.priority = 0;
timeout.tv_usec = 0;
timeout.tv_sec = resTimeout;
if (sendCmdBill_ (s, (resCmd) RES_EXEC, &cmdmsg, &retsock, &timeout) == -1)
{
closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
return (-1);
}
(void) sprintf (sock_buf, "%d", retsock);
if (initenv_ (NULL, NULL) < 0)
return (-1);
strcpy (pathbuf, genParams_[LSF_SERVERDIR].paramValue);
strcat (pathbuf, "/nios");
new_argv[0] = pathbuf;
new_argv[1] = "-n";
new_argv[2] = sock_buf;
if (cmdmsg.options & REXF_USEPTY)
{
if (cmdmsg.options & REXF_SHMODE)
new_argv[3] = "2";
else
new_argv[3] = "1";
}
else
new_argv[3] = "0";
new_argv[4] = 0;
max = sysconf (_SC_OPEN_MAX);
for (d = 3; d < max; ++d)
{
if (d != retsock)
(void) close (d);
}
(void) lsfExecvp (new_argv[0], new_argv);
lserrno = LSE_EXECV_SYS;
close (retsock);
close (s);
return (-1);
}
int
ls_rtaske(char *host, char **argv, int options, char **envp)
{
static u_short retport;
static int rpid;
static int reg_ls_donerex = FALSE;
struct sockaddr_in sin;
int max;
char c_chfd[8];
char pathbuf[MAXPATHLEN];
int d;
int niosOptions = 0;
char *new_argv[5];
int pid;
int s;
int descriptor[2];
struct resCmdBill cmdmsg;
struct lslibNiosRTask taskReq;
u_short taskPort = 0;
sigset_t newMask;
sigset_t oldMask;
socklen_t len;
if (!reg_ls_donerex) {
atexit( (void (*) ()) ls_donerex);
reg_ls_donerex = TRUE;
}
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0)
return(-1);
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0){
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
if (!nios_ok_)
niosOptions = options & REXF_SYNCNIOS;
options &= ~REXF_SYNCNIOS;
cmdmsg.options = options;
if (cmdmsg.options & REXF_SHMODE)
cmdmsg.options |= REXF_USEPTY;
if (!isatty(0) && !isatty(1))
cmdmsg.options &= ~REXF_USEPTY;
else if (cmdmsg.options & REXF_USEPTY ){
if (options & REXF_TTYASYNC){
if (rstty_async_(host) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
} else {
if (rstty_(host) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
}
if ( (genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
&& (strcasecmp(genParams_[LSF_INTERACTIVE_STDERR].paramValue,
"y") == 0) ) {
cmdmsg.options |= REXF_STDERR;
}
if (!nios_ok_) {
initSigHandler(SIGTSTP);
initSigHandler(SIGTTIN);
initSigHandler(SIGTTOU);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, cli_nios_fd) < 0) {
lserrno = LSE_SOCK_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
closesocket(s);
return(-1);
}
if ((pid = fork()) != 0) {
int mypid;
close(cli_nios_fd[1]);
mypid = getpid();
if (b_write_fix(cli_nios_fd[0], (char *) &mypid, sizeof (mypid)) !=
sizeof (mypid)) {
close(cli_nios_fd[0]);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_MSG_SYS;
return (-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &retport, sizeof (u_short))
!= sizeof(u_short) ) {
close(cli_nios_fd[0]);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_MSG_SYS;
return (-1);
}
nios_ok_ = TRUE;
if (waitpid(pid, 0, 0) <0) {
if (errno != ECHILD) {
close(cli_nios_fd[0]);
nios_ok_ = FALSE;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_WAIT_SYS;
return (-1);
}
}
} else {
if (fork()) {
max = sysconf(_SC_OPEN_MAX);
for (d = 3; d < max; ++d) {
(void)close(d);
}
exit(0);
}
if (initenv_(NULL, NULL) <0)
exit (-1);
strcpy(pathbuf, genParams_[LSF_SERVERDIR].paramValue);
strcat(pathbuf, "/nios");
sprintf(c_chfd, "%d", cli_nios_fd[1]);
new_argv[0] = pathbuf;
new_argv[1] = c_chfd;
if (cmdmsg.options & REXF_USEPTY) {
if (cmdmsg.options & REXF_SHMODE)
new_argv[2] = "2";
else
new_argv[2] = "1";
}
else
new_argv[2] = "0";
new_argv[3] = NULL;
max = sysconf(_SC_OPEN_MAX);
for (d = 3; d < max; ++d) {
if (d != cli_nios_fd[1])
(void)close(d);
}
for (d = 1; d < NSIG; d++)
Signal_(d, SIG_DFL);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
(void)lsfExecvp(new_argv[0], new_argv);
exit(-1);
}
}
if (envp) {
if (ls_rsetenv_async (host, envp) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
if (rexcwd_[0] != '\0')
strcpy(cmdmsg.cwd, rexcwd_);
else if (mygetwd_(cmdmsg.cwd) == 0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_WDIR;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
rpid++;
cmdmsg.rpid = rpid;
cmdmsg.retport = retport;
cmdmsg.argv = argv;
cmdmsg.priority = 0;
if (sendCmdBill_(s, (resCmd) RES_EXEC, &cmdmsg, NULL, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (cmdmsg.options & REXF_TASKPORT) {
if ((taskPort = getTaskPort(s)) == 0) {
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
}
len = sizeof(sin);
if (getpeername(s, (struct sockaddr *) &sin, &len) <0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_SOCK_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
SET_LSLIB_NIOS_HDR(taskReq.hdr, LIB_NIOS_RTASK, sizeof(taskReq.r));
taskReq.r.pid = rpid;
taskReq.r.peer = sin.sin_addr;
taskReq.r.pid = (niosOptions & REXF_SYNCNIOS)? -rpid : rpid;
if (b_write_fix(cli_nios_fd[0], (char *) &taskReq, sizeof(taskReq))
!= sizeof(taskReq)) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
if (tid_register(rpid, s, taskPort, host, options & REXF_TASKINFO) == -1) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_MALLOC;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (rpid);
}
int
main(int argc, char **argv)
{
static char fname[] = "res/main";
int nready;
int maxfd;
int i;
char *sp;
char *pathname = NULL;
int didSomething = 0;
char exbuf;
time_t thisPeriodic, lastPeriodic = 0, timeDiff;
fd_set rm, wm, em;
int sbdPty = FALSE;
char *sbdClHost = NULL;
ushort sbdClPort = 0;
char **sbdArgv = NULL;
int selectError = 0;
_i18n_init(I18N_CAT_RES);
saveDaemonDir_(argv[0]);
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) {
pathname = argv[i+1];
putEnv("LSF_ENVDIR",pathname);
break;
}
}
if (pathname == NULL) {
if ((pathname = getenv("LSF_ENVDIR")) == NULL)
pathname = LSETCDIR;
}
if (argc > 1) {
if (!strcmp(argv[1],"-V")) {
fputs(_LS_VERSION_, stderr);
exit(0);
}
}
if ((ls_readconfenv(resConfParams, NULL) < 0) ||
(initenv_(resParams, pathname) < 0) ) {
if ((sp = getenv("LSF_LOGDIR")) != NULL)
resParams[LSF_LOGDIR].paramValue = sp;
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1),
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_MM, fname, "initenv_",
pathname);
ls_syslog(LOG_ERR, I18N_Exiting);
exit(-1);
}
restart_argc = argc;
restart_argv = argv;
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) {
pathname = argv[i+1];
i++;
continue;
}
if (strcmp(argv[i], "-1") == 0) {
debug = 1;
continue;
}
if (strcmp(argv[i], "-2") == 0) {
debug = 2;
continue;
}
if (strcmp(argv[i], "-PTY_FIX") == 0) {
printf("PTY_FIX");
exit(0);
}
if ( (strcmp(argv[i], "-j") == 0) && (argv[i+1] != NULL) ) {
lsbJobStarter = argv[++i];
continue;
}
if (strcmp(argv[i], "-P") == 0) {
sbdPty = TRUE;
continue;
}
if (strcmp(argv[i], "-i") == 0) {
sbdFlags |= SBD_FLAG_STDIN;
continue;
}
if (strcmp(argv[i], "-o") == 0) {
sbdFlags |= SBD_FLAG_STDOUT;
continue;
}
if (strcmp(argv[i], "-e") == 0) {
sbdFlags |= SBD_FLAG_STDERR;
continue;
}
if (strcmp(argv[i], "-m") == 0 && argv[i+1] != NULL) {
sbdClHost = argv[i+1];
i++;
sbdMode = TRUE;
continue;
}
if (strcmp(argv[i], "-p") == 0 && argv[i+1] != NULL) {
sbdClPort = atoi(argv[i+1]);
i++;
sbdMode = TRUE;
continue;
}
if (argv[i][0] != '-') {
sbdMode = TRUE;
sbdArgv = argv + i;
break;
}
usage(argv[0]);
}
if (sbdMode) {
if (sbdClHost == NULL || sbdArgv == NULL) {
usage(argv[0]);
exit(-1);
}
if (sbdClPort) {
sbdFlags |= SBD_FLAG_TERM;
} else {
sbdFlags |= SBD_FLAG_STDIN | SBD_FLAG_STDOUT | SBD_FLAG_STDERR;
}
} else {
if (debug < 2)
for (i = sysconf(_SC_OPEN_MAX) ; i >= 0 ; i--)
close(i);
}
if (resParams[LSF_SERVERDIR].paramValue == NULL) {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1),
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5001,
"LSF_SERVERDIR not defined in %s/lsf.conf: %M; res exiting"), /* catgets 5001 */
pathname);
resExit_(-1);
}
if (! debug && resParams[LSF_RES_DEBUG].paramValue != NULL) {
debug = atoi(resParams[LSF_RES_DEBUG].paramValue);
if (debug <= 0)
debug = 1;
}
getLogClass_(resParams[LSF_DEBUG_RES].paramValue,
resParams[LSF_TIME_RES].paramValue);
if (getuid() == 0 && debug) {
if (sbdMode) {
debug = 0;
} else {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE,
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, I18N(5005,"Root cannot run RES in debug mode ... exiting."));/*catgets 5005 */
exit(-1);
}
}
if (debug > 1)
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, TRUE, "LOG_DEBUG");
else {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE,
resParams[LSF_LOG_MASK].paramValue);
}
if (logclass & (LC_TRACE | LC_HANG))
ls_syslog(LOG_DEBUG, "%s: logclass=%x", fname, logclass);
ls_syslog(LOG_DEBUG, "%s: LSF_SERVERDIR=%s", fname, resParams[LSF_SERVERDIR].paramValue);
init_res();
initSignals();
periodic(0);
if (sbdMode) {
lsbJobStart(sbdArgv, sbdClPort, sbdClHost, sbdPty);
}
maxfd = FD_SETSIZE;
for (;;) {
struct timeval *timep;
struct timeval timeout;
loop:
didSomething = 0;
for (i = 0; i < child_cnt; i++) {
if (children[i]->backClnPtr == NULL
&& !FD_IS_VALID(conn2NIOS.sock.fd)
&& children[i]->running == 0) {
delete_child (children[i]);
}
}
if (logclass & LC_TRACE) {
ls_syslog(LOG_DEBUG,"\
%s: %s Res child_res=<%d> child_go=<%d> child_cnt=<%d> client_cnt=<%d>",
fname, ((child_res) ? "Application" : "Root") ,
child_res, child_go, child_cnt, client_cnt);
if (child_cnt == 1 && children != NULL && children[0] != NULL) {
dumpChild(children[0], 1, "in main()");
}
}
if (child_res && child_go && child_cnt == 0 && client_cnt == 0) {
if (debug > 1)
printf (" \n Child <%d> Retired! \n", (int)getpid());
if (logclass & LC_TRACE) {
ls_syslog(LOG_DEBUG,"\
%s: Application Res is exiting.....", fname);
}
millisleep_(5000);
if (sbdMode) {
close(1);
close(2);
exit(lastChildExitStatus);
}
resExit_(EXIT_NO_ERROR);
}
int
checkConf(int verbose, int who)
{
char confCheckBuf[] = "RECONFIG_CHECK=TRUE";
pid_t pid;
char *daemon, *lsfEnvDir;
static struct config_param lsfParams[] =
{
{"LSF_SERVERDIR", NULL},
{"LSF_CONFDIR", NULL},
{"LSB_CONFDIR", NULL},
{"LSB_SHAREDIR", NULL},
{NULL, NULL},
};
struct config_param *plp;
LS_WAIT_T status;
int fatalErr = FALSE, cc = 0;
int fd;
if (lsfParams[0].paramValue == NULL) {
lsfEnvDir = getenv("LSF_ENVDIR");
cc = initenv_(lsfParams, lsfEnvDir);
}
if (cc < 0) {
if (lserrno == LSE_CONF_SYNTAX) {
char lno[20];
sprintf (lno, _i18n_msg_get(ls_catd, NL_SETN, 110,
"Line %d"), errLineNum_); /* catgets 110 */
ls_perror(lno);
} else
ls_perror("initenv_");
}
plp = lsfParams;
for (; plp->paramName != NULL; plp++)
if (plp->paramValue == NULL) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 111,
"%s is missing or has a syntax error in lsf.conf file\n"),/* catgets 111 */
plp->paramName);
fatalErr = TRUE;
}
if (fatalErr)
return (EXIT_FATAL_ERROR);
if (cc < 0)
return (EXIT_WARNING_ERROR);
if ((daemon = calloc(strlen(lsfParams[0].paramValue)+15,
sizeof(char))) == NULL) {
perror("calloc");
return (EXIT_FATAL_ERROR);
}
strcpy(daemon, lsfParams[0].paramValue);
strcat(daemon, ((who == 1) ? "/lim" : "/mbatchd"));
if (access(daemon, X_OK) < 0) {
perror(daemon);
free(daemon);
return (EXIT_FATAL_ERROR);
}
if (putenv(confCheckBuf)) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 112,
"Failed to set environment variable RECONFIG_CHECK\n")); /* catgets 112 */
free(daemon);
return(EXIT_FATAL_ERROR);
}
if ((pid = fork()) < 0) {
perror("fork");
free(daemon);
return (EXIT_FATAL_ERROR);
}
if (pid == 0) {
if (!verbose) {
fd = open(LSDEVNULL, O_RDWR);
dup2(fd, 1);
dup2(fd, 2);
}
if (changeUserEUId() < 0) {
exit(EXIT_FATAL_ERROR);
}
execlp(daemon, daemon, "-C", (char *)0);
perror("execlp");
exit(EXIT_RUN_ERROR);
}
free(daemon);
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,115, "\nChecking configuration files ...\n"))); /* catgets 115 */
if (waitpid(pid, &status, 0) < 0) {
perror("waitpid");
return(EXIT_FATAL_ERROR);
}
if (WIFEXITED(status) != 0 && WEXITSTATUS(status) != 0xf8)
if (verbose)
fprintf(stderr, "---------------------------------------------------------\n");
if (WIFEXITED(status) == 0) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 116,
"Child process killed by signal.\n\n")); /* catgets 116 */
return(EXIT_FATAL_ERROR);
}
switch (WEXITSTATUS(status)) {
case 0 :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 117,
"No errors found.\n\n")); /* catgets 117 */
return(EXIT_NO_ERROR);
case 0xff :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 118,
"There are fatal errors.\n\n")); /* catgets 118 */
return(EXIT_FATAL_ERROR);
case 0xf8 :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 119,
"Fail to run checking program \n\n")); /* catgets 119 */
return(EXIT_FATAL_ERROR);
case 0xfe :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 120,
"No fatal errors found.\n\n"));/* catgets 120 */
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 121, "Warning: Some configuration parameters may be incorrect.\n")); /* catgets 121 */
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 122,
" They are either ignored or replaced by default values.\n\n")); /* catgets 122 */
return(EXIT_WARNING_ERROR);
default :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 123,
"Errors found.\n\n")); /* catgets 123 */
return(EXIT_FATAL_ERROR);
}
}
int
ctrlSbdDebug(struct debugReq *pdebug)
{
static char fname[]="ctrlSbdDebug()";
int opCode;
int level;
int newClass;
int options;
char logFileName[MAXLSFNAMELEN];
char lsfLogDir[MAXPATHLEN];
char *dir;
char dynDbgEnv[MAXPATHLEN];
memset(logFileName, 0, sizeof(logFileName));
memset(lsfLogDir, 0, sizeof(lsfLogDir));
opCode = pdebug->opCode;
level = pdebug->level;
newClass = pdebug->logClass;
options = pdebug->options;
if (pdebug->logFileName[0] != '\0') {
if (((dir = strrchr(pdebug->logFileName,'/')) != NULL) ||
((dir = strrchr(pdebug->logFileName,'\\')) != NULL)) {
dir++;
ls_strcat(logFileName, sizeof(logFileName), dir);
*(--dir) = '\0';
ls_strcat(lsfLogDir, sizeof(lsfLogDir), pdebug->logFileName);
}
else {
ls_strcat(logFileName, sizeof(logFileName), pdebug->logFileName);
if (daemonParams[LSF_LOGDIR].paramValue
&& *(daemonParams[LSF_LOGDIR].paramValue)) {
ls_strcat(lsfLogDir, sizeof(lsfLogDir),
daemonParams[LSF_LOGDIR].paramValue);
}
else {
lsfLogDir[0] = '\0';
}
}
ls_strcat(logFileName, sizeof(logFileName), ".sbatchd");
}
else {
ls_strcat(logFileName, sizeof(logFileName), "sbatchd");
if (daemonParams[LSF_LOGDIR].paramValue
&& *(daemonParams[LSF_LOGDIR].paramValue)) {
ls_strcat(lsfLogDir, sizeof(lsfLogDir),
daemonParams[LSF_LOGDIR].paramValue);
} else {
lsfLogDir[0] = '\0';
}
}
if (options==1) {
struct config_param *plp;
for (plp = daemonParams; plp->paramName != NULL; plp++) {
if (plp->paramValue != NULL)
FREEUP(plp->paramValue);
}
if (initenv_(daemonParams, env_dir) < 0){
ls_openlog("sbatchd", daemonParams[LSF_LOGDIR].paramValue,
(debug > 1), daemonParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "initenv_");
die(SLAVE_FATAL);
return -1;
}
getLogClass_(daemonParams[LSB_DEBUG_SBD].paramValue,
daemonParams[LSB_TIME_SBD].paramValue);
closelog();
if (debug > 1)
ls_openlog("sbatchd", daemonParams[LSF_LOGDIR].paramValue, TRUE,
daemonParams[LSF_LOG_MASK].paramValue);
else
ls_openlog("sbatchd", daemonParams[LSF_LOGDIR].paramValue, FALSE,
daemonParams[LSF_LOG_MASK].paramValue);
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG, "%s: logclass=%x", fname, logclass);
cleanDynDbgEnv();
return(LSBE_NO_ERROR);
}
if (opCode==SBD_DEBUG) {
putMaskLevel(level, &(daemonParams[LSF_LOG_MASK].paramValue));
if (newClass>=0) {
logclass = newClass;
sprintf(dynDbgEnv, "%d", logclass);
putEnv("DYN_DBG_LOGCLASS", dynDbgEnv);
}
if ( pdebug->level>=0 ){
closelog();
if (debug > 1)
ls_openlog(logFileName, lsfLogDir, TRUE,
daemonParams[LSF_LOG_MASK].paramValue);
else
ls_openlog(logFileName, lsfLogDir, FALSE,
daemonParams[LSF_LOG_MASK].paramValue);
putEnv("DYN_DBG_LOGDIR", lsfLogDir);
putEnv("DYN_DBG_LOGFILENAME", logFileName);
sprintf(dynDbgEnv, "%d", pdebug->level);
putEnv("DYN_DBG_LOGLEVEL", dynDbgEnv);
}
}
else if (opCode == SBD_TIMING) {
if (level>=0)
timinglevel = level;
if (pdebug->logFileName[0] != '\0') {
if (debug > 1)
ls_openlog(logFileName, lsfLogDir,
TRUE, daemonParams[LSF_LOG_MASK].paramValue);
else
ls_openlog(logFileName, lsfLogDir,
FALSE, daemonParams[LSF_LOG_MASK].paramValue);
}
}
else {
ls_perror("No this debug command!\n");
return -1;
}
return (LSBE_NO_ERROR);
}
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;
}
int
ls_initrex(int num, int options)
{
struct servent *sv;
if (geteuid() == 0)
rootuid_ = TRUE;
if (initenv_(NULL, NULL)<0) {
if (rootuid_ && !(options & KEEPUID))
lsfSetUid(getuid());
return(-1);
}
inithostsock_();
lsQueueInit_(&requestQ, lsReqCmp_, NULL);
if (requestQ == NULL) {
lserrno = LSE_MALLOC;
return(-1);
}
res_addr_.sin_family = AF_INET;
if (genParams_[LSF_RES_PORT].paramValue) {
if ((res_addr_.sin_port = atoi(genParams_[LSF_RES_PORT].paramValue))
!= 0)
res_addr_.sin_port = htons(res_addr_.sin_port);
else
goto res_init_fail;
} else if (genParams_[LSF_RES_DEBUG].paramValue) {
res_addr_.sin_port = htons(RES_PORT);
} else {
# if defined(_COMPANY_X_)
if ((res_addr_.sin_port =
get_port_number(RES_SERVICE,(char *)NULL)) == -1) {
# else
if ((sv = getservbyname("res", "tcp")) != NULL)
res_addr_.sin_port = sv->s_port;
else {
# endif
res_init_fail:
lserrno = LSE_RES_NREG;
if (rootuid_ && !(options & KEEPUID))
lsfSetUid(getuid());
return (-1);
}
}
initconntbl_();
FD_ZERO(&connection_ok_);
if ((rootuid_) && (genParams_[LSF_AUTH].paramValue == NULL)) {
int i;
i = opensocks_(num);
if (!(options & KEEPUID))
lsfSetUid(getuid());
return (i);
} else {
return (num);
}
}
int
opensocks_(int num)
{
static char fname[] = "opensocks_";
int s;
int nextdescr;
int i;
totsockets_ = (num <= 0 || num > MAXCONNECT) ? LSF_DEFAULT_SOCKS : num;
if (logclass & LC_COMM)
ls_syslog(LOG_DEBUG,"%s: try to allocate num <%d> of socks",fname,num);
nextdescr = FIRST_RES_SOCK;
for (i = 0; i < totsockets_; i++) {
if ((s = CreateSock_(SOCK_STREAM)) < 0) {
if (logclass & LC_COMM)
ls_syslog(LOG_DEBUG,
"%s: CreateSock_ failed, iter:<%d> %s",
fname,i,strerror(errno));
totsockets_ = i;
if (i > 0) {
break;
} else {
return(-1);
}
}
if (s != nextdescr) {
if (dup2(s,nextdescr) < 0) {
if (logclass & LC_COMM)
ls_syslog(LOG_DEBUG,
"%s: dup2() failed, old:<%d>, new<%d>, iter:<%d> %s",
fname,s,nextdescr,i,strerror(errno));
close(s);
lserrno = LSE_SOCK_SYS;
totsockets_ = i;
if (i > 0)
break;
else
return (-1);
}
#if defined(FD_CLOEXEC)
fcntl(nextdescr, F_SETFD, (fcntl(nextdescr, F_GETFD)
| FD_CLOEXEC)) ;
#else
#if defined(FIOCLEX)
(void)ioctl(nextdescr, FIOCLEX, (char *)NULL);
#endif
#endif
close(s);
}
nextdescr++;
}
currentsocket_ = FIRST_RES_SOCK;
if (logclass & LC_COMM)
ls_syslog(LOG_DEBUG,"%s: returning num=<%d>",fname,totsockets_);
return (totsockets_);
}
/* ls_fdbusy()
*/
int
ls_fdbusy(int fd)
{
sTab hashSearchPtr;
hEnt *hEntPtr;
if (fd == chanSock_(limchans_[PRIMARY])
|| fd == chanSock_(limchans_[MASTER])
|| fd == chanSock_(limchans_[UNBOUND]))
return TRUE;
if (fd == cli_nios_fd[0])
return TRUE;
hEntPtr = h_firstEnt_(&conn_table, &hashSearchPtr);
while (hEntPtr) {
int *pfd;
pfd = hEntPtr->hData;
if (fd == pfd[0]
|| fd == pfd[1])
return (TRUE);
hEntPtr = h_nextEnt_(&hashSearchPtr);
}
if (rootuid_
&& fd >= currentsocket_
&& fd < FIRST_RES_SOCK + totsockets_)
return TRUE;
return FALSE;
}
int
main(int argc, char **argv){
static char fname[] = "main()";
char *pMethodName = NULL;
char *pMethodDir = NULL;
char *pIsOutput = NULL;
char *pJobID = NULL;
char *presAcctFN = NULL;
char resAcctFN[MAXFILENAMELEN];
char echkpntProgPath[MAXPATHLEN];
char *pChkpntDir = NULL;
pid_t iChildPid;
LS_WAIT_T iStatus;
char *cargv[MAX_ARGS];
int argIndex = 0;
int cc;
int iReValue;
char *jf, *jfn;
while ((cc = getopt(argc, argv, "cfksd:Vhx")) != EOF ){
switch(cc){
case 'c':
case 'f':
case 'k':
case 'x':
case 's':
break;
case 'V':
fputs(_LS_VERSION_, stderr);
exit(0);
case 'd':
pChkpntDir = optarg;
break;
case 'h':
usage(argv[0]);
exit(0);
default:
usage(argv[0]);
exit(-1);
}
}
if (pChkpntDir == NULL){
usage(argv[0]);
exit(-1);
}
if (access(pChkpntDir,W_OK | X_OK) < 0){
fprintf(stderr,"%s : the chkpnt dir %s can not be accessed\n",
fname,pChkpntDir);
exit(-1);
}
iReValue = fileIsExist(pChkpntDir);
if (iReValue == 1){
pMethodName = getEchkpntVar(ECHKPNT_METHOD);
if ((pMethodName == NULL)||(strcmp(pMethodName,"") == 0)){
pMethodName = ECHKPNT_DEFAULT_METHOD;
}
pMethodDir = getEchkpntVar(ECHKPNT_METHOD_DIR);
pIsOutput = getEchkpntVar(ECHKPNT_KEEP_OUTPUT);
}else if (iReValue == 0) {
initenv_(NULL,NULL);
pMethodName = getenv(ECHKPNT_METHOD);
if ((pMethodName == NULL)||(strcmp(pMethodName,"") == 0)){
pMethodName = ECHKPNT_DEFAULT_METHOD;
}
pMethodDir = getenv(ECHKPNT_METHOD_DIR);
pIsOutput = getenv(ECHKPNT_KEEP_OUTPUT);
{
jf = getenv("LSB_JOBFILENAME");
if (jf == NULL) {
fprintf(stderr, "%s : getenv of LSB_JOBFILENAME failed", fname);
} else {
jfn = strchr (jf, '/');
if (jfn) {
sprintf(resAcctFN, "%s/.%s.acct",LSTMPDIR,jfn+1);
presAcctFN = (char *) resAcctFN;
}
}
}
writeEchkpntVar(ECHKPNT_METHOD, pMethodName);
writeEchkpntVar(ECHKPNT_METHOD_DIR, pMethodDir);
writeEchkpntVar(ECHKPNT_KEEP_OUTPUT,pIsOutput);
writeEchkpntVar(ECHKPNT_ACCT_FILE,presAcctFN);
}else{
fprintf(stderr, "%s : the .echkpnt file content occurs error: %s\n",fname,strerror(errno));
exit(-1);
}
if ((pIsOutput != NULL)&&((strcmp(pIsOutput,ECHKPNT_OPEN_OUTPUT) == 0)
||(strcmp(pIsOutput,ECHKPNT_OPEN_OUTPUT_L) == 0))) {
initLog("Echkpnt");
}
#ifdef DEBUG
sprintf(logMesgBuf,"%s : the LSB_ECHKPNT_METHOD = %s\n",fname,pMethodName);
logMesg(logMesgBuf);
sprintf(logMesgBuf,"%s : the LSB_ECHKPNT_METHOD_DIR = %s\n",fname,pMethodDir != NULL?pMethodDir : "");
logMesg(logMesgBuf);
#endif
if (getEchkpntMethodDir(echkpntProgPath, pMethodDir, ECHKPNT_PROGRAM, pMethodName) == NULL){
sprintf(logMesgBuf, "%s : the echkpnt method(%s) path is not correct\n",fname,pMethodName);
goto Error;
}
#ifdef DEBUG
sprintf(logMesgBuf,"%s : the echkpntProgPath is : %s\n",fname,echkpntProgPath);
logMesg(logMesgBuf);
#endif
for(argIndex = 0;argIndex < argc; argIndex++){
cargv[argIndex] = argv[argIndex];
}
cargv[argIndex] = NULL;
if (strcmp(pMethodName, ECHKPNT_DEFAULT_METHOD) == 0){
cargv[0] = "echkpnt.default";
freeTable_();
#ifdef DEBUG
logMesg("the echkpnt.default will be executed\n");
#endif
closeLog();
execv(echkpntProgPath, cargv);
sprintf(logMesgBuf,"%s : execute the echkpnt.default fail\n%s\n",fname,
(errno? strerror(errno):""));
fprintf(stderr,"%s",logMesgBuf);
exit(-1);
}
iChildPid = fork();
if (iChildPid < 0){
sprintf(logMesgBuf, "%s : fork() fork a child process fail...\n",fname);
goto Error;
}else if (iChildPid == 0){
long lMaxfds;
int ii;
char progName[MAXFILENAMELEN];
sprintf(logMesgBuf,"erestart.%s",pMethodName);
setMesgHeader(logMesgBuf);
if ((pIsOutput == NULL) || ((strcmp(pIsOutput,ECHKPNT_OPEN_OUTPUT) != 0)
&&(strcmp(pIsOutput,ECHKPNT_OPEN_OUTPUT_L) != 0))){
if (redirectFd(ECHKPNT_DEFAULT_OUTPUT_FILE, 1) == -1){
sprintf(logMesgBuf, "%s : redirect stdout to %s file\n%s\n",
fname, ECHKPNT_DEFAULT_OUTPUT_FILE,
errno? strerror(errno) : "");
goto Error;
}
if (redirectFd(ECHKPNT_DEFAULT_OUTPUT_FILE, 2) == -1){
sprintf(logMesgBuf, "%s : redirect stderr to %s file\n%s\n",
fname, ECHKPNT_DEFAULT_OUTPUT_FILE,
errno? strerror(errno) : "");
goto Error;
}
}else{
char aFileName[MAXPATHLEN];
if ((getChkpntDirFile(aFileName, ECHKPNT_STDOUT_FILE) == -1)
|| (redirectFd(aFileName,1) == -1)){
sprintf(logMesgBuf,"%s : redirect the stdout to %s fail\n",
fname,ECHKPNT_STDOUT_FILE);
logMesg(logMesgBuf);
if (redirectFd(ECHKPNT_DEFAULT_OUTPUT_FILE, 1) == -1){
sprintf(logMesgBuf, "%s : redirect stdout to %s file fail\n%s\n",
fname, ECHKPNT_DEFAULT_OUTPUT_FILE,
errno? strerror(errno) : "");
goto Error;
}
}
if ((getChkpntDirFile(aFileName, ECHKPNT_STDERR_FILE) == -1)
|| (redirectFd(aFileName,2) == -1)){
sprintf(logMesgBuf,"%s : redirect the stderr to %s fail\n",
fname,ERESTART_STDERR_FILE);
logMesg(logMesgBuf);
if (redirectFd(ECHKPNT_DEFAULT_OUTPUT_FILE, 2) == -1){
sprintf(logMesgBuf, "%s : redirect stderr to %s file fail\n%s\n",
fname, ECHKPNT_DEFAULT_OUTPUT_FILE,
errno? strerror(errno) : "");
goto Error;
}
}
}
lMaxfds = sysconf(_SC_OPEN_MAX);
for (ii = 3; ii < lMaxfds; ii++){
close(ii);
}
sprintf(progName,"%s.%s",ECHKPNT_PROGRAM,pMethodName);
cargv[0] = progName;
freeTable_();
execv(echkpntProgPath,cargv);
sprintf(logMesgBuf, "%s : the child process execute the %s fail\n",fname,progName);
fprintf(stderr,"%s",logMesgBuf);
logMesg(logMesgBuf);
closeLog();
exit(-1);
}
while ((iChildPid = waitpid(iChildPid, &iStatus, 0)) < 0 && errno == EINTR);
if (iChildPid < 0 ){
sprintf(logMesgBuf, "%s : %s fail, \n%s\n",
fname, "waitpid", errno? strerror(errno) : "");
goto Error;
}else{
if (WEXITSTATUS(iStatus) != 0) {
sprintf(logMesgBuf, "%s : the echkpnt.%s fail,the exit value is %d\n",
fname, pMethodName,WEXITSTATUS(iStatus));
fprintf(stderr,"%s",logMesgBuf);
logMesg(logMesgBuf);
freeTable_();
closeLog();
exit(WEXITSTATUS(iStatus));
}
}
pJobID = getenv(ECHKPNT_JOBID);
if (pJobID == NULL){
writeEchkpntVar(ECHKPNT_OLD_JOBID,"");
sprintf(logMesgBuf,"%s : getenv() can not get the env variable LSB_JOBID\n",fname);
logMesg(logMesgBuf);
}else{
writeEchkpntVar(ECHKPNT_OLD_JOBID, pJobID);
}
freeTable_();
closeLog();
exit(0);
Error:
fprintf(stderr,"%s",logMesgBuf);
logMesg(logMesgBuf);
freeTable_();
closeLog();
exit(-1);
}
