getconfig.c

openPBS的开放源代码

    }


    if (!strcmp(cfg_option, "SMALL_JOB_MAX")) {
	schd_SMALL_JOB_MAX = atoi(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "WALLT_LIMIT_LARGE_JOB")) {
	schd_WALLT_LARGE_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "WALLT_LIMIT_SMALL_JOB")) {
	schd_WALLT_SMALL_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }


    if (!strcmp(cfg_option, "MAX_QUEUED_TIME")) {
	schd_MAX_QUEUED_TIME = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "SMALL_QUEUED_TIME")) {
	schd_SMALL_QUEUED_TIME = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "INTERACTIVE_LONG_WAIT")) {
	schd_INTERACTIVE_LONG_WAIT = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "SUBMIT_QUEUE")) {
	arg_to_qlist(cfg_arg, ",", &schd_SubmitQueue);
	return (0);
    }
    
    if (!strcmp(cfg_option, "BATCH_QUEUES")) {
	arg_to_qlist(cfg_arg, ",", &schd_BatchQueues);
	return (0);
    }
    
    if (!strcmp(cfg_option, "SPECIAL_QUEUE")) {
	arg_to_qlist(cfg_arg, ",", &schd_SpecialQueue);
	return (0);
    }
    
    if (!strcmp(cfg_option, "DEDICATED_QUEUES")) {
	arg_to_qlist(cfg_arg, ",", &schd_DedQueues);
	return (0);
    }

    if (!strcmp(cfg_option, "EXTERNAL_QUEUES")) {
	arg_to_qlist(cfg_arg, ",", &schd_ExternQueues);
	return (0);
    }

    if (!strcmp(cfg_option, "FAKE_MACHINE_MULT")) {
	schd_FAKE_MACH_MULT = atoi(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "AVOID_FRAGMENTATION")) {
	return schd_val2bool(cfg_arg, &schd_AVOID_FRAGS);
    }
    
    if (!strcmp(cfg_option, "MANAGE_HPM_COUNTERS")) {
	return schd_val2bool(cfg_arg, &schd_MANAGE_HPM);
    }
    
    if (!strcmp(cfg_option, "REVOKE_HPM_COUNTERS")) {
	return schd_val2bool(cfg_arg, &schd_REVOKE_HPM);
    }
    
    /* Unknown option -- return an error. */
    return (-1);
}

static int
post_config(void)
{
    /* char   *id = "post_config"; */

    /* Set up per-queue primetime enforcement. */
    if (schd_BatchQueues)
        schd_reset_observed_pt(schd_BatchQueues);
    if (schd_ExternQueues)
        schd_reset_observed_pt(schd_ExternQueues);

    /* Post processing complete. */
    return (1);
}

