void
freeResVal(struct resVal *resVal)
{
struct _rusage_ *r;
if (resVal == NULL)
return;
FREEUP(resVal->indicies);
FREEUP(resVal->selectStr);
resVal->selectStrSize = 0;
if (resVal->xorExprs) {
int i;
for (i = 0; resVal->xorExprs[i]; i++)
FREEUP(resVal->xorExprs[i]);
FREEUP(resVal->xorExprs);
}
_free_(resVal->val);
_free_(resVal->rusage_bit_map);
while ((r = pop_link(resVal->rl))) {
_free_(r->bitmap);
_free_(r->val);
_free_(r);
}
fin_link(resVal->rl);
}
/* parse_user_shares()
*
* parse user_shares[[g, 1] [e,1]]
*/
static link_t *
parse_user_shares(const char *user_shares)
{
link_t *l;
char *p;
char *u;
int cc;
int n;
struct share_acct *sacct;
uint32_t sum_shares;
linkiter_t iter;
u = strdup(user_shares);
assert(u);
p = strchr(u, '[');
*p++ = 0;
tokenize(p);
l = make_link();
sum_shares = 0;
while (1 ) {
char name[128];
uint32_t shares;
cc = sscanf(p, "%s%u%n", name, &shares, &n);
if (cc == EOF)
break;
if (cc != 2)
goto bail;
p = p + n;
sacct = make_sacct(name, shares);
assert(sacct);
sum_shares = sum_shares + sacct->shares;
enqueue_link(l, sacct);
}
traverse_init(l, &iter);
while ((sacct = traverse_link(&iter))) {
sacct->dshares = (double)sacct->shares/(double)sum_shares;
}
_free_(u);
return l;
bail:
_free_(u);
traverse_init(l, &iter);
while ((sacct = traverse_link(&iter)))
free_sacct(sacct);
fin_link(l);
return NULL;
}
/* free_sacct()
*/
void
free_sacct(void *s)
{
struct share_acct *sacct;
sacct = s;
_free_(sacct->name);
_free_(sacct);
}
static struct share_acct *
get_sacct(const char *acct_name, const char *user_list)
{
char name[128];
uint32_t shares;
int cc;
int n;
struct share_acct *sacct;
char *p;
char *p0;
p0 = p = strdup(user_list);
/* If we don't find account name
* in the user list make sure we
* return NULL and not random memory.
*/
sacct = NULL;
cc = sscanf(p, "%s%u%n", name, &shares, &n);
if (cc == EOF) {
_free_(p);
return NULL;
}
/* default can have users all
* or explicitly named users
*/
if (strcmp(name, "default") == 0) {
sacct = make_sacct(acct_name, shares);
goto pryc;
}
/* Match the user in the user_list
*/
while (1) {
cc = sscanf(p, "%s%u%n", name, &shares, &n);
if (cc == EOF)
break;
if (strcmp(name, acct_name) != 0) {
p = p + n;
continue;
}
sacct = make_sacct(name, shares);
break;
}
pryc:
_free_(p0);
return sacct;
}
/* get_rusage_entries()
*/
static link_t *
get_rusage_entries(const char *s)
{
char *p;
char *ss;
char *ss0;
char *z;
link_t *l;
l = make_link();
/* Return an empty link
*/
ss0 = ss = strdup(s);
if (! strstr(ss, "||")) {
enqueue_link(l, ss);
return l;
}
while ((p = strstr(ss, "||"))) {
*p = 0;
z = strdup(ss);
enqueue_link(l, z);
ss = p + 2;
}
z = strdup(ss);
enqueue_link(l, z);
_free_(ss0);
return l;
}
/*
* Aztec's library getenv() doesn't allow for Environment variables larger than
* 256 bytes. It also doesn't check the local environment, which would make
* elvis running on an AUX: port more useful.
*/
char *
getenv(char *var)
{
static char *buf;
buf = (char *) malloc(sizeof(*buf) * (ENVSIZE + 1));
if ((char *) 0 == buf)
{
return 0;
}
if (isOldDOS())
{
int bytes;
BPTR fh;
strcpy(buf, "env:");
strcat(buf, var);
fh = Open((UBYTE *) buf, MODE_OLDFILE);
if ((BPTR) 0 == fh)
{
_free_(buf);
return (char *) 0; /* return null for not defined */
}
bytes = Read(fh, (UBYTE *) buf, ENVSIZE);
Close(fh);
if (bytes == -1)
{
_free_(buf);
return (char *) 0; /* return null for not defined */
}
buf[bytes] = '\000';
} else if (-1 == GetVar((UBYTE *) var, (UBYTE *) buf, ENVSIZE, GVF_BINARY_VAR))
{ /* no varible defined, free memory */
_free_(buf);
return (char *) 0; /* return null for not defined */
}
return (char *) buf;
}
Vector<T>& Vector<T>::operator=(const Vector<T>& other) {
if (this != &other) { //check self assignment
_free_(); //free current vector
_size_ = other._size_;
_capacity_ = other._capacity_;
_elemAry_ = new T[_capacity_]();
size_t pos = 0;
for (int pos = 0; pos != other._size_; ++pos) {
_elemAry_[pos] = other[pos];
}
// memcpy(_elemAry_, other._elemAry_, sizeof(T) * _size_);
}
return *this;
}
int
main(int argc, char **argv)
{
int numQueues;
char **queues;
struct queueInfoEnt *queueInfo;
char lflag = FALSE;
int cc;
char *host;
char *user;
numQueues = 0;
user = host = NULL;
if (lsb_init(argv[0]) < 0) {
lsb_perror("lsb_init");
return -1;
}
while ((cc = getopt(argc, argv, "Vhlwm:u:")) != EOF) {
switch (cc) {
case 'l':
lflag = TRUE;
if (wflag) {
usage(argv[0]);
return -1;
}
break;
case 'w':
wflag = TRUE;
if (lflag) {
usage(argv[0]);
return -1;
}
break;
case 'm':
if (host != NULL || *optarg == '\0')
usage(argv[0]);
host = optarg;
break;
case 'u':
if (user != NULL || *optarg == '\0')
usage(argv[0]);
user = optarg;
break;
case 'V':
fputs(_LS_VERSION_, stderr);
return 0;
case 'h':
default:
usage(argv[0]);
return -1;
}
}
queues = NULL;
numQueues = 0;
if (optind < argc) {
numQueues = argc - optind;
queues = calloc(argc - optind, sizeof(char *));
for (cc = 0; cc < argc - optind; cc++)
queues[cc] = argv[optind + cc];
}
TIMEIT(0, (queueInfo = lsb_queueinfo(queues,
&numQueues,
host,
user,
0)), "lsb_queueinfo");
if (!queueInfo) {
if (lsberrno == LSBE_BAD_QUEUE && queues)
lsb_perror(queues[numQueues]);
else {
switch (lsberrno) {
case LSBE_BAD_HOST :
case LSBE_QUEUE_HOST :
lsb_perror(host);
break;
case LSBE_BAD_USER :
case LSBE_QUEUE_USE :
lsb_perror(user);
break;
default :
lsb_perror(NULL);
}
}
_free_(queues);
return -1;
}
if (lflag)
prtQueuesLong(numQueues, queueInfo);
else
prtQueuesShort(numQueues, queueInfo);
_free_(queues);
return 0;
}
/* parseUsage()
*/
static int
parseUsage(char *usageReq, struct resVal *resVal, struct lsInfo *lsInfo)
{
int i;
int m;
int entry;
float value;
char *token;
link_t *link;
linkiter_t iter;
struct _rusage_ *r;
char *s;
int *rusage_bit_map;
float *val;
char *usageReq2;
char *s2;
if ((i = strlen(usageReq)) == 0)
return PARSE_OK;
for (m = 0; m < i; m++)
if (usageReq[m] != ' ')
break;
if (m == i)
return PARSE_OK;
s2 = usageReq2 = strip_spaces(usageReq);
resVal->rl = make_link();
link = get_rusage_entries(usageReq2);
i = 0;
traverse_init(link, &iter);
while ((s = traverse_link(&iter))) {
/* Allocate for each element of the link
*/
rusage_bit_map = calloc(GET_INTNUM(lsInfo->nRes), sizeof(int));
val = calloc(lsInfo->nRes, sizeof(float));
resVal->genClass = 0;
while ((token = getNextToken(&s)) != NULL) {
if (token[0] == '-')
token++;
entry = getKeyEntry(token);
if (entry > 0) {
if (entry != KEY_DURATION && entry != KEY_DECAY)
goto pryc;
if (s[0] == '=') {
int returnValue;
if (entry == KEY_DURATION)
returnValue = getTimeVal(&s, &value);
else
returnValue = getVal(&s, &value);
if (returnValue < 0 || value < 0.0)
return PARSE_BAD_VAL;
if (entry == KEY_DURATION)
resVal->duration = value;
else
resVal->decay = value;
continue;
}
}
entry = getResEntry(token);
if (entry < 0)
goto pryc;
if (!(lsInfo->resTable[entry].flags & RESF_DYNAMIC)
&& (lsInfo->resTable[entry].valueType != LS_NUMERIC)) {
if (s[0] == '=') {
if (getVal(&s, &value) < 0 || value < 0.0)
goto pryc;
}
continue;
}
if (entry < MAXSRES)
resVal->genClass |= 1 << entry;
SET_BIT(entry, rusage_bit_map);
if (s[0] == '=') {
if (getVal(&s, &value) < 0 || value < 0.0)
goto pryc;
val[entry] = value;
}
}
/* Save the current rusage block
*/
r = calloc(1, sizeof(struct _rusage_));
r->bitmap = rusage_bit_map;
r->val = val;
enqueue_link(resVal->rl, r);
if (i == 0) {
/* The entry 0 is both in the link and
* in the resVal. The default values
* were allocated in setDefaults()
*/
_free_(resVal->rusage_bit_map);
_free_(resVal->val);
/* Copy the values as later we free them separately
*/
resVal->rusage_bit_map = calloc(GET_INTNUM(lsInfo->nRes),
sizeof(int));
memcpy(resVal->rusage_bit_map,
rusage_bit_map,
GET_INTNUM(lsInfo->nRes) * sizeof(int));
resVal->val = calloc(lsInfo->nRes, sizeof(float));
memcpy(resVal->val, r->val, lsInfo->nRes * sizeof(float));
}
++i;
} /* while (s = traverse_link()) */
resVal->options |= PR_RUSAGE;
while ((s = pop_link(link)))
_free_(s);
fin_link(link);
_free_(s2);
return PARSE_OK;
pryc:
_free_(rusage_bit_map);
_free_(val);
while ((s = pop_link(link)))
_free_(s);
fin_link(link);
while ((r = pop_link(resVal->rl))) {
_free_(r->bitmap);
_free_(r->val);
_free_(r);
}
fin_link(resVal->rl);
resVal->rl = NULL;
_free_(s2);
return PARSE_BAD_NAME;
}
void Vector<T>::clear() {
_free_();
}
/* parse_group_member()
*/
static link_t *
parse_group_member(const char *gname,
uint32_t num,
struct group_acct *grps)
{
link_t *l;
linkiter_t iter;
struct group_acct *g;
int cc;
char *w;
char *p;
uint32_t sum;
struct share_acct *sacct;
l = make_link();
g = NULL;
for (cc = 0; cc < num; cc++) {
/* Match the group name and the group
* must have shares.
*/
if (strcmp(gname, grps[cc].group) == 0
&& grps[cc].user_shares) {
g = calloc(1, sizeof(struct group_acct));
assert(g);
g->group = strdup(grps[cc].group);
g->memberList = strdup(grps[cc].memberList);
g->user_shares = strdup(grps[cc].user_shares);
tokenize(g->user_shares);
break;
}
}
/* gudness leaf member
* caller will free the link
*/
if (g == NULL)
return l;
p = g->memberList;
sum = 0;
while ((w = get_next_word(&p))) {
sacct = get_sacct(w, g->user_shares);
if (sacct == NULL) {
while ((sacct = pop_link(l)))
free_sacct(sacct);
fin_link(l);
return NULL;
}
sum = sum + sacct->shares;
enqueue_link(l, sacct);
}
traverse_init(l, &iter);
while ((sacct = traverse_link(&iter))) {
sacct->dshares = (double)sacct->shares/(double)sum;
}
_free_(g->group);
_free_(g->memberList);
_free_(g->user_shares);
_free_(g);
return l;
}
/* free_sacct()
*/
void
free_sacct(struct share_acct *sacct)
{
_free_(sacct->name);
_free_(sacct);
}
