static void
printsummary (void)
{
char localTimeStrBegin[60];
char localTimeStrEnd[60];
char *buf1, *buf2, *buf3, *buf4, *buf5;
if (tottasks == 0)
return;
strcpy (localTimeStrBegin, _i18n_ctime (ls_catd, 1, &actual_start.begin));
strcpy (localTimeStrEnd, _i18n_ctime (ls_catd, 1, &actual_start.end));
printf (_i18n_msg_get (ls_catd, NL_SETN, 1231, "Summary of %d task(s). (Exit status zero: %d; exit status non-zero: %d).\n"), /* catgets 1231 */
tottasks, totstatz, totstatnz);
sprintf (printline, _i18n_msg_get (ls_catd, NL_SETN, 1232, "Started between %s and %s"), /* catgets 1232 */
localTimeStrBegin, localTimeStrEnd);
printf ("%s", printline);
strcpy (localTimeStrBegin,
_i18n_ctime (ls_catd, 1, &actual_complete.begin));
strcpy (localTimeStrEnd, _i18n_ctime (ls_catd, 1, &actual_complete.end));
sprintf (printline, _i18n_msg_get (ls_catd, NL_SETN, 1234, "Completed between %s and %s"), /* catgets 1234 */
localTimeStrBegin, localTimeStrEnd);
printf ("%s\n", printline);
buf1 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1236, "Resource")); /* catgets 1236 */
buf2 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1237, "Total")); /* catgets 1237 */
buf3 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1238, "Average")); /* catgets 1238 */
buf4 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1239, "Maximum")); /* catgets 1239 */
buf5 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1240, "Minimum")); /* catgets 1240 */
printf (" %-30s%12s%12s%12s%12s\n", buf1, buf2, buf3, buf4, buf5);
FREEUP (buf1);
FREEUP (buf2);
FREEUP (buf3);
FREEUP (buf4);
FREEUP (buf5);
printresuse (cpu, _i18n_msg_get (ls_catd, NL_SETN, 1241, "CPU time (seconds):")); /* catgets 1241 */
printresuse (pf, _i18n_msg_get (ls_catd, NL_SETN, 1242, "Page faults:")); /* catgets 1242 */
printresuse (swaps, _i18n_msg_get (ls_catd, NL_SETN, 1243, "Swaps:")); /* catgets 1243 */
printresuse (bin, _i18n_msg_get (ls_catd, NL_SETN, 1244, "Block input:")); /* catgets 1244 */
printresuse (bout, _i18n_msg_get (ls_catd, NL_SETN, 1245, "Block output:")); /* catgets 1245 */
printresuse (msgs, _i18n_msg_get (ls_catd, NL_SETN, 1246, "Messages sent:")); /* catgets 1246 */
printresuse (msgr, _i18n_msg_get (ls_catd, NL_SETN, 1247, "Messages received:")); /* catgets 1247 */
printresuse (vcsw, _i18n_msg_get (ls_catd, NL_SETN, 1248, "Voluntary context switches:")); /* catgets 1248 */
printresuse (ivcsw, _i18n_msg_get (ls_catd, NL_SETN, 1249, "Involuntary context switches:")); /* catgets 1249 */
printresuse (turn, _i18n_msg_get (ls_catd, NL_SETN, 1250, "Turnaround time (seconds):")); /* catgets 1250 */
}
int
mapValues(struct keymap *keyList, char *line)
{
int pos = 0;
char *value;
int i = 0;
int found;
int numv = 0;
while (keyList[i].key != NULL) {
FREEUP (keyList[i].val);
if (keyList[i].position != -1)
numv++;
i++;
}
while ((value = getNextValue(&line)) != NULL) {
i=0;
found = FALSE;
while (keyList[i].key != NULL) {
if (keyList[i].position != pos) {
i++;
continue;
}
if (strcmp (value, "-") == 0)
keyList[i].val = putstr_("");
else {
if (keyList[i].val != NULL)
FREEUP (keyList[i].val);
keyList[i].val = putstr_(value);
}
found = TRUE;
break;
}
if (! found)
goto fail;
pos++;
}
if (pos != numv)
goto fail;
return 0;
fail:
i=0;
while (keyList[i].key != NULL) {
if (keyList[i].val != NULL) {
free(keyList[i].val);
keyList[i].val = NULL;
}
i++;
}
return -1;
}
int
doXferOptions( lsRcpXfer *lsXfer, int argc, char *argv[] )
{
int c;
while((c= getopt(argc, argv,"ahV")) != -1) {
switch(c) {
case 'a':
lsXfer->iOptions |= O_APPEND;
break;
case 'V':
fputs(_LS_VERSION_,stderr);
exit(-1);
case '?':
doXferUsage();
exit(-1);
case 'h':
doXferUsage();
exit(-1);
case ':':
doXferUsage();
exit(-1);
}
}
if (argc >= 3 && argv[argc-2]) {
lsXfer->szSourceArg = putstr_(argv[argc-2]);
parseXferArg(argv[argc-2],&(lsXfer->szHostUser),
&(lsXfer->szHost),
&(lsXfer->ppszHostFnames[0]));
} else {
doXferUsage();
exit(-1);
}
if (argc >= 3 && argv[argc-1]) {
lsXfer->szDestArg = putstr_(argv[argc-1]);
parseXferArg(argv[argc-1],&(lsXfer->szDestUser),
&(lsXfer->szDest),
&(lsXfer->ppszDestFnames[0]));
} else {
doXferUsage();
exit(-1);
}
return(0);
}
void
prtJobSubmit(struct jobInfoEnt *job, int prt_q, int tFormat)
{
char prline[MAXLINELEN];
char *timestr;
timestr = putstr_(_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->submitTime));
if (tFormat) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,569, "%s: Job <%s> submitted from host <%s>")), /* catgets 569 */
timestr, lsb_jobid2str(job->jobId), job->fromHost);
} else {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,570, "%s: Submitted from host <%s>")), /* catgets 570 */
timestr, job->fromHost);
}
FREEUP(timestr);
prtLine(prline);
if (job->submit.options2 & SUB2_HOLD) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,570, " with hold")));
/* catgets 570 */
prtLine(prline);
}
if (prt_q) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,571, ", to Queue <%s>")), job->submit.queue); /* catgets 571 */
prtLine(prline);
}
TIMEIT(2, prtBTTime(job), "prtBTTime");
}
static int
copyAdmins_ (struct clusterInfo *clusPtr, struct shortCInfo *clusShort)
{
int i, j;
if (clusShort->nAdmins <= 0)
return 0;
clusPtr->adminIds = calloc (clusShort->nAdmins, sizeof (int));
clusPtr->admins = calloc (clusShort->nAdmins, sizeof (char *));
if (!clusPtr->admins || !clusPtr->adminIds)
goto errReturn;
for (i = 0; i < clusShort->nAdmins; i++)
{
clusPtr->admins[i] = NULL;
clusPtr->adminIds[i] = clusShort->adminIds[i];
clusPtr->admins[i] = putstr_ (clusShort->admins[i]);
if (clusPtr->admins[i] == NULL)
{
for (j = 0; j < i; j++)
FREEUP (clusPtr->admins[j]);
goto errReturn;
}
}
return 0;
errReturn:
FREEUP (clusPtr->admins);
FREEUP (clusPtr->adminIds);
lserrno = LSE_MALLOC;
return (-1);
}
char *
lsb_sysmsg (void)
{
static char buf[512];
if (lsberrno >= LSBE_NUM_ERR) {
sprintf(buf, _i18n_msg_get(ls_catd, NL_SETN, 99, "Unknown batch system error number %d"), lsberrno); /* catgets 99 */
return buf;
}
if (lsberrno == LSBE_SYS_CALL) {
if (strerror(errno) != NULL && errno > 0)
sprintf(buf, "%s: %s", _i18n_msg_get(ls_catd, NL_SETN, lsb_errmsg_ID[lsberrno], lsb_errmsg[lsberrno]), strerror(errno));
else {
char *temp;
temp = putstr_(_i18n_msg_get(ls_catd, NL_SETN,
lsb_errmsg_ID[lsberrno], lsb_errmsg[lsberrno]));
sprintf(buf, "%s:%s %d", temp, _i18n_msg_get(ls_catd, NL_SETN, 98,
"unknown system error"), /* catgets 98 */
errno);
free(temp);
}
} else if (lsberrno == LSBE_LSLIB) {
sprintf(buf, "%s: %s", _i18n_msg_get(ls_catd, NL_SETN, lsb_errmsg_ID[lsberrno], lsb_errmsg[lsberrno]), ls_sysmsg());
} else {
return(_i18n_msg_get(ls_catd, NL_SETN, lsb_errmsg_ID[lsberrno],lsb_errmsg[lsberrno]));
}
return buf;
}
int
putInLists (char *word, struct admins *admins, int *numAds, char *forWhat)
{
static char fname[] = "putInLists";
struct passwd *pw;
char **tempNames;
int i, *tempIds, *tempGids;
if ((pw = getpwlsfuser_ (word)) == NULL)
{
if (logclass & LC_TRACE)
{
ls_syslog (LOG_DEBUG, _i18n_msg_get (ls_catd, NL_SETN, 5410, "%s: <%s> is not a valid user on this host"), fname, word); /* catgets 5410 */
}
}
if (isInlist (admins->adminNames, word, admins->nAdmins))
{
ls_syslog (LOG_WARNING, _i18n_msg_get (ls_catd, NL_SETN, 5411, "%s: Duplicate user name <%s> %s; ignored"), fname, word, forWhat); /* catgets 5411 */
return (0);
}
admins->adminIds[admins->nAdmins] = (pw == NULL) ? -1 : pw->pw_uid;
admins->adminGIds[admins->nAdmins] = (pw == NULL) ? -1 : pw->pw_gid;
admins->adminNames[admins->nAdmins] = putstr_ (word);
admins->nAdmins += 1;
if (admins->nAdmins >= *numAds)
{
*numAds = *numAds * 2;
tempIds = (int *) realloc (admins->adminIds, *numAds * sizeof (int));
tempGids = (int *) realloc (admins->adminGIds, *numAds * sizeof (int));
tempNames =
(char **) realloc (admins->adminNames, *numAds * sizeof (char *));
if (tempIds == NULL || tempGids == NULL || tempNames == NULL)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "realloc");
FREEUP (tempIds);
FREEUP (tempGids);
FREEUP (tempNames);
FREEUP (admins->adminIds);
FREEUP (admins->adminGIds);
for (i = 0; i < admins->nAdmins; i++)
FREEUP (admins->adminNames[i]);
FREEUP (admins->adminNames);
admins->nAdmins = 0;
lserrno = LSE_MALLOC;
return (-1);
}
else
{
admins->adminIds = tempIds;
admins->adminGIds = tempGids;
admins->adminNames = tempNames;
}
}
return (0);
}
static void
prtResourcesShort(int num, struct lsbSharedResourceInfo *info)
{
struct lsInfo *lsInfo;
int i, j, k;
char *buf1, *buf2, *buf3, *buf4;
if ((lsInfo = ls_info()) == NULL) {
ls_perror("lsinfo");
exit(-10);
}
buf1 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1645, "RESOURCE")); /* catgets 1645 */
buf2 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1646, "TOTAL")); /* catgets 1646 */
buf3 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1647, "RESERVED")); /* catgets 1647 */
buf4 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1648, "LOCATION")); /* catgets 1648 */
printf("%-20s%10s%15s%15s\n", buf1, buf2, buf3, buf4);
FREEUP(buf1);
FREEUP(buf2);
FREEUP(buf3);
FREEUP(buf4);
for (i = 0; i < num; i++) {
for (j = 0; j < info[i].nInstances; j++) {
for (k = 0; k < lsInfo->nRes; k++) {
if (strcmp(lsInfo->resTable[k].name,
info[i].resourceName) == 0) {
if (lsInfo->resTable[k].valueType & LS_NUMERIC) {
prtOneInstance(info[i].resourceName,
&(info[i].instances[j]));
}
}
}
}
}
}
static void
prtTableHeader ()
{
char *res, *val, *loc;
res = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 750, "RESOURCE")); /* catgets 750 */
val = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 751, "VALUE")); /* catgets 751 */
loc = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 752, "LOCATION")); /* catgets 752 */
if (res == NULL || val == NULL || loc == NULL)
{
printf (I18N_FUNC_FAIL_M, "prtTableHeader", "putstr_");
return;
}
else
printf ("%-25s%20s%15s\n", res, val, loc);
return;
}
int
putValue(struct keymap *keyList, char *key, char *value)
{
int i;
i=0;
while (keyList[i].key != NULL) {
if (strcasecmp(keyList[i].key, key) == 0) {
FREEUP (keyList[i].val);
if (strcmp (value, "-") == 0)
keyList[i].val = putstr_("");
else
keyList[i].val = putstr_(value);
return 0;
}
i++;
}
return -1;
}
/* setCreate()
*/
LS_BITSET_T *
setCreate(const int size,
int (*directFunction)(void *),
void *(*inverseFunction)(int ),
char *caller)
{
static char *fname = "setCreate()";
int sz;
LS_BITSET_T *set;
set = calloc(1, sizeof(LS_BITSET_T));
if (!set) {
bitseterrno = LS_BITSET_ERR_NOMEM;
ls_syslog(LOG_ERR,"%s %s", fname, setPerror(bitseterrno));
return NULL;
}
set->setDescription = putstr_(caller);
/* Size is the number of elements the caller wants
* to store in the set.
*/
sz = (size > 0) ? size : SET_DEFAULT_SIZE;
/* Width is how many bytes we need to store
* size number of elements.
*/
set->setWidth = (sz + WORDLENGTH - 1)/WORDLENGTH;
/* This is the new size eventually rounded up by 1.
*/
set->setSize = (set->setWidth) * WORDLENGTH;
set->setNumElements = 0;
set->bitmask = calloc(set->setWidth, sizeof(unsigned int));
if (!set->bitmask) {
bitseterrno = LS_BITSET_ERR_NOMEM;
return NULL;
}
if (directFunction)
set->getIndexByObject = directFunction;
else
set->getIndexByObject = NULL;
if (inverseFunction)
set->getObjectByIndex = inverseFunction;
else
set->getObjectByIndex = NULL;
return (set);
}
LIST_T *
listCreate(char *name)
{
LIST_T *list;
list = calloc(1, sizeof(LIST_T));
if (list == NULL)
return NULL;
list->name = putstr_(name);
list->forw = list->back = (LIST_ENTRY_T *)list;
return list;
}
LIST_OBSERVER_T *
listObserverCreate(char *name, void *extra, LIST_ENTRY_SELECT_OP_T select, ...)
{
LIST_OBSERVER_T *observer;
LIST_EVENT_TYPE_T etype;
LIST_EVENT_CALLBACK_FUNC_T callback;
va_list ap;
observer = calloc(1, sizeof(LIST_OBSERVER_T));
if (observer == NULL) {
listerrno = LIST_ERR_NOMEM;
goto Fail;
}
observer->name = putstr_(name);
observer->select = select;
observer->extra = extra;
va_start(ap, select);
for (;;) {
etype = va_arg(ap, LIST_EVENT_TYPE_T);
if (etype == LIST_EVENT_NULL)
break;
callback = va_arg(ap, LIST_EVENT_CALLBACK_FUNC_T);
switch (etype) {
case (int) LIST_EVENT_ENTER:
observer->enter = callback;
break;
case (int) LIST_EVENT_LEAVE:
observer->leave_ = callback;
break;
default:
listerrno = LIST_ERR_BADARG;
goto Fail;
}
}
return observer;
Fail:
FREEUP(observer);
return NULL;
}
LIST_ITERATOR_T *
listIteratorCreate(char *name)
{
LIST_ITERATOR_T *iter;
iter = calloc(1, sizeof(LIST_ITERATOR_T));
if (! iter) {
listerrno = (int)LIST_ERR_NOMEM;
return NULL;
}
iter->name = putstr_(name);
return iter;
}
void
putMaskLevel(int level, char **para)
{
level = level + LOG_DEBUG;
if ((level >= LOG_DEBUG) && (level <= LOG_DEBUG3)) {
FREEUP (*para);
switch(level) {
case LOG_DEBUG:
*para = putstr_("LOG_DEBUG");
break;
case LOG_DEBUG1:
*para = putstr_("LOG_DEBUG1");
break;
case LOG_DEBUG2:
*para = putstr_("LOG_DEBUG2");
break;
case LOG_DEBUG3:
*para = putstr_("LOG_DEBUG3");
break;
}
}
}
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
tid_register (int taskid, int socknum, u_short taskPort, char *host,
bool_t doTaskInfo)
{
struct tid *tidp;
int i;
if ((tidp = (struct tid *) malloc (sizeof (struct tid))) ==
(struct tid *) NULL)
{
lserrno = LSE_MALLOC;
return (-1);
}
tidp->rtid = taskid;
tidp->sock = socknum;
tidp->taskPort = taskPort;
tidp->host = putstr_ (host);
i = tid_index (taskid);
tidp->link = tid_buckets[i];
tid_buckets[i] = tidp;
if (doTaskInfo)
{
lsQueueInit_ (&tidp->tMsgQ, NULL, tMsgDestroy_);
if (tidp->tMsgQ == NULL)
{
return (-1);
}
}
else
tidp->tMsgQ = NULL;
tidp->refCount = (doTaskInfo) ? 2 : 1;
tidp->isEOF = (doTaskInfo) ? FALSE : TRUE;
return (0);
}
void
getLSFAdmins_(void)
{
struct clusterInfo *clusterInfo;
int i;
clusterInfo = ls_clusterinfo(NULL, NULL, NULL, 0, 0);
if (clusterInfo == NULL) {
return;
}
if (LSFAdmins.numAdmins != 0) {
FREEUP(LSFAdmins.names);
}
LSFAdmins.numAdmins = clusterInfo->nAdmins;
LSFAdmins.names = calloc(LSFAdmins.numAdmins, sizeof(char *));
if (LSFAdmins.names == NULL) {
LSFAdmins.numAdmins = 0;
return;
}
for (i = 0; i < LSFAdmins.numAdmins; i ++) {
LSFAdmins.names[i] = putstr_(clusterInfo->admins[i]);
if (LSFAdmins.names[i] == NULL) {
int j;
for (j = 0; j < i; j ++) {
FREEUP(LSFAdmins.names[j]);
}
FREEUP(LSFAdmins.names);
LSFAdmins.numAdmins = 0;
return;
}
}
}
char *
getTempDir_ (void)
{
static char *sp = NULL;
char *tmpSp = NULL;
struct stat stb;
if (sp)
{
return (sp);
}
tmpSp = genParams_[LSF_TMPDIR].paramValue;
if ((tmpSp != NULL) && (stat (tmpSp, &stb) == 0) && (S_ISDIR (stb.st_mode)))
{
sp = tmpSp;
}
else
{
tmpSp = getenv ("TMPDIR");
if ((tmpSp != NULL) && (stat (tmpSp, &stb) == 0)
&& (S_ISDIR (stb.st_mode)))
{
sp = putstr_ (tmpSp);
}
}
if (sp == NULL)
{
sp = "/tmp";
}
return sp;
}
/* h_addEnt_()
* Add an entry to a previously created hash table.
*/
hEnt *
h_addEnt_ (hTab * tabPtr, const char *key, int *newPtr)
{
hEnt *hEntPtr;
int *keyPtr;
struct hLinks *hList;
keyPtr = (int *) key;
hList = &(tabPtr->slotPtr[getAddr (tabPtr, (char *) keyPtr)]);
hEntPtr = h_findEnt ((char *) keyPtr, hList);
if (hEntPtr != NULL)
{
if (newPtr != NULL)
*newPtr = FALSE;
return hEntPtr;
}
if (tabPtr->numEnts >= RESETLIMIT * tabPtr->size)
{
resetTab (tabPtr);
hList = &(tabPtr->slotPtr[getAddr (tabPtr, (char *) keyPtr)]);
}
/* Create a new entry and increase the counter
* of entries.
*/
hEntPtr = malloc (sizeof (hEnt));
hEntPtr->keyname = putstr_ ((char *) keyPtr);
hEntPtr->hData = NULL;
insList_ ((struct hLinks *) hEntPtr, hList);
if (newPtr != NULL)
*newPtr = TRUE;
tabPtr->numEnts++;
return hEntPtr;
}
static int
setConfEnv (char *name, char *value, struct config_param *paramList)
{
if (paramList == NULL)
return (1);
if (value == NULL)
value = "";
for (; paramList->paramName; paramList++)
{
if (strcmp (paramList->paramName, name) == 0)
{
FREEUP (paramList->paramValue);
paramList->paramValue = putstr_ (value);
if (paramList->paramValue == NULL)
{
lserrno = LSE_MALLOC;
return (0);
}
}
}
return (1);
}
static int
doEnvParams_ (struct config_param *plp)
{
char *sp;
char *spp;
if (!plp)
return (0);
for (; plp->paramName != NULL; plp++)
{
if ((sp = getenv (plp->paramName)) != NULL)
{
if (NULL == (spp = putstr_ (sp)))
{
lserrno = LSE_MALLOC;
return (-1);
}
FREEUP (plp->paramValue);
plp->paramValue = spp;
}
}
return (0);
}
static int
makeShare (char *hostname, char ***nameTable, char ***valueTable,
char ***formatTable, int (*resourceSelect) (struct resItem *))
{
static int first = TRUE;
static struct lsSharedResourceInfo *resourceInfo;
static struct lsInfo *lsInfo;
static char **namTable;
static char **valTable;
static char **fmtTable;
static int numRes, nRes;
int k, i, j;
char *hPtr;
int ii, numHosts, found;
if (first == TRUE)
{
if ((lsInfo = ls_info ()) == NULL)
{
return (-1);
}
TIMEIT (0,
(resourceInfo =
ls_sharedresourceinfo (NULL, &numRes, NULL, 0)),
"ls_sharedresourceinfo");
if (resourceInfo == NULL)
{
return (-1);
}
if ((namTable = (char **) malloc (numRes * sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (-1);
}
if ((valTable = (char **) malloc (numRes * sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (-1);
}
if ((fmtTable = (char **) malloc (numRes * sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (-1);
}
first = FALSE;
}
else
{
for (i = 0; i < nRes; i++)
{
FREEUP (fmtTable[i]);
}
}
nRes = 0;
for (k = 0; k < numRes; k++)
{
found = FALSE;
for (j = 0; j < lsInfo->nRes; j++)
{
if (strcmp (lsInfo->resTable[j].name,
resourceInfo[k].resourceName) == 0)
{
if (resourceSelect (&lsInfo->resTable[j]))
{
found = TRUE;
break;
}
break;
}
}
if (!found)
{
continue;
}
namTable[nRes] = resourceInfo[k].resourceName;
found = FALSE;
for (i = 0; i < resourceInfo[k].nInstances; i++)
{
numHosts = resourceInfo[k].instances[i].nHosts;
for (ii = 0; ii < numHosts; ii++)
{
hPtr = resourceInfo[k].instances[i].hostList[ii];
if (strcmp (hPtr, hostname) == 0)
{
valTable[nRes] = resourceInfo[k].instances[i].value;
found = TRUE;
break;
}
}
if (found)
{
break;
}
}
if (!found)
{
valTable[nRes] = "-";
}
nRes++;
}
if (nRes)
{
j = 0;
for (i = 0; i < nRes; i++)
{
char fmt[16];
int nameLen;
nameLen = strlen (namTable[i]);
sprintf (fmt, "%s%d.%d%s", "%", nameLen + 2, nameLen + 1, "s");
fmtTable[j++] = putstr_ (fmt);
}
}
*nameTable = namTable;
*valueTable = valTable;
*formatTable = fmtTable;
return (nRes);
}
struct hostLoad *
ls_loadinfo(char *resreq,
int *numhosts,
int options,
char *fromhost,
char **hostlist,
int listsize,
char ***indxnamelist)
{
static char fname[] = "ls_loadinfo";
struct decisionReq loadReq;
char *indexfilter;
int i, j, *num;
int one = 1;
char tempresreq[MAXLINELEN];
int isClus;
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: Entering this routine...", fname);
if (!indxnamelist) {
lserrno = LSE_BAD_ARGS;
return(NULL);
}
if (hostlist && listsize)
loadReq.ofWhat = OF_HOSTS;
else
loadReq.ofWhat = OF_ANY;
loadReq.options = options;
strcpy(loadReq.hostType, " ");
if (numhosts == 0)
num = &one;
else
num = numhosts;
loadReq.numHosts = *num;
if (! *num) {
if (loadReq.ofWhat == OF_HOSTS)
loadReq.numHosts = listsize;
else
loadReq.numHosts = 9999;
loadReq.options &= ~EXACT;
}
if (loadReq.ofWhat == OF_HOSTS) {
char clusterinlist=0;
loadReq.numPrefs = listsize + 1;
loadReq.preferredHosts = calloc(loadReq.numPrefs, sizeof (char *));
if (loadReq.preferredHosts == NULL) {
lserrno = LSE_MALLOC;
return (NULL);
}
for (i=1; i<loadReq.numPrefs; i++) {
if ( (isClus = ls_isclustername(hostlist[i-1])) < 0 ) {
break;
} else if (isClus == 0) {
if ((Gethostbyname_(hostlist[i - 1])) == NULL) {
lserrno = LSE_BAD_HOST;
break;
}
loadReq.preferredHosts[i] = putstr_(hostlist[i - 1]);
} else {
loadReq.preferredHosts[i] = putstr_(hostlist[i-1]);
clusterinlist = 1;
}
if (loadReq.preferredHosts[i] == NULL) {
for (j=1; j<i; j++)
free(loadReq.preferredHosts[j]);
lserrno = LSE_MALLOC;
break;
}
}
if (i < loadReq.numPrefs) {
for (j=1; j<i; j++)
free(loadReq.preferredHosts[j]);
free(loadReq.preferredHosts);
return (NULL);
}
if (*num > listsize && (loadReq.options & EXACT) && !clusterinlist) {
lserrno = LSE_NO_HOST;
for (j=1; j<i; j++)
free(loadReq.preferredHosts[j]);
free(loadReq.preferredHosts);
return (NULL);
}
if (clusterinlist && !*num) {
loadReq.numHosts = 9999;
loadReq.options &= ~EXACT;
}
} else {
loadReq.numPrefs = 1;
loadReq.preferredHosts = (char **)
calloc(loadReq.numPrefs, sizeof (char *));
if (loadReq.preferredHosts == NULL) {
lserrno = LSE_MALLOC;
return (NULL);
}
}
if (*indxnamelist) {
indexfilter = namestofilter_(*indxnamelist);
if (!indexfilter)
return NULL;
} else
indexfilter = NULL;
if (resreq && indexfilter) {
if ((strlen(resreq) + strlen(indexfilter)) < MAXLINELEN - 8) {
char tmp[MAXLINELEN/2];
sprintf(tmp,"filter[%s]", indexfilter);
strcpy(tempresreq, resreq);
strcat(tempresreq, tmp);
resreq = tempresreq;
} else {
lserrno = LSE_BAD_ARGS;
return(NULL);
}
} else if (indexfilter) {
sprintf(tempresreq,"filter[%s]",indexfilter);
resreq = tempresreq;
}
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: loadReq.ofWhat=%d loadReq.numHosts=%d loadReq..numPrefs=%d", fname,loadReq.ofWhat, loadReq.numHosts,loadReq.numPrefs);
return (loadinfo_(resreq, &loadReq, fromhost, num, indxnamelist));
}
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);
}
int
mychdir_(char *path, struct hostent *hp)
{
char *goodpath = path;
char *sp = NULL;
sTab hashSearchPtr;
hEnt *hashEntryPtr;
static char first = TRUE;
char filename[MAXPATHLEN];
/*Bug#169, set hp to NULL to let the function do operation directly
* and do not try /net and /tmp_mnt
*/
hp = NULL;
if (path == NULL || strlen(path) == 0 || path[0] != '/' || AM_NEVER)
return (chdir(usePath(path)));
if (hp != NULL)
if (netHostChdir(path, hp) == 0)
return 0;
if (strstr(path, "/tmp_mnt" ) == path) {
sp = path + strlen("/tmp_mnt");
if (chdir(usePath(sp)) == 0)
return 0;
} else {
if (chdir(usePath(path)) == 0)
return 0;
}
if (errno != ENOENT && errno != ENOTDIR)
return -1;
if (getcwd(filename, sizeof(filename)) == NULL)
goto try;
sp = getenv("HOME");
if (sp != NULL)
chdir(sp);
chdir(filename);
try:
if (path[0] != '/')
return -1;
if ((goodpath=strstr(path,"/exp/lsf")) != NULL) {
if (chdir(usePath(goodpath)) == 0)
return 0;
}
if (strstr(path, "/tmp_mnt" ) == path) {
goodpath = path + strlen("/tmp_mnt");
} else {
if (chdir(usePath(path)) ==0)
return 0;
sp = getenv("PWD");
if (tryPwd(path, sp) == 0)
return 0;
}
if (goodpath == NULL)
goodpath = strchr(path+1, '/');
else
goodpath = strchr(goodpath+1, '/');
if (goodpath != NULL) {
if (chdir(usePath(goodpath)) == 0)
return 0;
} else {
return -1;
}
if (first) {
first = FALSE;
if (getMap_() != 0)
return -1;
}
hashEntryPtr = h_firstEnt_(&hashTab, &hashSearchPtr);
if (hashEntryPtr == NULL)
{
errno = ENOENT;
return -1;
}
while (hashEntryPtr != NULL) {
sprintf(filename, "%s%s", hashEntryPtr->keyname, goodpath);
if (chdir(usePath(filename)) == 0)
return 0;
hashEntryPtr = h_nextEnt_(&hashSearchPtr);
}
goodpath = strchr(goodpath+1, '/');
if (goodpath == NULL) {
return -1;
}
hashEntryPtr = h_firstEnt_(&hashTab, &hashSearchPtr);
while (hashEntryPtr != NULL) {
sprintf(filename, "%s%s", hashEntryPtr->keyname, goodpath);
if (chdir(usePath(filename)) == 0)
return 0;
hashEntryPtr = h_nextEnt_(&hashSearchPtr);
}
if (chdir(usePath(goodpath)) == 0)
return 0;
if ( strstr(path, "/tmp_mnt" ) != path)
return -1;
goodpath = path + strlen("/tmp_mnt");
if (*goodpath == '\0')
return -1;
strcpy(filename, goodpath);
sp = strchr(filename+1, '/');
if (sp == NULL)
return -1;
goodpath = strchr(sp+1, '/');
if (goodpath == NULL)
return -1;
if ((sp = strchr(goodpath+1, '/')) == NULL)
return -1;
*goodpath = '\0';
strcat(filename, sp);
if (chdir(usePath(filename)) ==0)
return 0;
if ((sp = strchr(goodpath+1, '/')) == NULL)
return (-1);
*goodpath = '\0';
strcat(filename, sp);
if (chdir(usePath(filename)) ==0)
return 0;
if (chdir(usePath(path)) == 0)
return 0;
return -1;
}
static int
tryPwd(char *path, char *pwdpath)
{
char *PA, *PAPB, *pa, *pb, *pc, *sp1;
char filename[MAXFILENAMELEN];
if (pwdpath == NULL)
return -1;
if (strcmp(pwdpath, "/") == 0)
return -1;
strcpy(filename, pwdpath);
sp1 = strchr(filename+1, '/');
if (sp1 != NULL)
*sp1 = '\0';
PA = putstr_(filename);
strcpy(filename, pwdpath);
if (sp1 != NULL) {
sp1 = strchr(sp1+1, '/');
if (sp1 != NULL)
*sp1 = '\0';
}
PAPB = putstr_(filename);
pa = path;
pb = strchr(path+1, '/');
if (pb == NULL)
pb = pa;
pc = strchr(pb+1, '/');
if (pc == NULL)
pc = pb;
strcpy(filename, PA);
strcat(filename, pa);
if (chdir(usePath(filename)) == 0) {
free(PA);
free(PAPB);
return 0;
}
strcpy(filename, PA);
strcat(filename, pb);
if (chdir(usePath(filename)) == 0) {
free(PA);
free(PAPB);
return 0;
}
strcpy(filename, PAPB);
strcat(filename, pc);
if (chdir(usePath(filename)) == 0) {
free(PA);
free(PAPB);
return 0;
}
strcpy(filename, PAPB);
strcat(filename, pb);
if (chdir(usePath(filename)) == 0) {
free(PA);
free(PAPB);
return 0;
}
free(PA);
free(PAPB);
return -1;
}
int
main(int argc, char** argv)
{
char* hosts = NULL;
struct runJobRequest runJobRequest;
int cc;
int c;
bool_t fFlag = FALSE;
bool_t bFlag = FALSE;
int rc;
rc = _i18n_init ( I18N_CAT_MIN );
if (lsb_init(argv[0]) < 0) {
lsb_perror("lsb_init");
exit (-1);
}
while((c = getopt(argc, argv, "m:fbhV")) != EOF) {
switch(c) {
case 'm':
hosts = putstr_(optarg);
if (hosts == NULL) {
perror("putstr_");
exit(-1);
}
break;
case 'f':
fFlag = TRUE;
break;
case 'b':
bFlag = TRUE;
break;
case 'V':
fputs(_LS_VERSION_, stderr);
return (0);
case 'h':
usage(argv[0]);
exit(-1);
}
}
if (argc <= optind) {
usage(argv[0]);
exit(-1);
}
memset((struct runJobRequest* )&runJobRequest, 0,
sizeof(struct runJobRequest));
if (getOneJobId (argv[argc - 1], &(runJobRequest.jobId), 0)) {
usage(argv[0]);
exit(-1);
}
runJobRequest.numHosts = countHosts(hosts);
if (runJobRequest.numHosts > 1) {
int i;
runJobRequest.hostname = (char **)calloc(runJobRequest.numHosts,
sizeof(char *));
if (runJobRequest.hostname == NULL) {
perror("calloc");
exit(-1);
}
for (i = 0; i < runJobRequest.numHosts; i++) {
while (isspace(*hosts)) hosts++;
runJobRequest.hostname[i] = hosts;
hosts += strlen(hosts) + 1;
}
} else
runJobRequest.hostname = &hosts;
runJobRequest.options = (fFlag == TRUE) ?
RUNJOB_OPT_NOSTOP : RUNJOB_OPT_NORMAL;
if (bFlag) {
runJobRequest.options |= RUNJOB_OPT_FROM_BEGIN;
}
cc = lsb_runjob(&runJobRequest);
if (cc < 0) {
lsb_perror((_i18n_msg_get(ls_catd,NL_SETN,2755, "Failed to run the job"))); /* catgets 2755 */
exit(-1);
}
printf((_i18n_msg_get(ls_catd,NL_SETN,2756, "Job <%s> is being forced to run.\n")), /* catgets 2756 */
lsb_jobid2str(runJobRequest.jobId));
_i18n_end ( ls_catd );
return (0);
}
int
main(int argc, char **argv)
{
static char fname[] = "lsinfo/main";
struct lsInfo *lsInfo;
int i, cc, nnames;
char *namebufs[256];
char longFormat = FALSE;
char rFlag = FALSE;
char tFlag = FALSE;
char mFlag = FALSE;
char mmFlag = FALSE;
int rc;
rc = _i18n_init ( I18N_CAT_MIN );
if (ls_initdebug(argv[0]) < 0) {
ls_perror("ls_initdebug");
exit(-1);
}
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: Entering this routine...", fname);
while ((cc = getopt(argc, argv, "VhlrmMt")) != EOF) {
switch(cc) {
case 'V':
fputs(_LS_VERSION_, stderr);
exit(0);
case 'l':
longFormat = TRUE;
break;
case 'r':
rFlag = TRUE;
break;
case 't':
tFlag = TRUE;
break;
case 'm':
mFlag = TRUE;
break;
case 'M':
mFlag = TRUE;
mmFlag = TRUE;
break;
case 'h':
default:
usage(argv[0]);
}
}
for (nnames=0; optind < argc; optind++, nnames++)
namebufs[nnames] = argv[optind];
if ((lsInfo = ls_info()) == NULL) {
ls_perror("lsinfo");
exit(-10);
}
if (!nnames && !rFlag && !mFlag && !tFlag && !mmFlag)
rFlag = mFlag = tFlag = TRUE;
else if (nnames)
rFlag = TRUE;
if (rFlag) {
if (!longFormat) {
char *buf1, *buf2, *buf3, *buf4;
buf1 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1804, "RESOURCE_NAME")), /* catgets 1804 */
buf2 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1805, " TYPE ")), /* catgets 1805 */
buf3 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1806, "ORDER")), /* catgets 1806 */
buf4 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1807, "DESCRIPTION")), /* catgets 1807 */
printf("%-13.13s %7.7s %5.5s %s\n",
buf1, buf2, buf3, buf4);
FREEUP(buf1);
FREEUP(buf2);
FREEUP(buf3);
FREEUP(buf4);
}
for (i=0; i < lsInfo->nRes; i++) {
if (!nameInList(namebufs, nnames, lsInfo->resTable[i].name))
continue;
if (!longFormat) {
printf("%-13.13s %7.7s %5.5s %s\n",
lsInfo->resTable[i].name,
valueTypeToStr(lsInfo->resTable[i].valueType),
orderTypeToStr(lsInfo->resTable[i].orderType),
lsInfo->resTable[i].des);
} else
print_long(&(lsInfo->resTable[i]));
}
for (i=0; i < nnames; i++)
if (namebufs[i])
printf(_i18n_msg_get(ls_catd,NL_SETN,1808, "%s: Resource name not found\n"),/* catgets 1808 */
namebufs[i]);
}
if (tFlag) {
if (rFlag)
putchar('\n');
puts(_i18n_msg_get(ls_catd,NL_SETN,1809, "TYPE_NAME")); /* catgets 1809 */
for (i=0;i<lsInfo->nTypes;i++)
puts(lsInfo->hostTypes[i]);
}
if (mFlag) {
if (rFlag || tFlag)
putchar('\n');
puts(_i18n_msg_get(ls_catd,NL_SETN,1810,
"MODEL_NAME CPU_FACTOR ARCHITECTURE")); /* catgets 1810 */
for (i = 0; i < lsInfo->nModels; ++i)
if (mmFlag || lsInfo->modelRefs[i])
printf("%-16s %6.2f %s\n", lsInfo->hostModels[i],
lsInfo->cpuFactor[i], lsInfo->hostArchs[i]);
}
_i18n_end ( ls_catd );
exit(0);
}
static int
makeShareFields(char *hostname, struct lsInfo *lsInfo, char ***nameTable,
char ***totalValues, char ***rsvValues, char ***formatTable)
{
static int first = TRUE;
static struct lsbSharedResourceInfo *resourceInfo;
static char **namTable;
static char **totalTable;
static char **rsvTable;
static char **fmtTable;
static int numRes, nRes;
int k, i, j;
char *hPtr;
int ii, numHosts, found;
if (first == TRUE) {
TIMEIT(0, (resourceInfo = lsb_sharedresourceinfo (NULL, &numRes, NULL, 0)), "ls_sharedresourceinfo");
if (resourceInfo == NULL) {
return (-1);
}
if ((namTable =
(char **) malloc (numRes * sizeof(char *))) == NULL){
lserrno = LSE_MALLOC;
return (-1);
}
if ((totalTable =
(char **) malloc (numRes * sizeof(char *))) == NULL){
lserrno = LSE_MALLOC;
return (-1);
}
if ((rsvTable =
(char **) malloc (numRes * sizeof(char *))) == NULL){
lserrno = LSE_MALLOC;
return (-1);
}
if ((fmtTable = (char **) malloc (numRes * sizeof(char *))) == NULL){
lserrno = LSE_MALLOC;
return (-1);
}
first = FALSE;
} else {
for (i = 0; i < nRes; i++) {
FREEUP(fmtTable[i]);
}
}
nRes = 0;
for (k = 0; k < numRes; k++) {
found = FALSE;
for (j = 0; j < lsInfo->nRes; j++) {
if (strcmp(lsInfo->resTable[j].name,
resourceInfo[k].resourceName) == 0) {
if ((lsInfo->resTable[j].flags & RESF_SHARED) &&
(lsInfo->resTable[j].valueType & LS_NUMERIC)) {
found = TRUE;
break;
}
break;
}
}
if (!found) {
continue;
}
namTable[nRes] = resourceInfo[k].resourceName;
found = FALSE;
for (i = 0; i < resourceInfo[k].nInstances; i++) {
numHosts = resourceInfo[k].instances[i].nHosts;
for (ii = 0; ii < numHosts; ii++) {
hPtr = resourceInfo[k].instances[i].hostList[ii];
if (strcmp(hPtr, hostname) == 0) {
totalTable[nRes] = resourceInfo[k].instances[i].totalValue;
rsvTable[nRes] = resourceInfo[k].instances[i].rsvValue;
found = TRUE;
break;
}
}
if (found == TRUE) {
break;
}
}
if (found == FALSE) {
totalTable[nRes] = "-";
rsvTable[nRes] = "-";
}
nRes++;
}
if (nRes) {
j = 0;
for (i = 0; i < nRes; i++) {
char fmt[16];
int lens, tmplens;
lens = strlen( namTable[i] );
tmplens = strlen( stripSpaces(totalTable[i]) );
if( lens < tmplens )
lens = tmplens;
tmplens = strlen( stripSpaces(rsvTable[i]) );
if( lens < tmplens )
lens = tmplens;
sprintf(fmt, "%s%ld%s", "%", (long)(lens + 1), "s");
fmtTable[j++] = putstr_(fmt);
}
}
*nameTable = namTable;
*totalValues = totalTable;
*rsvValues = rsvTable;
*formatTable = fmtTable;
return (nRes);
}
static void
printacctrec (const struct lsfAcctRec *acctrec)
{
char *buf1, *buf2, *buf3, *buf4, *buf5;
sprintf (printline, "%s", _i18n_ctime (ls_catd, 1, &acctrec->dispTime));
sprintf (printline + strlen (printline), _i18n_msg_get (ls_catd, NL_SETN, 1216, ": %s@%s executed pid %d on %s."), /* catgets 1216 */
acctrec->username, acctrec->fromHost, acctrec->pid,
acctrec->execHost);
printf ("%s\n", printline);
printf (" %s: %s\n", _i18n_msg_get (ls_catd, NL_SETN, 1217, "Command"), /* catgets 1217 */
acctrec->cmdln);
printf (" %s: %s\n", _i18n_msg_get (ls_catd, NL_SETN, 1218, "CWD"), /* catgets 1218 */
acctrec->cwd);
sprintf (printline, "%s", _i18n_ctime (ls_catd, 1, &acctrec->termTime));
sprintf (printline + strlen (printline), _i18n_msg_get (ls_catd, NL_SETN, 1219, ": Completed, exit status = %d."), /* catgets 1219 */
acctrec->exitStatus);
printf ("%s\n\n", printline);
printf ("%s:\n\n", _i18n_msg_get (ls_catd, NL_SETN, 1220, "Accounting information")); /* catgets 1220 */
buf1 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1221, "CPU time")); /* catgets 1221 */
buf2 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1222, "Page faults")); /* catgets 1222 */
buf3 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1223, "Swaps")); /* catgets 1223 */
buf4 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1224, "Blocks in")); /* catgets 1224 */
buf5 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1225, "Blocks out")); /* catgets 1225 */
printf ("%16.16s%16.16s%16.16s%16.16s%16.16s\n", buf1, buf2, buf3, buf4,
buf5);
FREEUP (buf1);
FREEUP (buf2);
FREEUP (buf3);
FREEUP (buf4);
FREEUP (buf5);
if (acctrec->lsfRu.ru_stime >= 0)
printf ("%16.1f", acctrec->lsfRu.ru_utime + acctrec->lsfRu.ru_stime);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_majflt >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_majflt);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_nswap >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_nswap);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_inblock >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_inblock);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_oublock >= 0)
printf ("%16.0f\n\n", acctrec->lsfRu.ru_oublock);
else
printf ("%16s\n\n", "-");
buf1 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1226, "Messages sent")); /* catgets 1226 */
buf2 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1227, "Messages rcvd")); /* catgets 1227 */
buf3 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1228, "Vol cont sw")); /* catgets 1228 */
buf4 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1229, "Invol cont sw")); /* catgets 1229 */
buf5 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1230, "Turnaround")); /* catgets 1230 */
printf ("%16.16s%16.16s%16.16s%16.16s%16.16s\n", buf1, buf2, buf3, buf4,
buf5);
FREEUP (buf1);
FREEUP (buf2);
FREEUP (buf3);
FREEUP (buf4);
FREEUP (buf5);
if (acctrec->lsfRu.ru_msgsnd >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_msgsnd);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_msgrcv >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_msgrcv);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_nvcsw >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_nvcsw);
else
printf ("%16s", "-");
if (acctrec->lsfRu.ru_nivcsw >= 0)
printf ("%16.0f", acctrec->lsfRu.ru_nivcsw);
else
printf ("%16s", "-");
printf ("%16.1f\n",
(double) difftime (acctrec->termTime, acctrec->dispTime));
printf ("%s\n\n", dashed_line);
}