static int 
validate_config(void)
{
    char   *id = "validate_config";
    char   *xit = "  Exiting.";
    /*
     * Some simple tests to make sure the configuration is
     * at least minimally rational.
     */

    if (schd_TEST_ONLY) {
	(void)sprintf(log_buffer, "NOTE: Scheduler is in testing-only mode.");
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s: %s\n", id, log_buffer));
    }

    DBPRT(("%s: validate submit queues\n", id));
    if (schd_SubmitQueue == NULL) {
	(void)sprintf(log_buffer, "No SUBMIT_QUEUE specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }
    if (schd_SubmitQueue->next != NULL) {
	(void)sprintf(log_buffer,
	    "Only one SUBMIT_QUEUE can be specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }

    DBPRT(("%s: validate batch queues\n", id));
    if (schd_BatchQueues == NULL) {
	(void)sprintf(log_buffer, "No BATCH_QUEUES specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }
    if (!qlist_unique(schd_BatchQueues)) {
	(void)sprintf(log_buffer, 
	    "Queues listed in BATCH_QUEUES cannot be repeated.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }

    if (schd_ExternQueues) {
	DBPRT(("%s: validate externally routed queues\n", id));
	if (!qlist_unique(schd_ExternQueues)) {
	    (void)sprintf(log_buffer, 
		"Queues listed in EXTERNAL_QUEUES cannot be repeated.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
    }

    if (schd_ENFORCE_PRIME_TIME) {
	DBPRT(("%s: validate primetime\n", id));
	if (schd_PRIME_TIME_START <= 0 || schd_PRIME_TIME_END <= 0) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_PRIME_TIME set but PRIME_TIME_START/END is not "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}

        if (schd_PT_WALLT_LIMIT <= 0) {
            (void)sprintf(log_buffer, 
                "ENFORCE_PRIME_TIME set but no PRIME_TIME_WALLT_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }

        if ((schd_PT_SMALL_NODE_LIMIT > 0) && 
            (schd_PT_SMALL_WALLT_LIMIT <= 0)) 
        {
            (void)sprintf(log_buffer, 
                "PRIMETIME_SMALL_NODE_LIMIT set but no "
		"PRIME_TIME_SMALL_WALLT_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }

        if ((schd_PT_SMALL_NODE_LIMIT <= 0) && 
            (schd_PT_SMALL_WALLT_LIMIT > 0))
        {
            (void)sprintf(log_buffer, 
                "PRIME_TIME_SMALL_WALLT_LIMIT set but no "
		"PRIMETIME_SMALL_NODE_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }
    }

    if (schd_SMALL_JOB_MAX) {
	if (schd_WALLT_LARGE_LIMIT <= 0) {
	    (void)sprintf(log_buffer, 
		"SMALL_JOB_MAX set but no WALLT_LIMIT_LARGE_JOB given.");
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}

	if (schd_WALLT_SMALL_LIMIT <= 0) {
	    (void)sprintf(log_buffer, 
		"SMALL_JOB_MAX set but no WALLT_LIMIT_SMALL_JOB given.");
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
    }

    if (schd_ENFORCE_DEDTIME) {
	DBPRT(("%s: validate dedicated queue\n", id));
	if (schd_DedQueues == NULL) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_DEDICATED_TIME set but no dedicated queues "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_one_per_host(schd_DedQueues)) {
	    (void)sprintf(log_buffer, 
	    "Only one DEDICATED_QUEUES entry per exechost allowed.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_disjoint(schd_DedQueues, schd_BatchQueues)) {
	    (void)sprintf(log_buffer, 
	    "Queues in DEDICATED_QUEUES may not be listed in BATCH_QUEUES.%s",
		    xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	DBPRT(("%s: validate dedicated time command\n", id));
	if (schd_DEDTIME_COMMAND == NULL) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_DEDICATED_TIME set but no DEDICATED_TIME_COMMAND "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (access(schd_DEDTIME_COMMAND, X_OK)) {
	    (void)sprintf(log_buffer, 
		"Execution denied for DEDICATED_TIME_COMMAND '%s'.%s", 
		schd_DEDTIME_COMMAND, xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);

	}
    }

    if (schd_SpecialQueue != NULL) {
	DBPRT(("%s: validate special queue\n", id));
	if (schd_SpecialQueue->next != NULL) {
	    (void)sprintf(log_buffer,
		"Only one SPECIAL_QUEUE can be specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
    }

    DBPRT(("%s: verify that queue sets are disjoint\n", id));
    if (!qlist_disjoint(schd_SubmitQueue, schd_BatchQueues)) {
	(void)sprintf(log_buffer, 
	    "SUBMIT_QUEUE %s cannot be listed in BATCH_QUEUES.%s",
		schd_SubmitQueue->queue->qname, xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }
    if (schd_SpecialQueue) {
	if (!qlist_disjoint(schd_SpecialQueue, schd_BatchQueues)) {
	    (void)sprintf(log_buffer, 
		"SPECIAL_QUEUE %s cannot be listed in BATCH_QUEUES.%s",
		    schd_SpecialQueue->queue->qname, xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_disjoint(schd_SubmitQueue, schd_SpecialQueue)) {
	    (void)sprintf(log_buffer, 
		"SUBMIT_QUEUE %s cannot be same as SPECIAL_QUEUE %s.%s",
		    schd_SubmitQueue->queue->qname, 
		    schd_SpecialQueue->queue->qname, xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (schd_DedQueues) {
	    if (!qlist_disjoint(schd_DedQueues, schd_SpecialQueue)) {
		(void)sprintf(log_buffer, 
		    "DEDICATED_QUEUES cannot be same as SPECIAL_QUEUE %s.%s",
			schd_SpecialQueue->queue->qname, xit);
		log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, 
		    log_buffer);
		DBPRT(("%s\n", log_buffer));
		return (0);
	    }
	}
    }

    if (schd_ExternQueues) {
	if (!qlist_disjoint(schd_ExternQueues, schd_BatchQueues)) {
	    (void)sprintf(log_buffer, 
		"Queues in EXTERNAL_QUEUES cannot also be in BATCH_QUEUES.%s", 
		    xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_disjoint(schd_ExternQueues, schd_SpecialQueue)) {
	    (void)sprintf(log_buffer, 
		"The SPECIAL_QUEUE %s cannot be listed in EXTERNAL_QUEUES.%s",
		    schd_SpecialQueue->queue->qname, xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (schd_DedQueues) {
	    if (!qlist_disjoint(schd_DedQueues, schd_ExternQueues)) {
		(void)sprintf(log_buffer, 
		    "DEDICATED_QUEUES cannot be listed in EXTERNAL_QUEUES.%s",
			xit);
		log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, 
		    log_buffer);
		DBPRT(("%s\n", log_buffer));
		return (0);
	    }
	}
    }

    if (schd_REVOKE_HPM && !schd_MANAGE_HPM) {
	    (void)sprintf(log_buffer, 
		"MANAGE_HPM_COUNTERS must be set for REVOKE_HPM_COUNTERS");
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }

    if ((schd_FAKE_MACH_MULT < 1)) {
	    (void)sprintf(log_buffer, 
		"FAKE_MACHINE_MULT must be integer number > 0.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }

    DBPRT(("%s: Scheduler configuration appears valid.\n", id));
    return (1);
}

/* print_config(): Dump the current config to the log */
static void
print_config(void)
{
    char   *id = "print_config";
    QueueList *qptr;

    if (schd_TEST_ONLY) {
	(void)sprintf(log_buffer, "%-24s = %s", "TEST_ONLY", 
	    schd_bool2val(schd_TEST_ONLY));
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_SubmitQueue) {
	(void)sprintf(log_buffer, "%-24s = %s@%s", "SUBMIT_QUEUE",
	    schd_SubmitQueue->queue->qname, schd_SubmitQueue->queue->exechost);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_BatchQueues) {
	for (qptr = schd_BatchQueues; qptr != NULL; qptr = qptr->next) {
	    (void)sprintf(log_buffer, "%-24s = %s@%s", 
		(qptr == schd_BatchQueues) ? "BATCH_QUEUES" : "",
		qptr->queue->qname, qptr->queue->exechost);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	}
    }

    if (schd_ExternQueues) {
	for (qptr = schd_ExternQueues; qptr != NULL; qptr = qptr->next) {
	    (void)sprintf(log_buffer, "%-24s = %s@%s", 
		(qptr == schd_ExternQueues) ? "EXTERN_QUEUES" : "",
		qptr->queue->qname, qptr->queue->exechost);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	}
    }

    if (schd_SpecialQueue) {
	(void)sprintf(log_buffer, "%-24s = %s@%s", "SPECIAL_QUEUE",
	  schd_SpecialQueue->queue->qname, schd_SpecialQueue->queue->exechost);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_DedQueues) {
	for (qptr = schd_DedQueues; qptr != NULL; qptr = qptr->next) {
	    (void)sprintf(log_buffer, "%-24s = %s@%s", 
		(qptr == schd_DedQueues) ? "DEDICATED_QUEUES" : "",
		qptr->queue->qname, qptr->queue->exechost);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	}
    }

    (void)sprintf(log_buffer, "%-24s = %s", "ENFORCE_PRIME_TIME",
	schd_booltime2val(schd_ENFORCE_PRIME_TIME));
    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

    (void)sprintf(log_buffer, "%-24s = %s", "PRIME_TIME_WALLT_LIMIT", 
        schd_sec2val(schd_PT_WALLT_LIMIT));
    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

    if (schd_PT_SMALL_NODE_LIMIT) {
        (void)sprintf(log_buffer, "%-24s = %d", "PRIME_TIME_SMALL_NODE_LIMIT", 
            schd_PT_SMALL_NODE_LIMIT);
        log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

        (void)sprintf(log_buffer, "%-24s = %s", "PRIME_TIME_SMALL_WALLT_LIMIT",
            schd_sec2val(schd_PT_SMALL_WALLT_LIMIT));
        log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    (void)sprintf(log_buffer, "%-24s = %s", "NONPRIME_DRAIN_SYS",