extern void add_extra_bluegene_buttons(List *button_list, int inx, int *color_inx) { block_info_msg_t *block_ptr = NULL; block_info_t *bg_info_ptr = NULL; int rc = SLURM_SUCCESS; ListIterator itr = NULL; grid_button_t *grid_button = NULL; grid_button_t *send_grid_button = NULL; int i=0; char *mp_str = NULL; char tmp_nodes[256]; int found = 0; int coord_y=0; uint16_t orig_state; rc = get_new_info_block(&block_ptr, 0); if ((rc != SLURM_SUCCESS) && (rc != SLURM_NO_CHANGE_IN_DATA)) { return; } if (!*button_list) *button_list = list_create(NULL); *color_inx %= sview_colors_cnt; itr = list_iterator_create(grid_button_list); while ((grid_button = list_next(itr))) { if (grid_button->inx == inx) break; } list_iterator_destroy(itr); if (!grid_button) return; orig_state = grid_button->state; /* remove all (if any) buttons pointing to this node since we will be creating all of them */ itr = list_iterator_create(*button_list); while ((send_grid_button = list_next(itr))) { if (send_grid_button->inx == grid_button->inx) list_remove(itr); } list_iterator_destroy(itr); for (i=0; i < block_ptr->record_count; i++) { bg_info_ptr = &block_ptr->block_array[i]; if (!_block_in_node(bg_info_ptr->mp_inx, inx)) continue; found = 1; mp_str = bg_info_ptr->mp_str; if (bg_info_ptr->ionode_str) { sprintf(tmp_nodes, "%s[%s]", mp_str, bg_info_ptr->ionode_str); mp_str = tmp_nodes; } if (bg_info_ptr->state & BG_BLOCK_ERROR_FLAG) grid_button->state = NODE_STATE_ERROR; else if (list_count(bg_info_ptr->job_list)) grid_button->state = NODE_STATE_ALLOCATED; else grid_button->state = NODE_STATE_IDLE; send_grid_button = create_grid_button_from_another( grid_button, mp_str, *color_inx); grid_button->state = orig_state; if (send_grid_button) { send_grid_button->button_list = *button_list; send_grid_button->table_x = 0; send_grid_button->table_y = coord_y++; //_add_button_signals(send_grid_button); /* this is a different signal than usual */ g_signal_connect( G_OBJECT(send_grid_button->button), "button-press-event", G_CALLBACK(_open_block), send_grid_button); g_signal_connect(G_OBJECT(grid_button->button), "enter-notify-event", G_CALLBACK(_mouseover_node), grid_button); g_signal_connect(G_OBJECT(grid_button->button), "leave-notify-event", G_CALLBACK(_mouseoff_node), grid_button); list_append(*button_list, send_grid_button); (*color_inx)++; } } if (!found) { send_grid_button = create_grid_button_from_another( grid_button, grid_button->node_name, *color_inx); if (send_grid_button) { send_grid_button->button_list = *button_list; send_grid_button->table_x = 0; send_grid_button->table_y = coord_y++; _add_button_signals(send_grid_button); list_append(*button_list, send_grid_button); (*color_inx)++; } } }
/* * 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; }
/* NOTE: Insure that mysql_conn->lock is NOT set on function entry */ static int _mysql_make_table_current(mysql_conn_t *mysql_conn, char *table_name, storage_field_t *fields, char *ending) { char *query = NULL; char *correct_query = NULL; MYSQL_RES *result = NULL; MYSQL_ROW row; int i = 0; List columns = NULL; ListIterator itr = NULL; char *col = NULL; int adding = 0; int run_update = 0; char *primary_key = NULL; char *unique_index = NULL; int old_primary = 0; char *old_index = NULL; char *temp = NULL; DEF_TIMERS; /* figure out the keys in the table */ query = xstrdup_printf("show index from %s", table_name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); return SLURM_ERROR; } xfree(query); while ((row = mysql_fetch_row(result))) { // row[2] is the key name if (!strcasecmp(row[2], "PRIMARY")) old_primary = 1; else if (!old_index) old_index = xstrdup(row[2]); } mysql_free_result(result); /* figure out the existing columns in the table */ query = xstrdup_printf("show columns from %s", table_name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); xfree(old_index); return SLURM_ERROR; } xfree(query); columns = list_create(slurm_destroy_char); while ((row = mysql_fetch_row(result))) { col = xstrdup(row[0]); //Field list_append(columns, col); } mysql_free_result(result); itr = list_iterator_create(columns); query = xstrdup_printf("alter table %s", table_name); correct_query = xstrdup_printf("alter table %s", table_name); START_TIMER; while (fields[i].name) { int found = 0; list_iterator_reset(itr); while ((col = list_next(itr))) { if (!strcmp(col, fields[i].name)) { xstrfmtcat(query, " modify %s %s,", fields[i].name, fields[i].options); xstrfmtcat(correct_query, " modify %s %s,", fields[i].name, fields[i].options); list_delete_item(itr); found = 1; break; } } if (!found) { if (i) { info("adding column %s after %s in table %s", fields[i].name, fields[i-1].name, table_name); xstrfmtcat(query, " add %s %s after %s,", fields[i].name, fields[i].options, fields[i-1].name); xstrfmtcat(correct_query, " modify %s %s,", fields[i].name, fields[i].options); } else { info("adding column %s at the beginning " "of table %s", fields[i].name, table_name); xstrfmtcat(query, " add %s %s first,", fields[i].name, fields[i].options); xstrfmtcat(correct_query, " modify %s %s,", fields[i].name, fields[i].options); } adding = 1; } i++; } list_iterator_reset(itr); while ((col = list_next(itr))) { adding = 1; info("dropping column %s from table %s", col, table_name); xstrfmtcat(query, " drop %s,", col); } list_iterator_destroy(itr); list_destroy(columns); if ((temp = strstr(ending, "primary key ("))) { int open = 0, close =0; int end = 0; while (temp[end++]) { if (temp[end] == '(') open++; else if (temp[end] == ')') close++; else continue; if (open == close) break; } if (temp[end]) { end++; primary_key = xstrndup(temp, end); if (old_primary) { xstrcat(query, " drop primary key,"); xstrcat(correct_query, " drop primary key,"); } xstrfmtcat(query, " add %s,", primary_key); xstrfmtcat(correct_query, " add %s,", primary_key); xfree(primary_key); } } if ((temp = strstr(ending, "unique index ("))) { int open = 0, close =0; int end = 0; while (temp[end++]) { if (temp[end] == '(') open++; else if (temp[end] == ')') close++; else continue; if (open == close) break; } if (temp[end]) { end++; unique_index = xstrndup(temp, end); if (old_index) { xstrfmtcat(query, " drop index %s,", old_index); xstrfmtcat(correct_query, " drop index %s,", old_index); } xstrfmtcat(query, " add %s,", unique_index); xstrfmtcat(correct_query, " add %s,", unique_index); xfree(unique_index); } } xfree(old_index); query[strlen(query)-1] = ';'; correct_query[strlen(correct_query)-1] = ';'; //info("%d query\n%s", __LINE__, query); /* see if we have already done this definition */ if (!adding) { char *quoted = slurm_add_slash_to_quotes(query); char *query2 = xstrdup_printf("select table_name from " "%s where definition='%s'", table_defs_table, quoted); MYSQL_RES *result = NULL; MYSQL_ROW row; xfree(quoted); run_update = 1; if ((result = mysql_db_query_ret(mysql_conn, query2, 0))) { if ((row = mysql_fetch_row(result))) run_update = 0; mysql_free_result(result); } xfree(query2); if (run_update) { run_update = 2; query2 = xstrdup_printf("select table_name from " "%s where table_name='%s'", table_defs_table, table_name); if ((result = mysql_db_query_ret( mysql_conn, query2, 0))) { if ((row = mysql_fetch_row(result))) run_update = 1; mysql_free_result(result); } xfree(query2); } } /* if something has changed run the alter line */ if (run_update || adding) { time_t now = time(NULL); char *query2 = NULL; char *quoted = NULL; if (run_update == 2) debug4("Table %s doesn't exist, adding", table_name); else debug("Table %s has changed. Updating...", table_name); if (mysql_db_query(mysql_conn, query)) { xfree(query); return SLURM_ERROR; } quoted = slurm_add_slash_to_quotes(correct_query); query2 = xstrdup_printf("insert into %s (creation_time, " "mod_time, table_name, definition) " "values (%ld, %ld, '%s', '%s') " "on duplicate key update " "definition='%s', mod_time=%ld;", table_defs_table, now, now, table_name, quoted, quoted, now); xfree(quoted); if (mysql_db_query(mysql_conn, query2)) { xfree(query2); return SLURM_ERROR; } xfree(query2); } xfree(query); xfree(correct_query); query = xstrdup_printf("make table current %s", table_name); END_TIMER2(query); xfree(query); return SLURM_SUCCESS; }
extern int sacctmgr_modify_job(int argc, char **argv) { int rc = SLURM_SUCCESS; slurmdb_job_modify_cond_t *job_cond = xmalloc(sizeof( slurmdb_job_modify_cond_t)); slurmdb_job_rec_t *job = slurmdb_create_job_rec(); int i=0; int cond_set = 0, rec_set = 0, set = 0; List ret_list = NULL; for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) { i++; cond_set += _set_cond(&i, argc, argv, job_cond); } else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) { i++; rec_set += _set_rec(&i, argc, argv, job); } else { cond_set += _set_cond(&i, argc, argv, job_cond); } } if (exit_code) { slurmdb_destroy_job_modify_cond(job_cond); slurmdb_destroy_job_rec(job); return SLURM_ERROR; } else if (!rec_set) { exit_code=1; fprintf(stderr, " You didn't give me anything to set\n"); slurmdb_destroy_job_modify_cond(job_cond); slurmdb_destroy_job_rec(job); return SLURM_ERROR; } else if (!cond_set) { if (!commit_check("You didn't set any conditions with 'WHERE'." "\nAre you sure you want to continue?")) { printf("Aborted\n"); slurmdb_destroy_job_modify_cond(job_cond); slurmdb_destroy_job_rec(job); return SLURM_SUCCESS; } } notice_thread_init(); ret_list = acct_storage_g_modify_job(db_conn, my_uid, job_cond, job); if (ret_list && list_count(ret_list)) { char *object = NULL; ListIterator itr = list_iterator_create(ret_list); printf(" Modified jobs...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); set = 1; } else if (ret_list) { printf(" Nothing modified\n"); rc = SLURM_ERROR; } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } FREE_NULL_LIST(ret_list); notice_thread_fini(); if (set) { if (commit_check("Would you like to commit changes?")) acct_storage_g_commit(db_conn, 1); else { printf(" Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); } } slurmdb_destroy_job_modify_cond(job_cond); slurmdb_destroy_job_rec(job); return rc; }
extern void jag_common_poll_data( List task_list, bool pgid_plugin, uint64_t cont_id, jag_callbacks_t *callbacks) { /* Update the data */ List prec_list = NULL; uint32_t total_job_mem = 0, total_job_vsize = 0; ListIterator itr; ListIterator itr2; jag_prec_t *prec = NULL; struct jobacctinfo *jobacct = NULL; static int processing = 0; char sbuf[72]; int energy_counted = 0; static int first = 1; xassert(callbacks); if (!pgid_plugin && (cont_id == (uint64_t)NO_VAL)) { debug("cont_id hasn't been set yet not running poll"); return; } if (processing) { debug("already running, returning"); return; } processing = 1; if (!callbacks->get_precs) callbacks->get_precs = _get_precs; prec_list = (*(callbacks->get_precs))(task_list, pgid_plugin, cont_id, callbacks); if (!list_count(prec_list) || !task_list || !list_count(task_list)) goto finished; /* We have no business being here! */ itr = list_iterator_create(task_list); while ((jobacct = list_next(itr))) { itr2 = list_iterator_create(prec_list); while ((prec = list_next(itr2))) { if (prec->pid == jobacct->pid) { uint32_t cpu_calc = (prec->ssec + prec->usec)/hertz; #if _DEBUG info("pid:%u ppid:%u rss:%d KB", prec->pid, prec->ppid, prec->rss); #endif /* find all my descendents */ if (callbacks->get_offspring_data) (*(callbacks->get_offspring_data)) (prec_list, prec, prec->pid); /* tally their usage */ jobacct->max_rss = MAX(jobacct->max_rss, prec->rss); jobacct->tot_rss = prec->rss; total_job_mem += prec->rss; jobacct->max_vsize = MAX(jobacct->max_vsize, prec->vsize); jobacct->tot_vsize = prec->vsize; total_job_vsize += prec->vsize; jobacct->max_pages = MAX(jobacct->max_pages, prec->pages); jobacct->tot_pages = prec->pages; jobacct->max_disk_read = MAX( jobacct->max_disk_read, prec->disk_read); jobacct->tot_disk_read = prec->disk_read; jobacct->max_disk_write = MAX( jobacct->max_disk_write, prec->disk_write); jobacct->tot_disk_write = prec->disk_write; jobacct->min_cpu = MAX(jobacct->min_cpu, cpu_calc); jobacct->last_total_cputime = jobacct->tot_cpu; jobacct->tot_cpu = cpu_calc; debug2("%d mem size %u %u time %u(%u+%u)", jobacct->pid, jobacct->max_rss, jobacct->max_vsize, jobacct->tot_cpu, prec->usec, prec->ssec); /* compute frequency */ jobacct->this_sampled_cputime = cpu_calc - jobacct->last_total_cputime; _get_sys_interface_freq_line( prec->last_cpu, "cpuinfo_cur_freq", sbuf); jobacct->act_cpufreq = _update_weighted_freq(jobacct, sbuf); debug2("Task average frequency = %u " "pid %d mem size %u %u time %u(%u+%u)", jobacct->act_cpufreq, jobacct->pid, jobacct->max_rss, jobacct->max_vsize, jobacct->tot_cpu, prec->usec, prec->ssec); /* get energy consumption * only once is enough since we * report per node energy consumption */ debug2("energycounted = %d", energy_counted); if (energy_counted == 0) { acct_gather_energy_g_get_data( energy_profile, &jobacct->energy); debug2("getjoules_task energy = %u", jobacct->energy.consumed_energy); energy_counted = 1; } /* We only profile on after the first poll. */ if (!first) acct_gather_profile_g_add_sample_data( ACCT_GATHER_PROFILE_TASK, jobacct); break; } } list_iterator_destroy(itr2); } list_iterator_destroy(itr); jobacct_gather_handle_mem_limit(total_job_mem, total_job_vsize); finished: list_destroy(prec_list); processing = 0; first = 0; }
extern List filetxt_jobcomp_process_get_jobs(slurmdb_job_cond_t *job_cond) { char line[BUFFER_SIZE]; char *fptr = NULL, *filein = NULL; int jobid = 0; char *partition = NULL; FILE *fd = NULL; int lc = 0; jobcomp_job_rec_t *job = NULL; slurmdb_selected_step_t *selected_step = NULL; char *selected_part = NULL; ListIterator itr = NULL; List job_info_list = NULL; filetxt_jobcomp_info_t *jobcomp_info = NULL; List job_list = list_create(jobcomp_destroy_job); filein = slurm_get_jobcomp_loc(); fd = _open_log_file(filein); while (fgets(line, BUFFER_SIZE, fd)) { lc++; fptr = line; /* break the record into NULL- terminated strings */ FREE_NULL_LIST(job_info_list); jobid = 0; partition = NULL; job_info_list = list_create(_destroy_filetxt_jobcomp_info); while(fptr) { jobcomp_info = xmalloc(sizeof(filetxt_jobcomp_info_t)); list_append(job_info_list, jobcomp_info); jobcomp_info->name = fptr; fptr = strstr(fptr, "="); if (!fptr) break; *fptr++ = 0; jobcomp_info->val = fptr; fptr = strstr(fptr, " "); if (!xstrcasecmp("JobId", jobcomp_info->name)) jobid = atoi(jobcomp_info->val); else if (!xstrcasecmp("Partition", jobcomp_info->name)) partition = jobcomp_info->val; if (!fptr) { fptr = strstr(jobcomp_info->val, "\n"); if (fptr) *fptr = 0; break; } else { *fptr++ = 0; if (*fptr == '\n') { *fptr = 0; break; } } } if (job_cond->step_list && list_count(job_cond->step_list)) { if (!jobid) continue; itr = list_iterator_create(job_cond->step_list); while((selected_step = list_next(itr))) { if (selected_step->jobid == jobid) continue; /* job matches */ list_iterator_destroy(itr); goto foundjob; } list_iterator_destroy(itr); continue; /* no match */ } foundjob: if (job_cond->partition_list && list_count(job_cond->partition_list)) { if (!partition) continue; itr = list_iterator_create(job_cond->partition_list); while((selected_part = list_next(itr))) if (!xstrcasecmp(selected_part, partition)) { list_iterator_destroy(itr); goto foundp; } list_iterator_destroy(itr); continue; /* no match */ } foundp: job = _parse_line(job_info_list); if (job) list_append(job_list, job); } FREE_NULL_LIST(job_info_list); if (ferror(fd)) { perror(filein); xfree(filein); exit(1); } fclose(fd); xfree(filein); return job_list; }
/* * Read and process the bluegene.conf configuration file so to interpret what * blocks are static/dynamic, torus/mesh, etc. */ extern int read_bg_conf(void) { int i; bool tmp_bool = 0; int count = 0; s_p_hashtbl_t *tbl = NULL; char *tmp_char = NULL; select_ba_request_t **blockreq_array = NULL; image_t **image_array = NULL; image_t *image = NULL; static time_t last_config_update = (time_t) 0; struct stat config_stat; ListIterator itr = NULL; char* bg_conf_file = NULL; static int *dims = NULL; if (!dims) dims = select_g_ba_get_dims(); if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("Reading the bluegene.conf file"); /* check if config file has changed */ bg_conf_file = get_extra_conf_path("bluegene.conf"); if (stat(bg_conf_file, &config_stat) < 0) fatal("can't stat bluegene.conf file %s: %m", bg_conf_file); if (last_config_update) { _reopen_bridge_log(); if (last_config_update == config_stat.st_mtime) { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("%s unchanged", bg_conf_file); } else { info("Restart slurmctld for %s changes " "to take effect", bg_conf_file); } last_config_update = config_stat.st_mtime; xfree(bg_conf_file); return SLURM_SUCCESS; } last_config_update = config_stat.st_mtime; /* initialization */ /* bg_conf defined in bg_node_alloc.h */ if (!(tbl = config_make_tbl(bg_conf_file))) fatal("something wrong with opening/reading bluegene " "conf file"); xfree(bg_conf_file); #ifdef HAVE_BGL if (s_p_get_array((void ***)&image_array, &count, "AltBlrtsImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->blrts_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_blrtsimage, "BlrtsImage", tbl)) { if (!list_count(bg_conf->blrts_list)) fatal("BlrtsImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->blrts_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_blrtsimage = xstrdup(image->name); info("Warning: using %s as the default BlrtsImage. " "If this isn't correct please set BlrtsImage", bg_conf->default_blrtsimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default BlrtsImage %s", bg_conf->default_blrtsimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_blrtsimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->blrts_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltLinuxImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->linux_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_linuximage, "LinuxImage", tbl)) { if (!list_count(bg_conf->linux_list)) fatal("LinuxImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->linux_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_linuximage = xstrdup(image->name); info("Warning: using %s as the default LinuxImage. " "If this isn't correct please set LinuxImage", bg_conf->default_linuximage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default LinuxImage %s", bg_conf->default_linuximage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_linuximage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->linux_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltRamDiskImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->ramdisk_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_ramdiskimage, "RamDiskImage", tbl)) { if (!list_count(bg_conf->ramdisk_list)) fatal("RamDiskImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->ramdisk_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_ramdiskimage = xstrdup(image->name); info("Warning: using %s as the default RamDiskImage. " "If this isn't correct please set RamDiskImage", bg_conf->default_ramdiskimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default RamDiskImage %s", bg_conf->default_ramdiskimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_ramdiskimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->ramdisk_list, image); } #elif defined HAVE_BGP if (s_p_get_array((void ***)&image_array, &count, "AltCnloadImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->linux_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_linuximage, "CnloadImage", tbl)) { if (!list_count(bg_conf->linux_list)) fatal("CnloadImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->linux_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_linuximage = xstrdup(image->name); info("Warning: using %s as the default CnloadImage. " "If this isn't correct please set CnloadImage", bg_conf->default_linuximage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default CnloadImage %s", bg_conf->default_linuximage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_linuximage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->linux_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltIoloadImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->ramdisk_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_ramdiskimage, "IoloadImage", tbl)) { if (!list_count(bg_conf->ramdisk_list)) fatal("IoloadImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->ramdisk_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_ramdiskimage = xstrdup(image->name); info("Warning: using %s as the default IoloadImage. " "If this isn't correct please set IoloadImage", bg_conf->default_ramdiskimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default IoloadImage %s", bg_conf->default_ramdiskimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_ramdiskimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->ramdisk_list, image); } #endif if (s_p_get_array((void ***)&image_array, &count, "AltMloaderImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->mloader_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_mloaderimage, "MloaderImage", tbl)) { if (!list_count(bg_conf->mloader_list)) fatal("MloaderImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->mloader_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_mloaderimage = xstrdup(image->name); info("Warning: using %s as the default MloaderImage. " "If this isn't correct please set MloaderImage", bg_conf->default_mloaderimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default MloaderImage %s", bg_conf->default_mloaderimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_mloaderimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->mloader_list, image); } if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt, "MidplaneNodeCnt", tbl)) { if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt, "BasePartitionNodeCnt", tbl)) { error("MidplaneNodeCnt not configured in bluegene.conf " "defaulting to 512 as MidplaneNodeCnt"); bg_conf->mp_cnode_cnt = 512; } } if (bg_conf->mp_cnode_cnt <= 0) fatal("You should have more than 0 nodes " "per base partition"); bg_conf->actual_cnodes_per_mp = bg_conf->mp_cnode_cnt; bg_conf->quarter_cnode_cnt = bg_conf->mp_cnode_cnt/4; /* bg_conf->cpus_per_mp should had already been set from the * node_init */ if (bg_conf->cpus_per_mp < bg_conf->mp_cnode_cnt) { fatal("For some reason we have only %u cpus per mp, but " "have %u cnodes per mp. You need at least the same " "number of cpus as you have cnodes per mp. " "Check the NodeName CPUs= " "definition in the slurm.conf.", bg_conf->cpus_per_mp, bg_conf->mp_cnode_cnt); } bg_conf->cpu_ratio = bg_conf->cpus_per_mp/bg_conf->mp_cnode_cnt; if (!bg_conf->cpu_ratio) fatal("We appear to have less than 1 cpu on a cnode. " "You specified %u for BasePartitionNodeCnt " "in the blugene.conf and %u cpus " "for each node in the slurm.conf", bg_conf->mp_cnode_cnt, bg_conf->cpus_per_mp); num_unused_cpus = 1; for (i = 0; i<SYSTEM_DIMENSIONS; i++) num_unused_cpus *= dims[i]; num_unused_cpus *= bg_conf->cpus_per_mp; num_possible_unused_cpus = num_unused_cpus; if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt, "NodeBoardNodeCnt", tbl)) { if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt, "NodeCardNodeCnt", tbl)) { error("NodeCardNodeCnt not configured in bluegene.conf " "defaulting to 32 as NodeCardNodeCnt"); bg_conf->nodecard_cnode_cnt = 32; } } if (bg_conf->nodecard_cnode_cnt <= 0) fatal("You should have more than 0 nodes per nodecard"); bg_conf->mp_nodecard_cnt = bg_conf->mp_cnode_cnt / bg_conf->nodecard_cnode_cnt; if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "IONodesPerMP", tbl)) if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "Numpsets", tbl)) fatal("Warning: IONodesPerMP not configured " "in bluegene.conf"); s_p_get_uint16(&bg_conf->max_block_err, "MaxBlockInError", tbl); tmp_bool = 0; s_p_get_boolean(&tmp_bool, "SubMidplaneSystem", tbl); bg_conf->sub_mp_sys = tmp_bool; #ifdef HAVE_BGQ tmp_bool = 0; s_p_get_boolean(&tmp_bool, "AllowSubBlockAllocations", tbl); bg_conf->sub_blocks = tmp_bool; /* You can only have 16 ionodes per midplane */ if (bg_conf->ionodes_per_mp > bg_conf->mp_nodecard_cnt) bg_conf->ionodes_per_mp = bg_conf->mp_nodecard_cnt; #endif for (i=0; i<SYSTEM_DIMENSIONS; i++) bg_conf->default_conn_type[i] = (uint16_t)NO_VAL; s_p_get_string(&tmp_char, "DefaultConnType", tbl); if (tmp_char) { verify_conn_type(tmp_char, bg_conf->default_conn_type); if ((bg_conf->default_conn_type[0] != SELECT_MESH) && (bg_conf->default_conn_type[0] != SELECT_TORUS)) fatal("Can't have a DefaultConnType of %s " "(only Mesh or Torus values are valid).", tmp_char); xfree(tmp_char); } else bg_conf->default_conn_type[0] = SELECT_TORUS; #ifndef HAVE_BG_L_P int first_conn_type = bg_conf->default_conn_type[0]; for (i=1; i<SYSTEM_DIMENSIONS; i++) { if (bg_conf->default_conn_type[i] == (uint16_t)NO_VAL) bg_conf->default_conn_type[i] = first_conn_type; else if (bg_conf->default_conn_type[i] >= SELECT_SMALL) fatal("Can't have a DefaultConnType of %s " "(only Mesh or Torus values are valid).", tmp_char); } #endif if (bg_conf->ionodes_per_mp) { bitstr_t *tmp_bitmap = NULL; int small_size = 1; /* THIS IS A HACK TO MAKE A 1 NODECARD SYSTEM WORK, * Sometime on a Q system the nodecard isn't in the 0 * spot so only do this if you know it is in that * spot. Otherwise say the whole midplane is there * and just make blocks over the whole thing. They * you can error out the blocks that aren't usable. */ if (bg_conf->sub_mp_sys && bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) { #ifdef HAVE_BGQ bg_conf->quarter_ionode_cnt = 1; bg_conf->nodecard_ionode_cnt = 1; #else bg_conf->quarter_ionode_cnt = 2; bg_conf->nodecard_ionode_cnt = 2; #endif } else { bg_conf->quarter_ionode_cnt = bg_conf->ionodes_per_mp/4; bg_conf->nodecard_ionode_cnt = bg_conf->quarter_ionode_cnt/4; } /* How many nodecards per ionode */ bg_conf->nc_ratio = ((double)bg_conf->mp_cnode_cnt / (double)bg_conf->nodecard_cnode_cnt) / (double)bg_conf->ionodes_per_mp; /* How many ionodes per nodecard */ bg_conf->io_ratio = (double)bg_conf->ionodes_per_mp / ((double)bg_conf->mp_cnode_cnt / (double)bg_conf->nodecard_cnode_cnt); /* How many cnodes per ionode */ bg_conf->ionode_cnode_cnt = bg_conf->nodecard_cnode_cnt * bg_conf->nc_ratio; //info("got %f %f", bg_conf->nc_ratio, bg_conf->io_ratio); /* figure out the smallest block we can have on the system */ #ifdef HAVE_BGL if (bg_conf->io_ratio >= 1) bg_conf->smallest_block=32; else bg_conf->smallest_block=128; #else if (bg_conf->io_ratio >= 2) bg_conf->smallest_block=16; else if (bg_conf->io_ratio == 1) bg_conf->smallest_block=32; else if (bg_conf->io_ratio == .5) bg_conf->smallest_block=64; else if (bg_conf->io_ratio == .25) bg_conf->smallest_block=128; else if (bg_conf->io_ratio == .125) bg_conf->smallest_block=256; else { error("unknown ioratio %f. Can't figure out " "smallest block size, setting it to midplane", bg_conf->io_ratio); bg_conf->smallest_block = 512; } #endif if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("Smallest block possible on this system is %u", bg_conf->smallest_block); /* below we are creating all the possible bitmaps for * each size of small block */ if ((int)bg_conf->nodecard_ionode_cnt < 1) { bg_conf->nodecard_ionode_cnt = 0; } else { bg_lists->valid_small32 = list_create(_destroy_bitmap); /* This is suppose to be = and not ==, we only want to decrement when small_size equals something. */ if ((small_size = bg_conf->nodecard_ionode_cnt)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small32, tmp_bitmap); } } /* If we only have 1 nodecard just jump to the end since this will never need to happen below. Pretty much a hack to avoid seg fault;). */ if (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) goto no_calc; bg_lists->valid_small128 = list_create(_destroy_bitmap); if ((small_size = bg_conf->quarter_ionode_cnt)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small128, tmp_bitmap); } #ifndef HAVE_BGL bg_lists->valid_small64 = list_create(_destroy_bitmap); if ((small_size = bg_conf->nodecard_ionode_cnt * 2)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small64, tmp_bitmap); } bg_lists->valid_small256 = list_create(_destroy_bitmap); if ((small_size = bg_conf->quarter_ionode_cnt * 2)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small256, tmp_bitmap); } #endif } else { fatal("your ionodes_per_mp is 0"); } no_calc: if (!s_p_get_uint16(&bg_conf->bridge_api_verb, "BridgeAPIVerbose", tbl)) info("Warning: BridgeAPIVerbose not configured " "in bluegene.conf"); if (!s_p_get_string(&bg_conf->bridge_api_file, "BridgeAPILogFile", tbl)) info("BridgeAPILogFile not configured in bluegene.conf"); else _reopen_bridge_log(); if (s_p_get_string(&tmp_char, "DenyPassthrough", tbl)) { if (strstr(tmp_char, "A")) ba_deny_pass |= PASS_DENY_A; if (strstr(tmp_char, "X")) ba_deny_pass |= PASS_DENY_X; if (strstr(tmp_char, "Y")) ba_deny_pass |= PASS_DENY_Y; if (strstr(tmp_char, "Z")) ba_deny_pass |= PASS_DENY_Z; if (!strcasecmp(tmp_char, "ALL")) ba_deny_pass |= PASS_DENY_ALL; bg_conf->deny_pass = ba_deny_pass; xfree(tmp_char); } if (!s_p_get_string(&tmp_char, "LayoutMode", tbl)) { info("Warning: LayoutMode was not specified in bluegene.conf " "defaulting to STATIC partitioning"); bg_conf->layout_mode = LAYOUT_STATIC; } else { if (!strcasecmp(tmp_char,"STATIC")) bg_conf->layout_mode = LAYOUT_STATIC; else if (!strcasecmp(tmp_char,"OVERLAP")) bg_conf->layout_mode = LAYOUT_OVERLAP; else if (!strcasecmp(tmp_char,"DYNAMIC")) bg_conf->layout_mode = LAYOUT_DYNAMIC; else { fatal("I don't understand this LayoutMode = %s", tmp_char); } xfree(tmp_char); } /* add blocks defined in file */ if (bg_conf->layout_mode != LAYOUT_DYNAMIC) { if (!s_p_get_array((void ***)&blockreq_array, &count, "MPs", tbl)) { if (!s_p_get_array((void ***)&blockreq_array, &count, "BPs", tbl)) { info("WARNING: no blocks defined in " "bluegene.conf, " "only making full system block"); /* create_full_system_block(NULL); */ if (bg_conf->sub_mp_sys || (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt)) fatal("On a sub-midplane system you " "need to define the blocks you " "want on your system."); } } for (i = 0; i < count; i++) { add_bg_record(bg_lists->main, NULL, blockreq_array[i], 0, 0); } } else if (bg_conf->sub_mp_sys || (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt)) /* we can't do dynamic here on a sub-midplane system */ fatal("On a sub-midplane system we can only do OVERLAP or " "STATIC LayoutMode. Please update your bluegene.conf."); #ifdef HAVE_BGQ if ((bg_recover != NOT_FROM_CONTROLLER) && s_p_get_string(&tmp_char, "RebootQOSList", tbl)) { bool valid; char *token, *last = NULL; slurmdb_qos_rec_t *qos = NULL; bg_conf->reboot_qos_bitmap = bit_alloc(g_qos_count); itr = list_iterator_create(assoc_mgr_qos_list); token = strtok_r(tmp_char, ",", &last); while (token) { valid = false; while((qos = list_next(itr))) { if (!strcasecmp(token, qos->name)) { bit_set(bg_conf->reboot_qos_bitmap, qos->id); valid = true; break; } } if (!valid) error("Invalid RebootQOSList value: %s", token); list_iterator_reset(itr); token = strtok_r(NULL, ",", &last); } list_iterator_destroy(itr); xfree(tmp_char); } #endif s_p_hashtbl_destroy(tbl); return SLURM_SUCCESS; }
extern List as_mysql_modify_accts(mysql_conn_t *mysql_conn, uint32_t uid, slurmdb_account_cond_t *acct_cond, slurmdb_account_rec_t *acct) { ListIterator itr = NULL; List ret_list = NULL; int rc = SLURM_SUCCESS; char *object = NULL; char *vals = NULL, *extra = NULL, *query = NULL, *name_char = NULL; time_t now = time(NULL); char *user_name = NULL; int set = 0; MYSQL_RES *result = NULL; MYSQL_ROW row; if (!acct_cond || !acct) { error("we need something to change"); return NULL; } if (check_connection(mysql_conn) != SLURM_SUCCESS) return NULL; xstrcat(extra, "where deleted=0"); if (acct_cond->assoc_cond && acct_cond->assoc_cond->acct_list && list_count(acct_cond->assoc_cond->acct_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->assoc_cond->acct_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "name='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->description_list && list_count(acct_cond->description_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->description_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "description='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->organization_list && list_count(acct_cond->organization_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->organization_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "organization='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct->description) xstrfmtcat(vals, ", description='%s'", acct->description); if (acct->organization) xstrfmtcat(vals, ", organization='%s'", acct->organization); if (!extra || !vals) { errno = SLURM_NO_CHANGE_IN_DATA; error("Nothing to change"); return NULL; } query = xstrdup_printf("select name from %s %s;", acct_table, extra); xfree(extra); 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); xfree(vals); return NULL; } rc = 0; ret_list = list_create(slurm_destroy_char); while ((row = mysql_fetch_row(result))) { object = xstrdup(row[0]); list_append(ret_list, object); if (!rc) { xstrfmtcat(name_char, "(name='%s'", object); rc = 1; } else { xstrfmtcat(name_char, " || name='%s'", object); } } mysql_free_result(result); if (!list_count(ret_list)) { errno = SLURM_NO_CHANGE_IN_DATA; debug3("didn't effect anything\n%s", query); xfree(query); xfree(vals); return ret_list; } xfree(query); xstrcat(name_char, ")"); user_name = uid_to_string((uid_t) uid); rc = modify_common(mysql_conn, DBD_MODIFY_ACCOUNTS, now, user_name, acct_table, name_char, vals, NULL); xfree(user_name); if (rc == SLURM_ERROR) { error("Couldn't modify accounts"); list_destroy(ret_list); errno = SLURM_ERROR; ret_list = NULL; } xfree(name_char); xfree(vals); return ret_list; }
extern List as_mysql_remove_accts(mysql_conn_t *mysql_conn, uint32_t uid, slurmdb_account_cond_t *acct_cond) { ListIterator itr = NULL; List ret_list = NULL; List coord_list = NULL; int rc = SLURM_SUCCESS; char *object = NULL; char *extra = NULL, *query = NULL, *name_char = NULL, *assoc_char = NULL; time_t now = time(NULL); char *user_name = NULL; int set = 0; MYSQL_RES *result = NULL; MYSQL_ROW row; bool jobs_running = 0; if (!acct_cond) { error("we need something to change"); return NULL; } if (check_connection(mysql_conn) != SLURM_SUCCESS) return NULL; xstrcat(extra, "where deleted=0"); if (acct_cond->assoc_cond && acct_cond->assoc_cond->acct_list && list_count(acct_cond->assoc_cond->acct_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->assoc_cond->acct_list); while ((object = list_next(itr))) { if (!object[0]) continue; if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "name='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->description_list && list_count(acct_cond->description_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->description_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "description='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->organization_list && list_count(acct_cond->organization_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->organization_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "organization='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (!extra) { error("Nothing to remove"); return NULL; } query = xstrdup_printf("select name from %s %s;", acct_table, extra); xfree(extra); if (!(result = mysql_db_query_ret( mysql_conn, query, 0))) { xfree(query); return NULL; } rc = 0; ret_list = list_create(slurm_destroy_char); while ((row = mysql_fetch_row(result))) { char *object = xstrdup(row[0]); list_append(ret_list, object); if (!rc) { xstrfmtcat(name_char, "name='%s'", object); xstrfmtcat(assoc_char, "t2.acct='%s'", object); rc = 1; } else { xstrfmtcat(name_char, " || name='%s'", object); xstrfmtcat(assoc_char, " || t2.acct='%s'", object); } } mysql_free_result(result); if (!list_count(ret_list)) { errno = SLURM_NO_CHANGE_IN_DATA; debug3("didn't effect anything\n%s", query); xfree(query); return ret_list; } xfree(query); /* We need to remove these accounts from the coord's that have it */ coord_list = as_mysql_remove_coord( mysql_conn, uid, ret_list, NULL); if (coord_list) list_destroy(coord_list); user_name = uid_to_string((uid_t) uid); slurm_mutex_lock(&as_mysql_cluster_list_lock); itr = list_iterator_create(as_mysql_cluster_list); while ((object = list_next(itr))) { if ((rc = remove_common(mysql_conn, DBD_REMOVE_ACCOUNTS, now, user_name, acct_table, name_char, assoc_char, object, ret_list, &jobs_running)) != SLURM_SUCCESS) break; } list_iterator_destroy(itr); slurm_mutex_unlock(&as_mysql_cluster_list_lock); xfree(user_name); xfree(name_char); xfree(assoc_char); if (rc == SLURM_ERROR) { list_destroy(ret_list); return NULL; } if (jobs_running) errno = ESLURM_JOBS_RUNNING_ON_ASSOC; else errno = SLURM_SUCCESS; return ret_list; }
static List _process_util_by_report(void *db_conn, char *calling_name, void *cond, cluster_report_t type) { ListIterator itr = NULL; ListIterator itr2 = NULL; ListIterator type_itr = NULL; slurmdb_cluster_cond_t cluster_cond; List type_list = NULL; List cluster_list = NULL; List first_list = NULL; slurmdb_cluster_rec_t *cluster = NULL; slurmdb_report_cluster_rec_t *slurmdb_report_cluster = NULL; time_t start_time, end_time; int exit_code = 0; uid_t my_uid = getuid(); List ret_list = list_create(slurmdb_destroy_report_cluster_rec); slurmdb_init_cluster_cond(&cluster_cond, 0); cluster_cond.with_deleted = 1; cluster_cond.with_usage = 1; if((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { start_time = ((slurmdb_association_cond_t *)cond)->usage_start; end_time = ((slurmdb_association_cond_t *)cond)->usage_end; cluster_cond.cluster_list = ((slurmdb_association_cond_t *)cond)->cluster_list; } else if((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) { start_time = ((slurmdb_wckey_cond_t *)cond)->usage_start; end_time = ((slurmdb_wckey_cond_t *)cond)->usage_end; cluster_cond.cluster_list = ((slurmdb_wckey_cond_t *)cond)->cluster_list; } else { error("unknown report type %d", type); return NULL; } /* This needs to be done on some systems to make sure cluster_cond isn't messed. This has happened on some 64 bit machines and this is here to be on the safe side. */ slurmdb_report_set_start_end_time(&start_time, &end_time); cluster_cond.usage_end = end_time; cluster_cond.usage_start = start_time; cluster_list = acct_storage_g_get_clusters( db_conn, my_uid, &cluster_cond); if(!cluster_list) { exit_code=1; fprintf(stderr, "%s: Problem with cluster query.\n", calling_name); goto end_it; } if((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { ((slurmdb_association_cond_t *)cond)->usage_start = start_time; ((slurmdb_association_cond_t *)cond)->usage_end = end_time; type_list = acct_storage_g_get_associations( db_conn, my_uid, cond); } else if((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) { ((slurmdb_wckey_cond_t *)cond)->usage_start = start_time; ((slurmdb_wckey_cond_t *)cond)->usage_end = end_time; type_list = acct_storage_g_get_wckeys( db_conn, my_uid, cond); } if(!type_list) { exit_code=1; fprintf(stderr, "%s: Problem with get query.\n", calling_name); goto end_it; } if((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { first_list = type_list; type_list = slurmdb_get_hierarchical_sorted_assoc_list( first_list); } /* set up the structures for easy retrieval later */ itr = list_iterator_create(cluster_list); type_itr = list_iterator_create(type_list); while((cluster = list_next(itr))) { slurmdb_cluster_accounting_rec_t *accting = NULL; /* check to see if this cluster is around during the time we are looking at */ if(!cluster->accounting_list || !list_count(cluster->accounting_list)) continue; slurmdb_report_cluster = xmalloc(sizeof(slurmdb_report_cluster_rec_t)); list_append(ret_list, slurmdb_report_cluster); slurmdb_report_cluster->name = xstrdup(cluster->name); if((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_UW)) slurmdb_report_cluster->user_list = list_create(slurmdb_destroy_report_user_rec); else if((type == CLUSTER_REPORT_AU) || (type == CLUSTER_REPORT_WU)) slurmdb_report_cluster->assoc_list = list_create(slurmdb_destroy_report_assoc_rec); /* get the amount of time and the average cpu count during the time we are looking at */ itr2 = list_iterator_create(cluster->accounting_list); while((accting = list_next(itr2))) { slurmdb_report_cluster->cpu_secs += accting->alloc_secs + accting->down_secs + accting->idle_secs + accting->resv_secs; slurmdb_report_cluster->cpu_count += accting->cpu_count; } list_iterator_destroy(itr2); slurmdb_report_cluster->cpu_count /= list_count(cluster->accounting_list); if((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) _process_assoc_type(type_itr, slurmdb_report_cluster, cluster->name, type); else if((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) _process_wckey_type(type_itr, slurmdb_report_cluster, cluster->name, type); list_iterator_reset(type_itr); } list_iterator_destroy(type_itr); list_iterator_destroy(itr); end_it: if(type_list) { list_destroy(type_list); type_list = NULL; } if(first_list) { list_destroy(first_list); first_list = NULL; } if(cluster_list) { list_destroy(cluster_list); cluster_list = NULL; } if(exit_code) { if(ret_list) { list_destroy(ret_list); ret_list = NULL; } } return ret_list; }
extern int as_mysql_add_accts(mysql_conn_t *mysql_conn, uint32_t uid, List acct_list) { ListIterator itr = NULL; int rc = SLURM_SUCCESS; slurmdb_account_rec_t *object = NULL; char *cols = NULL, *vals = NULL, *query = NULL, *txn_query = NULL; time_t now = time(NULL); char *user_name = NULL; char *extra = NULL, *tmp_extra = NULL; int affect_rows = 0; List assoc_list = list_create(slurmdb_destroy_association_rec); if (check_connection(mysql_conn) != SLURM_SUCCESS) return ESLURM_DB_CONNECTION; user_name = uid_to_string((uid_t) uid); itr = list_iterator_create(acct_list); while ((object = list_next(itr))) { if (!object->name || !object->name[0] || !object->description || !object->description[0] || !object->organization || !object->organization[0]) { error("We need an account name, description, and " "organization to add. %s %s %s", object->name, object->description, object->organization); rc = SLURM_ERROR; continue; } xstrcat(cols, "creation_time, mod_time, name, " "description, organization"); xstrfmtcat(vals, "%ld, %ld, '%s', '%s', '%s'", now, now, object->name, object->description, object->organization); xstrfmtcat(extra, ", description='%s', organization='%s'", object->description, object->organization); query = xstrdup_printf( "insert into %s (%s) values (%s) " "on duplicate key update deleted=0, mod_time=%ld %s;", acct_table, cols, vals, now, extra); debug3("%d(%s:%d) query\n%s", mysql_conn->conn, THIS_FILE, __LINE__, query); rc = mysql_db_query(mysql_conn, query); xfree(cols); xfree(vals); xfree(query); if (rc != SLURM_SUCCESS) { error("Couldn't add acct"); xfree(extra); continue; } affect_rows = last_affected_rows(mysql_conn); /* debug3("affected %d", affect_rows); */ if (!affect_rows) { debug3("nothing changed"); xfree(extra); continue; } /* we always have a ', ' as the first 2 chars */ tmp_extra = slurm_add_slash_to_quotes(extra+2); if (txn_query) xstrfmtcat(txn_query, ", (%ld, %u, '%s', '%s', '%s')", now, DBD_ADD_ACCOUNTS, object->name, user_name, tmp_extra); else xstrfmtcat(txn_query, "insert into %s " "(timestamp, action, name, actor, info) " "values (%ld, %u, '%s', '%s', '%s')", txn_table, now, DBD_ADD_ACCOUNTS, object->name, user_name, tmp_extra); xfree(tmp_extra); xfree(extra); if (!object->assoc_list) continue; list_transfer(assoc_list, object->assoc_list); } list_iterator_destroy(itr); xfree(user_name); if (rc != SLURM_ERROR) { if (txn_query) { xstrcat(txn_query, ";"); rc = mysql_db_query(mysql_conn, txn_query); xfree(txn_query); if (rc != SLURM_SUCCESS) { error("Couldn't add txn"); rc = SLURM_SUCCESS; } } } else xfree(txn_query); if (list_count(assoc_list)) { if (as_mysql_add_assocs(mysql_conn, uid, assoc_list) == SLURM_ERROR) { error("Problem adding user associations"); rc = SLURM_ERROR; } } list_destroy(assoc_list); return rc; }
static int _grid_table_by_switch(button_processor_t *button_processor, List node_list) { int rc = SLURM_SUCCESS; int inx = 0, ii = 0; switch_record_bitmaps_t *sw_nodes_bitmaps_ptr = g_switch_nodes_maps; #if TOPO_DEBUG /* engage if want original display below switched */ ListIterator itr = list_iterator_create(node_list); sview_node_info_t *sview_node_info_ptr = NULL; #endif button_processor->inx = &inx; for (ii=0; ii<g_topo_info_msg_ptr->record_count; ii++, sw_nodes_bitmaps_ptr++) { int j = 0, first, last; if (g_topo_info_msg_ptr->topo_array[ii].level) continue; first = bit_ffs(sw_nodes_bitmaps_ptr->node_bitmap); if (first == -1) continue; last = bit_fls(sw_nodes_bitmaps_ptr->node_bitmap); button_processor->inx = &j; button_processor->force_row_break = false; for (j = first; j <= last; j++) { if (TOPO_DEBUG) g_print("allocated node = %s button# %d\n", g_node_info_ptr->node_array[j].name, j); if (!bit_test(sw_nodes_bitmaps_ptr->node_bitmap, j)) continue; /* if (!working_sview_config.show_hidden) { */ /* if (!check_part_includes_node(j)) */ /* continue; */ /* } */ if (j == last) button_processor->force_row_break = true; if ((rc = _add_button_to_list( &g_node_info_ptr->node_array[j], button_processor)) != SLURM_SUCCESS) break; button_processor->force_row_break = false; } rc = _add_button_to_list(NULL, button_processor); } #if TOPO_DEBUG /* engage this if want original display below * switched grid */ button_processor->inx = &inx; while ((sview_node_info_ptr = list_next(itr))) { if ((rc = _add_button_to_list( sview_node_info_ptr->node_ptr, button_processor)) != SLURM_SUCCESS) break; inx++; } list_iterator_destroy(itr); #endif /* This is needed to get the correct width of the grid window. * If it is not given then we get a really narrow window. */ gtk_table_set_row_spacing(button_processor->table, (*button_processor->coord_y)? ((*button_processor->coord_y)-1):0, 1); return rc; }
extern int update_grid_table(GtkTable *table, List button_list, List node_list) { int rc = SLURM_SUCCESS; int coord_x=0, coord_y=0, inx=0; ListIterator itr = NULL, itr2 = NULL; sview_node_info_t *sview_node_info_ptr = NULL; button_processor_t button_processor; if (!node_list) { g_print("update_grid_table: no node_list given\n"); return SLURM_ERROR; } if (_init_button_processor(&button_processor, list_count(node_list)) != SLURM_SUCCESS) return SLURM_ERROR; button_processor.table = table; button_processor.button_list = button_list; button_processor.coord_x = &coord_x; button_processor.coord_y = &coord_y; button_processor.inx = &inx; gtk_table_resize(table, button_processor.table_y, working_sview_config.grid_x_width); gtk_table_set_row_spacings(table, 0); gtk_table_set_col_spacings(table, 0); itr = list_iterator_create(node_list); itr2 = list_iterator_create(button_list); while ((sview_node_info_ptr = list_next(itr))) { int found = 0; /* if (!working_sview_config.show_hidden */ /* && !check_part_includes_node(inx)) { */ /* inx++; */ /* continue; */ /* } */ // again: while ((button_processor.grid_button = list_next(itr2))) { if (button_processor.grid_button->inx != inx) { continue; } found = 1; if ((rc = _add_button_to_list( sview_node_info_ptr->node_ptr, &button_processor)) != SLURM_SUCCESS) goto end_it; break; } if (!found) { //list_iterator_reset(itr2); //goto again; return RESET_GRID; } inx++; } rc = _add_button_to_list(NULL, &button_processor); /* This is needed to get the correct width of the grid window. * If it is not given then we get a really narrow window. */ gtk_table_set_row_spacing(table, coord_y?(coord_y-1):0, 1); end_it: list_iterator_destroy(itr); list_iterator_destroy(itr2); return rc; }
extern void put_buttons_in_table(GtkTable *table, List button_list) { int coord_x=0, coord_y=0; button_processor_t button_processor; grid_button_t *grid_button = NULL; ListIterator itr = NULL; list_sort(button_list, (ListCmpF) _sort_button_inx); if (!button_list) { g_print("put_buttons_in_table: no node_list given\n"); return; } if (_init_button_processor(&button_processor, list_count(button_list)) != SLURM_SUCCESS) return; button_processor.table = table; button_processor.button_list = button_list; button_processor.coord_x = &coord_x; button_processor.coord_y = &coord_y; gtk_table_resize(table, button_processor.table_y, working_sview_config.grid_x_width); itr = list_iterator_create(button_list); while ((grid_button = list_next(itr))) { if (cluster_dims == 4) { grid_button->table = table; gtk_table_attach(table, grid_button->button, grid_button->table_x, (grid_button->table_x+1), grid_button->table_y, (grid_button->table_y+1), GTK_SHRINK, GTK_SHRINK, 1, 1); if (!grid_button->table_x) { gtk_table_set_row_spacing(table, grid_button->table_y, working_sview_config.gap_size); } } else if (cluster_dims == 3) { grid_button->table = table; gtk_table_attach(table, grid_button->button, grid_button->table_x, (grid_button->table_x+1), grid_button->table_y, (grid_button->table_y+1), GTK_SHRINK, GTK_SHRINK, 1, 1); if (!grid_button->table_x) { gtk_table_set_row_spacing(table, grid_button->table_y, working_sview_config.gap_size); } } else { grid_button->table = table; grid_button->table_x = coord_x; grid_button->table_y = coord_y; gtk_table_attach(table, grid_button->button, coord_x, (coord_x+1), coord_y, (coord_y+1), GTK_SHRINK, GTK_SHRINK, 1, 1); coord_x++; if (coord_x == working_sview_config.grid_x_width) { coord_x = 0; coord_y++; if (!(coord_y % working_sview_config.grid_vert)) gtk_table_set_row_spacing( table, coord_y-1, working_sview_config.gap_size); } if (coord_y == button_processor.table_y) break; if (coord_x && !(coord_x % working_sview_config.grid_hori)) gtk_table_set_col_spacing(table, coord_x-1, 5); } } list_iterator_destroy(itr); if (cluster_dims == 0) { /* This is needed to get the correct width of the grid window. * If it is not given then we get a really narrow window. */ gtk_table_set_row_spacing(table, coord_y?(coord_y-1):0, 1); } gtk_widget_show_all(GTK_WIDGET(table)); }
static int _handle_subgrps(List sinfo_list, uint16_t part_num, partition_info_t *part_ptr, node_info_t *node_ptr, uint32_t node_scaling) { uint16_t size; int *node_state; int i=0, state_cnt = 2; ListIterator iterator = NULL; enum node_states state[] = { NODE_STATE_ALLOCATED, NODE_STATE_ERROR }; /* If we ever update the hostlist stuff to support this stuff * then we can use this to tack on the end of the node name * the subgrp stuff. On bluegene systems this would be nice * to see the ionodes in certain states. * When asking for nodes that are reserved, we need to return * all states of those nodes. */ if (params.state_list) iterator = list_iterator_create(params.state_list); for(i=0; i<state_cnt; i++) { if (iterator) { node_info_t tmp_node, *tmp_node_ptr = &tmp_node; while ((node_state = list_next(iterator))) { tmp_node_ptr->node_state = *node_state; if ((((state[i] == NODE_STATE_ALLOCATED) && IS_NODE_DRAINING(tmp_node_ptr)) || (*node_state == NODE_STATE_DRAIN)) || (*node_state == state[i]) || (*node_state == NODE_STATE_RES)) break; } list_iterator_reset(iterator); if (!node_state) continue; } if (select_g_select_nodeinfo_get(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, state[i], &size) == SLURM_SUCCESS && size) { node_scaling -= size; node_ptr->node_state &= NODE_STATE_FLAGS; node_ptr->node_state |= state[i]; _insert_node_ptr(sinfo_list, part_num, part_ptr, node_ptr, size); } } /* now handle the idle */ if (iterator) { while ((node_state = list_next(iterator))) { node_info_t tmp_node, *tmp_node_ptr = &tmp_node; tmp_node_ptr->node_state = *node_state; if (((*node_state == NODE_STATE_DRAIN) || IS_NODE_DRAINED(tmp_node_ptr)) || (*node_state == NODE_STATE_IDLE) || (*node_state == NODE_STATE_RES)) break; } list_iterator_destroy(iterator); if (!node_state) return SLURM_SUCCESS; } node_ptr->node_state &= NODE_STATE_FLAGS; node_ptr->node_state |= NODE_STATE_IDLE; if ((int)node_scaling > 0) _insert_node_ptr(sinfo_list, part_num, part_ptr, node_ptr, node_scaling); return SLURM_SUCCESS; }
/* Fill in all the users that are coordinator for this account. This * will fill in if there are coordinators from a parent account also. */ static int _get_account_coords(mysql_conn_t *mysql_conn, slurmdb_account_rec_t *acct) { char *query = NULL, *cluster_name = NULL; slurmdb_coord_rec_t *coord = NULL; MYSQL_RES *result = NULL; MYSQL_ROW row; ListIterator itr; if (!acct) { error("We need a account to fill in."); return SLURM_ERROR; } if (!acct->coordinators) acct->coordinators = list_create(slurmdb_destroy_coord_rec); query = xstrdup_printf( "select user from %s where acct='%s' && deleted=0", acct_coord_table, acct->name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); return SLURM_ERROR; } xfree(query); while ((row = mysql_fetch_row(result))) { coord = xmalloc(sizeof(slurmdb_coord_rec_t)); list_append(acct->coordinators, coord); coord->name = xstrdup(row[0]); coord->direct = 1; } mysql_free_result(result); slurm_mutex_lock(&as_mysql_cluster_list_lock); itr = list_iterator_create(as_mysql_cluster_list); while ((cluster_name = list_next(itr))) { if (query) xstrcat(query, " union "); xstrfmtcat(query, "select distinct t0.user from %s as t0, " "\"%s_%s\" as t1, \"%s_%s\" as t2 " "where t0.acct=t1.acct && " "t1.lft<t2.lft && t1.rgt>t2.lft && " "t1.user='' && t2.acct='%s' " "&& t1.acct!='%s' && !t0.deleted", acct_coord_table, cluster_name, assoc_table, cluster_name, assoc_table, acct->name, acct->name); } list_iterator_destroy(itr); slurm_mutex_unlock(&as_mysql_cluster_list_lock); if (!query) { error("No clusters defined? How could there be accts?"); return SLURM_SUCCESS; } xstrcat(query, ";"); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); return SLURM_ERROR; } xfree(query); while ((row = mysql_fetch_row(result))) { coord = xmalloc(sizeof(slurmdb_coord_rec_t)); list_append(acct->coordinators, coord); coord->name = xstrdup(row[0]); coord->direct = 0; } mysql_free_result(result); return SLURM_SUCCESS; }
/* * _filter_out - Determine if the specified node should be filtered out or * reported. * node_ptr IN - node to consider filtering out * RET - true if node should not be reported, false otherwise */ static bool _filter_out(node_info_t *node_ptr) { static hostlist_t host_list = NULL; if (params.nodes) { if (host_list == NULL) host_list = hostlist_create(params.nodes); if (hostlist_find (host_list, node_ptr->name) == -1) return true; } if (params.dead_nodes && !IS_NODE_NO_RESPOND(node_ptr)) return true; if (params.responding_nodes && IS_NODE_NO_RESPOND(node_ptr)) return true; if (params.state_list) { int *node_state; bool match = false; uint32_t base_state; ListIterator iterator; uint16_t cpus = 0; node_info_t tmp_node, *tmp_node_ptr = &tmp_node; iterator = list_iterator_create(params.state_list); while ((node_state = list_next(iterator))) { tmp_node_ptr->node_state = *node_state; if (*node_state == NODE_STATE_DRAIN) { /* We search for anything that has the * drain flag set */ if (IS_NODE_DRAIN(node_ptr)) { match = true; break; } } else if (IS_NODE_DRAINING(tmp_node_ptr)) { /* We search for anything that gets mapped to * DRAINING in node_state_string */ if (IS_NODE_DRAINING(node_ptr)) { match = true; break; } } else if (IS_NODE_DRAINED(tmp_node_ptr)) { /* We search for anything that gets mapped to * DRAINED in node_state_string */ if (IS_NODE_DRAINED(node_ptr)) { match = true; break; } } else if (*node_state & NODE_STATE_FLAGS) { if (*node_state & node_ptr->node_state) { match = true; break; } } else if (*node_state == NODE_STATE_ERROR) { slurm_get_select_nodeinfo( node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ERROR, &cpus); if (cpus) { match = true; break; } } else if (*node_state == NODE_STATE_ALLOCATED) { slurm_get_select_nodeinfo( node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ALLOCATED, &cpus); if (params.cluster_flags & CLUSTER_FLAG_BG && !cpus && (IS_NODE_ALLOCATED(node_ptr) || IS_NODE_COMPLETING(node_ptr))) cpus = node_ptr->cpus; if (cpus) { match = true; break; } } else if (*node_state == NODE_STATE_IDLE) { base_state = node_ptr->node_state & (~NODE_STATE_NO_RESPOND); if (base_state == NODE_STATE_IDLE) { match = true; break; } } else { base_state = node_ptr->node_state & NODE_STATE_BASE; if (base_state == *node_state) { match = true; break; } } } list_iterator_destroy(iterator); if (!match) return true; } return false; }
extern List as_mysql_get_accts(mysql_conn_t *mysql_conn, uid_t uid, slurmdb_account_cond_t *acct_cond) { char *query = NULL; char *extra = NULL; char *tmp = NULL; List acct_list = NULL; ListIterator itr = NULL; char *object = NULL; int set = 0; int i=0, is_admin=1; MYSQL_RES *result = NULL; MYSQL_ROW row; uint16_t private_data = 0; slurmdb_user_rec_t user; /* if this changes you will need to edit the corresponding enum */ char *acct_req_inx[] = { "name", "description", "organization" }; enum { SLURMDB_REQ_NAME, SLURMDB_REQ_DESC, SLURMDB_REQ_ORG, SLURMDB_REQ_COUNT }; if (check_connection(mysql_conn) != SLURM_SUCCESS) return NULL; memset(&user, 0, sizeof(slurmdb_user_rec_t)); user.uid = uid; private_data = slurm_get_private_data(); if (private_data & PRIVATE_DATA_ACCOUNTS) { if (!(is_admin = is_user_min_admin_level( mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) { if (!is_user_any_coord(mysql_conn, &user)) { error("Only admins/coordinators " "can look at account usage"); errno = ESLURM_ACCESS_DENIED; return NULL; } } } if (!acct_cond) { xstrcat(extra, "where deleted=0"); goto empty; } if (acct_cond->with_deleted) xstrcat(extra, "where (deleted=0 || deleted=1)"); else xstrcat(extra, "where deleted=0"); if (acct_cond->assoc_cond && acct_cond->assoc_cond->acct_list && list_count(acct_cond->assoc_cond->acct_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->assoc_cond->acct_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "name='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->description_list && list_count(acct_cond->description_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->description_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "description='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } if (acct_cond->organization_list && list_count(acct_cond->organization_list)) { set = 0; xstrcat(extra, " && ("); itr = list_iterator_create(acct_cond->organization_list); while ((object = list_next(itr))) { if (set) xstrcat(extra, " || "); xstrfmtcat(extra, "organization='%s'", object); set = 1; } list_iterator_destroy(itr); xstrcat(extra, ")"); } empty: xfree(tmp); xstrfmtcat(tmp, "%s", acct_req_inx[i]); for(i=1; i<SLURMDB_REQ_COUNT; i++) { xstrfmtcat(tmp, ", %s", acct_req_inx[i]); } /* 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_ACCOUNTS)) { slurmdb_coord_rec_t *coord = NULL; set = 0; itr = list_iterator_create(user.coord_accts); while ((coord = list_next(itr))) { if (set) { xstrfmtcat(extra, " || name='%s'", coord->name); } else { set = 1; xstrfmtcat(extra, " && (name='%s'", coord->name); } } list_iterator_destroy(itr); if (set) xstrcat(extra,")"); } query = xstrdup_printf("select %s from %s %s", tmp, acct_table, extra); xfree(tmp); xfree(extra); 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); return NULL; } xfree(query); acct_list = list_create(slurmdb_destroy_account_rec); if (acct_cond && acct_cond->with_assocs) { /* We are going to be freeing the inners of this list in the acct->name so we don't free it here */ if (acct_cond->assoc_cond->acct_list) list_destroy(acct_cond->assoc_cond->acct_list); acct_cond->assoc_cond->acct_list = list_create(NULL); } while ((row = mysql_fetch_row(result))) { slurmdb_account_rec_t *acct = xmalloc(sizeof(slurmdb_account_rec_t)); list_append(acct_list, acct); acct->name = xstrdup(row[SLURMDB_REQ_NAME]); acct->description = xstrdup(row[SLURMDB_REQ_DESC]); acct->organization = xstrdup(row[SLURMDB_REQ_ORG]); if (acct_cond && acct_cond->with_coords) { _get_account_coords(mysql_conn, acct); } if (acct_cond && acct_cond->with_assocs) { if (!acct_cond->assoc_cond) { acct_cond->assoc_cond = xmalloc( sizeof(slurmdb_association_cond_t)); } list_append(acct_cond->assoc_cond->acct_list, acct->name); } } mysql_free_result(result); if (acct_cond && acct_cond->with_assocs && list_count(acct_cond->assoc_cond->acct_list)) { ListIterator assoc_itr = NULL; slurmdb_account_rec_t *acct = NULL; slurmdb_association_rec_t *assoc = NULL; List assoc_list = as_mysql_get_assocs( mysql_conn, uid, acct_cond->assoc_cond); if (!assoc_list) { error("no associations"); return acct_list; } itr = list_iterator_create(acct_list); assoc_itr = list_iterator_create(assoc_list); while ((acct = list_next(itr))) { while ((assoc = list_next(assoc_itr))) { if (strcmp(assoc->acct, acct->name)) continue; if (!acct->assoc_list) acct->assoc_list = list_create( slurmdb_destroy_association_rec); list_append(acct->assoc_list, assoc); list_remove(assoc_itr); } list_iterator_reset(assoc_itr); if (!acct->assoc_list) list_remove(itr); } list_iterator_destroy(itr); list_iterator_destroy(assoc_itr); list_destroy(assoc_list); } return acct_list; }
static jobcomp_job_rec_t *_parse_line(List job_info_list) { ListIterator itr = NULL; filetxt_jobcomp_info_t *jobcomp_info = NULL; jobcomp_job_rec_t *job = xmalloc(sizeof(jobcomp_job_rec_t)); char *temp = NULL; time_t start_time = 0; time_t end_time = 0; itr = list_iterator_create(job_info_list); while((jobcomp_info = list_next(itr))) { if (!xstrcasecmp("JobID", jobcomp_info->name)) { job->jobid = atoi(jobcomp_info->val); } else if (!xstrcasecmp("Partition", jobcomp_info->name)) { job->partition = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("StartTime", jobcomp_info->name)) { job->start_time = xstrdup(jobcomp_info->val); start_time = parse_time(job->start_time, 1); } else if (!xstrcasecmp("EndTime", jobcomp_info->name)) { job->end_time = xstrdup(jobcomp_info->val); end_time = parse_time(job->end_time, 1); } else if (!xstrcasecmp("Userid", jobcomp_info->name)) { temp = strstr(jobcomp_info->val, "("); if (!temp) { job->uid = atoi(jobcomp_info->val); error("problem getting correct uid from %s", jobcomp_info->val); } else { job->uid = atoi(temp + 1); job->uid_name = xstrdup(jobcomp_info->val); } } else if (!xstrcasecmp("GroupId", jobcomp_info->name)) { temp = strstr(jobcomp_info->val, "("); if (!temp) { job->gid = atoi(jobcomp_info->val); error("problem getting correct gid from %s", jobcomp_info->val); } else { job->gid = atoi(temp + 1); job->gid_name = xstrdup(jobcomp_info->val); } } else if (!xstrcasecmp("Name", jobcomp_info->name)) { job->jobname = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("NodeList", jobcomp_info->name)) { job->nodelist = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("NodeCnt", jobcomp_info->name)) { job->node_cnt = atoi(jobcomp_info->val); } else if (!xstrcasecmp("ProcCnt", jobcomp_info->name)) { job->proc_cnt = atoi(jobcomp_info->val); } else if (!xstrcasecmp("JobState", jobcomp_info->name)) { job->state = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("Timelimit", jobcomp_info->name)) { job->timelimit = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("Workdir", jobcomp_info->name)) { job->work_dir = xstrdup(jobcomp_info->val); } #ifdef HAVE_BG else if (!xstrcasecmp("MaxProcs", jobcomp_info->name)) { job->max_procs = atoi(jobcomp_info->val); } else if (!xstrcasecmp("Block_Id", jobcomp_info->name)) { job->blockid = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("Connection", jobcomp_info->name)) { job->connection = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("reboot", jobcomp_info->name)) { job->reboot = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("rotate", jobcomp_info->name)) { job->rotate = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("geometry", jobcomp_info->name)) { job->geo = xstrdup(jobcomp_info->val); } else if (!xstrcasecmp("start", jobcomp_info->name)) { job->bg_start_point = xstrdup(jobcomp_info->val); } #endif else { error("Unknown type %s: %s", jobcomp_info->name, jobcomp_info->val); } } job->elapsed_time = end_time - start_time; list_iterator_destroy(itr); return job; }
extern int sacctmgr_delete_qos(int argc, char *argv[]) { int rc = SLURM_SUCCESS; slurmdb_qos_cond_t *qos_cond = xmalloc(sizeof(slurmdb_qos_cond_t)); int i=0; List ret_list = NULL; int set = 0; for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!strncasecmp (argv[i], "Where", MAX(command_len, 5)) || !strncasecmp (argv[i], "Set", MAX(command_len, 3))) i++; set += _set_cond(&i, argc, argv, qos_cond, NULL); } if(!set) { exit_code=1; fprintf(stderr, " No conditions given to remove, not executing.\n"); slurmdb_destroy_qos_cond(qos_cond); return SLURM_ERROR; } else if(set == -1) { slurmdb_destroy_qos_cond(qos_cond); return SLURM_ERROR; } if (!g_qos_list) g_qos_list = acct_storage_g_get_qos( db_conn, my_uid, NULL); notice_thread_init(); ret_list = acct_storage_g_remove_qos(db_conn, my_uid, qos_cond); notice_thread_fini(); slurmdb_destroy_qos_cond(qos_cond); if(ret_list && list_count(ret_list)) { char *object = NULL; ListIterator itr = NULL; /* Check to see if person is trying to remove a default * qos of an association. _isdefault only works with the * output from acct_storage_g_remove_qos, and * with a previously got g_qos_list. */ if (_isdefault(ret_list)) { exit_code=1; fprintf(stderr, " Please either remove the qos' listed " "above from list and resubmit,\n" " or change the default qos to " "remove the qos.\n" " Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); goto end_it; } itr = list_iterator_create(ret_list); printf(" Deleting QOS(s)...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); if(commit_check("Would you like to commit changes?")) { acct_storage_g_commit(db_conn, 1); } else { printf(" Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); } } else if(ret_list) { printf(" Nothing deleted\n"); } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } end_it: if(ret_list) list_destroy(ret_list); return rc; }
int clib_package_install(clib_package_t *pkg, const char *dir, int verbose) { if (!pkg || !dir) return -1; char *pkg_dir = path_join(dir, pkg->name); if (NULL == pkg_dir) { return -1; } if (-1 == mkdirp(pkg_dir, 0777)) { free(pkg_dir); return -1; } if (NULL == pkg->url) { pkg->url = clib_package_url(pkg->author, pkg->repo_name, pkg->version); } if (NULL == pkg->url) { free(pkg_dir); return -1; } if (NULL != pkg->src) { // write package.json char *package_json = path_join(pkg_dir, "package.json"); if (NULL == package_json) { free(pkg_dir); return -1; } fs_write(package_json, pkg->json); free(package_json); // write each source list_node_t *node; list_iterator_t *it = list_iterator_new(pkg->src, LIST_HEAD); while ((node = list_iterator_next(it))) { char *filename = node->val; // download source file char *file_url = clib_package_file_url(pkg->url, filename); char *file_path = path_join(pkg_dir, basename(filename)); if (NULL == file_url || NULL == file_path) { if (file_url) free(file_url); free(pkg_dir); return -1; } if (verbose) { clib_package_log("fetch", file_url); clib_package_log("save", file_path); } int rc = http_get_file(file_url, file_path); free(file_url); free(file_path); if (-1 == rc) { if (verbose) clib_package_error("error", "unable to fetch %s", file_url); free(pkg_dir); return -1; } } list_iterator_destroy(it); } return clib_package_install_dependencies(pkg, dir, verbose); }
static int _set_cond(int *start, int argc, char *argv[], slurmdb_qos_cond_t *qos_cond, List format_list) { int i; int set = 0; int end = 0; int command_len = 0; if(!qos_cond) { error("No qos_cond given"); return -1; } for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if(!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!strncasecmp (argv[i], "Set", MAX(command_len, 3))) { i--; break; } else if (!end && !strncasecmp (argv[i], "WithDeleted", MAX(command_len, 5))) { qos_cond->with_deleted = 1; } else if(!end && !strncasecmp(argv[i], "where", MAX(command_len, 5))) { continue; } else if(!end || !strncasecmp (argv[i], "Names", MAX(command_len, 1)) || !strncasecmp (argv[i], "QOSLevel", MAX(command_len, 1))) { if(!qos_cond->name_list) { qos_cond->name_list = list_create(slurm_destroy_char); } if(slurm_addto_char_list(qos_cond->name_list, argv[i]+end)) set = 1; } else if(!strncasecmp (argv[i], "Descriptions", MAX(command_len, 1))) { if(!qos_cond->description_list) { qos_cond->description_list = list_create(slurm_destroy_char); } if(slurm_addto_char_list(qos_cond->description_list, argv[i]+end)) set = 1; } else if (!strncasecmp (argv[i], "Format", MAX(command_len, 1))) { if(format_list) slurm_addto_char_list(format_list, argv[i]+end); } else if(!strncasecmp (argv[i], "Ids", MAX(command_len, 1))) { ListIterator itr = NULL; char *temp = NULL; uint32_t id = 0; if(!qos_cond->id_list) { qos_cond->id_list = list_create(slurm_destroy_char); } if(slurm_addto_char_list(qos_cond->id_list, argv[i]+end)) set = 1; /* check to make sure user gave ints here */ itr = list_iterator_create(qos_cond->id_list); while ((temp = list_next(itr))) { if (get_uint(temp, &id, "QOS ID") != SLURM_SUCCESS) { exit_code = 1; list_delete_item(itr); } } list_iterator_destroy(itr); } else if (!strncasecmp (argv[i], "PreemptMode", MAX(command_len, 8))) { if(!qos_cond) continue; qos_cond->preempt_mode |= _parse_preempt_modes(argv[i]+end); if(qos_cond->preempt_mode == (uint16_t)NO_VAL) { fprintf(stderr, " Bad Preempt Mode given: %s\n", argv[i]); exit_code = 1; } else if (qos_cond->preempt_mode == PREEMPT_MODE_SUSPEND) { printf("PreemptType and PreemptMode " "values incompatible\n"); exit_code = 1; } else set = 1; } else { exit_code=1; fprintf(stderr, " Unknown condition: %s\n" " Use keyword 'set' to modify " "SLURM_PRINT_VALUE\n", argv[i]); } } (*start) = i; return set; }
static List _get_precs(List task_list, bool pgid_plugin, uint64_t cont_id, jag_callbacks_t *callbacks) { List prec_list = list_create(destroy_jag_prec); char proc_stat_file[256]; /* Allow ~20x extra length */ char proc_io_file[256]; /* Allow ~20x extra length */ static int slash_proc_open = 0; int i; if (!pgid_plugin) { pid_t *pids = NULL; int npids = 0; /* get only the processes in the proctrack container */ proctrack_g_get_pids(cont_id, &pids, &npids); if (!npids) { /* update consumed energy even if pids do not exist */ ListIterator itr = list_iterator_create(task_list); struct jobacctinfo *jobacct = NULL; if ((jobacct = list_next(itr))) { acct_gather_energy_g_get_data( energy_profile, &jobacct->energy); debug2("getjoules_task energy = %u", jobacct->energy.consumed_energy); } list_iterator_destroy(itr); debug4("no pids in this container %"PRIu64"", cont_id); goto finished; } for (i = 0; i < npids; i++) { snprintf(proc_stat_file, 256, "/proc/%d/stat", pids[i]); snprintf(proc_io_file, 256, "/proc/%d/io", pids[i]); _handle_stats(prec_list, proc_stat_file, proc_io_file, callbacks); } xfree(pids); } else { struct dirent *slash_proc_entry; char *iptr = NULL, *optr = NULL, *optr2 = NULL; if (slash_proc_open) { rewinddir(slash_proc); } else { slash_proc=opendir("/proc"); if (slash_proc == NULL) { perror("opening /proc"); goto finished; } slash_proc_open=1; } strcpy(proc_stat_file, "/proc/"); strcpy(proc_io_file, "/proc/"); while ((slash_proc_entry = readdir(slash_proc))) { /* Save a few cyles by simulating * strcat(statFileName, slash_proc_entry->d_name); * strcat(statFileName, "/stat"); * while checking for a numeric filename (which really * should be a pid). Then do the same for the * /proc/<pid>/io file name. */ optr = proc_stat_file + sizeof("/proc"); iptr = slash_proc_entry->d_name; i = 0; do { if ((*iptr < '0') || ((*optr++ = *iptr++) > '9')) { i = -1; break; } } while (*iptr); if (i == -1) continue; iptr = (char*)"/stat"; do { *optr++ = *iptr++; } while (*iptr); *optr = 0; optr2 = proc_io_file + sizeof("/proc"); iptr = slash_proc_entry->d_name; i = 0; do { if ((*iptr < '0') || ((*optr2++ = *iptr++) > '9')) { i = -1; break; } } while (*iptr); if (i == -1) continue; iptr = (char*)"/io"; do { *optr2++ = *iptr++; } while (*iptr); *optr2 = 0; _handle_stats(prec_list, proc_stat_file, proc_io_file, callbacks); } } finished: return prec_list; }
static bool _isdefault(List qos_list) { int rc = 0; slurmdb_association_cond_t assoc_cond; slurmdb_association_rec_t *assoc = NULL; ListIterator itr; List ret_list = NULL; char *name = NULL; if(!qos_list || !list_count(qos_list)) return rc; /* this needs to happen before any removing takes place so we can figure out things correctly */ xassert(g_qos_list); memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t)); assoc_cond.without_parent_info = 1; assoc_cond.def_qos_id_list = list_create(slurm_destroy_char); itr = list_iterator_create(qos_list); while ((name = list_next(itr))) { uint32_t id = str_2_slurmdb_qos(g_qos_list, name); if(id == NO_VAL) continue; list_append(assoc_cond.def_qos_id_list, xstrdup_printf("%u", id)); } list_iterator_destroy(itr); ret_list = acct_storage_g_get_associations( db_conn, my_uid, &assoc_cond); list_destroy(assoc_cond.def_qos_id_list); if(!ret_list || !list_count(ret_list)) goto end_it; fprintf(stderr," Associations listed below have these " "as their Default QOS.\n"); itr = list_iterator_create(ret_list); while((assoc = list_next(itr))) { name = slurmdb_qos_str(g_qos_list, assoc->def_qos_id); if (!assoc->user) { // see if this isn't a user fprintf(stderr, " DefQOS = %-10s C = %-10s A = %-20s\n", name, assoc->cluster, assoc->acct); } else if (assoc->partition) { // see if there is a partition name fprintf(stderr, " DefQOS = %-10s C = %-10s A = %-20s " "U = %-9s P = %s\n", name, assoc->cluster, assoc->acct, assoc->user, assoc->partition); } else { fprintf(stderr, " DefQOS = %-10s C = %-10s A = %-20s " "U = %-9s\n", name, assoc->cluster, assoc->acct, assoc->user); } } list_iterator_destroy(itr); rc = 1; end_it: if(ret_list) list_destroy(ret_list); return rc; }
extern List slurmdb_report_user_top_usage(void *db_conn, slurmdb_user_cond_t *user_cond, bool group_accounts) { List cluster_list = NULL; ListIterator itr = NULL; ListIterator itr2 = NULL; ListIterator itr3 = NULL; ListIterator cluster_itr = NULL; slurmdb_cluster_cond_t cluster_cond; List user_list = NULL; List usage_cluster_list = NULL; char *object = NULL; int exit_code = 0; slurmdb_user_rec_t *user = NULL; slurmdb_cluster_rec_t *cluster = NULL; slurmdb_assoc_rec_t *assoc = NULL; slurmdb_report_user_rec_t *slurmdb_report_user = NULL; slurmdb_report_cluster_rec_t *slurmdb_report_cluster = NULL; uid_t my_uid = getuid(); bool delete_user_cond = 0, delete_assoc_cond = 0, delete_cluster_list = 0; time_t start_time, end_time; if (!user_cond) { delete_user_cond = 1; user_cond = xmalloc(sizeof(slurmdb_user_cond_t)); } if (!user_cond->assoc_cond) { delete_assoc_cond = 1; user_cond->assoc_cond = xmalloc(sizeof(slurmdb_assoc_cond_t)); } if (!user_cond->assoc_cond->cluster_list) { delete_cluster_list = 1; user_cond->assoc_cond->cluster_list = list_create(slurm_destroy_char); } user_cond->with_deleted = 1; user_cond->with_assocs = 1; user_cond->assoc_cond->with_usage = 1; user_cond->assoc_cond->without_parent_info = 1; /* This needs to be done on some systems to make sure assoc_cond isn't messed up. This has happened on some 64 bit machines and this is here to be on the safe side. */ start_time = user_cond->assoc_cond->usage_start; end_time = user_cond->assoc_cond->usage_end; slurmdb_report_set_start_end_time(&start_time, &end_time); user_cond->assoc_cond->usage_start = start_time; user_cond->assoc_cond->usage_end = end_time; user_list = acct_storage_g_get_users(db_conn, my_uid, user_cond); if (!user_list) { exit_code=1; fprintf(stderr, " Problem with user query.\n"); goto end_it; } /* We have to get the clusters here or we will be unable to get the correct total time for the cluster if associations are not enforced. */ slurmdb_init_cluster_cond(&cluster_cond, 0); cluster_cond.with_usage = 1; cluster_cond.with_deleted = 1; cluster_cond.usage_end = user_cond->assoc_cond->usage_end; cluster_cond.usage_start = user_cond->assoc_cond->usage_start; cluster_cond.cluster_list = user_cond->assoc_cond->cluster_list; usage_cluster_list = acct_storage_g_get_clusters( db_conn, my_uid, &cluster_cond); if (!usage_cluster_list) { exit_code=1; fprintf(stderr, " Problem with cluster query.\n"); goto end_it; } cluster_list = list_create(slurmdb_destroy_report_cluster_rec); itr = list_iterator_create(usage_cluster_list); while((cluster = list_next(itr))) { /* check to see if this cluster is around during the time we are looking at */ if (!cluster->accounting_list || !list_count(cluster->accounting_list)) continue; slurmdb_report_cluster = slurmdb_cluster_rec_2_report(cluster); list_append(cluster_list, slurmdb_report_cluster); slurmdb_report_cluster->user_list = list_create(slurmdb_destroy_report_user_rec); } list_iterator_destroy(itr); FREE_NULL_LIST(usage_cluster_list); itr = list_iterator_create(user_list); cluster_itr = list_iterator_create(cluster_list); while((user = list_next(itr))) { struct passwd *passwd_ptr = NULL; if (!user->assoc_list || !list_count(user->assoc_list)) continue; passwd_ptr = getpwnam(user->name); if (passwd_ptr) user->uid = passwd_ptr->pw_uid; else user->uid = (uint32_t)NO_VAL; itr2 = list_iterator_create(user->assoc_list); while((assoc = list_next(itr2))) { if (!assoc->accounting_list || !list_count(assoc->accounting_list)) continue; while((slurmdb_report_cluster = list_next(cluster_itr))) { if (!xstrcmp(slurmdb_report_cluster->name, assoc->cluster)) { ListIterator user_itr = NULL; if (!group_accounts) { slurmdb_report_user = NULL; goto new_user; } user_itr = list_iterator_create( slurmdb_report_cluster-> user_list); while((slurmdb_report_user = list_next(user_itr))) { if (slurmdb_report_user->uid != NO_VAL) { if (slurmdb_report_user-> uid == user->uid) break; } else if (slurmdb_report_user-> name && !xstrcasecmp( slurmdb_report_user-> name, user->name)) break; } list_iterator_destroy(user_itr); new_user: if (!slurmdb_report_user) { slurmdb_report_user = xmalloc( sizeof (slurmdb_report_user_rec_t)); slurmdb_report_user->name = xstrdup(assoc->user); slurmdb_report_user->uid = user->uid; slurmdb_report_user->acct_list = list_create (slurm_destroy_char); list_append(slurmdb_report_cluster-> user_list, slurmdb_report_user); } break; } } if (!slurmdb_report_cluster) { error("This cluster '%s' hasn't " "registered yet, but we have jobs " "that ran?", assoc->cluster); slurmdb_report_cluster = xmalloc(sizeof(slurmdb_report_cluster_rec_t)); list_append(cluster_list, slurmdb_report_cluster); slurmdb_report_cluster->name = xstrdup(assoc->cluster); slurmdb_report_cluster->user_list = list_create(slurmdb_destroy_report_user_rec); slurmdb_report_user = xmalloc(sizeof(slurmdb_report_user_rec_t)); slurmdb_report_user->name = xstrdup(assoc->user); slurmdb_report_user->uid = user->uid; slurmdb_report_user->acct_list = list_create(slurm_destroy_char); list_append(slurmdb_report_cluster->user_list, slurmdb_report_user); } list_iterator_reset(cluster_itr); itr3 = list_iterator_create( slurmdb_report_user->acct_list); while((object = list_next(itr3))) { if (!xstrcmp(object, assoc->acct)) break; } list_iterator_destroy(itr3); if (!object) list_append(slurmdb_report_user->acct_list, xstrdup(assoc->acct)); slurmdb_transfer_acct_list_2_tres( assoc->accounting_list, &slurmdb_report_user->tres_list); } list_iterator_destroy(itr2); } list_iterator_destroy(itr); list_iterator_destroy(cluster_itr); end_it: if (delete_cluster_list) { FREE_NULL_LIST(user_cond->assoc_cond->cluster_list); user_cond->assoc_cond->cluster_list = NULL; } if (delete_assoc_cond) { slurmdb_destroy_assoc_cond(user_cond->assoc_cond); user_cond->assoc_cond = NULL; } if (delete_user_cond) { slurmdb_destroy_user_cond(user_cond); user_cond = NULL; } FREE_NULL_LIST(user_list); if (exit_code) { FREE_NULL_LIST(cluster_list); } return cluster_list; }
extern int sacctmgr_add_qos(int argc, char *argv[]) { int rc = SLURM_SUCCESS; int i=0, limit_set=0; ListIterator itr = NULL; slurmdb_qos_rec_t *qos = NULL; slurmdb_qos_rec_t *start_qos = xmalloc(sizeof(slurmdb_qos_rec_t)); List name_list = list_create(slurm_destroy_char); char *description = NULL; char *name = NULL; List qos_list = NULL; char *qos_str = NULL; slurmdb_init_qos_rec(start_qos, 0); for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!strncasecmp (argv[i], "Where", MAX(command_len, 5)) || !strncasecmp (argv[i], "Set", MAX(command_len, 3))) i++; limit_set += _set_rec(&i, argc, argv, name_list, start_qos); } if(exit_code) { list_destroy(name_list); xfree(description); return SLURM_ERROR; } else if(!list_count(name_list)) { list_destroy(name_list); slurmdb_destroy_qos_rec(start_qos); exit_code=1; fprintf(stderr, " Need name of qos to add.\n"); return SLURM_SUCCESS; } if(!g_qos_list) { g_qos_list = acct_storage_g_get_qos(db_conn, my_uid, NULL); if(!g_qos_list) { exit_code=1; fprintf(stderr, " Problem getting qos's " "from database. " "Contact your admin.\n"); list_destroy(name_list); xfree(description); return SLURM_ERROR; } } qos_list = list_create(slurmdb_destroy_qos_rec); itr = list_iterator_create(name_list); while((name = list_next(itr))) { qos = NULL; if(!sacctmgr_find_qos_from_list(g_qos_list, name)) { qos = xmalloc(sizeof(slurmdb_qos_rec_t)); slurmdb_init_qos_rec(qos, 0); qos->name = xstrdup(name); if(start_qos->description) qos->description = xstrdup(start_qos->description); else qos->description = xstrdup(name); qos->grace_time = start_qos->grace_time; qos->grp_cpu_mins = start_qos->grp_cpu_mins; qos->grp_cpus = start_qos->grp_cpus; qos->grp_jobs = start_qos->grp_jobs; qos->grp_nodes = start_qos->grp_nodes; qos->grp_submit_jobs = start_qos->grp_submit_jobs; qos->grp_wall = start_qos->grp_wall; qos->max_cpu_mins_pj = start_qos->max_cpu_mins_pj; qos->max_cpus_pj = start_qos->max_cpus_pj; qos->max_cpus_pu = start_qos->max_cpus_pu; qos->max_jobs_pu = start_qos->max_jobs_pu; qos->max_nodes_pj = start_qos->max_nodes_pj; qos->max_nodes_pu = start_qos->max_nodes_pu; qos->max_submit_jobs_pu = start_qos->max_submit_jobs_pu; qos->max_wall_pj = start_qos->max_wall_pj; qos->preempt_list = copy_char_list(start_qos->preempt_list); qos->preempt_mode = start_qos->preempt_mode; qos->priority = start_qos->priority; qos->usage_factor = start_qos->usage_factor; qos->usage_thres = start_qos->usage_thres; xstrfmtcat(qos_str, " %s\n", name); list_append(qos_list, qos); } } list_iterator_destroy(itr); list_destroy(name_list); if(!list_count(qos_list)) { printf(" Nothing new added.\n"); goto end_it; } if(qos_str) { printf(" Adding QOS(s)\n%s", qos_str); printf(" Settings\n"); if(description) printf(" Description = %s\n", description); else printf(" Description = %s\n", "QOS Name"); sacctmgr_print_qos_limits(start_qos); xfree(qos_str); } notice_thread_init(); if(list_count(qos_list)) rc = acct_storage_g_add_qos(db_conn, my_uid, qos_list); else goto end_it; notice_thread_fini(); if(rc == SLURM_SUCCESS) { if(commit_check("Would you like to commit changes?")) { acct_storage_g_commit(db_conn, 1); } else { printf(" Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); } } else { exit_code=1; fprintf(stderr, " Problem adding QOS: %s\n", slurm_strerror(rc)); rc = SLURM_ERROR; } end_it: list_destroy(qos_list); xfree(description); return rc; }
static void * _service_connection(void *arg) { slurmdbd_conn_t *conn = (slurmdbd_conn_t *) arg; uint32_t nw_size = 0, msg_size = 0, uid = NO_VAL; char *msg = NULL; ssize_t msg_read = 0, offset = 0; bool fini = false, first = true; Buf buffer = NULL; int rc = SLURM_SUCCESS; debug2("Opened connection %d from %s", conn->newsockfd, conn->ip); while (!fini) { if (!_fd_readable(conn->newsockfd)) break; /* problem with this socket */ msg_read = read(conn->newsockfd, &nw_size, sizeof(nw_size)); if (msg_read == 0) /* EOF */ break; if (msg_read != sizeof(nw_size)) { error("Could not read msg_size from " "connection %d(%s) uid(%d)", conn->newsockfd, conn->ip, uid); break; } msg_size = ntohl(nw_size); if ((msg_size < 2) || (msg_size > MAX_MSG_SIZE)) { error("Invalid msg_size (%u) from " "connection %d(%s) uid(%d)", msg_size, conn->newsockfd, conn->ip, uid); break; } msg = xmalloc(msg_size); offset = 0; while (msg_size > offset) { if (!_fd_readable(conn->newsockfd)) break; /* problem with this socket */ msg_read = read(conn->newsockfd, (msg + offset), (msg_size - offset)); if (msg_read <= 0) { error("read(%d): %m", conn->newsockfd); break; } offset += msg_read; } if (msg_size == offset) { rc = proc_req( conn, msg, msg_size, first, &buffer, &uid); first = false; if (rc != SLURM_SUCCESS && rc != ACCOUNTING_FIRST_REG) { error("Processing last message from " "connection %d(%s) uid(%d)", conn->newsockfd, conn->ip, uid); if (rc == ESLURM_ACCESS_DENIED || rc == SLURM_PROTOCOL_VERSION_ERROR) fini = true; } } else { buffer = make_dbd_rc_msg(conn->rpc_version, SLURM_ERROR, "Bad offset", 0); fini = true; } (void) _send_resp(conn->newsockfd, buffer); xfree(msg); } if (conn->ctld_port) { if (!shutdown_time) { slurmdb_cluster_rec_t cluster_rec; ListIterator itr; slurmdbd_conn_t *slurmdbd_conn; memset(&cluster_rec, 0, sizeof(slurmdb_cluster_rec_t)); cluster_rec.name = conn->cluster_name; cluster_rec.control_host = conn->ip; cluster_rec.control_port = conn->ctld_port; cluster_rec.tres_str = conn->tres_str; debug("cluster %s has disconnected", conn->cluster_name); clusteracct_storage_g_fini_ctld( conn->db_conn, &cluster_rec); slurm_mutex_lock(®istered_lock); itr = list_iterator_create(registered_clusters); while ((slurmdbd_conn = list_next(itr))) { if (conn == slurmdbd_conn) { list_delete_item(itr); break; } } list_iterator_destroy(itr); slurm_mutex_unlock(®istered_lock); } /* needs to be the last thing done */ acct_storage_g_commit(conn->db_conn, 1); } acct_storage_g_close_connection(&conn->db_conn); if (slurm_close(conn->newsockfd) < 0) error("close(%d): %m(%s)", conn->newsockfd, conn->ip); else debug2("Closed connection %d uid(%d)", conn->newsockfd, uid); xfree(conn->tres_str); xfree(conn->cluster_name); xfree(conn); _free_server_thread(pthread_self()); return NULL; }
extern int sacctmgr_list_qos(int argc, char *argv[]) { int rc = SLURM_SUCCESS; slurmdb_qos_cond_t *qos_cond = xmalloc(sizeof(slurmdb_qos_cond_t)); int i=0; ListIterator itr = NULL; ListIterator itr2 = NULL; slurmdb_qos_rec_t *qos = NULL; List qos_list = NULL; int field_count = 0; print_field_t *field = NULL; List format_list = list_create(slurm_destroy_char); List print_fields_list; /* types are of print_field_t */ for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!strncasecmp (argv[i], "Where", MAX(command_len, 5)) || !strncasecmp (argv[i], "Set", MAX(command_len, 3))) i++; _set_cond(&i, argc, argv, qos_cond, format_list); } if(exit_code) { slurmdb_destroy_qos_cond(qos_cond); list_destroy(format_list); return SLURM_ERROR; } else if(!list_count(format_list)) { slurm_addto_char_list(format_list, "Name,Prio,GraceT,Preempt,PreemptM," "Flags%40,UsageThres,GrpCPUs,GrpCPUMins," "GrpJ,GrpN,GrpS,GrpW," "MaxCPUs,MaxCPUMins,MaxJ,MaxN,MaxS,MaxW"); } print_fields_list = sacctmgr_process_format_list(format_list); list_destroy(format_list); if(exit_code) { list_destroy(print_fields_list); return SLURM_ERROR; } qos_list = acct_storage_g_get_qos(db_conn, my_uid, qos_cond); slurmdb_destroy_qos_cond(qos_cond); if(!qos_list) { exit_code=1; fprintf(stderr, " Problem with query.\n"); list_destroy(print_fields_list); return SLURM_ERROR; } itr = list_iterator_create(qos_list); itr2 = list_iterator_create(print_fields_list); print_fields_header(print_fields_list); field_count = list_count(print_fields_list); while((qos = list_next(itr))) { int curr_inx = 1; while((field = list_next(itr2))) { switch(field->type) { case PRINT_DESC: field->print_routine( field, qos->description, (curr_inx == field_count)); break; case PRINT_FLAGS: { char *tmp_char = slurmdb_qos_flags_str( qos->flags); field->print_routine( field, tmp_char, (curr_inx == field_count)); xfree(tmp_char); break; } case PRINT_UT: field->print_routine( field, qos->usage_thres, (curr_inx == field_count)); break; case PRINT_GRACE: field->print_routine( field, (uint64_t)qos->grace_time, (curr_inx == field_count)); break; case PRINT_GRPCM: field->print_routine( field, qos->grp_cpu_mins, (curr_inx == field_count)); break; case PRINT_GRPCRM: field->print_routine( field, qos->grp_cpu_run_mins, (curr_inx == field_count)); break; case PRINT_GRPC: field->print_routine(field, qos->grp_cpus, (curr_inx == field_count)); break; case PRINT_GRPJ: field->print_routine(field, qos->grp_jobs, (curr_inx == field_count)); break; case PRINT_GRPN: field->print_routine(field, qos->grp_nodes, (curr_inx == field_count)); break; case PRINT_GRPS: field->print_routine(field, qos->grp_submit_jobs, (curr_inx == field_count)); break; case PRINT_GRPW: field->print_routine( field, qos->grp_wall, (curr_inx == field_count)); break; case PRINT_ID: field->print_routine( field, qos->id, (curr_inx == field_count)); break; case PRINT_MAXCM: field->print_routine( field, qos->max_cpu_mins_pj, (curr_inx == field_count)); break; case PRINT_MAXC: field->print_routine(field, qos->max_cpus_pj, (curr_inx == field_count)); break; case PRINT_MAXCU: field->print_routine(field, qos->max_cpus_pu, (curr_inx == field_count)); break; case PRINT_MAXJ: field->print_routine(field, qos->max_jobs_pu, (curr_inx == field_count)); break; case PRINT_MAXN: field->print_routine(field, qos->max_nodes_pj, (curr_inx == field_count)); break; case PRINT_MAXNU: field->print_routine(field, qos->max_nodes_pu, (curr_inx == field_count)); break; case PRINT_MAXS: field->print_routine(field, qos->max_submit_jobs_pu, (curr_inx == field_count)); break; case PRINT_MAXW: field->print_routine( field, qos->max_wall_pj, (curr_inx == field_count)); break; case PRINT_NAME: field->print_routine( field, qos->name, (curr_inx == field_count)); break; case PRINT_PREE: if(!g_qos_list) g_qos_list = acct_storage_g_get_qos( db_conn, my_uid, NULL); field->print_routine( field, g_qos_list, qos->preempt_bitstr, (curr_inx == field_count)); break; case PRINT_PREEM: { char *tmp_char = "cluster"; if(qos->preempt_mode) tmp_char = xstrtolower( preempt_mode_string( qos->preempt_mode)); field->print_routine( field, tmp_char, (curr_inx == field_count)); break; } case PRINT_PRIO: field->print_routine( field, qos->priority, (curr_inx == field_count)); break; case PRINT_UF: field->print_routine( field, qos->usage_factor, (curr_inx == field_count)); break; default: field->print_routine( field, NULL, (curr_inx == field_count)); break; } curr_inx++; } list_iterator_reset(itr2); printf("\n"); } list_iterator_destroy(itr2); list_iterator_destroy(itr); list_destroy(qos_list); list_destroy(print_fields_list); return rc; }
extern List priority_p_get_priority_factors_list( priority_factors_request_msg_t *req_msg) { List req_job_list; List req_user_list; List ret_list = NULL; ListIterator itr; priority_factors_object_t *obj = NULL; struct job_record *job_ptr = NULL; time_t start_time = time(NULL); xassert(req_msg); req_job_list = req_msg->job_id_list; req_user_list = req_msg->uid_list; /* Read lock on jobs, nodes, and partitions */ slurmctld_lock_t job_read_lock = { NO_LOCK, READ_LOCK, READ_LOCK, READ_LOCK }; if (job_list && list_count(job_list)) { ret_list = list_create(slurm_destroy_priority_factors_object); lock_slurmctld(job_read_lock); itr = list_iterator_create(job_list); if (itr == NULL) fatal("list_iterator_create: malloc failure"); while ((job_ptr = list_next(itr))) { /* * We are only looking for pending jobs */ if (!IS_JOB_PENDING(job_ptr)) continue; /* * This means the job is not eligible yet */ if (!job_ptr->details->begin_time || (job_ptr->details->begin_time > start_time)) continue; /* * 0 means the job is held; 1 means system hold */ if (job_ptr->priority <= 1) continue; /* * Priority has been set elsewhere (e.g. by SlurmUser) */ if (job_ptr->direct_set_prio) continue; if (_filter_job(job_ptr, req_job_list, req_user_list)) continue; obj = xmalloc(sizeof(priority_factors_object_t)); memcpy(obj, job_ptr->prio_factors, sizeof(priority_factors_object_t)); obj->job_id = job_ptr->job_id; obj->user_id = job_ptr->user_id; list_append(ret_list, obj); } list_iterator_destroy(itr); unlock_slurmctld(job_read_lock); if (!list_count(ret_list)) { list_destroy(ret_list); ret_list = NULL; } } return ret_list; }
/* NOTE: Insure that mysql_conn->lock is NOT set on function entry */ static int _mysql_make_table_current(mysql_conn_t *mysql_conn, char *table_name, storage_field_t *fields, char *ending) { char *query = NULL; char *correct_query = NULL; MYSQL_RES *result = NULL; MYSQL_ROW row; int i = 0; List columns = NULL; ListIterator itr = NULL; char *col = NULL; int adding = 0; int run_update = 0; char *primary_key = NULL; char *unique_index = NULL; int old_primary = 0; char *old_index = NULL; char *temp = NULL, *temp2 = NULL; List keys_list = NULL; db_key_t *db_key = NULL; DEF_TIMERS; /* figure out the unique keys in the table */ query = xstrdup_printf("show index from %s where non_unique=0", table_name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); return SLURM_ERROR; } xfree(query); while ((row = mysql_fetch_row(result))) { // row[2] is the key name if (!xstrcasecmp(row[2], "PRIMARY")) old_primary = 1; else if (!old_index) old_index = xstrdup(row[2]); } mysql_free_result(result); /* figure out the non-unique keys in the table */ query = xstrdup_printf("show index from %s where non_unique=1", table_name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); return SLURM_ERROR; } xfree(query); itr = NULL; keys_list = list_create(_destroy_db_key); while ((row = mysql_fetch_row(result))) { if (!itr) itr = list_iterator_create(keys_list); else list_iterator_reset(itr); while ((db_key = list_next(itr))) { if (!xstrcmp(db_key->name, row[2])) break; } if (db_key) { xstrfmtcat(db_key->columns, ", %s", row[4]); } else { db_key = xmalloc(sizeof(db_key_t)); db_key->name = xstrdup(row[2]); // name db_key->columns = xstrdup(row[4]); // column name list_append(keys_list, db_key); // don't use list_push } } mysql_free_result(result); if (itr) { list_iterator_destroy(itr); itr = NULL; } /* figure out the existing columns in the table */ query = xstrdup_printf("show columns from %s", table_name); if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) { xfree(query); xfree(old_index); FREE_NULL_LIST(keys_list); return SLURM_ERROR; } xfree(query); columns = list_create(slurm_destroy_char); while ((row = mysql_fetch_row(result))) { col = xstrdup(row[0]); //Field list_append(columns, col); } mysql_free_result(result); itr = list_iterator_create(columns); #ifdef NO_ALTER_IGNORE_MYSQL /* In MySQL 5.7.4 we lost the ability to run 'alter ignore'. This was * needed when converting old tables to new schemas. If people convert * in the future from an older version of Slurm that needed the ignore * to work they will have to downgrade mysql to <= 5.7.3 to make things * work correctly or manually edit the database to get things to work. */ query = xstrdup_printf("alter table %s", table_name); #else query = xstrdup_printf("alter ignore table %s", table_name); #endif correct_query = xstrdup(query); START_TIMER; while (fields[i].name) { int found = 0; list_iterator_reset(itr); while ((col = list_next(itr))) { if (!xstrcmp(col, fields[i].name)) { xstrfmtcat(query, " modify `%s` %s,", fields[i].name, fields[i].options); xstrfmtcat(correct_query, " modify `%s` %s,", fields[i].name, fields[i].options); list_delete_item(itr); found = 1; break; } } if (!found) { if (i) { info("adding column %s after %s in table %s", fields[i].name, fields[i-1].name, table_name); xstrfmtcat(query, " add `%s` %s after %s,", fields[i].name, fields[i].options, fields[i-1].name); xstrfmtcat(correct_query, " modify `%s` %s,", fields[i].name, fields[i].options); } else { info("adding column %s at the beginning " "of table %s", fields[i].name, table_name); xstrfmtcat(query, " add `%s` %s first,", fields[i].name, fields[i].options); xstrfmtcat(correct_query, " modify `%s` %s,", fields[i].name, fields[i].options); } adding = 1; } i++; } list_iterator_reset(itr); while ((col = list_next(itr))) { adding = 1; info("dropping column %s from table %s", col, table_name); xstrfmtcat(query, " drop %s,", col); } list_iterator_destroy(itr); FREE_NULL_LIST(columns); if ((temp = strstr(ending, "primary key ("))) { int open = 0, close =0; int end = 0; while (temp[end++]) { if (temp[end] == '(') open++; else if (temp[end] == ')') close++; else continue; if (open == close) break; } if (temp[end]) { end++; primary_key = xstrndup(temp, end); if (old_primary) { xstrcat(query, " drop primary key,"); xstrcat(correct_query, " drop primary key,"); } xstrfmtcat(query, " add %s,", primary_key); xstrfmtcat(correct_query, " add %s,", primary_key); xfree(primary_key); } } if ((temp = strstr(ending, "unique index ("))) { int open = 0, close =0; int end = 0; while (temp[end++]) { if (temp[end] == '(') open++; else if (temp[end] == ')') close++; else continue; if (open == close) break; } if (temp[end]) { end++; unique_index = xstrndup(temp, end); if (old_index) { xstrfmtcat(query, " drop index %s,", old_index); xstrfmtcat(correct_query, " drop index %s,", old_index); } xstrfmtcat(query, " add %s,", unique_index); xstrfmtcat(correct_query, " add %s,", unique_index); xfree(unique_index); } } xfree(old_index); temp2 = ending; itr = list_iterator_create(keys_list); while ((temp = strstr(temp2, ", key "))) { int open = 0, close = 0, name_end = 0; int end = 5; char *new_key_name = NULL, *new_key = NULL; while (temp[end++]) { if (!name_end && (temp[end] == ' ')) { name_end = end; continue; } else if (temp[end] == '(') { open++; if (!name_end) name_end = end; } else if (temp[end] == ')') close++; else continue; if (open == close) break; } if (temp[end]) { end++; new_key_name = xstrndup(temp+6, name_end-6); new_key = xstrndup(temp+2, end-2); // skip ', ' while ((db_key = list_next(itr))) { if (!xstrcmp(db_key->name, new_key_name)) { list_remove(itr); break; } } list_iterator_reset(itr); if (db_key) { xstrfmtcat(query, " drop key %s,", db_key->name); xstrfmtcat(correct_query, " drop key %s,", db_key->name); _destroy_db_key(db_key); } else { xstrfmtcat(correct_query, " drop key %s,", new_key_name); info("adding %s to table %s", new_key, table_name); } xstrfmtcat(query, " add %s,", new_key); xstrfmtcat(correct_query, " add %s,", new_key); xfree(new_key); xfree(new_key_name); } temp2 = temp + end; } /* flush extra (old) keys */ while ((db_key = list_next(itr))) { info("dropping key %s from table %s", db_key->name, table_name); xstrfmtcat(query, " drop key %s,", db_key->name); } list_iterator_destroy(itr); FREE_NULL_LIST(keys_list); query[strlen(query)-1] = ';'; correct_query[strlen(correct_query)-1] = ';'; //info("%d query\n%s", __LINE__, query); /* see if we have already done this definition */ if (!adding) { char *quoted = slurm_add_slash_to_quotes(query); char *query2 = xstrdup_printf("select table_name from " "%s where definition='%s'", table_defs_table, quoted); MYSQL_RES *result = NULL; MYSQL_ROW row; xfree(quoted); run_update = 1; if ((result = mysql_db_query_ret(mysql_conn, query2, 0))) { if ((row = mysql_fetch_row(result))) run_update = 0; mysql_free_result(result); } xfree(query2); if (run_update) { run_update = 2; query2 = xstrdup_printf("select table_name from " "%s where table_name='%s'", table_defs_table, table_name); if ((result = mysql_db_query_ret( mysql_conn, query2, 0))) { if ((row = mysql_fetch_row(result))) run_update = 1; mysql_free_result(result); } xfree(query2); } } /* if something has changed run the alter line */ if (run_update || adding) { time_t now = time(NULL); char *query2 = NULL; char *quoted = NULL; if (run_update == 2) debug4("Table %s doesn't exist, adding", table_name); else debug("Table %s has changed. Updating...", table_name); if (mysql_db_query(mysql_conn, query)) { xfree(query); return SLURM_ERROR; } quoted = slurm_add_slash_to_quotes(correct_query); query2 = xstrdup_printf("insert into %s (creation_time, " "mod_time, table_name, definition) " "values (%ld, %ld, '%s', '%s') " "on duplicate key update " "definition='%s', mod_time=%ld;", table_defs_table, now, now, table_name, quoted, quoted, now); xfree(quoted); if (mysql_db_query(mysql_conn, query2)) { xfree(query2); return SLURM_ERROR; } xfree(query2); } xfree(query); xfree(correct_query); query = xstrdup_printf("make table current %s", table_name); END_TIMER2(query); xfree(query); return SLURM_SUCCESS; }