DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - download

⟦83b7fceaa⟧ TextFile

    Length: 10935 (0x2ab7)
    Types: TextFile
    Notes: R1k Text-file segment

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦c239b5e4c⟧ 
            └─⟦this⟧

TextFile

-- Copyright 1991 Verdix Corporation

with system;				use system;
with krn_defs;				use krn_defs;
with krn_entries;			use krn_entries;
with unchecked_conversion;
package krn_call_i is
	pragma suppress(ALL_CHECKS);
	pragma suppress(EXCEPTION_TABLES);
	pragma not_elaborated;

	-- Interface to the routines resident in the user program that call the
	-- kernel services

	-- Kernel services are restricted to only two parameters. No OUT
	-- parameters. May return an integer'size result.

	-------------------------------------------------------------------------
	-- Program services
	-------------------------------------------------------------------------
	procedure krn_program_init(arg: a_program_init_arg_t);
	  pragma interface(ADA, krn_program_init);
	  pragma interface_name(krn_program_init, "__KRN_CALL_PROGRAM_INIT");

	procedure krn_program_exit(status: integer);
	  pragma interface(ADA, krn_program_exit);
	  pragma interface_name(krn_program_exit, "__KRN_CALL_PROGRAM_EXIT");

	procedure krn_program_diagnostic(s_a: address; s_len: natural);
	  pragma interface(ADA, krn_program_diagnostic);
	  pragma interface_name(krn_program_diagnostic,
		"__KRN_CALL_PROGRAM_DIAGNOSTIC");

	function krn_program_start(arg: a_program_start_arg_t) return a_krn_pcb_t;
	  pragma interface(ADA, krn_program_start);
	  pragma interface_name(krn_program_start, "__KRN_CALL_PROGRAM_START");

	procedure krn_program_terminate(prg: a_krn_pcb_t; status: integer);
	  pragma interface(ADA, krn_program_terminate);
	  pragma interface_name(krn_program_terminate,
		"__KRN_CALL_PROGRAM_TERMINATE");

	procedure krn_program_set_is_server;
	  pragma interface(ADA, krn_program_set_is_server);
	  pragma interface_name(krn_program_set_is_server,
		"__KRN_CALL_PROGRAM_SET_IS_SERVER");

	-------------------------------------------------------------------------
	-- Task services
	-------------------------------------------------------------------------
	procedure krn_task_set_priority(t: a_krn_tcb_t; prio: priority);
	  pragma interface(ADA, krn_task_set_priority);
	  pragma interface_name(krn_task_set_priority,
		"__KRN_CALL_TASK_SET_PRIORITY");
	function krn_task_create(arg: a_task_create_arg_t) return a_krn_tcb_t;
	  pragma interface(ADA, krn_task_create);
	  pragma interface_name(krn_task_create, "__KRN_CALL_TASK_CREATE");
	procedure krn_task_activate(t: a_krn_tcb_t);
	  pragma interface(ADA, krn_task_activate);
	  pragma interface_name(krn_task_activate, "__KRN_CALL_TASK_ACTIVATE");
	procedure krn_task_terminate(t: a_krn_tcb_t);
	  pragma interface(ADA, krn_task_terminate);
	  pragma interface_name(krn_task_terminate, "__KRN_CALL_TASK_TERMINATE");
	procedure krn_task_suspend(t: a_krn_tcb_t);
	  pragma interface(ADA, krn_task_suspend);
      pragma interface_name(krn_task_suspend, "__KRN_CALL_TASK_SUSPEND");
	procedure krn_task_resume(t: a_krn_tcb_t);
	  pragma interface(ADA, krn_task_resume);
      pragma interface_name(krn_task_resume, "__KRN_CALL_TASK_RESUME");
    function krn_task_get_supervisor_state return boolean;
	  pragma interface(ADA, krn_task_get_supervisor_state);
      pragma interface_name(krn_task_get_supervisor_state,
		"__KRN_CALL_TASK_GET_SUPERVISOR_STATE");
	procedure krn_task_enter_supervisor_state;
	  pragma interface(ADA, krn_task_enter_supervisor_state);
      pragma interface_name(krn_task_enter_supervisor_state,
		"__KRN_CALL_TASK_ENTER_SUPERVISOR_STATE");
	procedure krn_task_leave_supervisor_state;
	  pragma interface(ADA, krn_task_leave_supervisor_state);
      pragma interface_name(krn_task_leave_supervisor_state,
		"__KRN_CALL_TASK_LEAVE_SUPERVISOR_STATE");
    procedure krn_task_wait;
      pragma interface(ADA, krn_task_wait);
      pragma interface_name(krn_task_wait, "__KRN_CALL_TASK_WAIT");
    function krn_task_timed_wait(sec: duration) return boolean;
      pragma interface(ADA, krn_task_timed_wait);
      pragma interface_name(krn_task_timed_wait, "__KRN_CALL_TASK_TIMED_WAIT");
    procedure krn_task_signal(t: a_krn_tcb_t);
      pragma interface(ADA, krn_task_signal);
      pragma interface_name(krn_task_signal, "__KRN_CALL_TASK_SIGNAL");
    procedure krn_task_signal_unlock(t: a_krn_tcb_t; mutex: a_mutex_t);
      pragma interface(ADA, krn_task_signal_unlock);
      pragma interface_name(krn_task_signal_unlock,
		"__KRN_CALL_TASK_SIGNAL_UNLOCK");
    procedure krn_task_signal_wait_unlock(t: a_krn_tcb_t; mutex: a_mutex_t);
      pragma interface(ADA, krn_task_signal_wait_unlock);
      pragma interface_name(krn_task_signal_wait_unlock,
		"__KRN_CALL_TASK_SIGNAL_WAIT_UNLOCK");

	-------------------------------------------------------------------------
	-- Kernel scheduling services
	-------------------------------------------------------------------------
	procedure krn_kernel_set_time_slicing_enabled(new_value: boolean);
	  pragma interface(ADA, krn_kernel_set_time_slicing_enabled);
	  pragma interface_name(krn_kernel_set_time_slicing_enabled,
		"__KRN_CALL_KERNEL_SET_TIME_SLICING_ENABLED");
	function krn_kernel_get_time_slicing_enabled return boolean;
	  pragma interface(ADA, krn_kernel_get_time_slicing_enabled);
	  pragma interface_name(krn_kernel_get_time_slicing_enabled,
		"__KRN_CALL_KERNEL_GET_TIME_SLICING_ENABLED");

	-------------------------------------------------------------------------
	-- Time services
	-------------------------------------------------------------------------
	procedure krn_time_set(arg: a_time_set_arg_t);
	  pragma interface(ADA, krn_time_set);
	  pragma interface_name(krn_time_set, "__KRN_CALL_TIME_SET");
	procedure krn_time_get(arg: a_time_get_arg_t);
	  pragma interface(ADA, krn_time_get);
	  pragma interface_name(krn_time_get, "__KRN_CALL_TIME_GET");
	procedure krn_time_delay(day: day_t; sec: duration);
	  pragma interface(ADA, krn_time_delay);
	  pragma interface_name(krn_time_delay, "__KRN_CALL_TIME_DELAY");

	-------------------------------------------------------------------------
	-- Callout and task storage services
	-------------------------------------------------------------------------
	-- Service to install a callout.
    function krn_callout_install(event: callout_event_t; proc: address)
		return integer;
	  pragma interface(ADA, krn_callout_install);
	  pragma interface_name(krn_callout_install, "__KRN_CALL_CALLOUT_INSTALL");

	-- Service to allocate storage in the task control block
    function krn_task_storage_alloc(size: natural) return task_storage_id;
	  pragma interface(ADA, krn_task_storage_alloc);
	  pragma interface_name(krn_task_storage_alloc,
		"__KRN_CALL_TASK_STORAGE_ALLOC");

	-------------------------------------------------------------------------
	-- Allocation services
	-------------------------------------------------------------------------
	function krn_alloc(size: natural) return address;
	  pragma interface(ADA, krn_alloc);
	  pragma interface_name(krn_alloc, "__KRN_CALL_ALLOC");
	procedure krn_free(a: address);
	  pragma interface(ADA, krn_free);
	  pragma interface_name(krn_free, "__KRN_CALL_FREE");

	-------------------------------------------------------------------------
	-- Interrupt services
	-------------------------------------------------------------------------
	function krn_isr_attach(iv: intr_vector_id_t; isr: address) return address;
	  pragma interface(ADA, krn_isr_attach);
	  pragma interface_name(krn_isr_attach, "__KRN_CALL_ISR_ATTACH");
	function krn_isr_detach(iv: intr_vector_id_t) return address;
	  pragma interface(ADA, krn_isr_detach);
	  pragma interface_name(krn_isr_detach, "__KRN_CALL_ISR_DETACH");
	function krn_isr_get(iv: intr_vector_id_t) return address;
	  pragma interface(ADA, krn_isr_get);
	  pragma interface_name(krn_isr_get, "__KRN_CALL_ISR_GET");
	function krn_isr_get_ivt return address;
	  pragma interface(ADA, krn_isr_get_ivt);
	  pragma interface_name(krn_isr_get_ivt, "__KRN_CALL_ISR_GET_IVT");

	-------------------------------------------------------------------------
	-- Semaphore services
	-------------------------------------------------------------------------
	procedure krn_semaphore_wait(s: a_semaphore_t);
	  pragma interface(ADA, krn_semaphore_wait);
	  pragma interface_name(krn_semaphore_wait, "__KRN_CALL_SEMAPHORE_WAIT");
	function krn_semaphore_timed_wait(s: a_semaphore_t; sec: duration)
		return boolean;
	  pragma interface(ADA, krn_semaphore_timed_wait);
	  pragma interface_name(krn_semaphore_timed_wait,
		"__KRN_CALL_SEMAPHORE_TIMED_WAIT");
	procedure krn_semaphore_signal(s: a_semaphore_t);
	  pragma interface(ADA, krn_semaphore_signal);
	  pragma interface_name(krn_semaphore_signal,
		"__KRN_CALL_SEMAPHORE_SIGNAL");

	-------------------------------------------------------------------------
	-- Mutex services
	-------------------------------------------------------------------------
	procedure krn_mutex_lock(mutex: a_mutex_t);
	  pragma interface(ADA, krn_mutex_lock);
	  pragma interface_name(krn_mutex_lock, "__KRN_CALL_MUTEX_LOCK");
	procedure krn_mutex_unlock(mutex: a_mutex_t);
	  pragma interface(ADA, krn_mutex_unlock);
	  pragma interface_name(krn_mutex_unlock, "__KRN_CALL_MUTEX_UNLOCK");
	procedure krn_cond_wait(cond: a_cond_t; mutex: a_mutex_t);
	  pragma interface(ADA, krn_cond_wait);
	  pragma interface_name(krn_cond_wait, "__KRN_CALL_COND_WAIT");
	function krn_cond_timed_wait(arg: a_cond_timed_wait_arg_t) return boolean;
	  pragma interface(ADA, krn_cond_timed_wait);
	  pragma interface_name(krn_cond_timed_wait, "__KRN_CALL_COND_TIMED_WAIT");
	procedure krn_cond_signal(cond: a_cond_t);
	  pragma interface(ADA, krn_cond_signal);
	  pragma interface_name(krn_cond_signal, "__KRN_CALL_COND_SIGNAL");
	procedure krn_cond_broadcast(cond: a_cond_t);
	  pragma interface(ADA, krn_cond_broadcast);
	  pragma interface_name(krn_cond_broadcast, "__KRN_CALL_COND_BROADCAST");

	-------------------------------------------------------------------------
	-- Mutex service combinations
	-------------------------------------------------------------------------
	-- cond_signal, mutex_unlock
	procedure krn_cond_signal_unlock(cond: a_cond_t; mutex: a_mutex_t);
	  pragma interface(ADA, krn_cond_signal_unlock);
	  pragma interface_name(krn_cond_signal_unlock,
		"__KRN_CALL_COND_SIGNAL_UNLOCK");

	-------------------------------------------------------------------------
	-- Pending interrupt services
	-------------------------------------------------------------------------
	procedure krn_pending_handle;
	  pragma interface(ADA, krn_pending_handle);
	  pragma interface_name(krn_pending_handle, "__KRN_CALL_PENDING_HANDLE");

	-------------------------------------------------------------------------
	-- Name services
	-------------------------------------------------------------------------
	procedure krn_name_services(srv: k_name_srv_t; arg: address);
	  pragma interface(ADA, krn_name_services);
	  pragma interface_name(krn_name_services, "__KRN_CALL_NAME_SERVICES");


end krn_call_i;
package body krn_call_i is
end krn_call_i