/*___INFO__MARK_BEGIN__*/ /************************************************************************* * * The Contents of this file are made available subject to the terms of * the Sun Industry Standards Source License Version 1.2 * * Sun Microsystems Inc., March, 2001 * * * Sun Industry Standards Source License Version 1.2 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.2 (the "License"); You may not use this file * except in compliance with the License. You may obtain a copy of the * License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2001 by Sun Microsystems, Inc. * * All Rights Reserved. * ************************************************************************/ /*___INFO__MARK_END__*/ #include #include #include #include #include "rmon/sgermon.h" #include "cull/cull_sort.h" #include "uti/sge_dstring.h" #include "uti/sge_prog.h" #include "uti/sge_parse_num_par.h" #include "uti/setup_path.h" #include "uti/sge_time.h" #include "uti/sge_stdlib.h" #include "sgeobj/sge_all_listsL.h" #include "sgeobj/sge_host.h" #include "sgeobj/parse.h" #include "sgeobj/sge_range.h" #include "sgeobj/sge_conf.h" #include "sgeobj/sge_answer.h" #include "sgeobj/sge_binding.h" #include "sgeobj/sge_pe.h" #include "sgeobj/sge_qinstance.h" #include "sgeobj/sge_qinstance_state.h" #include "sgeobj/sge_centry.h" #include "sgeobj/sge_schedd_conf.h" #include "sgeobj/sge_cqueue.h" #include "sgeobj/sge_ja_task.h" #include "sgeobj/sge_job.h" #include "sgeobj/sge_qinstance_type.h" #include "sgeobj/sge_ulong.h" #include "sgeobj/sge_usage.h" #include "sched/sge_sched.h" #include "sched/sge_urgency.h" #include "sched/sge_support.h" #include "sched/load_correction.h" #include "gdi/sge_gdi_ctx.h" #include "gdi/sge_gdi.h" #include "sge_cqueue_qstat.h" #include "sge_qstat.h" #include "qstat_printing.h" #include "sge.h" #include "msg_clients_common.h" static int qstat_env_get_all_lists(qstat_env_t *qstat_env, bool need_job_list, lList** alpp); int qstat_env_filter_queues(qstat_env_t *qstat_env, lList** filtered_queue_list, lList **alpp); static int filter_jobs(qstat_env_t *qstat_env, lList **alpp); static void calc_longest_queue_length(qstat_env_t *qstat_env); static int qstat_env_prepare(qstat_env_t* qstat_env, bool need_job_list, lList **alpp); static void remove_tagged_jobs(lList *job_list); static int qstat_handle_running_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); void qstat_env_destroy(qstat_env_t* qstat_env) { /* Free the lLists */ lFreeList(&qstat_env->resource_list); lFreeList(&qstat_env->qresource_list); lFreeList(&qstat_env->queueref_list); lFreeList(&qstat_env->peref_list); lFreeList(&qstat_env->user_list); lFreeList(&qstat_env->queue_user_list); lFreeList(&qstat_env->queue_list); lFreeList(&qstat_env->centry_list); lFreeList(&qstat_env->exechost_list); lFreeList(&qstat_env->schedd_config); lFreeList(&qstat_env->pe_list); lFreeList(&qstat_env->ckpt_list); lFreeList(&qstat_env->acl_list); lFreeList(&qstat_env->zombie_list); lFreeList(&qstat_env->job_list); lFreeList(&qstat_env->hgrp_list); lFreeList(&qstat_env->project_list); /* Free the lEnumerations */ lFreeWhat(&qstat_env->what_JB_Type); lFreeWhat(&qstat_env->what_JAT_Type_list); lFreeWhat(&qstat_env->what_JAT_Type_template); /* Do not free the context - it's a reference */ qstat_env->ctx = NULL; } static int handle_queue(lListElem *q, qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); static int handle_jobs_queue(lListElem *qep, qstat_env_t* qstat_env, int print_jobs_of_queue, qstat_handler_t *handler, lList **alpp); static int sge_handle_job(lListElem *job, lListElem *jatep, lListElem *qep, lListElem *gdil_ep, bool print_jobid, char *master, dstring *dyn_task_str, int slots, int slot, int slots_per_line, qstat_env_t *qstat_env, job_handler_t *handler, lList **alpp ); static int job_handle_subtask(lListElem *job, lListElem *ja_task, lListElem *pe_task, job_handler_t *handler, lList **alpp ); static int handle_pending_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); static int handle_finished_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); static int handle_error_jobs(qstat_env_t *qstat_env, qstat_handler_t* handler, lList **alpp); static int handle_zombie_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); static int handle_jobs_not_enrolled(lListElem *job, bool print_jobid, char *master, int slots, int slot, int *count, qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp); static int job_handle_resources(lList* cel, lList* centry_list, int slots, job_handler_t *handler, int(*start_func)(job_handler_t* handler, lList **alpp), int(*resource_func)(job_handler_t *handler, const char* name, const char* value, double uc, lList **alpp), int(*finish_func)(job_handler_t* handler, lList **alpp), lList **alpp); static void print_qstat_env_to(qstat_env_t *qstat_env, FILE* file); int qselect(qstat_env_t* qstat_env, qselect_handler_t* handler, lList **alpp) { lListElem *cqueue = NULL; lListElem *qep = NULL; DENTER(TOP_LAYER,"qselect"); /* we need the queue list in any case */ qstat_env->need_queues = true; if (qstat_env_prepare(qstat_env, false, alpp) != 0) { DRETURN(1); } if (qstat_env_filter_queues(qstat_env, NULL, alpp) <= 0) { DRETURN(1); } /* Do output */ if (handler->report_started != NULL) { handler->report_started(handler, alpp); } for_each(cqueue, qstat_env->queue_list) { lList *qinstance_list = lGetList(cqueue, CQ_qinstances); for_each(qep, qinstance_list) { if ((lGetUlong(qep, QU_tag) & TAG_SHOW_IT)!=0) { if (handler->report_queue != NULL) { handler->report_queue(handler, lGetString(qep, QU_full_name), alpp); } } } } if (handler->report_finished != NULL) { handler->report_finished(handler, alpp); } DRETURN(0); } int qstat_cqueue_summary(qstat_env_t *qstat_env, cqueue_summary_handler_t *handler, lList **alpp) { int ret = 0; lListElem *cqueue = NULL; DENTER(TOP_LAYER,"qstat_cqueue_summary"); if ((ret = qstat_env_prepare(qstat_env, true, alpp)) != 0 ) { DPRINTF(("qstat_env_prepare failed\n")); DRETURN(ret); } if ((ret = qstat_env_filter_queues(qstat_env, NULL, alpp)) < 0) { DPRINTF(("qstat_env_filter_queues failed\n")); DRETURN(ret); } if ((ret = filter_jobs(qstat_env, alpp)) != 0) { DPRINTF(("filter_jobs failed\n")); DRETURN(ret); } calc_longest_queue_length(qstat_env); correct_capacities(qstat_env->exechost_list, qstat_env->centry_list); handler->qstat_env = qstat_env; if (handler->report_started != NULL) { ret = handler->report_started(handler, alpp); if (ret) { DRETURN(ret); } } for_each (cqueue, qstat_env->queue_list) { if (lGetUlong(cqueue, CQ_tag) != TAG_DEFAULT) { cqueue_summary_t summary; memset(&summary, 0, sizeof(cqueue_summary_t)); cqueue_calculate_summary(cqueue, qstat_env->exechost_list, qstat_env->centry_list, &(summary.load), &(summary.is_load_available), &(summary.used), &(summary.resv), &(summary.total), &(summary.suspend_manual), &(summary.suspend_threshold), &(summary.suspend_on_subordinate), &(summary.suspend_calendar), &(summary.unknown), &(summary.load_alarm), &(summary.disabled_manual), &(summary.disabled_calendar), &(summary.ambiguous), &(summary.orphaned), &(summary.error), &(summary.available), &(summary.temp_disabled), &(summary.manual_intervention)); if (handler->report_cqueue != NULL && (ret = handler->report_cqueue(handler, lGetString(cqueue, CQ_name), &summary, alpp))) { DRETURN(ret); } } } if (handler->report_finished != NULL) { ret = handler->report_finished(handler, alpp); if (ret) { DRETURN(ret); } } handler->qstat_env = NULL; DRETURN(0); } int qstat_no_group(qstat_env_t* qstat_env, qstat_handler_t* handler, lList **alpp) { int ret = 0; DENTER(TOP_LAYER,"qstat_no_group"); if (getenv("SGE_QSTAT_ENV_DEBUG") != NULL) { print_qstat_env_to(qstat_env, stdout); qstat_env->global_showjobs = 1; qstat_env->global_showqueues = 1; } if ((ret = qstat_env_prepare(qstat_env, true, alpp)) != 0 ) { DRETURN(ret); } if ((ret = qstat_env_filter_queues(qstat_env, NULL, alpp)) < 0 ) { DRETURN(ret); } if ((ret = filter_jobs(qstat_env, alpp)) != 0 ) { DRETURN(ret); } calc_longest_queue_length(qstat_env); correct_capacities(qstat_env->exechost_list, qstat_env->centry_list); handler->qstat_env = qstat_env; handler->job_handler.qstat_env = qstat_env; if (handler->report_started && (ret = handler->report_started(handler, alpp))) { DPRINTF(("report_started failed\n")); DRETURN(ret); } if ((ret = qstat_handle_running_jobs(qstat_env, handler, alpp))) { DPRINTF(("qstat_handle_running_jobs failed\n")); DRETURN(ret); } remove_tagged_jobs(qstat_env->job_list); /* sort pending jobs */ if (lGetNumberOfElem(qstat_env->job_list)>0 ) { sgeee_sort_jobs(&(qstat_env->job_list)); } /* * * step 4: iterate over jobs that are pending; * tag them with TAG_FOUND_IT * * print the jobs that run in these queues * */ if ((ret = handle_pending_jobs(qstat_env, handler, alpp))) { DPRINTF(("handle_pending_jobs failed\n")); DRETURN(ret); } /* * * step 5: in case of SGE look for finished jobs and view them as * finished a non SGE-qstat will show them as error jobs * */ if ((ret=handle_finished_jobs(qstat_env, handler, alpp))) { DPRINTF(("handle_finished_jobs failed\n")); DRETURN(ret); } /* * * step 6: look for jobs not found. This should not happen, cause each * job is running in a queue, or pending. But if there is * s.th. wrong we have * to ensure to print this job just to give hints whats wrong * */ if ((ret=handle_error_jobs(qstat_env, handler, alpp))) { DPRINTF(("handle_error_jobs failed\n")); DRETURN(ret); } /* * * step 7: print recently finished jobs ('zombies') * */ if ((ret=handle_zombie_jobs(qstat_env, handler, alpp))) { DPRINTF(("handle_zombie_jobs failed\n")); DRETURN(ret); } if (handler->report_finished && (ret = handler->report_finished(handler, alpp))) { DPRINTF(("report_finished failed\n")); DRETURN(ret); } handler->qstat_env = NULL; handler->job_handler.qstat_env = NULL; DRETURN(0); } static void calc_longest_queue_length(qstat_env_t *qstat_env) { u_long32 name; char *env; lListElem *qep = NULL; if ((qstat_env->group_opt & GROUP_CQ_SUMMARY) == 0) { name = QU_full_name; } else { name = CQ_name; } if ((env = getenv("SGE_LONG_QNAMES")) != NULL){ qstat_env->longest_queue_length = atoi(env); if (qstat_env->longest_queue_length == -1) { for_each(qep, qstat_env->queue_list) { int length; const char *queue_name =lGetString(qep, name); if ((length = strlen(queue_name)) > qstat_env->longest_queue_length){ qstat_env->longest_queue_length = length; } } } else { if (qstat_env->longest_queue_length < 10) { qstat_env->longest_queue_length = 10; } } } } static int qstat_env_prepare(qstat_env_t* qstat_env, bool need_job_list, lList **alpp) { int ret = 0; DENTER(TOP_LAYER,"qstat_env_prepare"); ret = qstat_env_get_all_lists(qstat_env, need_job_list, alpp); if (ret) { DRETURN(ret); } else { lFreeList(alpp); } ret = sconf_set_config(&(qstat_env->schedd_config), alpp); if (!ret){ DPRINTF(("sconf_set_config failed\n")); DRETURN(ret); } centry_list_init_double(qstat_env->centry_list); sge_stopwatch_log(0, "Time for getting all lists"); if (getenv("MORE_INFO")) { if (qstat_env->global_showjobs) { lWriteListTo(qstat_env->job_list, stdout); DRETURN(0); } if (qstat_env->global_showqueues) { lWriteListTo(qstat_env->queue_list, stdout); DRETURN(0); } } DRETURN(0); } static void remove_tagged_jobs(lList *job_list) { lListElem *jep = lFirst(job_list); lListElem *tmp = NULL; while (jep) { lList *task_list; lListElem *jatep, *tmp_jatep; tmp = lNext(jep); task_list = lGetList(jep, JB_ja_tasks); jatep = lFirst(task_list); while (jatep) { tmp_jatep = lNext(jatep); if ((lGetUlong(jatep, JAT_suitable) & TAG_FOUND_IT)) { lRemoveElem(task_list, &jatep); } jatep = tmp_jatep; } jep = tmp; } } static int qstat_handle_running_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { lListElem *qep = NULL; int ret = 0; DENTER(TOP_LAYER,"qstat_handle_running_jobs"); /* no need to iterate through queues if queues are not printed */ if (!qstat_env->need_queues) { if ((ret = handle_jobs_queue(NULL, qstat_env, 1, handler, alpp))) { DPRINTF(("handle_jobs_queue failed\n")); } DRETURN(ret); } /* handle running jobs of a queue */ for_each(qep, qstat_env->queue_list) { const char* queue_name = lGetString(qep, QU_full_name); /* here we have the queue */ if (lGetUlong(qep, QU_tag) & TAG_SHOW_IT) { if ((qstat_env->full_listing & QSTAT_DISPLAY_NOEMPTYQ) && !qinstance_slots_used(qep)) { continue; } if (handler->report_queue_started && (ret=handler->report_queue_started(handler, queue_name, alpp))) { DPRINTF(("report_queue_started failed\n")); break; } if ((ret=handle_queue(qep, qstat_env, handler, alpp))) { DPRINTF(("handle_queue failed\n")); break; } if (qstat_env->shut_me_down != NULL && qstat_env->shut_me_down()) { DPRINTF(("shut_me_down\n")); ret = 1; break; } if ((ret = handle_jobs_queue(qep, qstat_env, 1, handler, alpp))) { DPRINTF(("handle_jobs_queue failed\n")); break; } if (handler->report_queue_finished && (ret=handler->report_queue_finished(handler, queue_name, alpp))) { DPRINTF(("report_queue_finished failed\n")); break; } } } DRETURN(ret); } static int handle_jobs_queue(lListElem *qep, qstat_env_t* qstat_env, int print_jobs_of_queue, qstat_handler_t *handler, lList **alpp) { lListElem *jlep; lListElem *jatep; lListElem *gdilep, *old_gdilep = NULL; u_long32 job_tag; u_long32 jid = 0, old_jid; u_long32 jataskid = 0, old_jataskid; const char *qnm = qep?lGetString(qep, QU_full_name):NULL; int ret = 0; dstring dyn_task_str = DSTRING_INIT; DENTER(TOP_LAYER, "handle_jobs_queue"); if (handler->report_queue_jobs_started && (ret=handler->report_queue_jobs_started(handler, qnm, alpp)) ) { DPRINTF(("report_queue_jobs_started failed\n")); goto error; } for_each(jlep, qstat_env->job_list) { int master, i; for_each(jatep, lGetList(jlep, JB_ja_tasks)) { u_long32 jstate = lGetUlong(jatep, JAT_state); if (qstat_env->shut_me_down && qstat_env->shut_me_down()) { DPRINTF(("shut_me_down\n")); ret = 1; goto error; } if (ISSET(jstate, JSUSPENDED_ON_SUBORDINATE) || ISSET(jstate, JSUSPENDED_ON_SLOTWISE_SUBORDINATE)) { lSetUlong(jatep, JAT_state, jstate & ~JRUNNING); } for_each (gdilep, lGetList(jatep, JAT_granted_destin_identifier_list)) { if (!qep || !strcmp(lGetString(gdilep, JG_qname), qnm)) { int slot_adjust = 0; int lines_to_print; int slots_per_line = 0; int slots_in_queue = lGetUlong(gdilep, JG_slots); if (!qep) qnm = lGetString(gdilep, JG_qname); job_tag = lGetUlong(jatep, JAT_suitable); job_tag |= TAG_FOUND_IT; lSetUlong(jatep, JAT_suitable, job_tag); master = !strcmp(qnm, lGetString(lFirst(lGetList(jatep, JAT_granted_destin_identifier_list)), JG_qname)); if (master) { const char *pe_name; lListElem *pe; if (((pe_name=lGetString(jatep, JAT_granted_pe))) && ((pe=pe_list_locate(qstat_env->pe_list, pe_name))) && !lGetBool(pe, PE_job_is_first_task)) slot_adjust = 1; } /* job distribution view ? */ if (!(qstat_env->group_opt & GROUP_NO_PETASK_GROUPS)) { /* no - condensed ouput format */ if (!master && !(qstat_env->full_listing & QSTAT_DISPLAY_FULL)) { /* skip all slave outputs except in full display mode */ continue; } /* print only on line per job for this queue */ lines_to_print = 1; /* always only show the number of job slots represented by the line */ if ((qstat_env->full_listing & QSTAT_DISPLAY_FULL)) { slots_per_line = slots_in_queue; } else { slots_per_line = sge_granted_slots(lGetList(jatep, JAT_granted_destin_identifier_list)); } } else { /* yes */ lines_to_print = (int)slots_in_queue+slot_adjust; slots_per_line = 1; } for (i=0; ifull_listing & QSTAT_DISPLAY_RUNNING)) { print_jobid = ((master && (i==0)) ? true : false); } else { print_jobid = false; } } if (!lGetNumberOfElem(qstat_env->user_list) || (lGetNumberOfElem(qstat_env->user_list) && (lGetUlong(jatep, JAT_suitable)&TAG_SELECT_IT))) { if (print_jobs_of_queue && (job_tag & TAG_SHOW_IT)) { if ((qstat_env->full_listing & QSTAT_DISPLAY_RUNNING) && (lGetUlong(jatep, JAT_state) & JRUNNING) ) { print_it = true; } else if ((qstat_env->full_listing & QSTAT_DISPLAY_SUSPENDED) && ((lGetUlong(jatep, JAT_state)&JSUSPENDED) || (lGetUlong(jatep, JAT_state)&JSUSPENDED_ON_THRESHOLD) || (lGetUlong(jatep, JAT_state)&JSUSPENDED_ON_SUBORDINATE) || (lGetUlong(jatep, JAT_state)&JSUSPENDED_ON_SLOTWISE_SUBORDINATE))) { print_it = true; } else if ((qstat_env->full_listing & QSTAT_DISPLAY_USERHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_USER)) { print_it = true; } else if ((qstat_env->full_listing & QSTAT_DISPLAY_OPERATORHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_OPERATOR)) { print_it = true; } else if ((qstat_env->full_listing & QSTAT_DISPLAY_SYSTEMHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_SYSTEM)) { print_it = true; } else if ((qstat_env->full_listing & QSTAT_DISPLAY_JOBARRAYHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_JA_AD)) { print_it = true; } else { print_it = false; } if (print_it) { sge_dstring_sprintf(&dyn_task_str, sge_u32, jataskid); ret = sge_handle_job(jlep, jatep, qep, gdilep, print_jobid, (master && different && (i==0))?"MASTER":"SLAVE", &dyn_task_str, slots_in_queue+slot_adjust, i, slots_per_line, qstat_env, &(handler->job_handler), alpp ); if (ret) { goto error; } } } } } } } } } if (handler->report_queue_jobs_finished && (ret=handler->report_queue_jobs_finished(handler, qnm, alpp)) ) { DPRINTF(("report_queue_jobs_finished failed\n")); goto error; } error: sge_dstring_free(&dyn_task_str); DRETURN(ret); } static int filter_jobs(qstat_env_t *qstat_env, lList **alpp) { lListElem *jep = NULL; lListElem *jatep = NULL; lListElem *up = NULL; DENTER(TOP_LAYER,"filter_jobs"); /* ** all jobs are selected */ for_each (jep, qstat_env->job_list) { for_each (jatep, lGetList(jep, JB_ja_tasks)) { if (!(lGetUlong(jatep, JAT_status) & JFINISHED)) lSetUlong(jatep, JAT_suitable, TAG_SHOW_IT); } } /* ** tag only jobs which satisfy the user list */ if (lGetNumberOfElem(qstat_env->user_list)) { DPRINTF(("------- selecting jobs -----------\n")); /* ok, now we untag the jobs if the user_list was specified */ for_each(up, qstat_env->user_list) for_each (jep, qstat_env->job_list) { if (up && lGetString(up, ST_name) && !fnmatch(lGetString(up, ST_name), lGetString(jep, JB_owner), FNM_NOESCAPE)) { for_each (jatep, lGetList(jep, JB_ja_tasks)) { lSetUlong(jatep, JAT_suitable, lGetUlong(jatep, JAT_suitable)|TAG_SHOW_IT|TAG_SELECT_IT); } } } } if (lGetNumberOfElem(qstat_env->peref_list) || lGetNumberOfElem(qstat_env->queueref_list) || lGetNumberOfElem(qstat_env->resource_list) || lGetNumberOfElem(qstat_env->queue_user_list)) { lListElem *cqueue = NULL; lListElem *qep = NULL; /* ** unselect all pending jobs that fit in none of the selected queues ** that way the pending jobs are really pending jobs for the queues ** printed */ sconf_set_qs_state(QS_STATE_EMPTY); for_each(jep, qstat_env->job_list) { int ret, show_job; show_job = 0; for_each(cqueue, qstat_env->queue_list) { const lList *qinstance_list = lGetList(cqueue, CQ_qinstances); for_each(qep, qinstance_list) { lListElem *host = NULL; if (!(lGetUlong(qep, QU_tag) & TAG_SHOW_IT)) { continue; } host = host_list_locate(qstat_env->exechost_list, lGetHost(qep, QU_qhostname)); if (host != NULL) { ret = sge_select_queue(lGetList(jep, JB_hard_resource_list), qep, host, qstat_env->exechost_list, qstat_env->centry_list, true, 1, qstat_env->queue_user_list, qstat_env->acl_list, jep); if (ret==1) { show_job = 1; break; } } /* we should have an error message here, even so it should not happen, that we have queue instances without a host, but.... */ } } for_each (jatep, lGetList(jep, JB_ja_tasks)) { if (!show_job && !(lGetUlong(jatep, JAT_status) == JRUNNING || (lGetUlong(jatep, JAT_status) == JTRANSFERING))) { DPRINTF(("show task "sge_u32"."sge_u32"\n", lGetUlong(jep, JB_job_number), lGetUlong(jatep, JAT_task_number))); lSetUlong(jatep, JAT_suitable, lGetUlong(jatep, JAT_suitable) & ~TAG_SHOW_IT); } } if (!show_job) { lSetList(jep, JB_ja_n_h_ids, NULL); lSetList(jep, JB_ja_u_h_ids, NULL); lSetList(jep, JB_ja_o_h_ids, NULL); lSetList(jep, JB_ja_s_h_ids, NULL); } } sconf_set_qs_state(QS_STATE_FULL); } /* * step 2.5: reconstruct queue stata structure */ if ((qstat_env->group_opt & GROUP_CQ_SUMMARY) != 0) { lPSortList(qstat_env->queue_list, "%I+ ", CQ_name); } else { lList *tmp_queue_list = NULL; lListElem *cqueue = NULL; tmp_queue_list = lCreateList("", QU_Type); for_each(cqueue, qstat_env->queue_list) { lList *qinstances = NULL; lXchgList(cqueue, CQ_qinstances, &qinstances); lAddList(tmp_queue_list, &qinstances); } lFreeList(&(qstat_env->queue_list)); qstat_env->queue_list = tmp_queue_list; tmp_queue_list = NULL; lPSortList(qstat_env->queue_list, "%I+ %I+ %I+", QU_seq_no, QU_qname, QU_qhostname); } DRETURN(0); } /*-------------------------------------------------------------------------*/ int qstat_env_filter_queues( qstat_env_t *qstat_env, lList** filtered_queue_list, lList **alpp) { int ret = 0; DENTER(TOP_LAYER, "qstat_env_filter_queues"); ret = filter_queues(NULL, qstat_env->queue_list, qstat_env->centry_list, qstat_env->hgrp_list, qstat_env->exechost_list, qstat_env->acl_list, qstat_env->project_list, qstat_env->pe_list, qstat_env->resource_list, qstat_env->queueref_list, qstat_env->peref_list, qstat_env->queue_user_list, qstat_env->queue_state, alpp); DRETURN(ret); } int filter_queues(lList **filtered_queue_list, lList *queue_list, lList *centry_list, lList *hgrp_list, lList *exechost_list, lList *acl_list, lList *prj_list, lList *pe_list, lList *resource_list, lList *queueref_list, lList *peref_list, lList *queue_user_list, u_long32 queue_states, lList **alpp) { int nqueues = 0; /* u_long32 empty_qs = 0; */ u_long32 empty_qs = 1; DENTER(TOP_LAYER, "filter_queues"); centry_list_init_double(centry_list); DPRINTF(("------- selecting queues -----------\n")); /* all queues are selected */ cqueue_list_set_tag(queue_list, TAG_SHOW_IT, true); /* unseclect all queues not selected by a -q (if exist) */ if (lGetNumberOfElem(queueref_list)>0) { if ((nqueues=select_by_qref_list(queue_list, hgrp_list, queueref_list))<0) { DRETURN(-1); } if (nqueues==0) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_QSTAT_NOQUEUESREMAININGAFTERXQUEUESELECTION_S, "-q"); if (filtered_queue_list != NULL) { *filtered_queue_list = NULL; } DRETURN(0); } } /* unselect all queues not selected by -qs */ select_by_queue_state(queue_states, exechost_list, queue_list, centry_list); /* unselect all queues not selected by a -U (if exist) */ if (lGetNumberOfElem(queue_user_list)>0) { if ((nqueues=select_by_queue_user_list(exechost_list, queue_list, queue_user_list, acl_list, prj_list))<0) { DRETURN(-1); } if (nqueues==0) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_QSTAT_NOQUEUESREMAININGAFTERXQUEUESELECTION_S, "-U"); if (filtered_queue_list != NULL) { *filtered_queue_list = NULL; } DRETURN(0); } } /* unselect all queues not selected by a -pe (if exist) */ if (lGetNumberOfElem(peref_list)>0) { if ((nqueues=select_by_pe_list(queue_list, peref_list, pe_list))<0) { DRETURN(-1); } if (nqueues==0) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_QSTAT_NOQUEUESREMAININGAFTERXQUEUESELECTION_S, "-pe"); if (filtered_queue_list != NULL) { *filtered_queue_list = NULL; } DRETURN(0); } } /* unselect all queues not selected by a -l (if exist) */ if (lGetNumberOfElem(resource_list)) { if (select_by_resource_list(resource_list, exechost_list, queue_list, centry_list, empty_qs)<0) { DRETURN(-1); } } if (rmon_mlgetl(&RMON_DEBUG_ON, GDI_LAYER) & INFOPRINT) { lListElem *cqueue; for_each(cqueue, queue_list) { lListElem *qep; lList *qinstance_list = lGetList(cqueue, CQ_qinstances); for_each(qep, qinstance_list) { if ((lGetUlong(qep, QU_tag) & TAG_SHOW_IT)!=0) { DPRINTF(("++ %s\n", lGetString(qep, QU_full_name))); } else { DPRINTF(("-- %s\n", lGetString(qep, QU_full_name))); } } } } if (!is_cqueue_selected(queue_list)) { if (filtered_queue_list != NULL) { *filtered_queue_list = NULL; } DRETURN(0); } if (filtered_queue_list != NULL) { static lCondition *tagged_queues = NULL; static lEnumeration *all_fields = NULL; if (!tagged_queues) { tagged_queues = lWhere("%T(%I == %u)", CQ_Type, CQ_tag, TAG_SHOW_IT); all_fields = lWhat("%T(ALL)", CQ_Type); } *filtered_queue_list = lSelect("FQL", queue_list, tagged_queues, all_fields); } DRETURN(1); } static int qstat_env_get_all_lists(qstat_env_t* qstat_env, bool need_job_list, lList** alpp) { lList **queue_l = qstat_env->need_queues ? &(qstat_env->queue_list) : NULL; lList **job_l = need_job_list ? &(qstat_env->job_list) : NULL; lList **centry_l = &(qstat_env->centry_list); lList **exechost_l = &(qstat_env->exechost_list); lList **sc_l = &(qstat_env->schedd_config); lList **pe_l = &(qstat_env->pe_list); lList **ckpt_l = &(qstat_env->ckpt_list); lList **acl_l = &(qstat_env->acl_list); lList **zombie_l = &(qstat_env->zombie_list); lList **hgrp_l = &(qstat_env->hgrp_list); /*lList *queueref_list = qstat_env->queueref_list; lList *peref_list = qstat_env->peref_list;*/ lList *user_list = qstat_env->user_list; lList **project_l = &(qstat_env->project_list); u_long32 show = qstat_env->full_listing; lCondition *where= NULL, *nw = NULL; lCondition *zw = NULL, *gc_where = NULL; lEnumeration *q_all, *pe_all, *ckpt_all, *acl_all, *ce_all, *up_all; lEnumeration *eh_all, *sc_what, *gc_what, *hgrp_what; lListElem *ep = NULL; lList *conf_l = NULL; lList *mal = NULL; int q_id = 0, j_id = 0, pe_id = 0, ckpt_id = 0, acl_id = 0, z_id = 0, up_id = 0; int ce_id, eh_id, sc_id, gc_id, hgrp_id = 0; int show_zombies = (show & QSTAT_DISPLAY_ZOMBIES) ? 1 : 0; state_gdi_multi state = STATE_GDI_MULTI_INIT; const char *cell_root = qstat_env->ctx->get_cell_root(qstat_env->ctx); u_long32 progid = qstat_env->ctx->get_who(qstat_env->ctx); DENTER(TOP_LAYER, "qstat_env_get_all_lists"); if (queue_l) { DPRINTF(("need queues\n")); q_all = lWhat("%T(ALL)", CQ_Type); q_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_CQ_LIST, SGE_GDI_GET, NULL, NULL, q_all, &state, true); lFreeWhat(&q_all); if (answer_list_has_error(alpp)) { DRETURN(1); } } else { DPRINTF(("queues not needed\n")); } /* ** jobs */ if (job_l) { lCondition *where = qstat_get_JB_Type_selection(user_list, show); lEnumeration *what = qstat_get_JB_Type_filter(qstat_env); j_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_JB_LIST, SGE_GDI_GET, NULL, where, what, &state, true); lFreeWhere(&where); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** job zombies */ if (zombie_l && show_zombies) { for_each(ep, user_list) { nw = lWhere("%T(%I p= %s)", JB_Type, JB_owner, lGetString(ep, ST_name)); if (!zw) zw = nw; else zw = lOrWhere(zw, nw); } z_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_ZOMBIE_LIST, SGE_GDI_GET, NULL, zw, qstat_get_JB_Type_filter(qstat_env), &state, true); lFreeWhere(&zw); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** complexes */ ce_all = lWhat("%T(ALL)", CE_Type); ce_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_CE_LIST, SGE_GDI_GET, NULL, NULL, ce_all, &state, true); lFreeWhat(&ce_all); if (answer_list_has_error(alpp)) { DRETURN(1); } /* ** exechosts */ where = lWhere("%T(%I!=%s)", EH_Type, EH_name, SGE_TEMPLATE_NAME); eh_all = lWhat("%T(ALL)", EH_Type); eh_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_EH_LIST, SGE_GDI_GET, NULL, where, eh_all, &state, true); lFreeWhat(&eh_all); lFreeWhere(&where); if (answer_list_has_error(alpp)) { DRETURN(1); } /* ** pe list */ if (pe_l) { pe_all = lWhat("%T(%I%I%I%I%I)", PE_Type, PE_name, PE_slots, PE_job_is_first_task, PE_control_slaves, PE_urgency_slots); pe_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_PE_LIST, SGE_GDI_GET, NULL, NULL, pe_all, &state, true); lFreeWhat(&pe_all); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** ckpt list */ if (ckpt_l) { ckpt_all = lWhat("%T(%I)", CK_Type, CK_name); ckpt_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_CK_LIST, SGE_GDI_GET, NULL, NULL, ckpt_all, &state, true); lFreeWhat(&ckpt_all); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** acl list */ if (acl_l) { acl_all = lWhat("%T(ALL)", US_Type); acl_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_US_LIST, SGE_GDI_GET, NULL, NULL, acl_all, &state, true); lFreeWhat(&acl_all); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** project list */ if (project_l) { up_all = lWhat("%T(ALL)", PR_Type); up_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_PR_LIST, SGE_GDI_GET, NULL, NULL, up_all, &state, true); lFreeWhat(&up_all); if (answer_list_has_error(alpp)) { DRETURN(1); } } /* ** scheduler configuration */ /* might be enough, but I am not sure */ /*sc_what = lWhat("%T(%I %I)", SC_Type, SC_user_sort, SC_job_load_adjustments);*/ sc_what = lWhat("%T(ALL)", SC_Type); sc_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_SC_LIST, SGE_GDI_GET, NULL, NULL, sc_what, &state, true); lFreeWhat(&sc_what); if (answer_list_has_error(alpp)) { DRETURN(1); } /* ** hgroup */ hgrp_what = lWhat("%T(ALL)", HGRP_Type); hgrp_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_RECORD, SGE_HGRP_LIST, SGE_GDI_GET, NULL, NULL, hgrp_what, &state, true); lFreeWhat(&hgrp_what); if (answer_list_has_error(alpp)) { DRETURN(1); } /* ** global cluster configuration */ gc_where = lWhere("%T(%I c= %s)", CONF_Type, CONF_name, SGE_GLOBAL_NAME); gc_what = lWhat("%T(ALL)", CONF_Type); gc_id = qstat_env->ctx->gdi_multi(qstat_env->ctx, alpp, SGE_GDI_SEND, SGE_CONF_LIST, SGE_GDI_GET, NULL, gc_where, gc_what, &state, true); qstat_env->ctx->gdi_wait(qstat_env->ctx, alpp, &mal, &state); lFreeWhat(&gc_what); lFreeWhere(&gc_where); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* ** handle results */ if (queue_l) { /* --- queue */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_CQ_LIST, q_id, mal, queue_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- job */ if (job_l) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_JB_LIST, j_id, mal, job_l); #if 0 /* EB: debug */ { lListElem *elem = NULL; for_each(elem, *job_l) { lListElem *task = lFirst(lGetList(elem, JB_ja_tasks)); fprintf(stderr, "jid="sge_u32" ", lGetUlong(elem, JB_job_number)); if (task) { dstring string = DSTRING_INIT; fprintf(stderr, "state=%s status=%s job_restarted="sge_u32"\n", sge_dstring_ulong_to_binstring(&string, lGetUlong(task, JAT_state)), sge_dstring_ulong_to_binstring(&string, lGetUlong(task, JAT_status)), lGetUlong(task, JAT_job_restarted)); sge_dstring_free(&string); } else { fprintf(stderr, "\n"); } } } #endif if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* * debug output to perform testsuite tests */ if (sge_getenv("_SGE_TEST_QSTAT_JOB_STATES") != NULL) { fprintf(stderr, "_SGE_TEST_QSTAT_JOB_STATES: jobs_received=%d\n", lGetNumberOfElem(*job_l)); } } /* --- job zombies */ if (zombie_l && show_zombies) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_ZOMBIE_LIST, z_id, mal, zombie_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- complex */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_CE_LIST, ce_id, mal, centry_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* --- exec host */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_EH_LIST, eh_id, mal, exechost_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* --- pe */ if (pe_l) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_PE_LIST, pe_id, mal, pe_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- ckpt */ if (ckpt_l) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_CK_LIST, ckpt_id, mal, ckpt_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- acl */ if (acl_l) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_US_LIST, acl_id, mal, acl_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- project */ if (project_l) { sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_PR_LIST, up_id, mal, project_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } } /* --- scheduler configuration */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_SC_LIST, sc_id, mal, sc_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* --- hgrp */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_HGRP_LIST, hgrp_id, mal, hgrp_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } /* -- apply global configuration for sge_hostcmp() scheme */ sge_gdi_extract_answer(alpp, SGE_GDI_GET, SGE_CONF_LIST, gc_id, mal, &conf_l); if (answer_list_has_error(alpp)) { lFreeList(&mal); DRETURN(1); } if (lFirst(conf_l)) { lListElem *local = NULL; merge_configuration(NULL, progid, cell_root, lFirst(conf_l), local, NULL); } lFreeList(&conf_l); lFreeList(&mal); DRETURN(0); } /* ------------------- Queue Handler ---------------------------------------- */ static int handle_queue(lListElem *q, qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { char arch_string[80]; char *load_avg_str; char load_alarm_reason[MAX_STRING_SIZE]; char suspend_alarm_reason[MAX_STRING_SIZE]; const char *queue_name = NULL; u_long32 interval; queue_summary_t summary; dstring type_string = DSTRING_INIT; dstring state_string = DSTRING_INIT; int ret = 0; DENTER(TOP_LAYER, "handle_queue"); memset(&summary, 0, sizeof(queue_summary_t)); *load_alarm_reason = 0; *suspend_alarm_reason = 0; /* make it possible to display any load value in qstat output */ if (!(load_avg_str=getenv("SGE_LOAD_AVG")) || !strlen(load_avg_str)) load_avg_str = LOAD_ATTR_LOAD_AVG; summary.load_avg_str = load_avg_str; if (!(qstat_env->full_listing & QSTAT_DISPLAY_FULL)) { DRETURN(0); } queue_name = lGetString(q, QU_full_name); /* compute the load and check for alarm states */ summary.has_load_value = sge_get_double_qattr(&(summary.load_avg), load_avg_str, q, qstat_env->exechost_list, qstat_env->centry_list, &(summary.has_load_value_from_object)) ? true : false; if (sge_load_alarm(NULL, q, lGetList(q, QU_load_thresholds), qstat_env->exechost_list, qstat_env->centry_list, NULL, true)) { qinstance_state_set_alarm(q, true); sge_load_alarm_reason(q, lGetList(q, QU_load_thresholds), qstat_env->exechost_list, qstat_env->centry_list, load_alarm_reason, MAX_STRING_SIZE - 1, "load"); } parse_ulong_val(NULL, &interval, TYPE_TIM, lGetString(q, QU_suspend_interval), NULL, 0); if (lGetUlong(q, QU_nsuspend) != 0 && interval != 0 && sge_load_alarm(NULL, q, lGetList(q, QU_suspend_thresholds), qstat_env->exechost_list, qstat_env->centry_list, NULL, false)) { qinstance_state_set_suspend_alarm(q, true); sge_load_alarm_reason(q, lGetList(q, QU_suspend_thresholds), qstat_env->exechost_list, qstat_env->centry_list, suspend_alarm_reason, MAX_STRING_SIZE - 1, "suspend"); } qinstance_print_qtype_to_dstring(q, &type_string, true); summary.queue_type = sge_dstring_get_string(&type_string); summary.resv_slots = qinstance_slots_reserved_now(q); summary.used_slots = qinstance_slots_used(q); summary.total_slots = (int)lGetUlong(q, QU_job_slots); /* arch */ if (!sge_get_string_qattr(arch_string, sizeof(arch_string)-1, LOAD_ATTR_ARCH, q, qstat_env->exechost_list, qstat_env->centry_list)) { summary.arch = arch_string; } else { summary.arch = NULL; } qinstance_state_append_to_dstring(q, &state_string); summary.state = sge_dstring_get_string(&state_string); if (handler->report_queue_summary && (ret=handler->report_queue_summary(handler, queue_name, &summary, alpp))) { DPRINTF(("report_queue_summary failed\n")); goto error; } if ((qstat_env->full_listing & QSTAT_DISPLAY_ALARMREASON)) { if (*load_alarm_reason) { if (handler->report_queue_load_alarm) { if ((ret=handler->report_queue_load_alarm(handler, queue_name, load_alarm_reason, alpp))) { DPRINTF(("report_queue_load_alarm failed\n")); goto error; } } } if (*suspend_alarm_reason) { if (handler->report_queue_suspend_alarm) { if ((ret=handler->report_queue_suspend_alarm(handler, queue_name, suspend_alarm_reason, alpp))) { DPRINTF(("report_queue_suspend_alarm failed\n")); goto error; } } } } if ((qstat_env->explain_bits & QI_ALARM) > 0) { if (*load_alarm_reason) { if (handler->report_queue_load_alarm) { if ((ret=handler->report_queue_load_alarm(handler, queue_name, load_alarm_reason, alpp))) { DPRINTF(("report_queue_load_alarm failed\n")); goto error; } } } } if ((qstat_env->explain_bits & QI_SUSPEND_ALARM) > 0) { if (*suspend_alarm_reason) { if (handler->report_queue_suspend_alarm) { if ((ret=handler->report_queue_suspend_alarm(handler, queue_name, suspend_alarm_reason, alpp))) { DPRINTF(("report_queue_suspend_alarm failed\n")); goto error; } } } } if (qstat_env->explain_bits != QI_DEFAULT && handler->report_queue_message) { lList *qim_list = lGetList(q, QU_message_list); lListElem *qim = NULL; for_each(qim, qim_list) { u_long32 type = lGetUlong(qim, QIM_type); if ((qstat_env->explain_bits & QI_AMBIGUOUS) == type || (qstat_env->explain_bits & QI_ERROR) == type) { const char *message = lGetString(qim, QIM_message); if ((ret=handler->report_queue_message(handler, queue_name, message, alpp))) { DPRINTF(("report_queue_message failed\n")); goto error; } } } } /* view (selected) resources of queue in case of -F [attr,attr,..] */ if (((qstat_env->full_listing & QSTAT_DISPLAY_QRESOURCES)) && handler->report_queue_resource) { dstring resource_string = DSTRING_INIT; lList *rlp; lListElem *rep; char dom[5]; u_long32 dominant = 0; const char *s; rlp = NULL; queue_complexes2scheduler(&rlp, q, qstat_env->exechost_list, qstat_env->centry_list); for_each (rep , rlp) { /* we had a -F request */ if (qstat_env->qresource_list) { lListElem *qres; qres = lGetElemStr(qstat_env->qresource_list, CE_name, lGetString(rep, CE_name)); if (qres == NULL) { qres = lGetElemStr(qstat_env->qresource_list, CE_name, lGetString(rep, CE_shortcut)); } /* if this complex variable wasn't requested with -F, skip it */ if (qres == NULL) { continue ; } } sge_dstring_clear(&resource_string); s = sge_get_dominant_stringval(rep, &dominant, &resource_string); monitor_dominance(dom, dominant); if ((ret=handler->report_queue_resource(handler, dom, lGetString(rep, CE_name), s, alpp))) { DPRINTF(("report_queue_resource failed\n")); break; } } lFreeList(&rlp); sge_dstring_free(&resource_string); } error: sge_dstring_free(&type_string); sge_dstring_free(&state_string); DRETURN(ret); } /* ------------------- Job Handler ------------------------------------------ */ static int handle_pending_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { lListElem *nxt, *jep, *jatep, *nxt_jatep; lList* ja_task_list = NULL; int FoundTasks; int ret = 0; int count = 0; dstring dyn_task_str = DSTRING_INIT; DENTER(TOP_LAYER, "handle_pending_jobs"); nxt = lFirst(qstat_env->job_list); while ((jep=nxt)) { nxt = lNext(jep); nxt_jatep = lFirst(lGetList(jep, JB_ja_tasks)); FoundTasks = 0; while ((jatep = nxt_jatep)) { if (qstat_env->shut_me_down && qstat_env->shut_me_down() ) { DPRINTF(("shut_me_down\n")); break; } nxt_jatep = lNext(jatep); if (!(((qstat_env->full_listing & QSTAT_DISPLAY_OPERATORHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_OPERATOR)) || ((qstat_env->full_listing & QSTAT_DISPLAY_USERHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_USER)) || ((qstat_env->full_listing & QSTAT_DISPLAY_SYSTEMHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_SYSTEM)) || ((qstat_env->full_listing & QSTAT_DISPLAY_JOBARRAYHOLD) && (lGetUlong(jatep, JAT_hold)&MINUS_H_TGT_JA_AD)) || ((qstat_env->full_listing & QSTAT_DISPLAY_JOBHOLD) && lGetList(jep, JB_jid_predecessor_list)) || ((qstat_env->full_listing & QSTAT_DISPLAY_STARTTIMEHOLD) && lGetUlong(jep, JB_execution_time)) || !(qstat_env->full_listing & QSTAT_DISPLAY_HOLD)) ) { break; } if (!(lGetUlong(jatep, JAT_suitable) & TAG_FOUND_IT) && VALID(JQUEUED, lGetUlong(jatep, JAT_state)) && !VALID(JFINISHED, lGetUlong(jatep, JAT_status))) { lSetUlong(jatep, JAT_suitable, lGetUlong(jatep, JAT_suitable)|TAG_FOUND_IT); if ((!lGetNumberOfElem(qstat_env->user_list) || (lGetNumberOfElem(qstat_env->user_list) && (lGetUlong(jatep, JAT_suitable)&TAG_SELECT_IT))) && (lGetUlong(jatep, JAT_suitable)&TAG_SHOW_IT)) { if ((qstat_env->full_listing & QSTAT_DISPLAY_PENDING) && (qstat_env->group_opt & GROUP_NO_TASK_GROUPS) > 0) { sge_dstring_sprintf(&dyn_task_str, sge_u32, lGetUlong(jatep, JAT_task_number)); if (count == 0 && handler->report_pending_jobs_started && (ret=handler->report_pending_jobs_started(handler, alpp))) { DPRINTF(("report_pending_jobs_started failed\n")); goto error; } ret = sge_handle_job(jep, jatep, NULL, NULL, true, NULL, &dyn_task_str, 0, 0, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { DPRINTF(("sge_handle_job failed\n")); goto error; } count++; } else { if (!ja_task_list) { ja_task_list = lCreateList("", lGetElemDescr(jatep)); } lAppendElem(ja_task_list, lCopyElem(jatep)); FoundTasks = 1; } } } } if ((qstat_env->full_listing & QSTAT_DISPLAY_PENDING) && (qstat_env->group_opt & GROUP_NO_TASK_GROUPS) == 0 && FoundTasks && ja_task_list) { lList *task_group = NULL; while ((task_group = ja_task_list_split_group(&ja_task_list))) { sge_dstring_clear(&dyn_task_str); ja_task_list_print_to_string(task_group, &dyn_task_str); if (count == 0 && handler->report_pending_jobs_started && (ret=handler->report_pending_jobs_started(handler, alpp))) { DPRINTF(("report_pending_jobs_started failed\n")); goto error; } ret = sge_handle_job(jep, lFirst(task_group), NULL, NULL, true, NULL, &dyn_task_str, 0, 0, 0, qstat_env, &(handler->job_handler), alpp); lFreeList(&task_group); if (ret) { DPRINTF(("sge_handle_job failed\n")); goto error; } count++; } } if (jep != nxt && (qstat_env->full_listing & QSTAT_DISPLAY_PENDING)) { ret = handle_jobs_not_enrolled(jep, true, NULL, 0, 0, &count, qstat_env, handler, alpp); } } if (count > 0 && handler->report_pending_jobs_finished && (ret=handler->report_pending_jobs_finished(handler, alpp))) { DPRINTF(("report_pending_jobs_finished failed\n")); goto error; } error: sge_dstring_free(&dyn_task_str); lFreeList(&ja_task_list); DRETURN(ret); } static int handle_finished_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { lListElem *jep, *jatep; int ret = 0; int count = 0; dstring dyn_task_str = DSTRING_INIT; DENTER(TOP_LAYER, "handle_finished_jobs"); for_each (jep, qstat_env->job_list) { for_each (jatep, lGetList(jep, JB_ja_tasks)) { if (qstat_env->shut_me_down && qstat_env->shut_me_down()) { DPRINTF(("shut_me_down\n")); ret = -1; break; } if (lGetUlong(jatep, JAT_status) == JFINISHED) { lSetUlong(jatep, JAT_suitable, lGetUlong(jatep, JAT_suitable)|TAG_FOUND_IT); if (!getenv("MORE_INFO")) continue; if (!lGetNumberOfElem(qstat_env->user_list) || (lGetNumberOfElem(qstat_env->user_list) && (lGetUlong(jatep, JAT_suitable)&TAG_SELECT_IT))) { if (count == 0) { if (handler->report_finished_jobs_started && (ret=handler->report_finished_jobs_started(handler, alpp))) { DPRINTF(("report_finished_jobs_started failed\n")); break; } } sge_dstring_sprintf(&dyn_task_str, sge_u32, lGetUlong(jatep, JAT_task_number)); ret = sge_handle_job(jep, jatep, NULL, NULL, true, NULL, &dyn_task_str, 0, 0, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { break; } count++; } } } } if (ret == 0 && count > 0) { if (handler->report_finished_jobs_finished && (ret=handler->report_finished_jobs_finished(handler, alpp))) { DPRINTF(("report_finished_jobs_finished failed\n")); } } sge_dstring_free(&dyn_task_str); DRETURN(ret); } static int handle_error_jobs(qstat_env_t *qstat_env, qstat_handler_t* handler, lList **alpp) { lListElem *jep, *jatep; int ret = 0; int count = 0; dstring dyn_task_str = DSTRING_INIT; DENTER(TOP_LAYER, "handle_error_jobs"); for_each(jep, qstat_env->job_list) { for_each (jatep, lGetList(jep, JB_ja_tasks)) { if (!(lGetUlong(jatep, JAT_suitable) & TAG_FOUND_IT) && lGetUlong(jatep, JAT_status) == JERROR) { lSetUlong(jatep, JAT_suitable, lGetUlong(jatep, JAT_suitable)|TAG_FOUND_IT); if (!lGetNumberOfElem(qstat_env->user_list) || (lGetNumberOfElem(qstat_env->user_list) && (lGetUlong(jatep, JAT_suitable)&TAG_SELECT_IT))) { sge_dstring_sprintf(&dyn_task_str, "sge_u32", lGetUlong(jatep, JAT_task_number)); if (count == 0) { if (handler->report_error_jobs_started && (ret=handler->report_error_jobs_started(handler, alpp))) { DPRINTF(("report_error_jobs_started failed\n")); goto error; } } ret = sge_handle_job(jep, jatep, NULL, NULL, true, NULL, &dyn_task_str, 0, 0, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { goto error; } count++; } } } } if (ret == 0 && count > 0 ) { if (handler->report_error_jobs_finished && (ret=handler->report_error_jobs_finished(handler, alpp))) { DPRINTF(("report_error_jobs_started failed\n")); } } error: sge_dstring_free(&dyn_task_str); DRETURN(ret); } static int handle_zombie_jobs(qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { lListElem *jep; int ret = 0; int count = 0; dstring dyn_task_str = DSTRING_INIT; DENTER(TOP_LAYER, "handle_zombie_jobs"); if (!(qstat_env->full_listing & QSTAT_DISPLAY_ZOMBIES)) { sge_dstring_free(&dyn_task_str); DRETURN(0); } for_each (jep, qstat_env->zombie_list) { lList *z_ids = NULL; z_ids = lGetList(jep, JB_ja_z_ids); if (z_ids != NULL) { lListElem *ja_task = NULL; u_long32 first_task_id = range_list_get_first_id(z_ids, NULL); sge_dstring_clear(&dyn_task_str); ja_task = job_get_ja_task_template_pending(jep, first_task_id); range_list_print_to_string(z_ids, &dyn_task_str, false, false, false); if (count == 0 && handler->report_zombie_jobs_started && (ret=handler->report_zombie_jobs_started(handler, alpp))) { DPRINTF(("report_zombie_jobs_started failed\n")); break; } ret = sge_handle_job(jep, ja_task, NULL, NULL, true, NULL, &dyn_task_str, 0,0, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { break; } count++; } } if (ret == 0 && count > 0 && handler->report_zombie_jobs_finished && (ret=handler->report_zombie_jobs_finished(handler, alpp))) { DPRINTF(("report_zombie_jobs_finished failed\n")); } sge_dstring_free(&dyn_task_str); DRETURN(ret); } static int handle_jobs_not_enrolled(lListElem *job, bool print_jobid, char *master, int slots, int slot, int *count, qstat_env_t *qstat_env, qstat_handler_t *handler, lList **alpp) { lList *range_list[16]; /* RN_Type */ u_long32 hold_state[16]; int i; dstring ja_task_id_string = DSTRING_INIT; int ret = 0; DENTER(TOP_LAYER, "handle_jobs_not_enrolled"); job_create_hold_id_lists(job, range_list, hold_state); for (i = 0; i <= 15; i++) { lList *answer_list = NULL; u_long32 first_id; int show = 0; if (((qstat_env->full_listing & QSTAT_DISPLAY_USERHOLD) && (hold_state[i] & MINUS_H_TGT_USER)) || ((qstat_env->full_listing & QSTAT_DISPLAY_OPERATORHOLD) && (hold_state[i] & MINUS_H_TGT_OPERATOR)) || ((qstat_env->full_listing & QSTAT_DISPLAY_SYSTEMHOLD) && (hold_state[i] & MINUS_H_TGT_SYSTEM)) || ((qstat_env->full_listing & QSTAT_DISPLAY_JOBARRAYHOLD) && (hold_state[i] & MINUS_H_TGT_JA_AD)) || ((qstat_env->full_listing & QSTAT_DISPLAY_STARTTIMEHOLD) && (lGetUlong(job, JB_execution_time) > 0)) || ((qstat_env->full_listing & QSTAT_DISPLAY_JOBHOLD) && (lGetList(job, JB_jid_predecessor_list) != 0)) || (!(qstat_env->full_listing & QSTAT_DISPLAY_HOLD)) ) { show = 1; } if (range_list[i] != NULL && show) { if ((qstat_env->group_opt & GROUP_NO_TASK_GROUPS) == 0) { sge_dstring_clear(&ja_task_id_string); range_list_print_to_string(range_list[i], &ja_task_id_string, false, false, false); first_id = range_list_get_first_id(range_list[i], &answer_list); if (answer_list_has_error(&answer_list) != 1) { lListElem *ja_task = job_get_ja_task_template_hold(job, first_id, hold_state[i]); lList *n_h_ids = NULL; lList *u_h_ids = NULL; lList *o_h_ids = NULL; lList *s_h_ids = NULL; lList *a_h_ids = NULL; lXchgList(job, JB_ja_n_h_ids, &n_h_ids); lXchgList(job, JB_ja_u_h_ids, &u_h_ids); lXchgList(job, JB_ja_o_h_ids, &o_h_ids); lXchgList(job, JB_ja_s_h_ids, &s_h_ids); lXchgList(job, JB_ja_a_h_ids, &a_h_ids); if (*count == 0 && handler->report_pending_jobs_started && (ret=handler->report_pending_jobs_started(handler, alpp))) { DPRINTF(("report_pending_jobs_started failed\n")); ret = 1; break; } ret = sge_handle_job(job, ja_task, NULL, NULL, print_jobid, master, &ja_task_id_string, slots, slot, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { DPRINTF(("sge_handle_job failed\n")); break; } lXchgList(job, JB_ja_n_h_ids, &n_h_ids); lXchgList(job, JB_ja_u_h_ids, &u_h_ids); lXchgList(job, JB_ja_o_h_ids, &o_h_ids); lXchgList(job, JB_ja_s_h_ids, &s_h_ids); lXchgList(job, JB_ja_a_h_ids, &a_h_ids); (*count)++; } } else { lListElem *range; /* RN_Type */ for_each(range, range_list[i]) { u_long32 start, end, step; range_get_all_ids(range, &start, &end, &step); for (; start <= end; start += step) { lListElem *ja_task = job_get_ja_task_template_hold(job, start, hold_state[i]); sge_dstring_sprintf(&ja_task_id_string, sge_u32, start); if (*count == 0 && handler->report_pending_jobs_started && (ret=handler->report_pending_jobs_started(handler, alpp))) { DPRINTF(("report_pending_jobs_started failed\n")); ret = 1; break; } ret = sge_handle_job(job, ja_task, NULL, NULL, print_jobid, NULL, &ja_task_id_string, slots, slot, 0, qstat_env, &(handler->job_handler), alpp); if (ret) { DPRINTF(("sge_handle_job failed\n")); break; } (*count)++; } } } } } job_destroy_hold_id_lists(job, range_list); sge_dstring_free(&ja_task_id_string); DRETURN(ret); } static int sge_handle_job(lListElem *job, lListElem *jatep, lListElem *qep, lListElem *gdil_ep, bool print_jobid, char *master, dstring *dyn_task_str, int slots, int slot, int slots_per_line, qstat_env_t *qstat_env, job_handler_t *handler, lList **alpp ) { u_long32 jstate; int sge_ext, tsk_ext, sge_urg, sge_pri, sge_time; lList *ql = NULL; lListElem *qrep; job_summary_t summary; u_long32 ret = 0; DENTER(TOP_LAYER, "sge_handle_job"); memset(&summary, 0, sizeof(job_summary_t)); summary.print_jobid = print_jobid; summary.is_zombie = job_is_zombie_job(job); if (gdil_ep) summary.queue = lGetString(gdil_ep, JG_qname); sge_ext = ((qstat_env->full_listing & QSTAT_DISPLAY_EXTENDED) == QSTAT_DISPLAY_EXTENDED); tsk_ext = (qstat_env->full_listing & QSTAT_DISPLAY_TASKS); sge_urg = (qstat_env->full_listing & QSTAT_DISPLAY_URGENCY); sge_pri = (qstat_env->full_listing & QSTAT_DISPLAY_PRIORITY); sge_time = !sge_ext; sge_time = sge_time | tsk_ext | sge_urg | sge_pri; summary.nprior = lGetDouble(jatep, JAT_prio); if (sge_pri || sge_urg) { summary.nurg = lGetDouble(job, JB_nurg); } if (sge_pri) { summary.nppri = lGetDouble(job, JB_nppri); } if (sge_pri || sge_ext) { summary.ntckts = lGetDouble(jatep, JAT_ntix); } if (sge_urg) { summary.urg = lGetDouble(job, JB_urg); summary.rrcontr = lGetDouble(job, JB_rrcontr); summary.wtcontr = lGetDouble(job, JB_wtcontr); summary.dlcontr = lGetDouble(job, JB_dlcontr); } if (sge_pri) { summary.priority = lGetUlong(job, JB_priority)-BASE_PRIORITY; } summary.name = lGetString(job, JB_job_name); summary.user = lGetString(job, JB_owner); if (sge_ext) { summary.project = lGetString(job, JB_project); summary.department = lGetString(job, JB_department); } /* move status info into state info */ jstate = lGetUlong(jatep, JAT_state); if (lGetUlong(jatep, JAT_status)==JTRANSFERING) { jstate |= JTRANSFERING; jstate &= ~JRUNNING; } if (lGetList(job, JB_jid_predecessor_list) || lGetUlong(jatep, JAT_hold)) { jstate |= JHELD; } if (lGetUlong(jatep, JAT_job_restarted)) { jstate &= ~JWAITING; jstate |= JMIGRATING; } job_get_state_string(summary.state, jstate); if (sge_time) { summary.submit_time = (time_t)lGetUlong(job, JB_submission_time); summary.start_time = (time_t)lGetUlong(jatep, JAT_start_time); } if (lGetUlong(jatep, JAT_status)==JRUNNING || lGetUlong(jatep, JAT_status)==JTRANSFERING) { summary.is_running = true; } else { summary.is_running = false; } if (sge_urg) { summary.deadline = (time_t)lGetUlong(job, JB_deadline); } if (sge_ext) { lListElem *up, *pe, *task; lList *job_usage_list; const char *pe_name; bool sum_pe_tasks = false; if (master == NULL || strcmp(master, "MASTER") == 0) { if (!(qstat_env->group_opt & GROUP_NO_PETASK_GROUPS)) { sum_pe_tasks = true; } job_usage_list = lCopyList(NULL, lGetList(jatep, JAT_scaled_usage_list)); } else { job_usage_list = lCreateList("", UA_Type); } /* sum pe-task usage based on queue slots */ if (job_usage_list) { int subtask_ndx=1; for_each(task, lGetList(jatep, JAT_task_list)) { lListElem *dst, *src, *ep; const char *qname; if (sum_pe_tasks || (summary.queue && ((ep=lFirst(lGetList(task, PET_granted_destin_identifier_list)))) && ((qname=lGetString(ep, JG_qname))) && !strcmp(qname, summary.queue) && ((subtask_ndx++%slots)==slot))) { for_each(src, lGetList(task, PET_scaled_usage)) { if ((dst=lGetElemStr(job_usage_list, UA_name, lGetString(src, UA_name)))) lSetDouble(dst, UA_value, lGetDouble(dst, UA_value) + lGetDouble(src, UA_value)); else lAppendElem(job_usage_list, lCopyElem(src)); } } } } /* scaled cpu usage */ if (!(up = lGetElemStr(job_usage_list, UA_name, USAGE_ATTR_CPU))) { summary.has_cpu_usage = false; } else { summary.has_cpu_usage = true; summary.cpu_usage = lGetDouble(up, UA_value); } /* scaled mem usage */ if (!(up = lGetElemStr(job_usage_list, UA_name, USAGE_ATTR_MEM))) { summary.has_mem_usage = false; } else { summary.has_mem_usage = true; summary.mem_usage = lGetDouble(up, UA_value); } /* scaled io usage */ if (!(up = lGetElemStr(job_usage_list, UA_name, USAGE_ATTR_IO))) { summary.has_io_usage = false; } else { summary.has_io_usage = true; summary.io_usage = lGetDouble(up, UA_value); } lFreeList(&job_usage_list); /* get tickets for job/slot */ summary.override_tickets = lGetUlong(job, JB_override_tickets); summary.share = lGetDouble(jatep, JAT_share); if (sge_ext) { summary.is_queue_assigned = false; } else { if (lGetList(jatep, JAT_granted_destin_identifier_list) != NULL) { summary.is_queue_assigned = true; } else { summary.is_queue_assigned = false; } } /* braces needed to suppress compiler warnings */ if ((pe_name=lGetString(jatep, JAT_granted_pe)) && (pe=pe_list_locate(qstat_env->pe_list, pe_name)) && lGetBool(pe, PE_control_slaves) && slots) { if (slot == 0) { summary.tickets = (u_long)lGetDouble(gdil_ep, JG_ticket); summary.otickets = (u_long)lGetDouble(gdil_ep, JG_oticket); summary.ftickets = (u_long)lGetDouble(gdil_ep, JG_fticket); summary.stickets = (u_long)lGetDouble(gdil_ep, JG_sticket); } else { if (slots) { summary.tickets = (u_long)(lGetDouble(gdil_ep, JG_ticket) / slots); summary.otickets = (u_long)(lGetDouble(gdil_ep, JG_oticket) / slots); summary.ftickets = (u_long)(lGetDouble(gdil_ep, JG_fticket) / slots); summary.stickets = (u_long)(lGetDouble(gdil_ep, JG_sticket) / slots); } else { summary.tickets = summary.otickets = summary.ftickets = summary.stickets = 0; } } } else { summary.tickets = (u_long)lGetDouble(jatep, JAT_tix); summary.otickets = (u_long)lGetDouble(jatep, JAT_oticket); summary.ftickets = (u_long)lGetDouble(jatep, JAT_fticket); summary.stickets = (u_long)lGetDouble(jatep, JAT_sticket); } } summary.master = master; if (slots_per_line == 0) { summary.slots = sge_job_slot_request(job, qstat_env->pe_list); } else { summary.slots = slots_per_line; } summary.is_array = job_is_array(job); if (summary.is_array) { summary.task_id = sge_dstring_get_string(dyn_task_str); } else { summary.task_id = NULL; } if ((ret = handler->report_job(handler, lGetUlong(job, JB_job_number), &summary, alpp))) { DPRINTF(("handler->report_job failed\n")); goto error; } if (tsk_ext) { lList *task_list = lGetList(jatep, JAT_task_list); lListElem *task, *ep; const char *qname; int subtask_ndx=1; if (handler->report_sub_tasks_started) { if ((ret = handler->report_sub_tasks_started(handler, alpp))) { DPRINTF(("(handler->report_sub_tasks_started failed\n")); goto error; } } /* print master sub-task belonging to this queue */ if (!slot && task_list && summary.queue && ((ep=lFirst(lGetList(jatep, JAT_granted_destin_identifier_list)))) && ((qname=lGetString(ep, JG_qname))) && !strcmp(qname, summary.queue)) { if ((ret=job_handle_subtask(job, jatep, NULL, handler, alpp))) { DPRINTF(("sge_handle_subtask failed\n")); goto error; } } /* print sub-tasks belonging to this queue */ for_each(task, task_list) { if (!slots || (summary.queue && ((ep=lFirst(lGetList(task, PET_granted_destin_identifier_list)))) && ((qname=lGetString(ep, JG_qname))) && !strcmp(qname, summary.queue) && ((subtask_ndx++%slots)==slot))) { if ((ret=job_handle_subtask(job, jatep, task, handler, alpp))) { DPRINTF(("sge_handle_subtask failed\n")); goto error; } } } if (handler->report_sub_tasks_finished) { if ((ret=handler->report_sub_tasks_finished(handler, alpp))) { DPRINTF(("(handler->report_sub_tasks_finished failed\n")); goto error; } } } /* print additional job info if requested */ if ((qstat_env->full_listing & QSTAT_DISPLAY_RESOURCES)) { if (handler->report_additional_info) { if ((ret=handler->report_additional_info(handler, FULL_JOB_NAME, lGetString(job, JB_job_name), alpp))) { DPRINTF(("handler->report_additional_info(Full jobname) failed")); goto error; } } if (summary.queue && handler->report_additional_info) { if ((ret=handler->report_additional_info(handler, MASTER_QUEUE, summary.queue, alpp))) { DPRINTF(("handler->report_additional_info(Master queue) failed")); goto error; } } if (lGetString(job, JB_pe) && handler->report_requested_pe) { dstring range_string = DSTRING_INIT; range_list_print_to_string(lGetList(job, JB_pe_range), &range_string, true, false, false); ret = handler->report_requested_pe(handler, lGetString(job, JB_pe), sge_dstring_get_string(&range_string), alpp); sge_dstring_free(&range_string); if (ret) { DPRINTF(("handler->report_requested_pe failed\n")); goto error; } } if (lGetString(jatep, JAT_granted_pe) && handler->report_granted_pe) { lListElem *gdil_ep; u_long32 pe_slots = 0; for_each (gdil_ep, lGetList(jatep, JAT_granted_destin_identifier_list)) { pe_slots += lGetUlong(gdil_ep, JG_slots); } if ((ret=handler->report_granted_pe(handler, lGetString(jatep, JAT_granted_pe), pe_slots, alpp))) { DPRINTF(("handler->report_granted_pe failed\n")); goto error; } } if (lGetString(job, JB_checkpoint_name) && handler->report_additional_info) { if ((ret=handler->report_additional_info(handler, CHECKPOINT_ENV, lGetString(job, JB_checkpoint_name), alpp))) { DPRINTF(("handler->report_additional_info(CHECKPOINT_ENV) failed\n")); goto error; } } /* Handle the Hard Resources */ ret = job_handle_resources(lGetList(job, JB_hard_resource_list), qstat_env->centry_list, sge_job_slot_request(job, qstat_env->pe_list), handler, handler->report_hard_resources_started, handler->report_hard_resource, handler->report_hard_resources_finished, alpp); if (ret) { DPRINTF(("handle_resources for hard resources failed\n")); goto error; } /* display default requests if necessary */ if (handler->report_request) { lList *attributes = NULL; lListElem *ce; const char *name; lListElem *hep; queue_complexes2scheduler(&attributes, qep, qstat_env->exechost_list, qstat_env->centry_list); for_each (ce, attributes) { double dval; name = lGetString(ce, CE_name); if (!lGetUlong(ce, CE_consumable) || !strcmp(name, "slots") || job_get_request(job, name)) { continue; } parse_ulong_val(&dval, NULL, lGetUlong(ce, CE_valtype), lGetString(ce, CE_default), NULL, 0); if (dval == 0.0) { continue; } /* For pending jobs (no queue/no exec host) we may print default request only if the consumable is specified in the global host. For running we print it if the resource is managed at this node/queue */ if ((qep && lGetSubStr(qep, CE_name, name, QU_consumable_config_list)) || (qep && (hep=host_list_locate(qstat_env->exechost_list, lGetHost(qep, QU_qhostname))) && lGetSubStr(hep, CE_name, name, EH_consumable_config_list)) || ((hep=host_list_locate(qstat_env->exechost_list, SGE_GLOBAL_NAME)) && lGetSubStr(hep, CE_name, name, EH_consumable_config_list))) { if ((ret=handler->report_request(handler, name, lGetString(ce, CE_default), alpp)) ) { DPRINTF(("handler->report_request failed\n")); break; } } } lFreeList(&attributes); if (ret) { goto error; } } /* Handle the Soft Resources */ ret = job_handle_resources(lGetList(job, JB_soft_resource_list), qstat_env->centry_list, sge_job_slot_request(job, qstat_env->pe_list), handler, handler->report_soft_resources_started, handler->report_soft_resource, handler->report_soft_resources_finished, alpp); if (ret) { DPRINTF(("handle_resources for soft resources failed\n")); goto error; } if (handler->report_hard_requested_queue) { ql = lGetList(job, JB_hard_queue_list); if (ql) { if (handler->report_hard_requested_queues_started && (ret=handler->report_hard_requested_queues_started(handler, alpp))) { DPRINTF(("handler->report_hard_requested_queues_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_hard_requested_queue(handler, lGetString(qrep, QR_name), alpp))) { DPRINTF(("handler->report_hard_requested_queue failed\n")); goto error; } } if (handler->report_hard_requested_queues_finished && (ret=handler->report_hard_requested_queues_finished(handler, alpp))) { DPRINTF(("handler->report_hard_requested_queues_finished failed\n")); goto error; } } } if (handler->report_soft_requested_queue) { ql = lGetList(job, JB_soft_queue_list); if (ql) { if (handler->report_soft_requested_queues_started && (ret=handler->report_soft_requested_queues_started(handler, alpp))) { DPRINTF(("handler->report_soft_requested_queue_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_soft_requested_queue(handler, lGetString(qrep, QR_name), alpp))) { DPRINTF(("handler->report_soft_requested_queue failed\n")); goto error; } } if (handler->report_soft_requested_queues_finished && (ret=handler->report_soft_requested_queues_finished(handler, alpp))) { DPRINTF(("handler->report_soft_requested_queues_finished failed\n")); goto error; } } } if (handler->report_master_hard_requested_queue) { ql = lGetList(job, JB_master_hard_queue_list); if (ql){ if (handler->report_master_hard_requested_queues_started && (ret=handler->report_master_hard_requested_queues_started(handler, alpp))) { DPRINTF(("handler->report_master_hard_requested_queues_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_master_hard_requested_queue(handler, lGetString(qrep, QR_name), alpp))) { DPRINTF(("handler->report_master_hard_requested_queue failed\n")); goto error; } } if (handler->report_master_hard_requested_queues_finished && (ret=handler->report_master_hard_requested_queues_finished(handler, alpp))) { DPRINTF(("handler->report_master_hard_requested_queues_finished failed\n")); goto error; } } } if (handler->report_predecessor_requested) { ql = lGetList(job, JB_jid_request_list ); if (ql) { if (handler->report_predecessors_requested_started && (ret=handler->report_predecessors_requested_started(handler, alpp))) { DPRINTF(("handler->report_predecessors_requested_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_predecessor_requested(handler, lGetString(qrep, JRE_job_name), alpp))) { DPRINTF(("handler->report_predecessor_requested failed\n")); goto error; } } if (handler->report_predecessors_requested_finished && (ret=handler->report_predecessors_requested_finished(handler, alpp))) { DPRINTF(("handler->report_predecessors_requested_finished failed\n")); goto error; } } } if (handler->report_predecessor) { ql = lGetList(job, JB_jid_predecessor_list); if (ql) { if (handler->report_predecessors_started && (ret=handler->report_predecessors_started(handler, alpp))) { DPRINTF(("handler->report_predecessors_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_predecessor(handler, lGetUlong(qrep, JRE_job_number), alpp))) { DPRINTF(("handler->report_predecessor failed\n")); goto error; } } if (handler->report_predecessors_finished && (ret=handler->report_predecessors_finished(handler, alpp))) { DPRINTF(("handler->report_predecessors_finished failed\n")); goto error; } } } if (handler->report_ad_predecessor_requested) { ql = lGetList(job, JB_ja_ad_request_list ); if (ql) { if (handler->report_ad_predecessors_requested_started && (ret=handler->report_ad_predecessors_requested_started(handler, alpp))) { DPRINTF(("handler->report_ad_predecessors_requested_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_ad_predecessor_requested(handler, lGetString(qrep, JRE_job_name), alpp))) { DPRINTF(("handler->report_ad_predecessor_requested failed\n")); goto error; } } if (handler->report_ad_predecessors_requested_finished && (ret=handler->report_ad_predecessors_requested_finished(handler, alpp))) { DPRINTF(("handler->report_ad_predecessors_requested_finished failed\n")); goto error; } } } if (handler->report_ad_predecessor) { ql = lGetList(job, JB_ja_ad_predecessor_list); if (ql) { if (handler->report_ad_predecessors_started && (ret=handler->report_ad_predecessors_started(handler, alpp))) { DPRINTF(("handler->report_ad_predecessors_started failed\n")); goto error; } for_each(qrep, ql) { if ((ret=handler->report_ad_predecessor(handler, lGetUlong(qrep, JRE_job_number), alpp))) { DPRINTF(("handler->report_ad_predecessor failed\n")); goto error; } } if (handler->report_ad_predecessors_finished && (ret=handler->report_ad_predecessors_finished(handler, alpp))) { DPRINTF(("handler->report_ad_predecessors_finished failed\n")); goto error; } } } if (handler->report_binding && (qstat_env->full_listing & QSTAT_DISPLAY_BINDING) != 0) { lList *binding_list = lGetList(job, JB_binding); if (binding_list != NULL) { lListElem *binding_elem = lFirst(binding_list); dstring binding_param = DSTRING_INIT; binding_print_to_string(binding_elem, &binding_param); if (handler->report_binding_started && (ret=handler->report_binding_started(handler, alpp))) { DPRINTF(("handler->report_binding_started failed\n")); goto error; } if ((ret=handler->report_binding(handler, sge_dstring_get_string(&binding_param), alpp))) { DPRINTF(("handler->report_binding failed\n")); goto error; } if (handler->report_binding_finished && (ret=handler->report_binding_finished(handler, alpp))) { DPRINTF(("handler->report_binding_finished failed\n")); goto error; } sge_dstring_free(&binding_param); } } } if (handler->report_job_finished && (ret=handler->report_job_finished(handler, lGetUlong(job, JB_job_number), alpp))) { DPRINTF(("handler->report_job_finished failed\n")); goto error; } #undef QSTAT_INDENT #undef QSTAT_INDENT2 error: DRETURN(ret); } static int job_handle_resources(lList* cel, lList* centry_list, int slots, job_handler_t *handler, int(*start_func)(job_handler_t* handler, lList **alpp), int(*resource_func)(job_handler_t* handler, const char* name, const char* value, double uc, lList **alpp), int(*finish_func)(job_handler_t* handler, lList **alpp), lList **alpp) { int ret = 0; const lListElem *ce, *centry; const char *s, *name; double uc; DENTER(TOP_LAYER,"job_handle_requests_from_ce_type"); if (start_func && (ret=start_func(handler, alpp))) { DPRINTF(("start_func failed\n")); DRETURN(ret); } /* walk through complex entries */ for_each (ce, cel) { name = lGetString(ce, CE_name); if ((centry = centry_list_locate(centry_list, name))) { uc = centry_urgency_contribution(slots, name, lGetDouble(ce, CE_doubleval), centry); } else { uc = 0.0; } s = lGetString(ce, CE_stringval); if ((ret=resource_func(handler, name, s, uc, alpp))) { DPRINTF(("resource_func failed\n")); break; } } if (ret == 0 && finish_func ) { if ((ret=finish_func(handler, alpp))) { DPRINTF(("finish_func failed")); } } DRETURN(ret); } static int job_handle_subtask(lListElem *job, lListElem *ja_task, lListElem *pe_task, job_handler_t *handler, lList **alpp ) { char task_state_string[8]; u_long32 tstate, tstatus; lListElem *ep; lList *usage_list; lList *scaled_usage_list; task_summary_t summary; int ret = 0; DENTER(TOP_LAYER, "job_handle_subtask"); /* is sub-task logically running */ if (pe_task == NULL) { tstatus = lGetUlong(ja_task, JAT_status); usage_list = lGetList(ja_task, JAT_usage_list); scaled_usage_list = lGetList(ja_task, JAT_scaled_usage_list); } else { tstatus = lGetUlong(pe_task, PET_status); usage_list = lGetList(pe_task, PET_usage); scaled_usage_list = lGetList(pe_task, PET_scaled_usage); } if (pe_task == NULL) { summary.task_id = ""; } else { summary.task_id = lGetString(pe_task, PET_id); } /* move status info into state info */ tstate = lGetUlong(ja_task, JAT_state); if (tstatus==JRUNNING) { tstate |= JRUNNING; tstate &= ~JTRANSFERING; } else if (tstatus==JTRANSFERING) { tstate |= JTRANSFERING; tstate &= ~JRUNNING; } else if (tstatus==JFINISHED) { tstate |= JEXITING; tstate &= ~(JRUNNING|JTRANSFERING); } if (lGetList(job, JB_jid_predecessor_list) || lGetUlong(ja_task, JAT_hold)) { tstate |= JHELD; } if (lGetUlong(ja_task, JAT_job_restarted)) { tstate &= ~JWAITING; tstate |= JMIGRATING; } /* write states into string */ job_get_state_string(task_state_string, tstate); summary.state = task_state_string; { lListElem *up; /* scaled cpu usage */ if (!(up = lGetElemStr(scaled_usage_list, UA_name, USAGE_ATTR_CPU))) { summary.has_cpu_usage = false; } else { summary.has_cpu_usage = true; summary.cpu_usage = lGetDouble(up, UA_value); } /* scaled mem usage */ if (!(up = lGetElemStr(scaled_usage_list, UA_name, USAGE_ATTR_MEM))) { summary.has_mem_usage = false; } else { summary.has_mem_usage = true; summary.mem_usage = lGetDouble(up, UA_value); } /* scaled io usage */ if (!(up = lGetElemStr(scaled_usage_list, UA_name, USAGE_ATTR_IO))) { summary.has_io_usage = false; } else { summary.has_io_usage = true; summary.io_usage = lGetDouble(up, UA_value); } } if (tstatus==JFINISHED) { ep=lGetElemStr(usage_list, UA_name, "exit_status"); if (ep) { summary.has_exit_status = true; summary.exit_status = (int)lGetDouble(ep, UA_value); } else { summary.has_exit_status = false; } } else { summary.has_exit_status = false; } ret = handler->report_sub_task(handler, &summary, alpp); DRETURN(ret); } /* ----------- functions from qstat_filter ---------------------------------- */ lCondition *qstat_get_JB_Type_selection(lList *user_list, u_long32 show) { lCondition *jw = NULL; lCondition *nw = NULL; DENTER(TOP_LAYER, "qstat_get_JB_Type_selection"); /* * Retrieve jobs only for those users specified via -u switch */ { lListElem *ep = NULL; lCondition *tmp_nw = NULL; for_each(ep, user_list) { tmp_nw = lWhere("%T(%I p= %s)", JB_Type, JB_owner, lGetString(ep, ST_name)); if (jw == NULL) { jw = tmp_nw; } else { jw = lOrWhere(jw, tmp_nw); } } } /* * Select jobs according to current state */ { lCondition *tmp_nw = NULL; /* * Pending jobs (all that are not running) */ if ((show & QSTAT_DISPLAY_PENDING) == QSTAT_DISPLAY_PENDING) { const u_long32 all_pending_flags = (QSTAT_DISPLAY_USERHOLD|QSTAT_DISPLAY_OPERATORHOLD| QSTAT_DISPLAY_SYSTEMHOLD|QSTAT_DISPLAY_JOBARRAYHOLD|QSTAT_DISPLAY_JOBHOLD| QSTAT_DISPLAY_STARTTIMEHOLD|QSTAT_DISPLAY_PEND_REMAIN); /* * Fine grained stated selection for pending jobs * or simply all pending jobs */ if (((show & all_pending_flags) == all_pending_flags) || ((show & all_pending_flags) == 0)) { /* * All jobs not running (= all pending) */ tmp_nw = lWhere("%T(!(%I -> %T((%I m= %u))))", JB_Type, JB_ja_tasks, JAT_Type, JAT_status, JRUNNING); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } /* * Array Jobs with one or more tasks pending */ tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_n_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_u_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_s_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_o_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } else { /* * User Hold */ if ((show & QSTAT_DISPLAY_USERHOLD) == QSTAT_DISPLAY_USERHOLD) { /* unenrolled jobs in user hold state ... */ tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_u_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } /* ... or enrolled jobs with an user hold */ tmp_nw = lWhere("%T((%I -> %T(%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_hold, MINUS_H_TGT_USER); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Operator Hold */ if ((show & QSTAT_DISPLAY_OPERATORHOLD) == QSTAT_DISPLAY_OPERATORHOLD) { tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_o_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T((%I -> %T(%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_hold, MINUS_H_TGT_OPERATOR); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * System Hold */ if ((show & QSTAT_DISPLAY_SYSTEMHOLD) == QSTAT_DISPLAY_SYSTEMHOLD) { tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_s_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T((%I -> %T(%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_hold, MINUS_H_TGT_SYSTEM); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Job Array Dependency Hold */ if ((show & QSTAT_DISPLAY_JOBARRAYHOLD) == QSTAT_DISPLAY_JOBARRAYHOLD) { tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_a_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T((%I -> %T(%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_hold, MINUS_H_TGT_JA_AD); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Start Time Hold */ if ((show & QSTAT_DISPLAY_STARTTIMEHOLD) == QSTAT_DISPLAY_STARTTIMEHOLD) { tmp_nw = lWhere("%T(%I > %u)", JB_Type, JB_execution_time, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Job Dependency Hold */ if ((show & QSTAT_DISPLAY_JOBHOLD) == QSTAT_DISPLAY_JOBHOLD) { tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_jid_predecessor_list, JRE_Type, JRE_job_number, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Rescheduled and jobs in error state (not in hold/no start time/no dependency) * and regular pending jobs */ if ((show & QSTAT_DISPLAY_PEND_REMAIN) == QSTAT_DISPLAY_PEND_REMAIN) { tmp_nw = lWhere("%T(%I -> %T((%I != %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_job_restarted, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T(%I -> %T((%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_state, JERROR); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } tmp_nw = lWhere("%T(%I -> %T((%I > %u)))", JB_Type, JB_ja_n_h_ids, RN_Type, RN_min, 0); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } } } /* * Running jobs (which are not suspended) * * NOTE: * This code is not quite correct. It select jobs * which are running and not suspended (qmod -s) * * Jobs which are suspended due to other mechanisms * (suspend on subordinate, thresholds, calendar) * should be rejected too, but this is not possible * because this information is not stored within * job or job array task. * * As a result to many jobs will be requested by qsub. */ if ((show & QSTAT_DISPLAY_RUNNING) == QSTAT_DISPLAY_RUNNING) { tmp_nw = lWhere("%T(((%I -> %T(%I m= %u)) || (%I -> %T(%I m= %u))) && !(%I -> %T((%I m= %u))))", JB_Type, JB_ja_tasks, JAT_Type, JAT_status, JRUNNING, JB_ja_tasks, JAT_Type, JAT_status, JTRANSFERING, JB_ja_tasks, JAT_Type, JAT_state, JSUSPENDED); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } /* * Suspended jobs * * NOTE: * see comment above */ if ((show & QSTAT_DISPLAY_SUSPENDED) == QSTAT_DISPLAY_SUSPENDED) { tmp_nw = lWhere("%T((%I -> %T(%I m= %u)) || (%I -> %T(%I m= %u)) || (%I -> %T(%I m= %u)))", JB_Type, JB_ja_tasks, JAT_Type, JAT_status, JRUNNING, JB_ja_tasks, JAT_Type, JAT_status, JTRANSFERING, JB_ja_tasks, JAT_Type, JAT_state, JSUSPENDED); if (nw == NULL) { nw = tmp_nw; } else { nw = lOrWhere(nw, tmp_nw); } } } if (nw != NULL) { if (jw == NULL) { jw = nw; } else { jw = lAndWhere(jw, nw); } } DRETURN(jw); } lEnumeration *qstat_get_JB_Type_filter(qstat_env_t* qstat_env) { DENTER(TOP_LAYER, "qstat_get_JB_Type_filter"); if (qstat_env->what_JAT_Type_template != NULL) { lWhatSetSubWhat(qstat_env->what_JB_Type, JB_ja_template, &(qstat_env->what_JAT_Type_template)); } if (qstat_env->what_JAT_Type_list != NULL) { lWhatSetSubWhat(qstat_env->what_JB_Type, JB_ja_tasks, &(qstat_env->what_JAT_Type_list)); } DRETURN(qstat_env->what_JB_Type); } void qstat_filter_add_core_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_job_number, JB_owner, JB_type, JB_pe, JB_jid_predecessor_list, JB_ja_ad_predecessor_list, JB_job_name, JB_submission_time, JB_pe_range, JB_ja_structure, JB_ja_tasks, JB_ja_n_h_ids, JB_ja_u_h_ids, JB_ja_o_h_ids, JB_ja_s_h_ids, JB_ja_a_h_ids, JB_ja_z_ids, JB_ja_template, JB_execution_time, JB_hard_queue_list, JB_project, NoName }; const int nm_JAT_Type_template[] = { JAT_task_number, JAT_prio, JAT_hold, JAT_state, JAT_status, JAT_job_restarted, JAT_start_time, NoName }; const int nm_JAT_Type_list[] = { JAT_task_number, JAT_status, JAT_granted_destin_identifier_list, JAT_suitable, JAT_granted_pe, JAT_state, JAT_prio, JAT_hold, JAT_job_restarted, JAT_start_time, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_template); lMergeWhat(&(qstat_env->what_JAT_Type_template), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_list); lMergeWhat(&(qstat_env->what_JAT_Type_list), &tmp_what); } void qstat_filter_add_ext_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_department, JB_override_tickets, NoName }; const int nm_JAT_Type_template[] = { JAT_ntix, JAT_scaled_usage_list, JAT_granted_pe, JAT_tix, JAT_oticket, JAT_fticket, JAT_sticket, JAT_share, NoName }; const int nm_JAT_Type_list[] = { JAT_ntix, JAT_scaled_usage_list, JAT_task_list, JAT_tix, JAT_oticket, JAT_fticket, JAT_sticket, JAT_share, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_template); lMergeWhat(&(qstat_env->what_JAT_Type_template), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_list); lMergeWhat(&(qstat_env->what_JAT_Type_list), &tmp_what); } void qstat_filter_add_pri_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_nppri, JB_nurg, JB_priority, NoName }; const int nm_JAT_Type_template[] = { JAT_ntix, NoName }; const int nm_JAT_Type_list[] = { JAT_ntix, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_template); lMergeWhat(&(qstat_env->what_JAT_Type_template), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_list); lMergeWhat(&(qstat_env->what_JAT_Type_list), &tmp_what); } void qstat_filter_add_urg_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_deadline, JB_nurg, JB_urg, JB_rrcontr, JB_dlcontr, JB_wtcontr, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_l_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_checkpoint_name, JB_hard_resource_list, JB_soft_resource_list, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_pe_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_checkpoint_name, JB_hard_resource_list, JB_soft_resource_list, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_q_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_checkpoint_name, JB_hard_resource_list, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_r_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_checkpoint_name, JB_hard_resource_list, JB_soft_resource_list, JB_hard_queue_list, JB_soft_queue_list, JB_master_hard_queue_list, JB_jid_request_list, JB_ja_ad_request_list, JB_binding, NoName }; const int nm_JAT_Type_template[] = { JAT_granted_pe, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_template); lMergeWhat(&(qstat_env->what_JAT_Type_template), &tmp_what); } void qstat_filter_add_xml_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_jobshare, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_U_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JB_Type[] = { JB_checkpoint_name, JB_hard_resource_list, NoName }; tmp_what = lIntVector2What(JB_Type, nm_JB_Type); lMergeWhat(&(qstat_env->what_JB_Type), &tmp_what); } void qstat_filter_add_t_attributes(qstat_env_t *qstat_env) { lEnumeration *tmp_what = NULL; const int nm_JAT_Type_list[] = { JAT_task_list, JAT_usage_list, JAT_scaled_usage_list, NoName }; const int nm_JAT_Type_template[] = { JAT_task_list, JAT_usage_list, JAT_scaled_usage_list, NoName }; tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_list); lMergeWhat(&(qstat_env->what_JAT_Type_list), &tmp_what); tmp_what = lIntVector2What(JAT_Type, nm_JAT_Type_template); lMergeWhat(&(qstat_env->what_JAT_Type_template), &tmp_what); } const char* sge_get_dominant_stringval(lListElem *rep, u_long32 *dominant_p, dstring *resource_string_p) { const char *s = NULL; u_long32 type = lGetUlong(rep, CE_valtype); DENTER(TOP_LAYER, "sge_get_dominant_stringval"); switch (type) { case TYPE_HOST: case TYPE_STR: case TYPE_CSTR: case TYPE_RESTR: if (!(lGetUlong(rep, CE_pj_dominant)&DOMINANT_TYPE_VALUE)) { *dominant_p = lGetUlong(rep, CE_pj_dominant); s = lGetString(rep, CE_pj_stringval); } else { *dominant_p = lGetUlong(rep, CE_dominant); s = lGetString(rep, CE_stringval); } break; case TYPE_TIM: if (!(lGetUlong(rep, CE_pj_dominant)&DOMINANT_TYPE_VALUE)) { double val = lGetDouble(rep, CE_pj_doubleval); *dominant_p = lGetUlong(rep, CE_pj_dominant); double_print_time_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } else { double val = lGetDouble(rep, CE_doubleval); *dominant_p = lGetUlong(rep, CE_dominant); double_print_time_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } break; case TYPE_MEM: if (!(lGetUlong(rep, CE_pj_dominant)&DOMINANT_TYPE_VALUE)) { double val = lGetDouble(rep, CE_pj_doubleval); *dominant_p = lGetUlong(rep, CE_pj_dominant); double_print_memory_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } else { double val = lGetDouble(rep, CE_doubleval); *dominant_p = lGetUlong(rep, CE_dominant); double_print_memory_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } break; case TYPE_INT: if (!(lGetUlong(rep, CE_pj_dominant)&DOMINANT_TYPE_VALUE)) { double val = lGetDouble(rep, CE_pj_doubleval); *dominant_p = lGetUlong(rep, CE_pj_dominant); double_print_int_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } else { double val = lGetDouble(rep, CE_doubleval); *dominant_p = lGetUlong(rep, CE_dominant); double_print_int_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } break; default: if (!(lGetUlong(rep, CE_pj_dominant)&DOMINANT_TYPE_VALUE)) { double val = lGetDouble(rep, CE_pj_doubleval); *dominant_p = lGetUlong(rep, CE_pj_dominant); double_print_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } else { double val = lGetDouble(rep, CE_doubleval); *dominant_p = lGetUlong(rep, CE_dominant); double_print_to_dstring(val, resource_string_p); s = sge_dstring_get_string(resource_string_p); } break; } DRETURN(s); } /*-------------------------------------------------------------------------* * NAME * build_job_state_filter - set the full_listing flags in the qstat_env * according to job_state * * PARAMETER * qstat_env - the qstat_env * job_state - the job_state * alpp - answer list for error reporting * * RETURN * 0 - full_listing flags in qstat_env set * else - error, reason has been reported in alpp. * * DESCRIPTION *-------------------------------------------------------------------------*/ int build_job_state_filter(qstat_env_t *qstat_env, const char* job_state, lList **alpp) { int ret = 0; DENTER(TOP_LAYER, "build_job_state_filter"); if (job_state != NULL) { /* * list of options for the -s switch * when you add options, make sure that single byte options (e.g. "h") * come after multi byte options starting with the same character (e.g. "hs")! */ static char* flags[] = { "hu", "hs", "ho", "hd", "hj", "ha", "h", "p", "r", "s", "z", "a", NULL }; static u_long32 bits[] = { (QSTAT_DISPLAY_USERHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_SYSTEMHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_OPERATORHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_JOBARRAYHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_JOBHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_STARTTIMEHOLD|QSTAT_DISPLAY_PENDING), (QSTAT_DISPLAY_HOLD|QSTAT_DISPLAY_PENDING), QSTAT_DISPLAY_PENDING, QSTAT_DISPLAY_RUNNING, QSTAT_DISPLAY_SUSPENDED, QSTAT_DISPLAY_ZOMBIES, (QSTAT_DISPLAY_PENDING|QSTAT_DISPLAY_RUNNING|QSTAT_DISPLAY_SUSPENDED), 0 }; int i; const char *s; u_long32 rm_bits = 0; /* initialize bitmask */ for (i =0 ; flags[i] != 0; i++) { rm_bits |= bits[i]; } qstat_env->full_listing &= ~rm_bits; /* * search each 'flag' in argstr * if we find the whole string we will set the corresponding * bits in '*qstat_env->full_listing' */ s = job_state; while (*s != '\0') { bool matched = false; for (i = 0; flags[i] != NULL; i++) { if (strncmp(s, flags[i], strlen(flags[i])) == 0) { qstat_env->full_listing |= bits[i]; s += strlen(flags[i]); matched = true; } } if (!matched) { answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, "%s", MSG_OPTIONS_WRONGARGUMENTTOSOPT); ret = -1; break; } } } DRETURN(ret); } static void print_qstat_env_to(qstat_env_t *qstat_env, FILE* file) { lInit(nmv); fprintf(file, "======================================================\n"); fprintf(file, "QSTAT_ENV\n"); fprintf(file, "------------------------------------------------------\n"); fprintf(file, "resource_list:\n"); if (qstat_env->resource_list != NULL) { lWriteListTo(qstat_env->resource_list, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "qresource_list:\n"); if (qstat_env->resource_list != NULL) { lWriteListTo(qstat_env->resource_list, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "queueref_list:\n"); if (qstat_env->resource_list != NULL) { lWriteListTo(qstat_env->resource_list, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "user_list:\n"); if (qstat_env->resource_list != NULL) { lWriteListTo(qstat_env->resource_list, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "what_JB_Type:\n"); if (qstat_env->what_JB_Type != NULL) { lWriteWhatTo(qstat_env->what_JB_Type, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "what_JAT_Type_template:\n"); if (qstat_env->what_JAT_Type_template != NULL) { lWriteWhatTo(qstat_env->what_JAT_Type_template, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "what_JAT_Type_list:\n"); if (qstat_env->what_JAT_Type_list != NULL) { lWriteWhatTo(qstat_env->what_JAT_Type_list, stdout); } else { fprintf(file, "NULL\n"); } fprintf(file, "------------------------------------------------------\n"); fprintf(file, "Params:\n"); fprintf(file,"full_listing = %x\n", (int)qstat_env->full_listing); { int masks [] = { QSTAT_DISPLAY_EXTENDED, QSTAT_DISPLAY_RESOURCES, QSTAT_DISPLAY_QRESOURCES, QSTAT_DISPLAY_TASKS, QSTAT_DISPLAY_NOEMPTYQ, QSTAT_DISPLAY_PENDING, QSTAT_DISPLAY_SUSPENDED, QSTAT_DISPLAY_RUNNING, QSTAT_DISPLAY_FINISHED, QSTAT_DISPLAY_ZOMBIES, QSTAT_DISPLAY_ALARMREASON, QSTAT_DISPLAY_USERHOLD, QSTAT_DISPLAY_SYSTEMHOLD, QSTAT_DISPLAY_OPERATORHOLD, QSTAT_DISPLAY_JOBARRAYHOLD, QSTAT_DISPLAY_JOBHOLD, QSTAT_DISPLAY_STARTTIMEHOLD, QSTAT_DISPLAY_URGENCY, QSTAT_DISPLAY_PRIORITY, QSTAT_DISPLAY_PEND_REMAIN }; const char* text [] = { "QSTAT_DISPLAY_EXTENDED", "QSTAT_DISPLAY_RESOURCES", "QSTAT_DISPLAY_QRESOURCES", "QSTAT_DISPLAY_TASKS", "QSTAT_DISPLAY_NOEMPTYQ", "QSTAT_DISPLAY_PENDING", "QSTAT_DISPLAY_SUSPENDED", "QSTAT_DISPLAY_RUNNING", "QSTAT_DISPLAY_FINISHED", "QSTAT_DISPLAY_ZOMBIES", "QSTAT_DISPLAY_ALARMREASON", "QSTAT_DISPLAY_USERHOLD", "QSTAT_DISPLAY_SYSTEMHOLD", "QSTAT_DISPLAY_OPERATORHOLD", "QSTAT_DISPLAY_JOBARRAYHOLD", "QSTAT_DISPLAY_JOBHOLD", "QSTAT_DISPLAY_STARTTIMEHOLD", "QSTAT_DISPLAY_URGENCY", "QSTAT_DISPLAY_PRIORITY", "QSTAT_DISPLAY_PEND_REMAIN", NULL }; int i=0; while (text[i] != NULL) { if (qstat_env->full_listing & masks[i]) { fprintf(file," = %s\n", text[i]); } i++; } } fprintf(file, "qselect_mode = %x\n", (int)qstat_env->qselect_mode); fprintf(file, "group_opt = %x\n", (int)qstat_env->group_opt); fprintf(file, "queue_state = %x\n", (int)qstat_env->queue_state); fprintf(file, "explain_bits = %x\n", (int)qstat_env->explain_bits); fprintf(file, "job_info = %x\n", (int)qstat_env->job_info); fprintf(file, "======================================================\n"); }