/* * license_job_get - Get the licenses required for a job * IN job_ptr - job identification * RET SLURM_SUCCESS or failure code */ extern int license_job_get(struct job_record *job_ptr) { ListIterator iter; licenses_t *license_entry, *match; int rc = SLURM_SUCCESS; if (!job_ptr->license_list) /* no licenses needed */ return rc; slurm_mutex_lock(&license_mutex); iter = list_iterator_create(job_ptr->license_list); if (iter == NULL) fatal("malloc failure from list_iterator_create"); while ((license_entry = (licenses_t *) list_next(iter))) { match = list_find_first(license_list, _license_find_rec, license_entry->name); if (match) { match->used += license_entry->total; license_entry->used += license_entry->total; } else { error("could not find license %s for job %u", license_entry->name, job_ptr->job_id); rc = SLURM_ERROR; } } list_iterator_destroy(iter); _licenses_print("acquire_license", license_list, job_ptr->job_id); slurm_mutex_unlock(&license_mutex); return rc; }
/* * license_job_return - Return the licenses allocated to a job * IN job_ptr - job identification * RET SLURM_SUCCESS or failure code */ extern int license_job_return(struct job_record *job_ptr) { ListIterator iter; licenses_t *license_entry, *match; int rc = SLURM_SUCCESS; if (!job_ptr->license_list) /* no licenses needed */ return rc; slurm_mutex_lock(&license_mutex); iter = list_iterator_create(job_ptr->license_list); while ((license_entry = (licenses_t *) list_next(iter))) { match = list_find_first(license_list, _license_find_rec, license_entry->name); if (match) { if (match->used >= license_entry->total) match->used -= license_entry->total; else { error("license use count underflow for %s", match->name); match->used = 0; rc = SLURM_ERROR; } license_entry->used = 0; } else { /* This can happen after a reconfiguration */ error("job returning unknown license %s", license_entry->name); } } list_iterator_destroy(iter); _licenses_print("return_license", license_list, job_ptr->job_id); slurm_mutex_unlock(&license_mutex); return rc; }
/* Initialize licenses on this system based upon slurm.conf */ extern int license_init(char *licenses) { bool valid; slurm_mutex_lock(&license_mutex); if (license_list) fatal("license_list already defined"); license_list = _build_license_list(licenses, &valid); if (!valid) fatal("Invalid configured licenses: %s", licenses); _licenses_print("init_license", license_list, 0); slurm_mutex_unlock(&license_mutex); return SLURM_SUCCESS; }
/* Update licenses on this system based upon slurm.conf. * Preserve all previously allocated licenses */ extern int license_update(char *licenses) { ListIterator iter; licenses_t *license_entry, *match; List new_list; bool valid; new_list = _build_license_list(licenses, &valid); if (!valid) fatal("Invalid configured licenses: %s", licenses); slurm_mutex_lock(&license_mutex); if (!license_list) { /* no licenses before now */ license_list = new_list; slurm_mutex_unlock(&license_mutex); return SLURM_SUCCESS; } iter = list_iterator_create(license_list); if (iter == NULL) fatal("malloc failure from list_iterator_create"); while ((license_entry = (licenses_t *) list_next(iter))) { match = list_find_first(new_list, _license_find_rec, license_entry->name); if (!match) { info("license %s removed with %u in use", license_entry->name, license_entry->used); } else { match->used = license_entry->used; if (match->used > match->total) { info("license %s count decreased", match->name); } } } list_iterator_destroy(iter); list_destroy(license_list); license_list = new_list; _licenses_print("update_license", license_list, 0); slurm_mutex_unlock(&license_mutex); return SLURM_SUCCESS; }
/* * license_validate - Test if the required licenses are valid * IN licenses - required licenses * OUT valid - true if required licenses are valid and a sufficient number * are configured (though not necessarily available now) * RET license_list, must be destroyed by caller */ extern List license_validate(char *licenses, bool *valid) { ListIterator iter; licenses_t *license_entry, *match; List job_license_list; job_license_list = _build_license_list(licenses, valid); if (!job_license_list) return job_license_list; slurm_mutex_lock(&license_mutex); _licenses_print("request_license", job_license_list, 0); iter = list_iterator_create(job_license_list); if (iter == NULL) fatal("malloc failure from list_iterator_create"); while ((license_entry = (licenses_t *) list_next(iter))) { if (license_list) { match = list_find_first(license_list, _license_find_rec, license_entry->name); } else match = NULL; if (!match) { debug("could not find license %s for job", license_entry->name); *valid = false; break; } else if (license_entry->total > match->total) { debug("job wants more %s licenses than configured", match->name); *valid = false; break; } } list_iterator_destroy(iter); slurm_mutex_unlock(&license_mutex); if (!(*valid)) { list_destroy(job_license_list); job_license_list = NULL; } return job_license_list; }