/*
* 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;
}
