symbol *except_gentables()
{
//printf("except_gentables()\n");
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
symbol *s;
int sz; // size so far
dt_t **pdt;
unsigned fsize; // target size of function pointer
long spoff;
block *b;
int guarddim;
int i;
// BUG: alloca() changes the stack size, which is not reflected
// in the fixed eh tables.
assert(!usedalloca);
s = symbol_generate(SCstatic,tsint);
s->Sseg = UNKNOWN;
symbol_keep(s);
symbol_debug(s);
fsize = 4;
pdt = &s->Sdt;
sz = 0;
/*
void* pointer to start of function
unsigned offset of ESP from EBP
unsigned offset from start of function to return code
unsigned nguards; // dimension of guard[]
{ unsigned offset; // offset of start of guarded section
unsigned endoffset; // ending offset of guarded section
int last_index; // previous index (enclosing guarded section)
unsigned catchoffset; // offset to catch block from symbol
void *finally; // finally code to execute
} guard[];
catchoffset:
unsigned ncatches; // number of catch blocks
{ void *type; // symbol representing type
unsigned bpoffset; // EBP offset of catch variable
void *handler; // catch handler code
} catch[];
*/
#define GUARD_SIZE 5 // number of 4 byte values in one guard
sz = 0;
// Address of start of function
symbol_debug(funcsym_p);
pdt = dtxoff(pdt,funcsym_p,0,TYnptr);
sz += fsize;
//printf("ehtables: func = %s, offset = x%x, startblock->Boffset = x%x\n", funcsym_p->Sident, funcsym_p->Soffset, startblock->Boffset);
// Get offset of ESP from EBP
spoff = cod3_spoff();
pdt = dtdword(pdt,spoff);
sz += 4;
// Offset from start of function to return code
pdt = dtdword(pdt,retoffset);
sz += 4;
// First, calculate starting catch offset
guarddim = 0; // max dimension of guard[]
for (b = startblock; b; b = b->Bnext)
{
if (b->BC == BC_try && b->Bscope_index >= guarddim)
guarddim = b->Bscope_index + 1;
// printf("b->BC = %2d, Bscope_index = %2d, last_index = %2d, offset = x%x\n",
// b->BC, b->Bscope_index, b->Blast_index, b->Boffset);
}
pdt = dtdword(pdt,guarddim);
sz += 4;
unsigned catchoffset = sz + guarddim * (GUARD_SIZE * 4);
// Generate guard[]
i = 0;
for (b = startblock; b; b = b->Bnext)
{
//printf("b = %p, b->Btry = %p, b->offset = %x\n", b, b->Btry, b->Boffset);
if (b->BC == BC_try)
{ dt_t *dt;
block *bhandler;
int nsucc;
unsigned endoffset;
block *bn;
assert(b->Bscope_index >= i);
if (i < b->Bscope_index)
{ int fillsize = (b->Bscope_index - i) * (GUARD_SIZE * 4);
pdt = dtnzeros(pdt, fillsize);
sz += fillsize;
}
i = b->Bscope_index + 1;
nsucc = list_nitems(b->Bsucc);
pdt = dtdword(pdt,b->Boffset - startblock->Boffset); // offset to start of block
// Compute ending offset
for (bn = b->Bnext; 1; bn = bn->Bnext)
{
//printf("\tbn = %p, bn->Btry = %p, bn->offset = %x\n", bn, bn->Btry, bn->Boffset);
assert(bn);
if (bn->Btry == b->Btry)
{ endoffset = bn->Boffset - startblock->Boffset;
break;
}
}
pdt = dtdword(pdt,endoffset); // offset past end of guarded block
pdt = dtdword(pdt,b->Blast_index); // parent index
if (b->jcatchvar) // if try-catch
{
pdt = dtdword(pdt,catchoffset);
pdt = dtdword(pdt,0); // no finally handler
catchoffset += 4 + (nsucc - 1) * (3 * 4);
}
else // else try-finally
{
assert(nsucc == 2);
pdt = dtdword(pdt,0); // no catch offset
bhandler = list_block(list_next(b->Bsucc));
assert(bhandler->BC == BC_finally);
// To successor of BC_finally block
bhandler = list_block(bhandler->Bsucc);
pdt = dtxoff(pdt,funcsym_p,bhandler->Boffset - startblock->Boffset, TYnptr); // finally handler address
//pdt = dtcoff(pdt,bhandler->Boffset); // finally handler address
}
sz += GUARD_SIZE + 4;
}
}
// Generate catch[]
for (b = startblock; b; b = b->Bnext)
{
if (b->BC == BC_try)
{ block *bhandler;
int nsucc;
if (b->jcatchvar) // if try-catch
{ list_t bl;
nsucc = list_nitems(b->Bsucc);
pdt = dtdword(pdt,nsucc - 1); // # of catch blocks
sz += 4;
for (bl = list_next(b->Bsucc); bl; bl = list_next(bl))
{
block *bcatch = list_block(bl);
pdt = dtxoff(pdt,bcatch->Bcatchtype,0,TYjhandle);
pdt = dtdword(pdt,cod3_bpoffset(b->jcatchvar)); // EBP offset
pdt = dtxoff(pdt,funcsym_p,bcatch->Boffset - startblock->Boffset, TYnptr); // catch handler address
//pdt = dtcoff(pdt,bcatch->Boffset); // catch handler address
sz += 3 * 4;
}
}
}
}
assert(sz != 0);
outdata(s); // output the scope table
obj_ehtables(funcsym_p,funcsym_p->Ssize,s);
#endif
return NULL;
}
void *
cerebrod_event_queue_monitor(void *arg)
{
List temp_event_queue;
_event_queue_monitor_initialize();
/* Don't bother if there isn't an event queue (i.e. no event modules) */
if (!event_queue)
return NULL;
temp_event_queue = List_create((ListDelF)cerebrod_event_to_send_destroy);
/*
* achu: The listener and thus event update initialization is
* started after this thread is started. So the and event_index may
* not be set up the first time this loop is reached.
*
* However, it must be set after the condition is signaled, b/c the
* listener (and thus event update code) and event node timeout
* thread begin after the listener is setup.
*
* Thus, we put the event_queue assert inside the loop.
*/
for (;;)
{
struct cerebrod_event_to_send *ets;
ListIterator eitr;
ListIterator titr;
Pthread_mutex_lock(&event_queue_lock);
assert(event_queue);
while (list_count(event_queue) == 0)
Pthread_cond_wait(&event_queue_cond, &event_queue_lock);
/* Debug dumping in the below loop can race with the debug
* dumping from the listener, b/c of racing on the
* event_queue_lock. To avoid this race, we copy the data off
* the event_queue, so the event_queue_lock can be freed up.
*/
eitr = List_iterator_create(event_queue);
while ((ets = list_next(eitr)))
{
List_append(temp_event_queue, ets);
List_remove(eitr);
}
List_iterator_destroy(eitr);
Pthread_mutex_unlock(&event_queue_lock);
titr = List_iterator_create(temp_event_queue);
while ((ets = list_next(titr)))
{
List connections;
_event_dump(ets->event);
Pthread_mutex_lock(&event_connections_lock);
if ((connections = Hash_find(event_connections_index, ets->event_name)))
{
char buf[CEREBRO_MAX_PACKET_LEN];
int elen;
if ((elen = _event_marshall(ets->event,
buf,
CEREBRO_MAX_PACKET_LEN)) > 0)
{
ListIterator citr;
int *fd;
citr = List_iterator_create(connections);
while ((fd = list_next(citr)))
{
if (fd_write_n(*fd, buf, elen) < 0)
{
CEREBRO_DBG(("fd_write_n: %s", strerror(errno)));
if (errno == EPIPE
|| errno == EINVAL
|| errno == EBADF
|| errno == ENODEV
|| errno == ENETDOWN
|| errno == ENETUNREACH)
{
#if CEREBRO_DEBUG
if (conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Event Connection Died: errno = %d\n", errno);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
#endif /* CEREBRO_DEBUG */
List_delete(citr);
}
continue;
}
}
List_iterator_destroy(citr);
}
}
Pthread_mutex_unlock(&event_connections_lock);
List_delete(titr);
}
List_iterator_destroy(titr);
}
List_destroy(temp_event_queue);
return NULL; /* NOT REACHED */
}
// LAB2: below code is used to check the first fit allocation algorithm (your EXERCISE 1)
// NOTICE: You SHOULD NOT CHANGE basic_check, default_check functions!
static void
default_check(void) {
int count = 0, total = 0;
list_entry_t *le = &free_list;
while ((le = list_next(le)) != &free_list) {
struct Page *p = le2page(le, page_link);
assert(PageProperty(p));
count ++, total += p->property;
}
assert(total == nr_free_pages());
basic_check();
struct Page *p0 = alloc_pages(5), *p1, *p2;
assert(p0 != NULL);
assert(!PageProperty(p0));
list_entry_t free_list_store = free_list;
list_init(&free_list);
assert(list_empty(&free_list));
assert(alloc_page() == NULL);
unsigned int nr_free_store = nr_free;
nr_free = 0;
free_pages(p0 + 2, 3);
assert(alloc_pages(4) == NULL);
assert(PageProperty(p0 + 2) && p0[2].property == 3);
assert((p1 = alloc_pages(3)) != NULL);
assert(alloc_page() == NULL);
assert(p0 + 2 == p1);
p2 = p0 + 1;
free_page(p0);
free_pages(p1, 3);
assert(PageProperty(p0) && p0->property == 1);
assert(PageProperty(p1) && p1->property == 3);
assert((p0 = alloc_page()) == p2 - 1);
free_page(p0);
assert((p0 = alloc_pages(2)) == p2 + 1);
free_pages(p0, 2);
free_page(p2);
assert((p0 = alloc_pages(5)) != NULL);
assert(alloc_page() == NULL);
assert(nr_free == 0);
nr_free = nr_free_store;
free_list = free_list_store;
free_pages(p0, 5);
le = &free_list;
while ((le = list_next(le)) != &free_list) {
struct Page *p = le2page(le, page_link);
count --, total -= p->property;
}
assert(count == 0);
assert(total == 0);
}
extern int setup_job_cluster_cond_limits(mysql_conn_t *mysql_conn,
slurmdb_job_cond_t *job_cond,
char *cluster_name, char **extra)
{
int set = 0;
ListIterator itr = NULL;
char *object = NULL;
if (!job_cond)
return SLURM_SUCCESS;
/* this must be done before resvid_list since we set
resvid_list up here */
if (job_cond->resv_list && list_count(job_cond->resv_list)) {
char *query = xstrdup_printf(
"select distinct job_db_inx from \"%s_%s\" where (",
cluster_name, job_table);
int my_set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
itr = list_iterator_create(job_cond->resv_list);
while ((object = list_next(itr))) {
if (my_set)
xstrcat(query, " || ");
xstrfmtcat(query, "resv_name='%s'", object);
my_set = 1;
}
list_iterator_destroy(itr);
xstrcat(query, ")");
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
error("couldn't query the database");
goto no_resv;
}
xfree(query);
if (!job_cond->resvid_list)
job_cond->resvid_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
list_append(job_cond->resvid_list, xstrdup(row[0]));
}
mysql_free_result(result);
}
no_resv:
if (job_cond->resvid_list && list_count(job_cond->resvid_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->resvid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_resv='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->state_list && list_count(job_cond->state_list)) {
itr = list_iterator_create(job_cond->state_list);
while ((object = list_next(itr))) {
uint32_t state = (uint32_t)slurm_atoul(object);
state &= JOB_STATE_BASE;
if (state == JOB_SUSPENDED)
break;
}
list_iterator_destroy(itr);
if (object) {
MYSQL_RES *result = NULL;
MYSQL_ROW row;
char *query = xstrdup_printf(
"select job_db_inx from \"%s_%s\"",
cluster_name, suspend_table);
if (job_cond->usage_start) {
if (!job_cond->usage_end) {
xstrfmtcat(query,
" where (!time_end "
"|| (%d between "
"time_start and time_end))",
(int)job_cond->usage_start);
} else {
xstrfmtcat(query,
" where (!time_end "
"|| (time_start && "
"((%d between time_start "
"and time_end) "
"|| (time_start between "
"%d and %d))))",
(int)job_cond->usage_start,
(int)job_cond->usage_start,
(int)job_cond->usage_end);
}
} else if (job_cond->usage_end) {
xstrfmtcat(query, " where (time_start && "
"time_start < %d)",
(int)job_cond->usage_end);
}
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
result = mysql_db_query_ret(mysql_conn, query, 0);
xfree(query);
if (!result)
return SLURM_ERROR;
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set)
xstrfmtcat(*extra,
" || t1.job_db_inx=%s",
row[0]);
else {
set = 1;
if (*extra)
xstrfmtcat(
*extra,
" || (t1.job_db_inx=%s",
row[0]);
else
xstrfmtcat(*extra, " where "
"(t1.job_db_inx=%s",
row[0]);
}
}
mysql_free_result(result);
if (set)
xstrcat(*extra, ")");
}
}
return SLURM_SUCCESS;
}
/* Creates a tree model containing the completions */
void _search_entry(sview_search_info_t *sview_search_info)
{
int id = 0;
char title[100];
ListIterator itr = NULL;
popup_info_t *popup_win = NULL;
GError *error = NULL;
char *upper = NULL, *lower = NULL;
char *type;
if (cluster_flags & CLUSTER_FLAG_BG)
type = "Midplane";
else
type = "Node";
if (sview_search_info->int_data == NO_VAL &&
(!sview_search_info->gchar_data
|| !strlen(sview_search_info->gchar_data))) {
g_print("nothing given to search for.\n");
return;
}
switch(sview_search_info->search_type) {
case SEARCH_JOB_STATE:
id = JOB_PAGE;
upper = job_state_string(sview_search_info->int_data);
lower = str_tolower(upper);
snprintf(title, 100, "Job(s) in the %s state", lower);
xfree(lower);
break;
case SEARCH_JOB_ID:
id = JOB_PAGE;
snprintf(title, 100, "Job %s info",
sview_search_info->gchar_data);
break;
case SEARCH_JOB_USER:
id = JOB_PAGE;
snprintf(title, 100, "Job(s) info for user %s",
sview_search_info->gchar_data);
break;
case SEARCH_BLOCK_STATE:
id = BLOCK_PAGE;
upper = bg_block_state_string(sview_search_info->int_data);
lower = str_tolower(upper);
snprintf(title, 100, "BG Block(s) in the %s state", lower);
xfree(lower);
break;
case SEARCH_BLOCK_NAME:
id = BLOCK_PAGE;
snprintf(title, 100, "Block %s info",
sview_search_info->gchar_data);
break;
case SEARCH_BLOCK_SIZE:
id = BLOCK_PAGE;
sview_search_info->int_data =
revert_num_unit(sview_search_info->gchar_data);
if (sview_search_info->int_data == -1)
return;
snprintf(title, 100, "Block(s) of size %d cnodes",
sview_search_info->int_data);
break;
case SEARCH_PARTITION_NAME:
id = PART_PAGE;
snprintf(title, 100, "Partition %s info",
sview_search_info->gchar_data);
break;
case SEARCH_PARTITION_STATE:
id = PART_PAGE;
if (sview_search_info->int_data)
snprintf(title, 100, "Partition(s) that are up");
else
snprintf(title, 100, "Partition(s) that are down");
break;
case SEARCH_NODE_NAME:
id = NODE_PAGE;
snprintf(title, 100, "%s(s) %s info",
type, sview_search_info->gchar_data);
break;
case SEARCH_NODE_STATE:
id = NODE_PAGE;
upper = node_state_string(sview_search_info->int_data);
lower = str_tolower(upper);
snprintf(title, 100, "%s(s) in the %s state",
type, lower);
xfree(lower);
break;
case SEARCH_RESERVATION_NAME:
id = RESV_PAGE;
snprintf(title, 100, "Reservation %s info",
sview_search_info->gchar_data);
break;
default:
g_print("unknown search type %d.\n",
sview_search_info->search_type);
return;
}
itr = list_iterator_create(popup_list);
while ((popup_win = list_next(itr))) {
if (popup_win->spec_info)
if (!strcmp(popup_win->spec_info->title, title)) {
break;
}
}
list_iterator_destroy(itr);
if (!popup_win) {
popup_win = create_popup_info(id, id, title);
} else {
gtk_window_present(GTK_WINDOW(popup_win->popup));
return;
}
memcpy(popup_win->spec_info->search_info, sview_search_info,
sizeof(sview_search_info_t));
if (!sview_thread_new((gpointer)popup_thr, popup_win, FALSE, &error)) {
g_printerr ("Failed to create main popup thread: %s\n",
error->message);
return;
}
return;
}
LIST *
var_expand(
LIST *l,
char *in,
char *end,
LOL *lol,
int cancopyin )
{
char out_buf[ MAXSYM ];
string buf[1];
string out1[1]; /* Temporary buffer */
size_t prefix_length;
char *out;
char *inp = in;
char *ov; /* for temp copy of variable in outbuf */
int depth;
if( DEBUG_VAREXP )
printf( "expand '%.*s'\n", end - in, in );
/* This gets alot of cases: $(<) and $(>) */
if( in[0] == '$' && in[1] == '(' && in[3] == ')' && !in[4] )
{
switch( in[2] )
{
case '1':
case '<':
return list_copy( l, lol_get( lol, 0 ) );
case '2':
case '>':
return list_copy( l, lol_get( lol, 1 ) );
}
}
/* Just try simple copy of in to out. */
while( in < end )
if( *in++ == '$' && *in == '(' )
goto expand;
/* No variables expanded - just add copy of input string to list. */
/* Cancopyin is an optimization: if the input was already a list */
/* item, we can use the copystr() to put it on the new list. */
/* Otherwise, we use the slower newstr(). */
if( cancopyin )
{
return list_new( l, copystr( inp ) );
}
else
{
LIST* r;
string_new( buf );
string_append_range( buf, inp, end );
r = list_new( l, newstr( buf->value) );
string_free( buf );
return r;
}
expand:
string_new( buf );
string_append_range( buf, inp, in - 1); /* copy the part before '$'. */
/*
* Input so far (ignore blanks):
*
* stuff-in-outbuf $(variable) remainder
* ^ ^
* in end
* Output so far:
*
* stuff-in-outbuf $
* ^ ^
* out_buf out
*
*
* We just copied the $ of $(...), so back up one on the output.
* We now find the matching close paren, copying the variable and
* modifiers between the $( and ) temporarily into out_buf, so that
* we can replace :'s with MAGIC_COLON. This is necessary to avoid
* being confused by modifier values that are variables containing
* :'s. Ugly.
*/
depth = 1;
inp = ++in; /* skip over the '(' */
while( in < end && depth )
{
switch( *in++ )
{
case '(': depth++; break;
case ')': depth--; break;
}
}
/*
* Input so far (ignore blanks):
*
* stuff-in-outbuf $(variable) remainder
* ^ ^ ^
* inp in end
*/
prefix_length = buf->size;
string_append_range( buf, inp, in - 1 );
out = buf->value + prefix_length;
for ( ov = out; ov < buf->value + buf->size; ++ov )
{
switch( *ov )
{
case ':': *ov = MAGIC_COLON; break;
case '[': *ov = MAGIC_LEFT; break;
case ']': *ov = MAGIC_RIGHT; break;
}
}
/*
* Input so far (ignore blanks):
*
* stuff-in-outbuf $(variable) remainder
* ^ ^
* in end
* Output so far:
*
* stuff-in-outbuf variable
* ^ ^ ^
* out_buf out ov
*
* Later we will overwrite 'variable' in out_buf, but we'll be
* done with it by then. 'variable' may be a multi-element list,
* so may each value for '$(variable element)', and so may 'remainder'.
* Thus we produce a product of three lists.
*/
{
LIST *variables = 0;
LIST *remainder = 0;
LIST *vars;
/* Recursively expand variable name & rest of input */
if( out < ov )
variables = var_expand( L0, out, ov, lol, 0 );
if( in < end )
remainder = var_expand( L0, in, end, lol, 0 );
/* Now produce the result chain */
/* For each variable name */
for( vars = variables; vars; vars = list_next( vars ) )
{
LIST *value, *evalue = 0;
char *colon;
char *bracket;
string variable[1];
char *varname;
int sub1 = 0, sub2 = -1;
VAR_EDITS edits;
/* Look for a : modifier in the variable name */
/* Must copy into varname so we can modify it */
string_copy( variable, vars->string );
varname = variable->value;
if( colon = strchr( varname, MAGIC_COLON ) )
{
string_truncate( variable, colon - varname );
var_edit_parse( colon + 1, &edits );
}
/* Look for [x-y] subscripting */
/* sub1 and sub2 are x and y. */
if ( bracket = strchr( varname, MAGIC_LEFT ) )
{
/*
** Make all syntax errors in [] subscripting
** result in the same behavior: silenty return an empty
** expansion (by setting sub2 = 0). Brute force parsing;
** May get moved into yacc someday.
*/
char *s = bracket + 1;
string_truncate( variable, bracket - varname );
do /* so we can use "break" */
{
/* Allow negative indexes. */
if (! isdigit( *s ) && ! ( *s == '-') )
{
sub2 = 0;
break;
}
sub1 = atoi(s);
/* Skip over the first symbol, which is either a digit or dash. */
s++;
while ( isdigit( *s ) ) s++;
if ( *s == MAGIC_RIGHT )
{
sub2 = sub1;
break;
}
if ( *s != '-')
{
sub2 = 0;
break;
}
s++;
if ( *s == MAGIC_RIGHT )
{
sub2 = -1;
break;
}
if (! isdigit( *s ) && ! ( *s == '-') )
{
sub2 = 0;
break;
}
/* First, compute the index of the last element. */
sub2 = atoi(s);
s++;
while ( isdigit( *s ) ) s++;
if ( *s != MAGIC_RIGHT)
sub2 = 0;
} while (0);
/*
** Anything but the end of the string, or the colon
** introducing a modifier is a syntax error.
*/
s++;
if (*s && *s != MAGIC_COLON)
sub2 = 0;
*bracket = '\0';
}
/* Get variable value, specially handling $(<), $(>), $(n) */
if( varname[0] == '<' && !varname[1] )
value = lol_get( lol, 0 );
else if( varname[0] == '>' && !varname[1] )
value = lol_get( lol, 1 );
else if( varname[0] >= '1' && varname[0] <= '9' && !varname[1] )
value = lol_get( lol, varname[0] - '1' );
else
value = var_get( varname );
/* Handle negitive indexes: part two. */
{
int length = list_length( value );
if (sub1 < 0)
sub1 = length + sub1;
else
sub1 -= 1;
if (sub2 < 0)
sub2 = length + 1 + sub2 - sub1;
else
sub2 -= sub1;
/*
** The "sub2 < 0" test handles the semantic error
** of sub2 < sub1.
*/
if ( sub2 < 0 )
sub2 = 0;
}
/* The fast path: $(x) - just copy the variable value. */
/* This is only an optimization */
if( out == out_buf && !bracket && !colon && in == end )
{
string_free( variable );
l = list_copy( l, value );
continue;
}
/* Handle start subscript */
while( sub1 > 0 && value )
--sub1, value = list_next( value );
/* Empty w/ :E=default? */
if( !value && colon && edits.empty.ptr )
evalue = value = list_new( L0, newstr( edits.empty.ptr ) );
/* For each variable value */
string_new( out1 );
for( ; value; value = list_next( value ) )
{
LIST *rem;
size_t postfix_start;
/* Handle end subscript (length actually) */
if( sub2 >= 0 && --sub2 < 0 )
break;
string_truncate( buf, prefix_length );
/* Apply : mods, if present */
if( colon && edits.filemods )
var_edit_file( value->string, out1, &edits );
else
string_append( out1, value->string );
if( colon && ( edits.upshift || edits.downshift || edits.to_slashes || edits.to_windows ) )
var_edit_shift( out1, &edits );
/* Handle :J=joinval */
/* If we have more values for this var, just */
/* keep appending them (with the join value) */
/* rather than creating separate LIST elements. */
if( colon && edits.join.ptr &&
( list_next( value ) || list_next( vars ) ) )
{
string_append( out1, edits.join.ptr );
continue;
}
string_append( buf, out1->value );
string_free( out1 );
string_new( out1 );
/* If no remainder, append result to output chain. */
if( in == end )
{
l = list_new( l, newstr( buf->value ) );
continue;
}
/* For each remainder, append the complete string */
/* to the output chain. */
/* Remember the end of the variable expansion so */
/* we can just tack on each instance of 'remainder' */
postfix_start = buf->size;
for( rem = remainder; rem; rem = list_next( rem ) )
{
string_truncate( buf, postfix_start );
string_append( buf, rem->string );
l = list_new( l, newstr( buf->value ) );
}
}
string_free( out1 );
/* Toss used empty */
if( evalue )
list_free( evalue );
string_free( variable );
}
/* variables & remainder were gifts from var_expand */
/* and must be freed */
if( variables )
list_free( variables );
if( remainder)
list_free( remainder );
if( DEBUG_VAREXP )
{
printf( "expanded to " );
list_print( l );
printf( "\n" );
}
string_free( buf );
return l;
}
}
extern List as_mysql_jobacct_process_get_jobs(mysql_conn_t *mysql_conn,
uid_t uid,
slurmdb_job_cond_t *job_cond)
{
char *extra = NULL;
char *tmp = NULL, *tmp2 = NULL;
ListIterator itr = NULL;
int is_admin=1;
int i;
List job_list = NULL;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
int only_pending = 0;
List use_cluster_list = as_mysql_cluster_list;
char *cluster_name;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_JOBS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
/* Only fill in the coordinator accounts here
we will check them later when we actually
try to get the jobs.
*/
is_user_any_coord(mysql_conn, &user);
}
}
if (job_cond
&& job_cond->state_list && (list_count(job_cond->state_list) == 1)
&& (slurm_atoul(list_peek(job_cond->state_list)) == JOB_PENDING))
only_pending = 1;
setup_job_cond_limits(mysql_conn, job_cond, &extra);
xfree(tmp);
xstrfmtcat(tmp, "%s", job_req_inx[0]);
for(i=1; i<JOB_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", job_req_inx[i]);
}
xfree(tmp2);
xstrfmtcat(tmp2, "%s", step_req_inx[0]);
for(i=1; i<STEP_REQ_COUNT; i++) {
xstrfmtcat(tmp2, ", %s", step_req_inx[i]);
}
if (job_cond
&& job_cond->cluster_list && list_count(job_cond->cluster_list))
use_cluster_list = job_cond->cluster_list;
else
slurm_mutex_lock(&as_mysql_cluster_list_lock);
job_list = list_create(slurmdb_destroy_job_rec);
itr = list_iterator_create(use_cluster_list);
while ((cluster_name = list_next(itr))) {
int rc;
if ((rc = _cluster_get_jobs(mysql_conn, &user, job_cond,
cluster_name, tmp, tmp2, extra,
is_admin, only_pending, job_list))
!= SLURM_SUCCESS)
error("Problem getting jobs for cluster %s",
cluster_name);
}
list_iterator_destroy(itr);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
xfree(tmp);
xfree(tmp2);
xfree(extra);
return job_list;
}
void *lru_dirty_thread(apr_thread_t *th, void *data)
{
cache_t *c = (cache_t *)data;
cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
double df;
int n, i;
ex_id_t *id;
segment_t *seg;
opque_t *q;
op_generic_t *gop;
cache_segment_t *s;
skiplist_iter_t it;
segment_t **flush_list;
cache_lock(c);
log_printf(15, "Dirty thread launched\n");
while (c->shutdown_request == 0) {
apr_thread_cond_timedwait(cp->dirty_trigger, c->lock, cp->dirty_max_wait);
df = cp->max_bytes;
df = c->stats.dirty_bytes / df;
log_printf(15, "Dirty thread running. dirty fraction=%lf dirty bytes=" XOT " inprogress=%d cached segments=%d\n", df, c->stats.dirty_bytes, cp->flush_in_progress, list_key_count(c->segments));
cp->flush_in_progress = 1;
q = new_opque();
n = list_key_count(c->segments);
type_malloc(flush_list, segment_t *, n);
it = list_iter_search(c->segments, NULL, 0);
list_next(&it, (list_key_t **)&id, (list_data_t **)&seg);
i = 0;
while (seg != NULL) {
log_printf(15, "Flushing seg=" XIDT " i=%d\n", *id, i);
flush_log();
flush_list[i] = seg;
s = (cache_segment_t *)seg->priv;
atomic_set(s->cache_check_in_progress, 1); //** Flag it as being checked
gop = cache_flush_range(seg, s->c->da, 0, -1, s->c->timeout);
gop_set_myid(gop, i);
opque_add(q, gop);
i++;
list_next(&it, (list_key_t **)&id, (list_data_t **)&seg);
}
cache_unlock(c);
//** Flag the tasks as they complete
opque_start_execution(q);
while ((gop = opque_waitany(q)) != NULL) {
i = gop_get_myid(gop);
segment_lock(flush_list[i]);
s = (cache_segment_t *)flush_list[i]->priv;
log_printf(15, "Flush completed seg=" XIDT " i=%d\n", segment_id(flush_list[i]), i);
flush_log();
atomic_set(s->cache_check_in_progress, 0); //** Flag it as being finished
segment_unlock(flush_list[i]);
gop_free(gop, OP_DESTROY);
}
opque_free(q, OP_DESTROY);
cache_lock(c);
cp->flush_in_progress = 0;
free(flush_list);
df = cp->max_bytes;
df = c->stats.dirty_bytes / df;
log_printf(15, "Dirty thread sleeping. dirty fraction=%lf dirty bytes=" XOT " inprogress=%d\n", df, c->stats.dirty_bytes, cp->flush_in_progress);
// apr_thread_cond_timedwait(cp->dirty_trigger, c->lock, cp->dirty_max_wait);
}
log_printf(15, "Dirty thread Exiting\n");
cache_unlock(c);
return(NULL);
}
/*
* slurm_job_step_get_pids - get the complete list of pids for a given
* job step
*
* IN job_id
* IN step_id
* IN node_list, optional, if NULL then all nodes in step are returned.
* OUT resp
* RET SLURM_SUCCESS on success SLURM_ERROR else
*/
extern int slurm_job_step_get_pids(uint32_t job_id, uint32_t step_id,
char *node_list,
job_step_pids_response_msg_t **resp)
{
int rc = SLURM_SUCCESS;
slurm_msg_t req_msg;
job_step_id_msg_t req;
ListIterator itr;
List ret_list = NULL;
ret_data_info_t *ret_data_info = NULL;
slurm_step_layout_t *step_layout = NULL;
job_step_pids_response_msg_t *resp_out;
bool created = 0;
xassert(resp);
if (!node_list) {
if (!(step_layout =
slurm_job_step_layout_get(job_id, step_id))) {
rc = errno;
error("slurm_job_step_get_pids: "
"problem getting step_layout for %u.%u: %s",
job_id, step_id, slurm_strerror(rc));
return rc;
}
node_list = step_layout->node_list;
}
if (!*resp) {
resp_out = xmalloc(sizeof(job_step_pids_response_msg_t));
*resp = resp_out;
created = 1;
} else
resp_out = *resp;
debug("slurm_job_step_get_pids: "
"getting pid information of job %u.%u on nodes %s",
job_id, step_id, node_list);
slurm_msg_t_init(&req_msg);
memset(&req, 0, sizeof(job_step_id_msg_t));
resp_out->job_id = req.job_id = job_id;
resp_out->step_id = req.step_id = step_id;
req_msg.msg_type = REQUEST_JOB_STEP_PIDS;
req_msg.data = &req;
if (!(ret_list = slurm_send_recv_msgs(node_list,
&req_msg, 0, false))) {
error("slurm_job_step_get_pids: got an error no list returned");
rc = SLURM_ERROR;
if (created) {
slurm_job_step_pids_response_msg_free(resp_out);
*resp = NULL;
}
goto cleanup;
}
itr = list_iterator_create(ret_list);
while((ret_data_info = list_next(itr))) {
switch (ret_data_info->type) {
case RESPONSE_JOB_STEP_PIDS:
if (!resp_out->pid_list)
resp_out->pid_list = list_create(
slurm_free_job_step_pids);
list_push(resp_out->pid_list,
ret_data_info->data);
ret_data_info->data = NULL;
break;
case RESPONSE_SLURM_RC:
rc = slurm_get_return_code(ret_data_info->type,
ret_data_info->data);
error("slurm_job_step_get_pids: "
"there was an error with the "
"list pid request rc = %s",
slurm_strerror(rc));
break;
default:
rc = slurm_get_return_code(ret_data_info->type,
ret_data_info->data);
error("slurm_job_step_get_pids: "
"unknown return given %d rc = %s",
ret_data_info->type, slurm_strerror(rc));
break;
}
}
list_iterator_destroy(itr);
list_destroy(ret_list);
if (resp_out->pid_list)
list_sort(resp_out->pid_list, (ListCmpF)_sort_pids_by_name);
cleanup:
slurm_step_layout_destroy(step_layout);
return rc;
}
int main( int argc, char **argv, char **arg_environ )
{
int n;
char *s;
struct option optv[N_OPTS];
const char *all = "all";
int anyhow = 0;
int status;
int arg_c = argc;
char ** arg_v = argv;
# ifdef OS_MAC
InitGraf(&qd.thePort);
# endif
argc--, argv++;
if( ( n = getoptions( argc, argv, "-:d:j:f:gs:t:ano:qv", optv ) ) < 0 )
{
printf( "\nusage: jam [ options ] targets...\n\n" );
printf( "-a Build all targets, even if they are current.\n" );
printf( "-dx Set the debug level to x (0-9).\n" );
printf( "-fx Read x instead of Jambase.\n" );
/* printf( "-g Build from newest sources first.\n" ); */
printf( "-jx Run up to x shell commands concurrently.\n" );
printf( "-n Don't actually execute the updating actions.\n" );
printf( "-ox Write the updating actions to file x.\n" );
printf( "-q Quit quickly as soon as a target fails.\n" );
printf( "-sx=y Set variable x=y, overriding environment.\n" );
printf( "-tx Rebuild x, even if it is up-to-date.\n" );
printf( "-v Print the version of jam and exit.\n" );
printf( "--x Option is ignored.\n\n" );
exit( EXITBAD );
}
argc -= n, argv += n;
/* Version info. */
if( ( s = getoptval( optv, 'v', 0 ) ) )
{
printf( "Boost.Jam " );
printf( "Version %s. %s.\n", VERSION, OSMINOR );
printf( " Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc. \n" );
printf( " Copyright 2001 David Turner.\n" );
printf( " Copyright 2001-2004 David Abrahams.\n" );
printf( " Copyright 2002-2004 Rene Rivera.\n" );
return EXITOK;
}
/* Pick up interesting options */
if( ( s = getoptval( optv, 'n', 0 ) ) )
globs.noexec++, globs.debug[2] = 1;
if( ( s = getoptval( optv, 'q', 0 ) ) )
globs.quitquick = 1;
if( ( s = getoptval( optv, 'a', 0 ) ) )
anyhow++;
if( ( s = getoptval( optv, 'j', 0 ) ) )
globs.jobs = atoi( s );
if( ( s = getoptval( optv, 'g', 0 ) ) )
globs.newestfirst = 1;
/* Turn on/off debugging */
for( n = 0; s = getoptval( optv, 'd', n ); n++ )
{
int i;
/* First -d, turn off defaults. */
if( !n )
for( i = 0; i < DEBUG_MAX; i++ )
globs.debug[i] = 0;
i = atoi( s );
if( i < 0 || i >= DEBUG_MAX )
{
printf( "Invalid debug level '%s'.\n", s );
continue;
}
/* n turns on levels 1-n */
/* +n turns on level n */
if( *s == '+' )
globs.debug[i] = 1;
else while( i )
globs.debug[i--] = 1;
}
#ifndef NDEBUG
run_unit_tests();
#endif
#if YYDEBUG != 0
if ( DEBUG_PARSE )
yydebug = 1;
#endif
/* Set JAMDATE first */
{
char *date;
time_t clock;
time( &clock );
date = newstr( ctime( &clock ) );
/* Trim newline from date */
if( strlen( date ) == 25 )
date[ 24 ] = 0;
var_set( "JAMDATE", list_new( L0, newstr( date ) ), VAR_SET );
}
{
/* Pleace don't change the following line. The 'bump_version.py' script
expect a specific format of it. */
char *major_version = "03", *minor_version = "01", *changenum = "10";
var_set( "JAM_VERSION",
list_new( list_new( list_new( L0, newstr( major_version ) ),
newstr( minor_version ) ),
newstr( changenum ) ),
VAR_SET );
}
/* And JAMUNAME */
# ifdef unix
{
struct utsname u;
if( uname( &u ) >= 0 )
{
var_set( "JAMUNAME",
list_new(
list_new(
list_new(
list_new(
list_new( L0,
newstr( u.sysname ) ),
newstr( u.nodename ) ),
newstr( u.release ) ),
newstr( u.version ) ),
newstr( u.machine ) ), VAR_SET );
}
}
# endif /* unix */
/* load up environment variables */
var_defines( use_environ );
/*
* Jam defined variables OS, OSPLAT
* We load them after environment, so that
* setting OS in environment does not
* change Jam notion of the current platform.
*/
var_defines( othersyms );
/* Load up variables set on command line. */
for( n = 0; s = getoptval( optv, 's', n ); n++ )
{
char *symv[2];
symv[0] = s;
symv[1] = 0;
var_defines( symv );
}
/* Set the ARGV to reflect the complete list of arguments of invocation. */
for ( n = 0; n < arg_c; ++n )
{
var_set( "ARGV", list_new( L0, newstr( arg_v[n] ) ), VAR_APPEND );
}
/* Initialize built-in rules */
load_builtins();
/* Add the targets in the command line to update list */
for ( n = 0; n < argc; ++n )
{
mark_target_for_updating(argv[n]);
}
/* Parse ruleset */
{
FRAME frame[1];
frame_init( frame );
for( n = 0; s = getoptval( optv, 'f', n ); n++ )
parse_file( s, frame );
if( !n )
parse_file( "+", frame );
}
status = yyanyerrors();
/* Manually touch -t targets */
for( n = 0; s = getoptval( optv, 't', n ); n++ )
touchtarget( s );
/* If an output file is specified, set globs.cmdout to that */
if( s = getoptval( optv, 'o', 0 ) )
{
if( !( globs.cmdout = fopen( s, "w" ) ) )
{
printf( "Failed to write to '%s'\n", s );
exit( EXITBAD );
}
globs.noexec++;
}
/* Now make target */
{
LIST* targets = targets_to_update();
if ( !targets )
{
status |= make( 1, &all, anyhow );
}
else
{
int targets_count = list_length(targets);
const char **targets2 = (const char **)malloc(targets_count * sizeof(char *));
int n = 0;
for ( ; targets; targets = list_next(targets) )
{
targets2[n++] = targets->string;
}
status |= make( targets_count, targets2, anyhow );
free(targets);
}
}
if ( DEBUG_PROFILE )
profile_dump();
/* Widely scattered cleanup */
var_done();
donerules();
donestamps();
donestr();
/* close cmdout */
if( globs.cmdout )
fclose( globs.cmdout );
return status ? EXITBAD : EXITOK;
}
ex_off_t _lru_attempt_free_mem(cache_t *c, segment_t *page_seg, ex_off_t bytes_to_free)
{
cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
cache_segment_t *s;
segment_t *pseg;
cache_page_t *p;
page_lru_t *lp;
Stack_ele_t *ele;
op_generic_t *gop;
opque_t *q;
ex_off_t total_bytes, freed_bytes, pending_bytes, *poff;
ex_off_t *segid;
ex_off_t min_off, max_off;
list_iter_t sit;
int count, bits, cw, flush_count;
list_t *table;
page_table_t *ptable;
pigeon_coop_hole_t pch, pt_pch;
log_printf(15, "START seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " stack_size=%d\n", segment_id(page_seg), bytes_to_free, cp->bytes_used, stack_size(cp->stack));
freed_bytes = 0;
pending_bytes = 0;
total_bytes = 0;
//** cache_lock(c) is already acquired
pch = reserve_pigeon_coop_hole(cp->free_pending_tables);
table = *(list_t **)pigeon_coop_hole_data(&pch);
//** Get the list of pages to free
move_to_bottom(cp->stack);
ele = stack_unlink_current(cp->stack, 1);
while ((total_bytes < bytes_to_free) && (ele != NULL)) {
p = (cache_page_t *)get_stack_ele_data(ele);
lp = (page_lru_t *)p->priv;
bits = atomic_get(p->bit_fields);
log_printf(15, "checking page for release seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
flush_log();
if ((bits & C_TORELEASE) == 0) { //** Skip it if already flagged for removal
ptable = (page_table_t *)list_search(table, (list_key_t *)&(segment_id(p->seg)));
if (ptable == NULL) { //** Have to make a new segment entry
pt_pch = reserve_pigeon_coop_hole(cp->free_page_tables);
ptable = (page_table_t *)pigeon_coop_hole_data(&pt_pch);
ptable->seg = p->seg;
ptable->id = segment_id(p->seg);
ptable->pch = pt_pch;
list_insert(table, &(ptable->id), ptable);
}
cp->limbo_pages++;
log_printf(15, "UNLINKING seg=" XIDT " p->offset=" XOT " bits=%d limbo=%d\n", segment_id(p->seg), p->offset, bits, cp->limbo_pages);
atomic_inc(p->access_pending[CACHE_READ]); //** Do this so it's not accidentally deleted
push(ptable->stack, p);
s = (cache_segment_t *)p->seg->priv;
total_bytes += s->page_size;
free(lp->ele);
lp->ele = NULL; //** Mark it as removed from the list so a page_release doesn't free also
}
if (total_bytes < bytes_to_free) ele = stack_unlink_current(cp->stack, 1);
}
if (total_bytes == 0) { //** Nothing to do so exit
log_printf(15, "Nothing to do so exiting\n");
release_pigeon_coop_hole(cp->free_pending_tables, &pch);
return(0);
}
cache_unlock(c); //** Don't need the cache lock for the next part
q = new_opque();
opque_start_execution(q);
//** Now cycle through the segments to be freed
pending_bytes = 0;
sit = list_iter_search(table, list_first_key(table), 0);
list_next(&sit, (list_key_t **)&segid, (list_data_t **)&ptable);
while (ptable != NULL) {
//** Verify the segment is still valid. If not then just delete everything
pseg = list_search(c->segments, segid);
if (pseg != NULL) {
segment_lock(ptable->seg);
min_off = s->total_size;
max_off = -1;
s = (cache_segment_t *)ptable->seg->priv;
while ((p = pop(ptable->stack)) != NULL) {
atomic_dec(p->access_pending[CACHE_READ]); //** Removed my access control from earlier
flush_count = atomic_get(p->access_pending[CACHE_FLUSH]);
cw = atomic_get(p->access_pending[CACHE_WRITE]);
count = atomic_get(p->access_pending[CACHE_READ]) + cw + flush_count;
bits = atomic_get(p->bit_fields);
if (count != 0) { //** Currently in use so wait for it to be released
if (cw > 0) { //** Got writes so need to wait until they complete otherwise the page may not get released
bits = bits | C_TORELEASE; //** Mark it for release
atomic_set(p->bit_fields, bits);
_cache_drain_writes(p->seg, p); //** Drain the write ops
bits = atomic_get(p->bit_fields); //** Get the bit fields to see if it's dirty
}
if (flush_count == 0) { //** Make sure it's not already being flushed
if ((bits & C_ISDIRTY) != 0) { //** Have to flush it don't have to track it cause the flush will do the release
if (min_off > p->offset) min_off = p->offset;
if (max_off < p->offset) max_off = p->offset;
}
}
bits = bits | C_TORELEASE;
log_printf(15, "in use tagging for release seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
atomic_set(p->bit_fields, bits);
pending_bytes += s->page_size;
} else { //** Not in use
if ((bits & (C_ISDIRTY|C_EMPTY)) == 0) { //** Don't have to flush it just drop the page
cp->limbo_pages--;
log_printf(15, "FREEING page seg=" XIDT " p->offset=" XOT " bits=%d limbo=%d\n", segment_id(p->seg), p->offset, bits, cp->limbo_pages);
list_remove(s->pages, &(p->offset), p); //** Have to do this here cause p->offset is the key var
if (p->data[0].ptr) free(p->data[0].ptr);
if (p->data[1].ptr) free(p->data[1].ptr);
lp = (page_lru_t *)p->priv;
free(lp);
freed_bytes += s->page_size;
} else { //** Got to flush the page first but don't have to track it cause the flush will do the release
if (p->offset > -1) { //** Skip blank pages
if (min_off > p->offset) min_off = p->offset;
if (max_off < p->offset) max_off = p->offset;
}
bits = bits | C_TORELEASE;
atomic_set(p->bit_fields, bits);
pending_bytes += s->page_size;
if (p->offset > -1) {
log_printf(15, "FLUSHING page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
} else {
log_printf(15, "RELEASE trigger for empty page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
}
}
}
list_next(&sit, (list_key_t **)&poff, (list_data_t **)&p);
}
segment_unlock(ptable->seg);
if (max_off>-1) {
gop = cache_flush_range(ptable->seg, s->c->da, min_off, max_off + s->page_size - 1, s->c->timeout);
opque_add(q, gop);
}
} else { //** Segment has been deleted so drop everything cause it's already freeed
empty_stack(ptable->stack, 0);
}
cache_lock(c);
release_pigeon_coop_hole(cp->free_page_tables, &(ptable->pch));
cache_unlock(c);
list_next(&sit, (skiplist_key_t **)&pseg, (skiplist_data_t **)&ptable);
}
cache_lock(c);
log_printf(15, "BEFORE waitall seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " freed_bytes=" XOT " pending_bytes=" XOT "\n",
segment_id(page_seg), bytes_to_free, cp->bytes_used, freed_bytes, pending_bytes);
cache_unlock(c);
//** Wait for any tasks to complete
opque_waitall(q);
opque_free(q, OP_DESTROY);
//** Had this when we came in
cache_lock(c);
log_printf(15, "AFTER waitall seg=" XIDT " bytes_used=" XOT "\n", segment_id(page_seg), cp->bytes_used);
cp->bytes_used -= freed_bytes; //** Update how much I directly freed
log_printf(15, "AFTER used update seg=" XIDT " bytes_used=" XOT "\n", segment_id(page_seg), cp->bytes_used);
//** Clean up
empty_skiplist(table);
release_pigeon_coop_hole(cp->free_pending_tables, &pch);
log_printf(15, "total_bytes marked for removal =" XOT "\n", total_bytes);
return(total_bytes);
}
/* returns number of objects added to list */
extern int _addto_uid_char_list(List char_list, char *names)
{
int i=0, start=0;
char *name = NULL, *tmp_char = NULL;
ListIterator itr = NULL;
char quote_c = '\0';
int quote = 0;
int count = 0;
if (!char_list) {
error("No list was given to fill in");
return 0;
}
itr = list_iterator_create(char_list);
if (names) {
if (names[i] == '\"' || names[i] == '\'') {
quote_c = names[i];
quote = 1;
i++;
}
start = i;
while(names[i]) {
//info("got %d - %d = %d", i, start, i-start);
if (quote && names[i] == quote_c)
break;
else if (names[i] == '\"' || names[i] == '\'')
names[i] = '`';
else if (names[i] == ',') {
if ((i-start) > 0) {
name = xmalloc((i-start+1));
memcpy(name, names+start, (i-start));
//info("got %s %d", name, i-start);
name = _string_to_uid( name );
while((tmp_char = list_next(itr))) {
if (!xstrcasecmp(tmp_char,
name))
break;
}
if (!tmp_char) {
list_append(char_list, name);
count++;
} else
xfree(name);
list_iterator_reset(itr);
}
i++;
start = i;
if (!names[i]) {
info("There is a problem with "
"your request. It appears you "
"have spaces inside your list.");
break;
}
}
i++;
}
if ((i-start) > 0) {
name = xmalloc((i-start)+1);
memcpy(name, names+start, (i-start));
name = _string_to_uid( name );
while((tmp_char = list_next(itr))) {
if (!xstrcasecmp(tmp_char, name))
break;
}
if (!tmp_char) {
list_append(char_list, name);
count++;
} else
xfree(name);
}
}
list_iterator_destroy(itr);
return count;
}
// LAB2: below code is used to check the first fit allocation algorithm (your EXERCISE 1)
// NOTICE: You SHOULD NOT CHANGE basic_check, default_check functions!
static void
default_check(void) {
// 好吧，我们现在来看一下默认的测试吧！
int count = 0, total = 0;
list_entry_t *le = &free_list; // free_list应该是一个文件头吧！
while ((le = list_next(le)) != &free_list) { // 开始遍历
struct Page *p = le2page(le, page_link);
assert(PageProperty(p));
count ++, total += p->property; // counter表示一个有多少个page，total表示一共有多少个空闲页
}
assert(total == nr_free_pages());
basic_check();
struct Page *p0 = alloc_pages(5), *p1, *p2; // 分配5个页面给p0
assert(p0 != NULL);
assert(!PageProperty(p0));
list_entry_t free_list_store = free_list;
list_init(&free_list);
assert(list_empty(&free_list));
assert(alloc_page() == NULL); // 然后分配一个页面应该为空，确实应该为空
unsigned int nr_free_store = nr_free; // 空闲的页面的数目
nr_free = 0; // 然后将他们全部变为0
free_pages(p0 + 2, 3); // 这个玩意能free吗？
assert(alloc_pages(4) == NULL); // 因为nr_free=3
assert(PageProperty(p0 + 2) && p0[2].property == 3);
assert((p1 = alloc_pages(3)) != NULL); // 给p1分配3块,现在nr_free=0
assert(alloc_page() == NULL);
assert(p0 + 2 == p1);
p2 = p0 + 1;
free_page(p0); // 好吧，释放一个页面, nr_free=1
free_pages(p1, 3); // 现在nr_free = 4
assert(PageProperty(p0) && p0->property == 1);
assert(PageProperty(p1) && p1->property == 3);
/** p0 p2 p1 end
* | | | | | |
* -------------------------------
* | N N N N |
* | |
* -------------------------------
*/
assert((p0 = alloc_page()) == p2 - 1); // 这里出错了。我倒是要看一看啦！这里应该不会出错啊，参照上面的图，重新分配的话，会分配p0，恰好是p2-1
free_page(p0);
assert((p0 = alloc_pages(2)) == p2 + 1); // 这里是测试first fit的
/** start p2 p0 end
* | | | | | |
* -------------------------------
* | N N |
* | |
* -------------------------------
*/
free_pages(p0, 2);
free_page(p2);
/** start p2 p0 end
* | | | | | |
* -------------------------------
* | N N N N N |
* | |
* -------------------------------
*/
assert((p0 = alloc_pages(5)) != NULL);
assert(alloc_page() == NULL);
assert(nr_free == 0);
nr_free = nr_free_store; // 恢复原来的样子
free_list = free_list_store;
free_pages(p0, 5);
le = &free_list;
while ((le = list_next(le)) != &free_list) { // 又要开始遍历了,这里主要是测试经过这么折腾之后，没有出现页丢失的情况
struct Page *p = le2page(le, page_link);
count --, total -= p->property;
}
assert(count == 0);
assert(total == 0);
}
int
run_access (newts_nfref *ref)
{
List access_list;
short changed = FALSE;
short redraw = TRUE;
int c;
int first = 0;
int entries;
entries = get_access_list (ref, &access_list);
while (1)
{
if (redraw)
display_access (&access_list, first, entries);
redraw = FALSE;
mvprintw (LINES - 2, 0, _("Option: "));
refresh ();
c = getch ();
switch (c)
{
case '?':
access_help ();
/* Fall through. */
case 'r': /* Redraw the screen. */
case '\f':
redraw = TRUE;
break;
case '!':
redraw = TRUE;
spawn_subshell ();
break;
case 's':
move (LINES - 2, 0);
clrtoeol ();
printw (_("Sorting..."));
refresh ();
list_merge_sort (&access_list);
redraw = TRUE;
break;
case 'Q': /* Quit without saving. */
case 'K':
list_destroy (&access_list);
return 0;
case 'q':
case 'k':
if (changed)
{
list_merge_sort (&access_list);
write_access_list (ref, &access_list);
}
list_destroy (&access_list);
return 0;
case '-':
case KEY_UP:
case KEY_PPAGE:
first -= c == KEY_UP ? 1 : (LINES - 6) / 2 - 1;
if (first < 0)
first = 0;
redraw = TRUE;
break;
case '+':
case KEY_DOWN:
case KEY_NPAGE:
first += c == KEY_DOWN ? 1 : (LINES - 6) / 2 - 1;
if (first >= entries - (LINES - 6) / 2)
{
first = entries - (LINES - 6) - 3;
if (first < 0)
first = 0;
}
redraw = TRUE;
break;
case 'i': /* Insert new entries. */
{
char *persistent_error = NULL;
short stop = FALSE;
while (entries < NPERMS && !stop)
{
ListNode *node;
struct access *access_entry;
char *temp, *name, *prompt;
int key, i;
int y, x;
enum newts_access_scopes scope;
int scope_is_set = FALSE;
int mode;
short restart = FALSE;
short advice_displayed = FALSE;
if (traditional)
mvprintw (LINES - 5, 39, _("Entry type: "));
else
{
clear ();
display_access (&access_list, first, entries);
if (persistent_error != NULL)
{
move (LINES - 3, 0);
clrtoeol ();
printw ("%s", persistent_error);
persistent_error = NULL;
}
move (LINES - 2, 0);
clrtoeol ();
printw (_("Entry type: "));
}
refresh ();
if (!traditional)
advice_displayed = FALSE;
getyx (stdscr, y, x);
while (scope_is_set == FALSE)
{
key = getch ();
if (key == '\n' || key == '\r' || key == KEY_ENTER ||
key == 'q' || key == 'k')
{
if (traditional && (key == 'k' || key == 'q'))
echochar (key);
stop = TRUE;
break;
}
switch (key)
{
case 'u':
if (traditional)
{
echochar (key);
move (y, x);
}
scope = SCOPE_USER;
scope_is_set = TRUE;
break;
case 'g':
if (traditional)
{
echochar (key);
move (y, x);
}
scope = SCOPE_GROUP;
scope_is_set = TRUE;
break;
case 's':
if (traditional)
{
echochar (key);
move (y, x);
}
scope = SCOPE_SYSTEM;
scope_is_set = TRUE;
break;
case KEY_RESIZE:
break;
case EOF:
clear ();
display_access (&access_list, first, entries);
if (traditional)
{
if (advice_displayed)
mvprintw (LINES - 5, 54, "(u,g,s, q,k,<cr>)");
move (LINES - 5, 51);
}
else
{
if (advice_displayed)
mvprintw (LINES - 3, 0,
_("Please enter 'u', 'g', or 's'; or "
"'q', 'k', or <RET> to exit."));
mvprintw (LINES - 2, 0, _("Entry type: "));
}
refresh ();
break;
default:
advice_displayed = TRUE;
if (traditional)
{
mvprintw (LINES - 5, 54, "(u,g,s, q,k,<cr>)");
move (LINES - 5, 51);
}
else
{
move (LINES - 3, 0);
clrtoeol ();
printw (_("Please enter 'u', 'g', or 's'; or 'q', "
"'k', or <RET> to exit."));
move (LINES - 2, 0);
clrtoeol ();
printw (_("Entry type: "));
}
refresh ();
break;
}
}
if (stop) continue;
if (traditional)
{
prompt = newts_nmalloc (strlen (_("Name: ")) + 40,
sizeof (char));
strcpy (prompt, " ");
strncat (prompt, _("Name: "),
strlen (_("Name: ")) + 1);
move (LINES - 4, 0);
clrtoeol ();
}
else
{
move (LINES - 3, 0);
clrtoeol ();
prompt = newts_strdup (scope == SCOPE_SYSTEM ? _("System name: ") :
scope == SCOPE_GROUP ? _("Group name: ") :
_("User name: "));
move (LINES - 2, 0);
clrtoeol ();
}
refresh ();
temp = gl_getline (prompt);
temp[strlen (temp) - 1] = '\0';
newts_free (prompt);
if (strlen (temp) == 0)
continue;
name = newts_strdup (temp);
gl_histadd (name);
if (scope == SCOPE_USER)
{
if (strcasecmp (name, "other") != 0)
{
struct passwd *pw = getpwnam (name);
if (pw == NULL)
{
if (traditional)
{
move (LINES - 3, 0);
clrtoeol ();
mvprintw (LINES - 3, 39, _("--No such user--"));
}
else
persistent_error = _("No such user.");
continue;
}
endpwent ();
}
}
if (scope == SCOPE_GROUP)
{
if (strcasecmp (name, "other") != 0)
{
struct group *gp = getgrnam (name);
if (gp == NULL)
{
if (traditional)
{
move (LINES - 3, 0);
clrtoeol ();
mvprintw (LINES - 3, 39, _("--No such group--"));
}
else
persistent_error = _("No such group.");
continue;
}
endgrent ();
}
}
node = list_head (&access_list);
for (i=0; i<entries; i++)
{
access_entry = (struct access *) list_data (node);
if (access_scope (access_entry) == scope &&
strcmp (access_name (access_entry), name) == 0)
{
if (traditional)
{
move (LINES - 3, 0);
clrtoeol ();
mvprintw (LINES - 3, 39, _("%s entry exists"), name);
}
else
persistent_error =
scope == SCOPE_USER ? _("User already exists in "
"permission table.") :
(scope == SCOPE_GROUP ? _("Group already exists in "
"permission table.") :
_("System already exists in permission table."));
restart = TRUE;
continue;
}
node = list_next (node);
if (node == NULL)
continue;
}
if (restart)
continue;
{
struct access *new_access = access_alloc ();
access_set_permissions (new_access, READ | WRITE | REPLY);
access_set_scope (new_access, scope);
access_set_name (new_access, name);
get_mode (new_access, &access_list, first, entries);
list_insert_sorted (&access_list, (void *) new_access);
}
newts_free (name);
entries++;
redraw = TRUE;
changed = TRUE;
clear ();
display_access (&access_list, first, entries);
}
if (!traditional)
redraw = TRUE;
break;
}
case 'd': /* Delete existing entries. */
{
ListNode *node, *prev;
struct access *data;
int key, number, i;
move (LINES - 2, 0);
clrtoeol ();
if (traditional)
printw ("%s", _("Delete entry #: "));
else
printw ("%s", _("Delete entry number: "));
key = getch ();
while (key != '\n' && key != '\r' && key != KEY_ENTER &&
(key < '1' || key > '9'))
key = getch ();
if (key == '\n' || key == '\r' || key == KEY_ENTER)
{
redraw = TRUE;
break;
}
number = get_number (key, entries);
if (number < 0)
{
redraw = TRUE;
break;
}
if (number > entries || key < '0' || key > '9' || number == 0)
{
clear ();
display_access (&access_list, first, entries);
if (traditional)
{
move (LINES - 1, 0);
clrtoeol ();
printw ("%s", _("Bad entry"));
}
else
{
move (LINES - 3, 0);
clrtoeol ();
printw ("%s", _("Invalid entry."));
}
break;
}
number--; /* Adjust to base zero. */
prev = NULL;
node = list_head (&access_list);
for (i=0; i<number; i++)
{
prev = node;
node = list_next (prev);
}
data = (struct access *) list_data (node);
if (data->scope == SCOPE_USER && strcmp (data->name, username) == 0)
{
clear ();
display_access (&access_list, first, entries);
if (traditional)
{
move (LINES - 1, 0);
clrtoeol ();
printw ("%s", _(" Can't Delete self"));
}
else
{
move (LINES - 3, 0);
clrtoeol ();
printw ("%s", _("Can't delete own entry."));
}
break;
}
list_remove_next (&access_list, prev, NULL);
entries--;
changed = TRUE;
redraw = TRUE;
break;
}
case 'm': /* Modify existing entries. */
{
ListNode *node;
struct access *existing_entry;
int key, number, i;
move (LINES - 2, 0);
clrtoeol ();
if (traditional)
printw ("%s", _("Modify entry #: "));
else
printw ("%s", _("Modify entry number: "));
key = getch ();
while (key != '\n' && key != '\r' && key != KEY_ENTER &&
(key < '1' || key > '9'))
key = getch ();
if (key == '\n' || key == '\r' || key == KEY_ENTER)
{
redraw = TRUE;
break;
}
number = get_number (key, entries);
if (number < 0)
{
redraw = TRUE;
break;
}
if (number > entries || key < '0' || key > '9' || number == 0)
{
clear ();
display_access (&access_list, first, entries);
if (traditional)
{
move (LINES - 1, 0);
clrtoeol ();
printw ("%s", _("Bad entry"));
}
else
{
move (LINES - 3, 0);
clrtoeol ();
printw ("%s", _("Invalid entry."));
}
break;
}
number--; /* Adjust to base zero. */
node = list_head (&access_list);
for (i=0; i<number; i++)
{
node = list_next (node);
}
existing_entry = (struct access *) list_data (node);
get_mode (existing_entry, &access_list, first, entries);
changed = TRUE;
redraw = TRUE;
break;
}
case '\004':
list_destroy (&access_list);
return QUITNOSEQ;
case 'z':
list_destroy (&access_list);
return QUITSEQ;
default:
beep ();
break;
}
}
return 0;
}
static int _copy_allocation(char *com, List allocated_blocks)
{
ListIterator results_i;
allocated_block_t *allocated_block = NULL;
allocated_block_t *temp_block = NULL;
select_ba_request_t *request = NULL;
int i = 1, j;
int len = strlen(com);
char letter = '\0';
int count = 1;
int *geo = NULL, *geo_ptr = NULL;
/* look for the space after copy */
while ((com[i-1] != ' ') && (i < len))
i++;
if (i <= len) {
/* Here we are looking for a real number for the count
* instead of the params.cluster_base so atoi is ok */
if ((com[i] >= '0') && (com[i] <= '9'))
count = atoi(com+i);
else {
letter = com[i];
i++;
if (com[i] != '\n') {
while ((com[i-1] != ' ') && (i < len))
i++;
if ((com[i] >= '0') && (com[i] <= '9'))
count = atoi(com+i);
}
}
}
results_i = list_iterator_create(allocated_blocks);
while ((allocated_block = list_next(results_i)) != NULL) {
temp_block = allocated_block;
if (allocated_block->letter != letter)
continue;
break;
}
list_iterator_destroy(results_i);
if (!letter)
allocated_block = temp_block;
if (!allocated_block) {
memset(error_string, 0, 255);
sprintf(error_string,
"Could not find requested record to copy");
return 0;
}
for (i = 0; i < count; i++) {
request = (select_ba_request_t*)
xmalloc(sizeof(select_ba_request_t));
for (j = 0; j < params.cluster_dims; j++) {
request->geometry[j] = allocated_block->request->
geometry[j];
request->conn_type[j] = allocated_block->request->
conn_type[j];
}
request->size = allocated_block->request->size;
request->rotate =allocated_block->request->rotate;
request->elongate = allocated_block->request->elongate;
request->deny_pass = allocated_block->request->deny_pass;
#ifndef HAVE_BGL
request->small16 = allocated_block->request->small16;
request->small64 = allocated_block->request->small64;
request->small256 = allocated_block->request->small256;
#endif
request->small32 = allocated_block->request->small32;
request->small128 = allocated_block->request->small128;
request->rotate_count= 0;
request->elongate_count = 0;
request->elongate_geos = list_create(NULL);
request->avail_mp_bitmap = NULL;
results_i = list_iterator_create(request->elongate_geos);
while ((geo_ptr = list_next(results_i)) != NULL) {
geo = xmalloc(sizeof(int) * params.cluster_dims);
for (j = 0; j < params.cluster_dims; j++)
geo[j] = geo_ptr[j];
list_append(request->elongate_geos, geo);
}
list_iterator_destroy(results_i);
if ((allocated_block = _make_request(request)) == NULL) {
memset(error_string, 0, 255);
sprintf(error_string,
"Problem with the copy\n"
"Are you sure there is enough room for it?");
xfree(request);
return 0;
}
list_append(allocated_blocks, allocated_block);
}
return 1;
}
/*remove the destination element from the list*/
int list_remove_element(devList * list, devNode *element,void **data){
sky_trace_enter();
//don't deal with the NULL or a empty list.
if((element == NULL )||( list_size(list) == 0)){
return -1;
}
/*remove the element of the list*/
//*data = element->prev->data;
sky_dbg("the content of the deleted node is %s\n",element->data);
#ifdef DOUBLE_CIRCULAR_LINK
/*head tail节点中并没有数据*/
/*循环双向链表*/
if( element == list->head){
*data = element->next->data;
//list->head = element->next;
//if(list->head == NULL){
// list->tail = NULL;
//}else{
//list->head->next = list->head->next->next;
list->head->next->next->prev = list->head->next->prev;
list->head->next = list->head->next->next;
//}
}else if(element == list->tail){
*data = element->prev->data;
sky_trace_line();
list->tail->prev->prev->next = list->tail;
list->tail->prev = list->tail->prev->prev;
}else{
list_prev(element)->next = list_next(element);
list_next(element)->prev = list_prev(element);
}
#else
/*非循环双向链表*/
if( element == list->head)//the element is the head node
{
list->head = element->next;
if(list->head ==NULL){//the element->next==NULL
list->tail = NULL;
}else{
element->next->prev = NULL;//throw out the element
}
}else //if the element is not the head node.
{
if(element == list->tail ){
list->tail = element->next;
}else{
list_next(element)->prev = list_prev(element);
list_prev(element)->next = list_next(element);
}
/*
element->prev->next = element->next;
if( element->next == NULL) //deal with the last element.
{
list->tail = element->prev;
}else{
element->next->prev = element->prev;
}*/
}
#endif
/*free the memery*/
free(element);
/*adjust the size*/
list->size--;
sleep(1);
sky_trace_exit();
return 0;
}
static int _save_allocation(char *com, List allocated_blocks)
{
int len = strlen(com);
int i=5, j=0;
allocated_block_t *allocated_block = NULL;
char filename[50];
char *save_string = NULL;
FILE *file_ptr = NULL;
char *extra = NULL;
ListIterator results_i;
memset(filename, 0, 50);
if (len > 5)
while (i<len) {
while (com[i-1]!=' ' && i<len) {
i++;
}
while (i<len && com[i]!=' ') {
filename[j] = com[i];
i++;
j++;
}
}
if (filename[0]=='\0') {
time_t now_time = time(NULL);
sprintf(filename,"bluegene.conf.%ld",
(long int) now_time);
}
file_ptr = fopen(filename,"w");
if (file_ptr!=NULL) {
char *image_dir = NULL;
xstrcat(save_string,
"#\n# bluegene.conf file generated by smap\n");
xstrcat(save_string,
"# See the bluegene.conf man page for "
"more information\n");
xstrcat(save_string, "#\n");
#ifdef HAVE_BGL
image_dir = "/bgl/BlueLight/ppcfloor/bglsys/bin";
xstrfmtcat(save_string, "BlrtsImage=%s/rts_hw.rts\n",
image_dir);
xstrfmtcat(save_string, "LinuxImage=%s/zImage.elf\n",
image_dir);
xstrfmtcat(save_string,
"MloaderImage=%s/mmcs-mloader.rts\n",
image_dir);
xstrfmtcat(save_string,
"RamDiskImage=%s/ramdisk.elf\n",
image_dir);
xstrcat(save_string, "Numpsets=8 # io poor\n");
xstrcat(save_string, "# Numpsets=64 # io rich\n");
#elif defined HAVE_BGP
image_dir = "/bgsys/drivers/ppcfloor/boot";
xstrfmtcat(save_string, "CnloadImage=%s/cns,%s/cnk\n",
image_dir, image_dir);
xstrfmtcat(save_string, "MloaderImage=%s/uloader\n",
image_dir);
xstrfmtcat(save_string,
"IoloadImage=%s/cns,%s/linux,%s/ramdisk\n",
image_dir, image_dir, image_dir);
xstrcat(save_string, "Numpsets=4 # io poor\n");
xstrcat(save_string, "# Numpsets=32 # io rich\n");
#else
image_dir = "/bgsys/drivers/ppcfloor/boot";
xstrfmtcat(save_string, "MloaderImage=%s/uloader\n",
image_dir);
xstrcat(save_string, "Numpsets=4 # io semi-poor\n");
xstrcat(save_string, "# Numpsets=16 # io rich\n");
#endif
xstrcat(save_string, "BridgeAPILogFile="
"/var/log/slurm/bridgeapi.log\n");
xstrcat(save_string, "BridgeAPIVerbose=2\n");
xstrfmtcat(save_string, "BasePartitionNodeCnt=%d\n",
base_part_node_cnt);
xstrfmtcat(save_string, "NodeCardNodeCnt=%d\n",
nodecard_node_cnt);
if (!list_count(allocated_blocks))
xstrcat(save_string, "LayoutMode=DYNAMIC\n");
else {
xstrfmtcat(save_string, "LayoutMode=%s\n", layout_mode);
xstrfmtcat(save_string, "#\n# Block Layout\n#\n");
}
results_i = list_iterator_create(allocated_blocks);
while ((allocated_block = list_next(results_i)) != NULL) {
select_ba_request_t *request = allocated_block->request;
if (request->small16 || request->small32
|| request->small64 || request->small128
|| request->small256) {
#ifdef HAVE_BGL
xstrfmtcat(extra,
" 32CNBlocks=%d "
"128CNBlocks=%d",
request->small32,
request->small128);
#elif defined HAVE_BGP
xstrfmtcat(extra,
" 16CNBlocks=%d "
"32CNBlocks=%d "
"64CNBlocks=%d "
"128CNBlocks=%d "
"256CNBlocks=%d",
request->small16,
request->small32,
request->small64,
request->small128,
request->small256);
#else
xstrfmtcat(extra,
" 32CNBlocks=%d "
"64CNBlocks=%d "
"128CNBlocks=%d "
"256CNBlocks=%d",
request->small32,
request->small64,
request->small128,
request->small256);
#endif
}
xstrfmtcat(save_string, "BPs=%s", request->save_name);
for (i=0; i<SYSTEM_DIMENSIONS; i++) {
if (request->conn_type[i] == (uint16_t)NO_VAL)
break;
if (i)
xstrcat(save_string, ",");
else
xstrcat(save_string, " Type=");
xstrfmtcat(save_string, "%s", conn_type_string(
request->conn_type[i]));
#ifdef HAVE_BG_L_P
break;
#endif
}
if (extra) {
xstrfmtcat(save_string, "%s\n", extra);
xfree(extra);
} else
xstrcat(save_string, "\n");
}
list_iterator_destroy(results_i);
fputs(save_string, file_ptr);
xfree(save_string);
fclose (file_ptr);
}
return 1;
}
LIST * compile_eval( PARSE * parse, FRAME * frame )
{
LIST * ll;
LIST * lr;
LIST * s;
LIST * t;
int status = 0;
/* Short circuit lr eval for &&, ||, and 'in'. */
ll = parse_evaluate( parse->left, frame );
lr = 0;
switch ( parse->num )
{
case EXPR_AND:
case EXPR_IN : if ( ll ) goto eval; break;
case EXPR_OR : if ( !ll ) goto eval; break;
default: eval: lr = parse_evaluate( parse->right, frame );
}
/* Now eval. */
switch ( parse->num )
{
case EXPR_NOT: if ( !ll ) status = 1; break;
case EXPR_AND: if ( ll && lr ) status = 1; break;
case EXPR_OR : if ( ll || lr ) status = 1; break;
case EXPR_IN:
/* "a in b": make sure each of ll is equal to something in lr. */
for ( t = ll; t; t = list_next( t ) )
{
for ( s = lr; s; s = list_next( s ) )
if ( !strcmp( t->string, s->string ) )
break;
if ( !s ) break;
}
/* No more ll? Success. */
if ( !t ) status = 1;
break;
case EXPR_EXISTS: if ( lcmp( ll, L0 ) != 0 ) status = 1; break;
case EXPR_EQUALS: if ( lcmp( ll, lr ) == 0 ) status = 1; break;
case EXPR_NOTEQ : if ( lcmp( ll, lr ) != 0 ) status = 1; break;
case EXPR_LESS : if ( lcmp( ll, lr ) < 0 ) status = 1; break;
case EXPR_LESSEQ: if ( lcmp( ll, lr ) <= 0 ) status = 1; break;
case EXPR_MORE : if ( lcmp( ll, lr ) > 0 ) status = 1; break;
case EXPR_MOREEQ: if ( lcmp( ll, lr ) >= 0 ) status = 1; break;
}
if ( DEBUG_IF )
{
debug_compile( 0, "if", frame );
list_print( ll );
printf( "(%d) ", status );
list_print( lr );
printf( "\n" );
}
/* Find something to return. */
/* In odd circumstances (like "" = "") */
/* we'll have to return a new string. */
if ( !status ) t = 0;
else if ( ll ) t = ll, ll = 0;
else if ( lr ) t = lr, lr = 0;
else t = list_new( L0, newstr( "1" ) );
if ( ll ) list_free( ll );
if ( lr ) list_free( lr );
return t;
}
extern int setup_job_cond_limits(mysql_conn_t *mysql_conn,
slurmdb_job_cond_t *job_cond,
char **extra)
{
int set = 0;
ListIterator itr = NULL;
char *object = NULL;
slurmdb_selected_step_t *selected_step = NULL;
if (!job_cond)
return 0;
if (job_cond->acct_list && list_count(job_cond->acct_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->acct_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.account='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->associd_list && list_count(job_cond->associd_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->associd_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_assoc='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->userid_list && list_count(job_cond->userid_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->userid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_user='******'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->groupid_list && list_count(job_cond->groupid_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->groupid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_group='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->jobname_list && list_count(job_cond->jobname_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->jobname_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.job_name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->partition_list && list_count(job_cond->partition_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->partition_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.partition='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->qos_list && list_count(job_cond->qos_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->qos_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_qos='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->step_list && list_count(job_cond->step_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->step_list);
while ((selected_step = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_job=%u",
selected_step->jobid);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->cpus_min) {
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
if (job_cond->cpus_max) {
xstrfmtcat(*extra, "(t1.cpus_alloc between %u and %u))",
job_cond->cpus_min, job_cond->cpus_max);
} else {
xstrfmtcat(*extra, "(t1.cpus_alloc='%u'))",
job_cond->cpus_min);
}
}
if (job_cond->nodes_min) {
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
if (job_cond->nodes_max) {
xstrfmtcat(*extra,
"(t1.nodes_alloc between %u and %u))",
job_cond->nodes_min, job_cond->nodes_max);
} else {
xstrfmtcat(*extra, "(t1.nodes_alloc='%u'))",
job_cond->nodes_min);
}
}
if (job_cond->timelimit_min) {
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
if (job_cond->timelimit_max) {
xstrfmtcat(*extra, "(t1.timelimit between %u and %u))",
job_cond->timelimit_min,
job_cond->timelimit_max);
} else {
xstrfmtcat(*extra, "(t1.timelimit='%u'))",
job_cond->timelimit_min);
}
}
if (job_cond->state_list && list_count(job_cond->state_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->state_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
_state_time_string(extra, (uint32_t)slurm_atoul(object),
job_cond->usage_start,
job_cond->usage_end);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
} else {
/* Only do this (default of all eligible jobs) if no
state is given */
if (job_cond->usage_start) {
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
if (!job_cond->usage_end)
xstrfmtcat(*extra,
"(t1.time_end >= %ld "
"|| t1.time_end = 0))",
job_cond->usage_start);
else
xstrfmtcat(*extra,
"(t1.time_eligible < %ld "
"&& (t1.time_end >= %ld "
"|| t1.time_end = 0)))",
job_cond->usage_end,
job_cond->usage_start);
} else if (job_cond->usage_end) {
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
xstrfmtcat(*extra,
"(t1.time_eligible < %ld))",
job_cond->usage_end);
}
}
if (job_cond->wckey_list && list_count(job_cond->wckey_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->wckey_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.wckey='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
return set;
}
void *heap_alloc(size_t size, unsigned int alignment)
{
void *ptr;
#if DEBUG_HEAP
size_t original_size = size;
#endif
LTRACEF("size %zd, align %d\n", size, alignment);
// alignment must be power of 2
if (alignment & (alignment - 1))
return NULL;
// we always put a size field + base pointer + magic in front of the allocation
size += sizeof(struct alloc_struct_begin);
#if DEBUG_HEAP
size += PADDING_SIZE;
#endif
// make sure we allocate at least the size of a struct free_heap_chunk so that
// when we free it, we can create a struct free_heap_chunk struct and stick it
// in the spot
if (size < sizeof(struct free_heap_chunk))
size = sizeof(struct free_heap_chunk);
// round up size to a multiple of native pointer size
size = ROUNDUP(size, sizeof(void *));
// deal with nonzero alignments
if (alignment > 0) {
if (alignment < 16)
alignment = 16;
// add alignment for worst case fit
size += alignment;
}
// critical section
enter_critical_section();
// walk through the list
ptr = NULL;
struct free_heap_chunk *chunk;
list_for_every_entry(&theheap.free_list, chunk, struct free_heap_chunk, node) {
DEBUG_ASSERT((chunk->len % sizeof(void *)) == 0); // len should always be a multiple of pointer size
// is it big enough to service our allocation?
if (chunk->len >= size) {
ptr = chunk;
// remove it from the list
struct list_node *next_node = list_next(&theheap.free_list, &chunk->node);
list_delete(&chunk->node);
if (chunk->len > size + sizeof(struct free_heap_chunk)) {
// there's enough space in this chunk to create a new one after the allocation
struct free_heap_chunk *newchunk = heap_create_free_chunk((uint8_t *)ptr + size, chunk->len - size);
// truncate this chunk
chunk->len -= chunk->len - size;
// add the new one where chunk used to be
if (next_node)
list_add_before(next_node, &newchunk->node);
else
list_add_tail(&theheap.free_list, &newchunk->node);
}
// the allocated size is actually the length of this chunk, not the size requested
DEBUG_ASSERT(chunk->len >= size);
size = chunk->len;
#if DEBUG_HEAP
memset(ptr, ALLOC_FILL, size);
#endif
ptr = (void *)((addr_t)ptr + sizeof(struct alloc_struct_begin));
// align the output if requested
if (alignment > 0) {
ptr = (void *)ROUNDUP((addr_t)ptr, alignment);
}
struct alloc_struct_begin *as = (struct alloc_struct_begin *)ptr;
as--;
as->magic = HEAP_MAGIC;
as->ptr = (void *)chunk;
as->size = size;
#if DEBUG_HEAP
as->padding_start = ((uint8_t *)ptr + original_size);
as->padding_size = (((addr_t)chunk + size) - ((addr_t)ptr + original_size));
// printf("padding start %p, size %u, chunk %p, size %u\n", as->padding_start, as->padding_size, chunk, size);
memset(as->padding_start, PADDING_FILL, as->padding_size);
#endif
break;
}
}
LTRACEF("returning ptr %p\n", ptr);
// heap_dump();
exit_critical_section();
return ptr;
}
static int _cluster_get_jobs(mysql_conn_t *mysql_conn,
slurmdb_user_rec_t *user,
slurmdb_job_cond_t *job_cond,
char *cluster_name,
char *job_fields, char *step_fields,
char *sent_extra,
bool is_admin, int only_pending, List sent_list)
{
char *query = NULL;
char *extra = xstrdup(sent_extra);
uint16_t private_data = slurm_get_private_data();
slurmdb_selected_step_t *selected_step = NULL;
MYSQL_RES *result = NULL, *step_result = NULL;
MYSQL_ROW row, step_row;
slurmdb_job_rec_t *job = NULL;
slurmdb_step_rec_t *step = NULL;
time_t now = time(NULL);
List job_list = list_create(slurmdb_destroy_job_rec);
ListIterator itr = NULL;
List local_cluster_list = NULL;
int set = 0;
char *prefix="t2";
int rc = SLURM_SUCCESS;
int last_id = -1, curr_id = -1;
local_cluster_t *curr_cluster = NULL;
/* This is here to make sure we are looking at only this user
* if this flag is set. We also include any accounts they may be
* coordinator of.
*/
if (!is_admin && (private_data & PRIVATE_DATA_JOBS)) {
query = xstrdup_printf("select lft from \"%s_%s\" "
"where user='******'",
cluster_name, assoc_table, user->name);
if (user->coord_accts) {
slurmdb_coord_rec_t *coord = NULL;
itr = list_iterator_create(user->coord_accts);
while ((coord = list_next(itr))) {
xstrfmtcat(query, " || acct='%s'",
coord->name);
}
list_iterator_destroy(itr);
}
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(extra);
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set) {
xstrfmtcat(extra,
" || (%s between %s.lft and %s.rgt)",
row[0], prefix, prefix);
} else {
set = 1;
if (extra)
xstrfmtcat(extra,
" && ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
else
xstrfmtcat(extra,
" where ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
}
}
if (set)
xstrcat(extra,")");
mysql_free_result(result);
}
setup_job_cluster_cond_limits(mysql_conn, job_cond,
cluster_name, &extra);
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"left join \"%s_%s\" as t2 "
"on t1.id_assoc=t2.id_assoc",
job_fields, cluster_name, job_table,
cluster_name, assoc_table);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
/* Here we want to order them this way in such a way so it is
easy to look for duplicates, it is also easy to sort the
resized jobs.
*/
xstrcat(query, " group by id_job, time_submit desc");
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Here we set up environment to check used nodes of jobs.
Since we store the bitmap of the entire cluster we can use
that to set up a hostlist and set up the bitmap to make
things work. This should go before the setup of conds
since we could update the start/end time.
*/
if (job_cond && job_cond->used_nodes) {
local_cluster_list = setup_cluster_list_with_inx(
mysql_conn, job_cond, (void **)&curr_cluster);
if (!local_cluster_list) {
rc = SLURM_ERROR;
goto end_it;
}
}
while ((row = mysql_fetch_row(result))) {
char *id = row[JOB_REQ_ID];
bool job_ended = 0;
int submit = slurm_atoul(row[JOB_REQ_SUBMIT]);
curr_id = slurm_atoul(row[JOB_REQ_JOBID]);
if (job_cond && !job_cond->duplicates
&& (curr_id == last_id)
&& (slurm_atoul(row[JOB_REQ_STATE]) != JOB_RESIZING))
continue;
/* check the bitmap to see if this is one of the jobs
we are looking for */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
row[JOB_REQ_NODE_INX], submit)) {
last_id = curr_id;
continue;
}
job = slurmdb_create_job_rec();
job->state = slurm_atoul(row[JOB_REQ_STATE]);
if (curr_id == last_id)
/* put in reverse so we order by the submit getting
larger which it is given to us in reverse
order from the database */
list_prepend(job_list, job);
else
list_append(job_list, job);
last_id = curr_id;
job->alloc_cpus = slurm_atoul(row[JOB_REQ_ALLOC_CPUS]);
job->alloc_nodes = slurm_atoul(row[JOB_REQ_ALLOC_NODES]);
job->associd = slurm_atoul(row[JOB_REQ_ASSOCID]);
job->resvid = slurm_atoul(row[JOB_REQ_RESVID]);
job->cluster = xstrdup(cluster_name);
/* we want a blank wckey if the name is null */
if (row[JOB_REQ_WCKEY])
job->wckey = xstrdup(row[JOB_REQ_WCKEY]);
else
job->wckey = xstrdup("");
job->wckeyid = slurm_atoul(row[JOB_REQ_WCKEYID]);
if (row[JOB_REQ_USER_NAME])
job->user = xstrdup(row[JOB_REQ_USER_NAME]);
else
job->uid = slurm_atoul(row[JOB_REQ_UID]);
if (row[JOB_REQ_LFT])
job->lft = slurm_atoul(row[JOB_REQ_LFT]);
if (row[JOB_REQ_ACCOUNT] && row[JOB_REQ_ACCOUNT][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT]);
else if (row[JOB_REQ_ACCOUNT1] && row[JOB_REQ_ACCOUNT1][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT1]);
if (row[JOB_REQ_BLOCKID])
job->blockid = xstrdup(row[JOB_REQ_BLOCKID]);
job->eligible = slurm_atoul(row[JOB_REQ_ELIGIBLE]);
job->submit = submit;
job->start = slurm_atoul(row[JOB_REQ_START]);
job->end = slurm_atoul(row[JOB_REQ_END]);
job->timelimit = slurm_atoul(row[JOB_REQ_TIMELIMIT]);
/* since the job->end could be set later end it here */
if (job->end) {
job_ended = 1;
if (!job->start || (job->start > job->end))
job->start = job->end;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (job->start && (job->start < job_cond->usage_start))
job->start = job_cond->usage_start;
if (!job->end || job->end > job_cond->usage_end)
job->end = job_cond->usage_end;
if (!job->start)
job->start = job->end;
job->elapsed = job->end - job->start;
if (row[JOB_REQ_SUSPENDED]) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
/* get the suspended time for this job */
query = xstrdup_printf(
"select time_start, time_end from "
"\"%s_%s\" where "
"(time_start < %ld && (time_end >= %ld "
"|| time_end = 0)) && job_db_inx=%s "
"order by time_start",
cluster_name, suspend_table,
job_cond->usage_end,
job_cond->usage_start,
id);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE,
__LINE__, query);
if (!(result2 = mysql_db_query_ret(
mysql_conn,
query, 0))) {
list_destroy(job_list);
job_list = NULL;
break;
}
xfree(query);
while ((row2 = mysql_fetch_row(result2))) {
time_t local_start =
slurm_atoul(row2[0]);
time_t local_end =
slurm_atoul(row2[1]);
if (!local_start)
continue;
if (job->start > local_start)
local_start = job->start;
if (job->end < local_end)
local_end = job->end;
if ((local_end - local_start) < 1)
continue;
job->elapsed -=
(local_end - local_start);
job->suspended +=
(local_end - local_start);
}
mysql_free_result(result2);
}
} else {
job->suspended = slurm_atoul(row[JOB_REQ_SUSPENDED]);
/* fix the suspended number to be correct */
if (job->state == JOB_SUSPENDED)
job->suspended = now - job->suspended;
if (!job->start) {
job->elapsed = 0;
} else if (!job->end) {
job->elapsed = now - job->start;
} else {
job->elapsed = job->end - job->start;
}
job->elapsed -= job->suspended;
}
if ((int)job->elapsed < 0)
job->elapsed = 0;
job->jobid = curr_id;
job->jobname = xstrdup(row[JOB_REQ_NAME]);
job->gid = slurm_atoul(row[JOB_REQ_GID]);
job->exitcode = slurm_atoul(row[JOB_REQ_EXIT_CODE]);
job->derived_ec = slurm_atoul(row[JOB_REQ_DERIVED_EC]);
job->derived_es = xstrdup(row[JOB_REQ_DERIVED_ES]);
if (row[JOB_REQ_PARTITION])
job->partition = xstrdup(row[JOB_REQ_PARTITION]);
if (row[JOB_REQ_NODELIST])
job->nodes = xstrdup(row[JOB_REQ_NODELIST]);
if (!job->nodes || !strcmp(job->nodes, "(null)")) {
xfree(job->nodes);
job->nodes = xstrdup("(unknown)");
}
job->track_steps = slurm_atoul(row[JOB_REQ_TRACKSTEPS]);
job->priority = slurm_atoul(row[JOB_REQ_PRIORITY]);
job->req_cpus = slurm_atoul(row[JOB_REQ_REQ_CPUS]);
job->requid = slurm_atoul(row[JOB_REQ_KILL_REQUID]);
job->qosid = slurm_atoul(row[JOB_REQ_QOS]);
job->show_full = 1;
if (only_pending || (job_cond && job_cond->without_steps))
goto skip_steps;
if (job_cond && job_cond->step_list
&& list_count(job_cond->step_list)) {
set = 0;
itr = list_iterator_create(job_cond->step_list);
while ((selected_step = list_next(itr))) {
if (selected_step->jobid != job->jobid) {
continue;
} else if (selected_step->stepid == NO_VAL) {
job->show_full = 1;
break;
} else if (selected_step->stepid == INFINITE)
selected_step->stepid =
SLURM_BATCH_SCRIPT;
if (set)
xstrcat(extra, " || ");
else
xstrcat(extra, " && (");
/* The stepid could be -2 so use %d not %u */
xstrfmtcat(extra, "t1.id_step=%d",
selected_step->stepid);
set = 1;
job->show_full = 0;
}
list_iterator_destroy(itr);
if (set)
xstrcat(extra, ")");
}
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"where t1.job_db_inx=%s",
step_fields, cluster_name,
step_table, id);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(step_result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Querying the steps in the fashion was faster than
doing only 1 query and then matching the steps up
later with the job.
*/
while ((step_row = mysql_fetch_row(step_result))) {
/* check the bitmap to see if this is one of the steps
we are looking for */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
step_row[STEP_REQ_NODE_INX],
submit))
continue;
step = slurmdb_create_step_rec();
step->tot_cpu_sec = 0;
step->tot_cpu_usec = 0;
step->job_ptr = job;
if (!job->first_step_ptr)
job->first_step_ptr = step;
list_append(job->steps, step);
step->stepid = slurm_atoul(step_row[STEP_REQ_STEPID]);
/* info("got step %u.%u", */
/* job->header.jobnum, step->stepnum); */
step->state = slurm_atoul(step_row[STEP_REQ_STATE]);
step->exitcode =
slurm_atoul(step_row[STEP_REQ_EXIT_CODE]);
step->ncpus = slurm_atoul(step_row[STEP_REQ_CPUS]);
step->nnodes = slurm_atoul(step_row[STEP_REQ_NODES]);
step->ntasks = slurm_atoul(step_row[STEP_REQ_TASKS]);
step->task_dist =
slurm_atoul(step_row[STEP_REQ_TASKDIST]);
if (!step->ntasks)
step->ntasks = step->ncpus;
step->start = slurm_atoul(step_row[STEP_REQ_START]);
step->end = slurm_atoul(step_row[STEP_REQ_END]);
/* if the job has ended end the step also */
if (!step->end && job_ended) {
step->end = job->end;
step->state = job->state;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (step->start
&& (step->start < job_cond->usage_start))
step->start = job_cond->usage_start;
if (!step->start && step->end)
step->start = step->end;
if (!step->end
|| (step->end > job_cond->usage_end))
step->end = job_cond->usage_end;
}
/* figure this out by start stop */
step->suspended =
slurm_atoul(step_row[STEP_REQ_SUSPENDED]);
if (!step->end) {
step->elapsed = now - step->start;
} else {
step->elapsed = step->end - step->start;
}
step->elapsed -= step->suspended;
if ((int)step->elapsed < 0)
step->elapsed = 0;
step->user_cpu_sec =
slurm_atoul(step_row[STEP_REQ_USER_SEC]);
step->user_cpu_usec =
slurm_atoul(step_row[STEP_REQ_USER_USEC]);
step->sys_cpu_sec =
slurm_atoul(step_row[STEP_REQ_SYS_SEC]);
step->sys_cpu_usec =
slurm_atoul(step_row[STEP_REQ_SYS_USEC]);
step->tot_cpu_sec +=
step->user_cpu_sec + step->sys_cpu_sec;
step->tot_cpu_usec +=
step->user_cpu_usec + step->sys_cpu_usec;
step->stats.vsize_max =
slurm_atoul(step_row[STEP_REQ_MAX_VSIZE]);
step->stats.vsize_max_taskid =
slurm_atoul(step_row[STEP_REQ_MAX_VSIZE_TASK]);
step->stats.vsize_ave =
atof(step_row[STEP_REQ_AVE_VSIZE]);
step->stats.rss_max =
slurm_atoul(step_row[STEP_REQ_MAX_RSS]);
step->stats.rss_max_taskid =
slurm_atoul(step_row[STEP_REQ_MAX_RSS_TASK]);
step->stats.rss_ave =
atof(step_row[STEP_REQ_AVE_RSS]);
step->stats.pages_max =
slurm_atoul(step_row[STEP_REQ_MAX_PAGES]);
step->stats.pages_max_taskid =
slurm_atoul(step_row[STEP_REQ_MAX_PAGES_TASK]);
step->stats.pages_ave =
atof(step_row[STEP_REQ_AVE_PAGES]);
step->stats.cpu_min =
slurm_atoul(step_row[STEP_REQ_MIN_CPU]);
step->stats.cpu_min_taskid =
slurm_atoul(step_row[STEP_REQ_MIN_CPU_TASK]);
step->stats.cpu_ave = atof(step_row[STEP_REQ_AVE_CPU]);
step->stepname = xstrdup(step_row[STEP_REQ_NAME]);
step->nodes = xstrdup(step_row[STEP_REQ_NODELIST]);
step->stats.vsize_max_nodeid =
slurm_atoul(step_row[STEP_REQ_MAX_VSIZE_NODE]);
step->stats.rss_max_nodeid =
slurm_atoul(step_row[STEP_REQ_MAX_RSS_NODE]);
step->stats.pages_max_nodeid =
slurm_atoul(step_row[STEP_REQ_MAX_PAGES_NODE]);
step->stats.cpu_min_nodeid =
slurm_atoul(step_row[STEP_REQ_MIN_CPU_NODE]);
step->requid =
slurm_atoul(step_row[STEP_REQ_KILL_REQUID]);
}
mysql_free_result(step_result);
if (!job->track_steps) {
/* If we don't have track_steps we want to see
if we have multiple steps. If we only have
1 step check the job name against the step
name in most all cases it will be
different. If it is different print out
the step separate.
*/
if (list_count(job->steps) > 1)
job->track_steps = 1;
else if (step && step->stepname && job->jobname) {
if (strcmp(step->stepname, job->jobname))
job->track_steps = 1;
}
}
skip_steps:
/* need to reset here to make the above test valid */
step = NULL;
}
mysql_free_result(result);
end_it:
if (local_cluster_list)
list_destroy(local_cluster_list);
if (rc == SLURM_SUCCESS)
list_transfer(sent_list, job_list);
list_destroy(job_list);
return rc;
}
int main_loop( CamConfig *ccfg, Socket *picture_sock, char *picture_mem ){
Socket *listen_socket;
SockSet *readset = NULL, *writeset = NULL;
list_t *client_sockets;
lnode_t *node;
int cfg_listen_port, highest_fd, picture_client_ready;
int num_sclients, num_clients;
ClientInfo *clientinfo, *clientinfo2;
if( (client_sockets = list_create( -1 )) == NULL)
return -1;
cfg_listen_port = camconfig_query_def_int( ccfg, SEC_SOCKET,
"listen_port",
CAMCONFIG_DEF_LISTEN_PORT );
if( (readset = sockset_new()) == NULL ||
(writeset = sockset_new()) == NULL )
{
camserv_log( MODNAME, "Error allocating memory for socksets!");
if( readset ) sockset_dest( readset );
if( writeset ) sockset_dest( writeset );
list_destroy( client_sockets );
return -1;
}
if((listen_socket = socket_serve_tcp( NULL, cfg_listen_port, 100 )) == NULL )
{
camserv_log( MODNAME, "Error setting up socket on port \"%d\". Exiting",
cfg_listen_port );
list_destroy( client_sockets );
sockset_dest( readset );
sockset_dest( writeset );
return -1;
}
highest_fd = MAX( socket_query_fd( listen_socket ),
socket_query_fd( picture_sock ));
clientinfo = clientinfo_new( listen_socket );
clientinfo2 = clientinfo_new( picture_sock );
if( !clientinfo || !clientinfo2 ||
sockset_add_fd( readset, listen_socket, clientinfo ) == -1 ||
sockset_add_fd( readset, picture_sock, clientinfo2 ) == -1 )
{
camserv_log( MODNAME, "Error adding initial sockets to sockset!");
sockset_dest( readset );
sockset_dest( writeset );
if( clientinfo ) clientinfo_dest( clientinfo );
if( clientinfo2 ) clientinfo_dest( clientinfo2 );
list_destroy( client_sockets );
return -1;
}
num_clients = 0;
num_sclients = 0;
picture_client_ready = 1;
setup_signals();
Abort = 0;
while( !Abort ){
int sel_res, i, nset_socks;
void **set_socks;
/* Only need to execute this if we have a streaming client */
if( (num_sclients > 0) && picture_client_ready == 1 ){
send( socket_query_fd( picture_sock ), "0", sizeof( "0" ), 0 );
picture_client_ready = 0;
}
sockset_reset( readset );
sockset_reset( writeset );
sel_res = sockset_select( highest_fd + 1, readset, writeset, NULL );
/* Service the event */
if( sel_res == -1 ){
camserv_log( MODNAME, "select() failure: %s", strerror( errno ));
break;
} else if( sel_res == 0 ){
camserv_log( MODNAME, "Unexpected select() fall through!" );
continue;
}
/* Readable sockets */
set_socks = sockset_query_socks( readset );
nset_socks = sockset_query_nsocks( readset );
for( i=0; i< nset_socks; i++ ){
ClientInfo *new_cinfo;
clientinfo = set_socks[ i ];
if( clientinfo->socket == listen_socket ) {
/* New client */
if( (new_cinfo = accept_client( listen_socket )) == NULL )
continue;
if( (node = lnode_create( new_cinfo )) == NULL ){
clientinfo_dest( new_cinfo );
continue;
}
if( sockset_add_fd( readset, new_cinfo->socket, new_cinfo ) == -1 ){
camserv_log( MODNAME, "Failed to add socket %d to socket read set!",
socket_query_fd( new_cinfo->socket ));
clientinfo_dest( new_cinfo );
lnode_destroy( node );
continue;
}
if( socket_query_fd( new_cinfo->socket ) > highest_fd )
highest_fd = socket_query_fd( new_cinfo->socket );
list_append( client_sockets, node );
num_clients++;
/* Init resource limit for this client */
new_cinfo->create_time = time( NULL );
new_cinfo->bytes = 0;
new_cinfo->frames = 0;
new_cinfo->max_seconds = camconfig_query_def_int( ccfg, SEC_SOCKET,
"max_seconds", 0 );
new_cinfo->max_bytes = camconfig_query_def_int( ccfg, SEC_SOCKET,
"max_bytes", 0 );
new_cinfo->max_frames = camconfig_query_def_int( ccfg, SEC_SOCKET,
"max_frames", 0 );
/* Send fresh request for a picture */
send( socket_query_fd( picture_sock ), "0", sizeof( "0" ), 0 );
picture_client_ready = 0;
/* Put this read socket on hold until the picture comes back */
sockset_hold( readset, new_cinfo->socket );
} else {
char cmdbuf[ 1024 ];
int readlen;
clientinfo = set_socks[ i ];
/* Regular joe client, set readable */
if( (readlen = read( socket_query_fd( clientinfo->socket), cmdbuf,
sizeof( cmdbuf ) - 1)) <= 0 )
{
camserv_log( MODNAME, "Closing socket: %s",
socket_query_remote_name( clientinfo->socket ));
if (clientinfo->client_type == CLIENT_T_BROWSER ||
clientinfo->client_type == CLIENT_T_PROXY) {
num_sclients--;
}
client_remove( client_sockets, clientinfo );
sockset_del_fd( readset, clientinfo->socket );
sockset_unhold_all( writeset );
sockset_del_fd( writeset, clientinfo->socket );
clientinfo_dest( clientinfo );
num_clients--;
} else {
if( clientinfo->socket == picture_sock ) {
if( dispatch_pictaker( cmdbuf, picture_mem ) == -1 )
camserv_log( MODNAME, "Pictaker dispatch failure!");
sockset_unhold_all( writeset );
/* Release the read hold as the picture has now been taken */
sockset_unhold_all( readset );
picture_client_ready = 1;
} else {
/* Information from a regular client */
cmdbuf[ readlen ] = '\0';
if( clientinfo->client_type == CLIENT_T_UNINIT ) {
char *preamble;
int pre_size;
/* Figure out what type of client we have */
if( !strncmp( cmdbuf, "GET", 3 )) {
if( strstr( cmdbuf, "/singleframe" )) {
clientinfo->client_type = CLIENT_T_SINGLE;
} else {
clientinfo->client_type = CLIENT_T_BROWSER;
num_sclients++;
}
} else if( !strncmp( cmdbuf, "PROXY", 5 )) {
clientinfo->client_type = CLIENT_T_PROXY;
/* Here we are in the same state as being done writing a pic */
clientinfo->state = CINFO_STATE_PICTURE;
num_sclients++;
databuf_buf_set( clientinfo->writebuf, NULL, 0 );
} else
clientinfo->client_type = CLIENT_T_BROWSER;
if( clientinfo->client_type != CLIENT_T_PROXY ) {
/* Send the initial preamble. Only now we can decide which
type of preamble to send (single vs. multi-part) */
if( clientinfo->client_type == CLIENT_T_SINGLE )
preamble = get_single_preamble_text( &pre_size );
else
preamble = get_multi_preamble_text( &pre_size );
databuf_buf_set( clientinfo->writebuf, preamble, pre_size );
}
if( sockset_add_fd( writeset, clientinfo->socket,
clientinfo ) == -1 )
{
camserv_log( MODNAME, "Failed to add socket %d to write set!",
socket_query_fd( clientinfo->socket ));
}
}
}
}
}
}
if( set_socks != NULL ) free( set_socks );
/* Writable sockets */
set_socks = sockset_query_socks( writeset );
nset_socks = sockset_query_nsocks( writeset );
for( i=0; i< nset_socks; i++ ){
ClientInfo *cinfo;
cinfo = set_socks[ i ];
if( cinfo->client_type == CLIENT_T_BROWSER ||
cinfo->client_type == CLIENT_T_SINGLE )
{
int result;
if( (result = write_regular_client( cinfo, writeset )) != 0 ){
/* result: 1=close requested, -1=error detected */
if( result == -1 )
camserv_log( MODNAME, "Databuf write error on socket: %s\n",
socket_query_remote_name( cinfo->socket ));
if (cinfo->client_type == CLIENT_T_BROWSER) {
num_sclients--;
}
client_remove( client_sockets, cinfo );
sockset_del_fd( readset, cinfo->socket );
sockset_del_fd( writeset, cinfo->socket );
clientinfo_dest( cinfo );
num_clients--;
}
} else {
if( write_proxy_client( cinfo, writeset ) == -1 ){
camserv_log( MODNAME, "Databuf write error on socket: %d",
socket_query_fd( cinfo->socket ));
/* Should be proxy, but better check */
if (cinfo->client_type == CLIENT_T_PROXY) {
num_sclients--;
}
client_remove( client_sockets, cinfo );
sockset_del_fd( readset, cinfo->socket );
sockset_del_fd( writeset, cinfo->socket );
clientinfo_dest( cinfo );
num_clients--;
}
}
}
if( set_socks != NULL ) free( set_socks );
}
camserv_log( MODNAME, "Aborting.");
sockset_dest( readset );
sockset_dest( writeset );
for( node = list_first( client_sockets) ; node;
node=list_next( client_sockets, node ))
{
clientinfo_dest( node->data );
}
/* Tell the picture taker to get out! Get out! */
camserv_log( MODNAME, "Closing picture taker");
send( socket_query_fd( picture_sock ), "9", sizeof( "9" ), 0 );
sleep( 3 );
camserv_log( MODNAME, "done\n");
list_destroy_nodes( client_sockets );
list_destroy( client_sockets );
socket_dest( listen_socket );
return 0;
}
static void _layout_conf_dbd(GtkTreeStore *treestore)
{
ListIterator itr = NULL;
GtkTreeIter iter;
config_key_pair_t *key_pair;
int update = 0;
time_t now = time(NULL);
char tmp_str[128], *user_name = NULL;
List dbd_config_list = NULL;
/* first load accounting parms from slurm.conf */
char *acct_storage_backup_host =
slurm_get_accounting_storage_backup_host();
char *acct_storage_host = slurm_get_accounting_storage_host();
char *acct_storage_loc = slurm_get_accounting_storage_loc();
char *acct_storage_pass = slurm_get_accounting_storage_pass();
uint32_t acct_storage_port = slurm_get_accounting_storage_port();
char *acct_storage_type = slurm_get_accounting_storage_type();
char *acct_storage_user = slurm_get_accounting_storage_user();
char *auth_type = slurm_get_auth_type();
uint16_t msg_timeout = slurm_get_msg_timeout();
char *plugin_dir = slurm_get_plugin_dir();
uint16_t private_data = slurm_get_private_data();
uint32_t slurm_user_id = slurm_get_slurm_user_id();
uint16_t track_wckey = slurm_get_track_wckey();
slurm_make_time_str(&now, tmp_str, sizeof(tmp_str));
add_display_treestore_line_with_font(
update, treestore, &iter,
"SLURM Configuration data as of", tmp_str, "bold");
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageBackupHost",
acct_storage_backup_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageHost", acct_storage_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageLoc", acct_storage_loc);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePass", acct_storage_pass);
sprintf(tmp_str, "%u", acct_storage_port);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePort", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageType", acct_storage_type);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageUser", acct_storage_user);
add_display_treestore_line(update, treestore, &iter,
"AuthType", auth_type);
sprintf(tmp_str, "%u sec", msg_timeout);
add_display_treestore_line(update, treestore, &iter,
"MessageTimeout", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"PluginDir", plugin_dir);
private_data_string(private_data, tmp_str, sizeof(tmp_str));
add_display_treestore_line(update, treestore, &iter,
"PrivateData", tmp_str);
user_name = uid_to_string(slurm_user_id);
sprintf(tmp_str, "%s(%u)", user_name, slurm_user_id);
xfree(user_name);
add_display_treestore_line(update, treestore, &iter,
"SlurmUserId", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"SLURM_CONF", default_slurm_config_file);
add_display_treestore_line(update, treestore, &iter,
"SLURM_VERSION", SLURM_VERSION_STRING);
sprintf(tmp_str, "%u", track_wckey);
add_display_treestore_line(update, treestore, &iter,
"TrackWCKey", tmp_str);
xfree(acct_storage_backup_host);
xfree(acct_storage_host);
xfree(acct_storage_loc);
xfree(acct_storage_pass);
xfree(acct_storage_type);
xfree(acct_storage_user);
xfree(auth_type);
xfree(plugin_dir);
/* now load accounting parms from slurmdbd.conf */
/* second load slurmdbd.conf parms */
if (!(dbd_config_list = slurmdb_config_get(NULL)))
return;
add_display_treestore_line_with_font(
update, treestore, &iter,
"\nSlurmDBD Configuration:", NULL, "bold");
itr = list_iterator_create(dbd_config_list);
while ((key_pair = list_next(itr))) {
add_display_treestore_line(update, treestore, &iter,
key_pair->name,
key_pair->value);
}
list_iterator_destroy(itr);
}
void print_fields(type_t type, void *object)
{
if (!object) {
fatal ("Job or step record is NULL");
return;
}
slurmdb_job_rec_t *job = (slurmdb_job_rec_t *)object;
slurmdb_step_rec_t *step = (slurmdb_step_rec_t *)object;
jobcomp_job_rec_t *job_comp = (jobcomp_job_rec_t *)object;
print_field_t *field = NULL;
int curr_inx = 1;
struct passwd *pw = NULL;
struct group *gr = NULL;
char outbuf[FORMAT_STRING_SIZE];
bool got_stats = false;
int cpu_tres_rec_count = 0;
int step_cpu_tres_rec_count = 0;
switch(type) {
case JOB:
step = NULL;
if (!job->track_steps)
step = (slurmdb_step_rec_t *)job->first_step_ptr;
/* set this to avoid printing out info for things that
don't mean anything. Like an allocation that never
ran anything.
*/
if (!step)
job->track_steps = 1;
else
step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU);
if (job->stats.cpu_min != NO_VAL)
got_stats = true;
job_comp = NULL;
cpu_tres_rec_count = slurmdb_find_tres_count_in_string(
(job->tres_alloc_str && job->tres_alloc_str[0]) ?
job->tres_alloc_str : job->tres_req_str,
TRES_CPU);
break;
case JOBSTEP:
job = step->job_ptr;
if (step->stats.cpu_min != NO_VAL)
got_stats = true;
if ((step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU)) == INFINITE64)
step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
(job->tres_alloc_str &&
job->tres_alloc_str[0]) ?
job->tres_alloc_str : job->tres_req_str,
TRES_CPU);
job_comp = NULL;
break;
case JOBCOMP:
job = NULL;
step = NULL;
break;
default:
break;
}
if ((uint64_t)cpu_tres_rec_count == INFINITE64)
cpu_tres_rec_count = 0;
if ((uint64_t)step_cpu_tres_rec_count == INFINITE64)
step_cpu_tres_rec_count = 0;
list_iterator_reset(print_fields_itr);
while((field = list_next(print_fields_itr))) {
char *tmp_char = NULL, id[FORMAT_STRING_SIZE];
int tmp_int = NO_VAL, tmp_int2 = NO_VAL;
double tmp_dub = (double)NO_VAL; /* don't use NO_VAL64
unless we can
confirm the values
coming in are
NO_VAL64 */
uint32_t tmp_uint32 = NO_VAL;
uint64_t tmp_uint64 = NO_VAL64;
memset(&outbuf, 0, sizeof(outbuf));
switch(field->type) {
case PRINT_ALLOC_CPUS:
switch(type) {
case JOB:
tmp_int = cpu_tres_rec_count;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_int = step_cpu_tres_rec_count;
break;
case JOBCOMP:
default:
tmp_int = job_comp->proc_cnt;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_ALLOC_GRES:
switch(type) {
case JOB:
tmp_char = job->alloc_gres;
break;
case JOBSTEP:
tmp_char = step->job_ptr->alloc_gres;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_ALLOC_NODES:
switch(type) {
case JOB:
tmp_int = job->alloc_nodes;
tmp_char = job->tres_alloc_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ACCOUNT:
switch(type) {
case JOB:
tmp_char = job->account;
break;
case JOBSTEP:
tmp_char = step->job_ptr->account;
break;
case JOBCOMP:
default:
tmp_char = "n/a";
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_ACT_CPUFREQ:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub =
step->stats.act_cpufreq;
break;
case JOBSTEP:
tmp_dub = step->stats.act_cpufreq;
break;
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit2((double)tmp_dub,
outbuf, sizeof(outbuf),
UNIT_KILO, 1000,
params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ASSOCID:
switch(type) {
case JOB:
tmp_int = job->associd;
break;
case JOBSTEP:
tmp_int = step->job_ptr->associd;
break;
case JOBCOMP:
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_AVECPU:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.cpu_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.cpu_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
tmp_char = _elapsed_time((long)tmp_dub, 0);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_AVEDISKREAD:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_read_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_read_ave;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEDISKWRITE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_write_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_write_ave;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEPAGES:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.pages_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.pages_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVERSS:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.rss_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.rss_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEVSIZE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.vsize_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.vsize_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_BLOCKID:
switch(type) {
case JOB:
tmp_char = job->blockid;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->blockid;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_CLUSTER:
switch(type) {
case JOB:
tmp_char = job->cluster;
break;
case JOBSTEP:
tmp_char = step->job_ptr->cluster;
break;
case JOBCOMP:
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_COMMENT:
switch(type) {
case JOB:
tmp_char = job->derived_es;
break;
case JOBSTEP:
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub = step->
stats.consumed_energy;
break;
case JOBSTEP:
tmp_dub = step->stats.consumed_energy;
break;
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit2((double)tmp_dub,
outbuf, sizeof(outbuf),
UNIT_NONE, 1000,
params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY_RAW:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub = step->
stats.consumed_energy;
break;
case JOBSTEP:
tmp_dub = step->stats.consumed_energy;
break;
default:
break;
}
}
field->print_routine(field,
tmp_dub,
(curr_inx == field_count));
break;
case PRINT_CPU_TIME:
switch(type) {
case JOB:
tmp_uint64 = (uint64_t)job->elapsed
* (uint64_t)cpu_tres_rec_count;
break;
case JOBSTEP:
tmp_uint64 = (uint64_t)step->elapsed
* (uint64_t)step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_CPU_TIME_RAW:
switch(type) {
case JOB:
tmp_uint64 = (uint64_t)job->elapsed
* (uint64_t)cpu_tres_rec_count;
break;
case JOBSTEP:
tmp_uint64 = (uint64_t)step->elapsed
* (uint64_t)step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_DERIVED_EC:
tmp_int2 = 0;
switch(type) {
case JOB:
tmp_int = job->derived_ec;
if (tmp_int == NO_VAL)
tmp_int = 0;
if (WIFSIGNALED(tmp_int))
tmp_int2 = WTERMSIG(tmp_int);
snprintf(outbuf, sizeof(outbuf), "%d:%d",
WEXITSTATUS(tmp_int), tmp_int2);
break;
case JOBSTEP:
case JOBCOMP:
default:
outbuf[0] = '\0';
break;
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ELAPSED:
switch(type) {
case JOB:
tmp_int = job->elapsed;
break;
case JOBSTEP:
tmp_int = step->elapsed;
break;
case JOBCOMP:
tmp_int = job_comp->elapsed_time;
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_ELIGIBLE:
switch(type) {
case JOB:
tmp_int = job->eligible;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_END:
switch(type) {
case JOB:
tmp_int = job->end;
break;
case JOBSTEP:
tmp_int = step->end;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->end_time, 1);
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_EXITCODE:
tmp_int = 0;
tmp_int2 = 0;
switch(type) {
case JOB:
tmp_int = job->exitcode;
break;
case JOBSTEP:
tmp_int = step->exitcode;
break;
case JOBCOMP:
default:
break;
}
if (tmp_int != NO_VAL) {
if (WIFSIGNALED(tmp_int))
tmp_int2 = WTERMSIG(tmp_int);
tmp_int = WEXITSTATUS(tmp_int);
if (tmp_int >= 128)
tmp_int -= 128;
}
snprintf(outbuf, sizeof(outbuf), "%d:%d",
tmp_int, tmp_int2);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_GID:
switch(type) {
case JOB:
tmp_int = job->gid;
break;
case JOBSTEP:
tmp_int = NO_VAL;
break;
case JOBCOMP:
tmp_int = job_comp->gid;
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_GROUP:
switch(type) {
case JOB:
tmp_int = job->gid;
break;
case JOBSTEP:
tmp_int = NO_VAL;
break;
case JOBCOMP:
tmp_int = job_comp->gid;
break;
default:
tmp_int = NO_VAL;
break;
}
tmp_char = NULL;
if ((gr=getgrgid(tmp_int)))
tmp_char=gr->gr_name;
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_JOBID:
if (type == JOBSTEP)
job = step->job_ptr;
if (job) {
if (job->array_task_str) {
_xlate_task_str(job);
snprintf(id, FORMAT_STRING_SIZE,
"%u_[%s]",
job->array_job_id,
job->array_task_str);
} else if (job->array_task_id != NO_VAL)
snprintf(id, FORMAT_STRING_SIZE,
"%u_%u",
job->array_job_id,
job->array_task_id);
else
snprintf(id, FORMAT_STRING_SIZE,
"%u",
job->jobid);
}
switch (type) {
case JOB:
tmp_char = xstrdup(id);
break;
case JOBSTEP:
if (step->stepid == SLURM_BATCH_SCRIPT) {
tmp_char = xstrdup_printf(
"%s.batch", id);
} else if (step->stepid == SLURM_EXTERN_CONT) {
tmp_char = xstrdup_printf(
"%s.extern", id);
} else {
tmp_char = xstrdup_printf(
"%s.%u",
id, step->stepid);
}
break;
case JOBCOMP:
tmp_char = xstrdup_printf("%u",
job_comp->jobid);
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_JOBIDRAW:
switch (type) {
case JOB:
tmp_char = xstrdup_printf("%u", job->jobid);
break;
case JOBSTEP:
if (step->stepid == SLURM_BATCH_SCRIPT) {
tmp_char = xstrdup_printf(
"%u.batch",
step->job_ptr->jobid);
} else if (step->stepid == SLURM_EXTERN_CONT) {
tmp_char = xstrdup_printf(
"%u.extern",
step->job_ptr->jobid);
} else {
tmp_char = xstrdup_printf(
"%u.%u",
step->job_ptr->jobid,
step->stepid);
}
break;
case JOBCOMP:
tmp_char = xstrdup_printf("%u",
job_comp->jobid);
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_JOBNAME:
switch(type) {
case JOB:
tmp_char = job->jobname;
break;
case JOBSTEP:
tmp_char = step->stepname;
break;
case JOBCOMP:
tmp_char = job_comp->jobname;
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_LAYOUT:
switch(type) {
case JOB:
/* below really should be step. It is
not a typo */
if (!job->track_steps)
tmp_char = slurm_step_layout_type_name(
step->task_dist);
break;
case JOBSTEP:
tmp_char = slurm_step_layout_type_name(
step->task_dist);
break;
case JOBCOMP:
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREAD:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_read_max;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_read_max;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREADNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
disk_read_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.
disk_read_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKREADTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
disk_read_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
disk_read_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.
disk_write_max;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_write_max;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITENODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
disk_write_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.
disk_write_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKWRITETASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
disk_write_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
disk_write_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXPAGES:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 =
job->stats.pages_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.pages_max;
break;
case JOBCOMP:
default:
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXPAGESNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
pages_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.pages_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXPAGESTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
pages_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
pages_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXRSS:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 = job->stats.rss_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.rss_max;
break;
case JOBCOMP:
default:
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXRSSNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
rss_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.rss_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXRSSTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 = job->stats.
rss_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.rss_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 = job->stats.
vsize_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.vsize_max;
break;
case JOBCOMP:
default:
tmp_uint64 = (uint64_t)NO_VAL64;
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZENODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
vsize_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.vsize_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXVSIZETASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
vsize_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
vsize_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MINCPU:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.cpu_min;
break;
case JOBSTEP:
tmp_dub = step->stats.cpu_min;
break;
case JOBCOMP:
default:
break;
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
tmp_char = _elapsed_time(
(long)tmp_dub, 0);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
cpu_min_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.cpu_min_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 = job->stats.
cpu_min_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.cpu_min_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_NODELIST:
switch(type) {
case JOB:
tmp_char = job->nodes;
break;
case JOBSTEP:
tmp_char = step->nodes;
break;
case JOBCOMP:
tmp_char = job_comp->nodelist;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_NNODES:
switch(type) {
case JOB:
tmp_int = job->alloc_nodes;
tmp_char = (job->tres_alloc_str &&
job->tres_alloc_str[0])
? job->tres_alloc_str :
job->tres_req_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_NTASKS:
switch(type) {
case JOB:
if (!job->track_steps && !step)
tmp_int = cpu_tres_rec_count;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_int = step->ntasks;
break;
case JOBCOMP:
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_PRIO:
switch(type) {
case JOB:
tmp_int = job->priority;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_PARTITION:
switch(type) {
case JOB:
tmp_char = job->partition;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->partition;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_QOS:
switch(type) {
case JOB:
tmp_int = job->qosid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
if (!g_qos_list) {
slurmdb_qos_cond_t qos_cond;
memset(&qos_cond, 0,
sizeof(slurmdb_qos_cond_t));
qos_cond.with_deleted = 1;
g_qos_list = slurmdb_qos_get(
acct_db_conn, &qos_cond);
}
tmp_char = _find_qos_name_from_list(g_qos_list,
tmp_int);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_QOSRAW:
switch(type) {
case JOB:
tmp_int = job->qosid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MIN:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_min;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MAX:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_max;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_GOV:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_gov;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUS:
switch(type) {
case JOB:
tmp_int = job->req_cpus;
break;
case JOBSTEP:
tmp_int = step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_REQ_GRES:
switch(type) {
case JOB:
tmp_char = job->req_gres;
break;
case JOBSTEP:
tmp_char = step->job_ptr->req_gres;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_REQ_MEM:
switch(type) {
case JOB:
tmp_uint32 = job->req_mem;
break;
case JOBSTEP:
tmp_uint32 = step->job_ptr->req_mem;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 != (uint32_t)NO_VAL) {
bool per_cpu = false;
if (tmp_uint32 & MEM_PER_CPU) {
tmp_uint32 &= (~MEM_PER_CPU);
per_cpu = true;
}
convert_num_unit((double)tmp_uint32,
outbuf, sizeof(outbuf),
UNIT_MEGA,
params.convert_flags);
if (per_cpu)
sprintf(outbuf+strlen(outbuf), "c");
else
sprintf(outbuf+strlen(outbuf), "n");
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_NODES:
switch(type) {
case JOB:
tmp_int = 0;
tmp_char = job->tres_req_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_RESERVATION:
switch(type) {
case JOB:
if (job->resv_name) {
tmp_char = job->resv_name;
} else {
tmp_char = NULL;
}
break;
case JOBSTEP:
tmp_char = NULL;
break;
case JOBCOMP:
tmp_char = NULL;
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_RESERVATION_ID:
switch(type) {
case JOB:
if (job->resvid)
tmp_uint32 = job->resvid;
else
tmp_uint32 = NO_VAL;
break;
case JOBSTEP:
tmp_uint32 = NO_VAL;
break;
case JOBCOMP:
tmp_uint32 = NO_VAL;
break;
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_RESV:
switch(type) {
case JOB:
if (job->start)
tmp_int = job->start - job->eligible;
else
tmp_int = time(NULL) - job->eligible;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_RESV_CPU:
switch(type) {
case JOB:
if (job->start)
tmp_int = (job->start - job->eligible)
* job->req_cpus;
else
tmp_int = (time(NULL) - job->eligible)
* job->req_cpus;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_RESV_CPU_RAW:
switch(type) {
case JOB:
if (job->start)
tmp_int = (job->start - job->eligible)
* job->req_cpus;
else
tmp_int = (time(NULL) - job->eligible)
* job->req_cpus;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_START:
switch(type) {
case JOB:
tmp_int = job->start;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->start_time, 1);
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_STATE:
switch(type) {
case JOB:
tmp_int = job->state;
tmp_int2 = job->requid;
break;
case JOBSTEP:
tmp_int = step->state;
tmp_int2 = step->requid;
break;
case JOBCOMP:
tmp_char = job_comp->state;
break;
default:
break;
}
if (((tmp_int & JOB_STATE_BASE) == JOB_CANCELLED) &&
(tmp_int2 != -1))
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s by %d",
job_state_string(tmp_int),
tmp_int2);
else if (tmp_int != NO_VAL)
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s",
job_state_string(tmp_int));
else if (tmp_char)
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s",
tmp_char);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_SUBMIT:
switch(type) {
case JOB:
tmp_int = job->submit;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->start_time, 1);
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_SUSPENDED:
switch(type) {
case JOB:
tmp_int = job->suspended;
break;
case JOBSTEP:
tmp_int = step->suspended;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_SYSTEMCPU:
if (got_stats) {
switch(type) {
case JOB:
tmp_int = job->sys_cpu_sec;
tmp_int2 = job->sys_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->sys_cpu_sec;
tmp_int2 = step->sys_cpu_usec;
break;
case JOBCOMP:
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TIMELIMIT:
switch(type) {
case JOB:
if (job->timelimit == INFINITE)
tmp_char = "UNLIMITED";
else if (job->timelimit == NO_VAL)
tmp_char = "Partition_Limit";
else if (job->timelimit) {
char tmp1[128];
mins2time_str(job->timelimit,
tmp1, sizeof(tmp1));
tmp_char = tmp1;
}
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->timelimit;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_TOTALCPU:
switch(type) {
case JOB:
tmp_int = job->tot_cpu_sec;
tmp_int2 = job->tot_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->tot_cpu_sec;
tmp_int2 = step->tot_cpu_usec;
break;
case JOBCOMP:
break;
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TRESA:
switch(type) {
case JOB:
tmp_char = job->tres_alloc_str;
break;
case JOBSTEP:
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
if (!g_tres_list) {
slurmdb_tres_cond_t tres_cond;
memset(&tres_cond, 0,
sizeof(slurmdb_tres_cond_t));
tres_cond.with_deleted = 1;
g_tres_list = slurmdb_tres_get(
acct_db_conn, &tres_cond);
}
tmp_char = slurmdb_make_tres_string_from_simple(
tmp_char, g_tres_list);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TRESR:
switch(type) {
case JOB:
tmp_char = job->tres_req_str;
break;
case JOBSTEP:
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
if (!g_tres_list) {
slurmdb_tres_cond_t tres_cond;
memset(&tres_cond, 0,
sizeof(slurmdb_tres_cond_t));
tres_cond.with_deleted = 1;
g_tres_list = slurmdb_tres_get(
acct_db_conn, &tres_cond);
}
tmp_char = slurmdb_make_tres_string_from_simple(
tmp_char, g_tres_list);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_UID:
switch(type) {
case JOB:
if (job->user) {
if ((pw=getpwnam(job->user)))
tmp_int = pw->pw_uid;
} else
tmp_int = job->uid;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_int = job_comp->uid;
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_USER:
switch(type) {
case JOB:
if (job->user)
tmp_char = job->user;
else if (job->uid != -1) {
if ((pw=getpwuid(job->uid)))
tmp_char = pw->pw_name;
}
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->uid_name;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_USERCPU:
if (got_stats) {
switch(type) {
case JOB:
tmp_int = job->user_cpu_sec;
tmp_int2 = job->user_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->user_cpu_sec;
tmp_int2 = step->user_cpu_usec;
break;
case JOBCOMP:
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_WCKEY:
switch(type) {
case JOB:
tmp_char = job->wckey;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_WCKEYID:
switch(type) {
case JOB:
tmp_int = job->wckeyid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
default:
break;
}
curr_inx++;
}
printf("\n");
}
void *
cerebrod_event_server(void *arg)
{
int server_fd;
_event_server_initialize();
if ((server_fd = _event_server_setup_socket(0)) < 0)
CEREBRO_EXIT(("event server fd setup failed"));
for (;;)
{
ListIterator eitr;
struct cerebrod_event_connection_data *ecd;
struct pollfd *pfds;
int pfdslen = 0;
int i;
/* Note that the list_count won't grow larger after the first
* mutex block, b/c the cerebrod_event_queue_monitor thread can
* never add to the event_connections. It can only shrink it.
*/
Pthread_mutex_lock(&event_connections_lock);
if (event_connections)
pfdslen = List_count(event_connections);
Pthread_mutex_unlock(&event_connections_lock);
/* The + 1 is b/c of the server_fd. */
pfdslen++;
pfds = Malloc(sizeof(struct pollfd) * pfdslen);
memset(pfds, '\0', sizeof(struct pollfd) * pfdslen);
pfds[0].fd = server_fd;
pfds[0].events = POLLIN;
pfds[0].revents = 0;
/* No 'event_connections' if there are no events */
if (event_connections)
{
i = 1;
Pthread_mutex_lock(&event_connections_lock);
eitr = List_iterator_create(event_connections);
while ((ecd = list_next(eitr)))
{
pfds[i].fd = ecd->fd;
pfds[i].events = POLLIN;
pfds[i].revents = 0;
i++;
}
List_iterator_destroy(eitr);
Pthread_mutex_unlock(&event_connections_lock);
}
Poll(pfds, pfdslen, -1);
/* Deal with the server fd first */
if (pfds[0].revents & POLLERR)
CEREBRO_DBG(("server_fd POLLERR"));
else if (pfds[0].revents & POLLIN)
{
unsigned int client_addr_len;
int fd;
struct sockaddr_in client_addr;
client_addr_len = sizeof(struct sockaddr_in);
if ((fd = accept(server_fd,
(struct sockaddr *)&client_addr,
&client_addr_len)) < 0)
server_fd = cerebrod_reinit_socket(server_fd,
0,
_event_server_setup_socket,
"event_server: accept");
if (fd >= 0)
_event_server_service_connection(fd);
}
/* Deal with the connecting fds */
for (i = 1; i < pfdslen; i++)
{
if (pfds[i].revents & POLLERR)
{
CEREBRO_DBG(("fd = %d POLLERR", pfds[i].fd));
Pthread_mutex_lock(&event_connections_lock);
_delete_event_connection_fd(pfds[i].fd);
Pthread_mutex_unlock(&event_connections_lock);
continue;
}
if (pfds[i].revents & POLLIN)
{
char buf[CEREBRO_MAX_PACKET_LEN];
int n;
/* We should not expect any actual data. If
* we get some, just eat it and move on.
*
* The common situation is that the client
* closes the connection. So we need to delete
* our fd.
*/
n = fd_read_n(pfds[i].fd,
buf,
CEREBRO_MAX_PACKET_LEN);
if (n < 0)
CEREBRO_DBG(("fd_read_n = %s", strerror(errno)));
if (n <= 0)
{
#if CEREBRO_DEBUG
if (conf.debug && conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Event Server Close Fd: %d\n", pfds[i].fd);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
#endif /* CEREBRO_DEBUG */
Pthread_mutex_lock(&event_connections_lock);
_delete_event_connection_fd(pfds[i].fd);
Pthread_mutex_unlock(&event_connections_lock);
}
}
}
Free(pfds);
}
return NULL; /* NOT REACHED */
}
int mm_unmap_keep_pages(struct mm_struct *mm, uintptr_t addr, size_t len)
{
uintptr_t start = ROUNDDOWN(addr, PGSIZE), end =
ROUNDUP(addr + len, PGSIZE);
if (!USER_ACCESS(start, end)) {
return -E_INVAL;
}
assert(mm != NULL);
struct vma_struct *vma;
if ((vma = find_vma(mm, start)) == NULL || end <= vma->vm_start) {
return 0;
}
if (vma->vm_start < start && end < vma->vm_end) {
struct vma_struct *nvma;
if ((nvma =
vma_create(vma->vm_start, start, vma->vm_flags)) == NULL) {
return -E_NO_MEM;
}
vma_copymapfile(nvma, vma);
vma_resize(vma, end, vma->vm_end);
insert_vma_struct(mm, nvma);
return 0;
}
list_entry_t free_list, *le;
list_init(&free_list);
while (vma->vm_start < end) {
le = list_next(&(vma->list_link));
remove_vma_struct(mm, vma);
list_add(&free_list, &(vma->list_link));
if (le == &(mm->mmap_list)) {
break;
}
vma = le2vma(le, list_link);
}
le = list_next(&free_list);
while (le != &free_list) {
vma = le2vma(le, list_link);
le = list_next(le);
uintptr_t un_start, un_end;
if (vma->vm_start < start) {
un_start = start, un_end = vma->vm_end;
vma_resize(vma, vma->vm_start, un_start);
insert_vma_struct(mm, vma);
} else {
un_start = vma->vm_start, un_end = vma->vm_end;
if (end < un_end) {
un_end = end;
vma_resize(vma, un_end, vma->vm_end);
insert_vma_struct(mm, vma);
} else {
vma_unmapfile(vma);
vma_destroy(vma);
}
}
//unmap_range(mm->pgdir, un_start, un_end);
}
return 0;
}
static int _load_fed_parts(slurm_msg_t *req_msg,
partition_info_msg_t **part_info_msg_pptr,
uint16_t show_flags, char *cluster_name,
slurmdb_federation_rec_t *fed)
{
int cluster_inx = 0, i;
load_part_resp_struct_t *part_resp;
partition_info_msg_t *orig_msg = NULL, *new_msg = NULL;
uint32_t new_rec_cnt;
slurmdb_cluster_rec_t *cluster;
ListIterator iter;
pthread_attr_t load_attr;
int pthread_count = 0;
pthread_t *load_thread = 0;
load_part_req_struct_t *load_args;
List resp_msg_list;
*part_info_msg_pptr = NULL;
/* Spawn one pthread per cluster to collect partition information */
resp_msg_list = list_create(NULL);
load_thread = xmalloc(sizeof(pthread_attr_t) *
list_count(fed->cluster_list));
iter = list_iterator_create(fed->cluster_list);
while ((cluster = (slurmdb_cluster_rec_t *) list_next(iter))) {
int retries = 0;
if ((cluster->control_host == NULL) ||
(cluster->control_host[0] == '\0'))
continue; /* Cluster down */
load_args = xmalloc(sizeof(load_part_req_struct_t));
load_args->cluster = cluster;
load_args->cluster_inx = cluster_inx++;
load_args->req_msg = req_msg;
load_args->resp_msg_list = resp_msg_list;
load_args->show_flags = show_flags;
slurm_attr_init(&load_attr);
if (pthread_attr_setdetachstate(&load_attr,
PTHREAD_CREATE_JOINABLE))
error("pthread_attr_setdetachstate error %m");
while (pthread_create(&load_thread[pthread_count], &load_attr,
_load_part_thread, (void *) load_args)) {
error("pthread_create error %m");
if (++retries > MAX_RETRIES)
fatal("Can't create pthread");
usleep(10000); /* sleep and retry */
}
pthread_count++;
slurm_attr_destroy(&load_attr);
}
list_iterator_destroy(iter);
/* Wait for all pthreads to complete */
for (i = 0; i < pthread_count; i++)
pthread_join(load_thread[i], NULL);
xfree(load_thread);
/* Maintain a consistent cluster/node ordering */
list_sort(resp_msg_list, _sort_by_cluster_inx);
/* Merge the responses into a single response message */
iter = list_iterator_create(resp_msg_list);
while ((part_resp = (load_part_resp_struct_t *) list_next(iter))) {
new_msg = part_resp->new_msg;
if (!orig_msg) {
orig_msg = new_msg;
*part_info_msg_pptr = orig_msg;
} else {
/* Merge the node records */
orig_msg->last_update = MIN(orig_msg->last_update,
new_msg->last_update);
new_rec_cnt = orig_msg->record_count +
new_msg->record_count;
if (new_msg->record_count) {
orig_msg->partition_array =
xrealloc(orig_msg->partition_array,
sizeof(partition_info_t) *
new_rec_cnt);
(void) memcpy(orig_msg->partition_array +
orig_msg->record_count,
new_msg->partition_array,
sizeof(partition_info_t) *
new_msg->record_count);
orig_msg->record_count = new_rec_cnt;
}
xfree(new_msg->partition_array);
xfree(new_msg);
}
xfree(part_resp);
}
list_iterator_destroy(iter);
FREE_NULL_LIST(resp_msg_list);
if (!orig_msg)
slurm_seterrno_ret(SLURM_ERROR);
return SLURM_PROTOCOL_SUCCESS;
}
void get_command(void)
{
char com[255];
int text_width, text_startx;
allocated_block_t *allocated_block = NULL;
int i = 0;
int count = 0;
WINDOW *command_win = NULL;
List allocated_blocks = NULL;
ListIterator results_i;
if (params.commandline && !params.command) {
printf("Configure won't work with commandline mode.\n");
printf("Please remove the -c from the commandline.\n");
bg_configure_ba_fini();
exit(0);
}
if (working_cluster_rec) {
char *cluster_name = slurm_get_cluster_name();
if (strcmp(working_cluster_rec->name, cluster_name)) {
xfree(cluster_name);
endwin();
printf("To use the configure option you must be on the "
"cluster the configure is for.\nCross cluster "
"support doesn't exist today.\nSorry for the "
"inconvenince.\n");
bg_configure_ba_fini();
exit(0);
}
xfree(cluster_name);
}
bg_configure_ba_setup_wires();
color_count = 0;
allocated_blocks = list_create(_destroy_allocated_block);
if (params.commandline) {
snprintf(com, sizeof(com), "%s", params.command);
goto run_command;
} else {
/* make sure we don't get any noisy debug */
ba_configure_set_ba_debug_flags(0);
text_width = text_win->_maxx;
text_startx = text_win->_begx;
command_win = newwin(3, text_width - 1, LINES - 4,
text_startx + 1);
curs_set(1);
echo();
}
while (strcmp(com, "quit")) {
clear_window(grid_win);
print_grid();
clear_window(text_win);
box(text_win, 0, 0);
box(grid_win, 0, 0);
if (!params.no_header)
_print_header_command();
if (error_string != NULL) {
i = 0;
while (error_string[i] != '\0') {
if (error_string[i] == '\n') {
main_ycord++;
main_xcord=1;
i++;
}
mvwprintw(text_win,
main_ycord,
main_xcord,
"%c",
error_string[i++]);
main_xcord++;
}
main_ycord++;
main_xcord = 1;
memset(error_string, 0, 255);
}
results_i = list_iterator_create(allocated_blocks);
count = list_count(allocated_blocks)
- (LINES-(main_ycord+5));
if (count<0)
count=0;
i=0;
while ((allocated_block = list_next(results_i)) != NULL) {
if (i >= count)
_print_text_command(allocated_block);
i++;
}
list_iterator_destroy(results_i);
wnoutrefresh(text_win);
wnoutrefresh(grid_win);
doupdate();
clear_window(command_win);
box(command_win, 0, 0);
mvwprintw(command_win, 0, 3,
"Input Command: (type quit to change view, "
"exit to exit)");
wmove(command_win, 1, 1);
wgetstr(command_win, com);
if (!strcmp(com, "exit")) {
endwin();
if (allocated_blocks)
list_destroy(allocated_blocks);
bg_configure_ba_fini();
exit(0);
}
run_command:
if (!strcmp(com, "quit") || !strcmp(com, "\\q")) {
break;
} else if (!strncasecmp(com, "layout", 6)) {
_set_layout(com);
} else if (!strncasecmp(com, "basepartition", 13)) {
_set_base_part_cnt(com);
} else if (!strncasecmp(com, "nodecard", 8)) {
_set_nodecard_cnt(com);
} else if (!strncasecmp(com, "resolve", 7) ||
!strncasecmp(com, "r ", 2)) {
_resolve(com);
} else if (!strncasecmp(com, "resume", 6)) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%s", com);
} else if (!strncasecmp(com, "drain", 5)) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%s", com);
} else if (!strncasecmp(com, "alldown", 7)) {
_change_state_all_bps(com, NODE_STATE_DOWN);
} else if (!strncasecmp(com, "down", 4)) {
_change_state_bps(com, NODE_STATE_DOWN);
} else if (!strncasecmp(com, "allup", 5)) {
_change_state_all_bps(com, NODE_STATE_IDLE);
} else if (!strncasecmp(com, "up", 2)) {
_change_state_bps(com, NODE_STATE_IDLE);
} else if (!strncasecmp(com, "remove", 6)
|| !strncasecmp(com, "delete", 6)
|| !strncasecmp(com, "drop", 4)) {
_remove_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "create", 6)) {
_create_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "copy", 4)
|| !strncasecmp(com, "c ", 2)
|| !strncasecmp(com, "c\0", 2)) {
_copy_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "save", 4)) {
_save_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "load", 4)) {
_load_configuration(com, allocated_blocks);
} else if (!strncasecmp(com, "clear all", 9)
|| !strncasecmp(com, "clear", 5)) {
list_flush(allocated_blocks);
} else {
memset(error_string, 0, 255);
sprintf(error_string, "Unknown command '%s'",com);
}
if (params.commandline) {
bg_configure_ba_fini();
exit(1);
}
}
if (allocated_blocks)
list_destroy(allocated_blocks);
params.display = 0;
noecho();
clear_window(text_win);
main_xcord = 1;
main_ycord = 1;
curs_set(0);
print_date();
get_job();
return;
}
/* Restituisce il primo tcb_t della coda la cui testa è puntata da head.
Il tcb_t non viene però rimosso dalla coda. Restituisce NULL la coda
è vuota*/
tcb_t *headThread(struct list_head *head) {
return container_of(list_next(head), typeof(tcb_t), t_next);
}
/*
* We don't use the api here because it does things we aren't needing
* like printing out information and not returning times.
*/
local_cluster_rec_t *_job_will_run (job_desc_msg_t *req)
{
slurm_msg_t req_msg, resp_msg;
will_run_response_msg_t *will_run_resp;
int rc;
char buf[64];
char *type = "processors";
local_cluster_rec_t *local_cluster = NULL;
/* req.immediate = true; implicit */
slurm_msg_t_init(&req_msg);
req_msg.msg_type = REQUEST_JOB_WILL_RUN;
req_msg.data = req;
rc = slurm_send_recv_controller_msg(&req_msg, &resp_msg);
if (rc < 0) {
slurm_seterrno(SLURM_SOCKET_ERROR);
return NULL;
}
switch (resp_msg.msg_type) {
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno(rc);
break;
case RESPONSE_JOB_WILL_RUN:
if (working_cluster_rec->flags & CLUSTER_FLAG_BG)
type = "cnodes";
will_run_resp = (will_run_response_msg_t *) resp_msg.data;
slurm_make_time_str(&will_run_resp->start_time,
buf, sizeof(buf));
debug("Job %u to start at %s on cluster %s using %u %s on %s",
will_run_resp->job_id, buf, working_cluster_rec->name,
will_run_resp->proc_cnt, type,
will_run_resp->node_list);
local_cluster = xmalloc(sizeof(local_cluster_rec_t));
local_cluster->cluster_rec = working_cluster_rec;
local_cluster->start_time = will_run_resp->start_time;
if (will_run_resp->preemptee_job_id) {
local_cluster->preempt_cnt =
list_count(will_run_resp->preemptee_job_id);
if (opt.verbose >= LOG_LEVEL_DEBUG) {
ListIterator itr;
uint32_t *job_id_ptr;
char *job_list = NULL, *sep = "";
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u",
sep, *job_id_ptr);
}
debug(" Preempts: %s", job_list);
xfree(job_list);
}
}
slurm_free_will_run_response_msg(will_run_resp);
break;
default:
slurm_seterrno(SLURM_UNEXPECTED_MSG_ERROR);
return NULL;
break;
}
return local_cluster;
}