changelog

开放源码实时操作系统源码.

	* include/thread.inl (measure_stack_usage): Deal with stack limits.

2001-09-07  Nick Garnett  <[e-mail]>

	* src/common/thread.cxx (set_priority): Change argument to
	instrumentation call to new_priority rather than current
	priority. (Suggested by Andrew Lunn).

2001-09-05  Jesper Skov  <[e-mail]>

	* include/mqueue.inl (Cyg_Mqueue): Initialize busy flag of last
	entry in the list.

2001-09-04  Jonathan Larmour  <[e-mail]>

	* cdl/instrument.cdl (CYGDBG_KERNEL_INSTRUMENT_BUILD_HOST_DUMP): 
	Remove redundant requires, and adjust make rule to be more portable
	across hosts.
	(CYGDBG_KERNEL_INSTRUMENT_MSGS_BUILD_HEADERFILE):
	Invoke script with sh directly rather than rely on executable attribute.

	* host/instr/readme.txt: Update build of host dump as per the changed
	CDL.

	* cdl/kernel.cdl: Don't build nullinst.cxx any more.
	Build meminst.cxx only in CYGPKG_KERNEL_INSTRUMENT.
	* src/instrmnt/nullinst.cxx: Delete. It causes confusion in the
	library as it declares cyg_instrument like meminst.cxx does.

2001-08-31  Nick Garnett  <[e-mail]>

	* src/intr/intr.cxx: Clean up typo in DSR table
	case. dsr_table_tail and dsr_table_head were not being subscripted
	in a couple of places.

2001-08-23  Hugo Tyson  <[e-mail]>
2001-08-20  Andrew Lunn <[e-mail]>

	* include/instrument_desc.h: New file.  This contains the table of
	events used to print the nice information.  It should be
	regenerated when the instrumentation numbers change.

	* src/instrmnt/meminst.cxx (cyg_instrument_msg):
	returns an ASCII string describing the type of event the
	instrumentation code logged.

	* include/instrmnt.h: Added function prototype.

	* cdl/instrument.cdl: Configury for enabling the new function, and
	optionally rebuilding its header file and building a host tool.

	* host/instr/dump_instr.c: New file.  A host program to print the
	instrumentation information in a human readable form.

	* host/instr/instrument.sh: New file.  Script to generate table of
	events with textual representation.

	* host/instr/readme.txt: New file.  Helpful information.

2001-08-23  Nick Garnett  <[e-mail]>

	* include/kapidata.h (CYG_THREADTIMER_MEMBERS):
	Substituted an expicit cyg_alarm object for CYG_ALARM_MEMBERS in
	this definition. In some architectures (MIPS in particular) the
	structures need to be padded to a multiple of 64 bits. This was
	not happening with the macro substituted versions.
	This is just a temporary fix, I'll leave it to Jifl to sort out a
	real patch when he returns.

2001-08-23  Hugo Tyson  <[e-mail]>

	* src/common/thread.cxx: Properly qualify Cyg_Thread::destructors
	array so that it builds when destructors are not used.

2001-08-23  Nick Garnett  <[e-mail]>

	* src/sched/mlqueue.cxx: Added code to
	Cyg_SchedThread_Implementation::to_queue_head() to handle a NULL
	thread queue pointer. This compensates for a minor change in
	behaviour of the scheduler.

2001-08-22  Jonathan Larmour  <[e-mail]>

	* cdl/thread.cdl: Add kernel thread destructor options.
	* include/kapidata.h: Add thread destructor entries to cyg_thread
	* include/thread.hxx (Cyg_Thread): Give per-thread data indexes
	their own type, cyg_data_index.
	Include new thread destructor data members, and new add_destructor
	and rem_destructor member functions.
	* include/thread.inl: Use a cyg_data_index for per-thread data handle.
	(add_destructor): New Cyg_Thread member function.
	(rem_destructor): Ditto.
	* src/common/kapi.cxx: Use cyg_data_index type for per-thread data
	functions.
	* src/common/thread.cxx (Cyg_Thread): initialise per-thread
	destructors if needed.
	Define static destructors if needed.
	(exit): Call destructors.
	(new_data_index): Use cyg_data_index type.
	(free_data_index): Ditto.

2001-08-22  Hugo Tyson  <[e-mail]>
  
	* src/sync/mutex.cxx (Cyg_Mutex): Add initialization of the
	priority ceiling value in the non-dynamic protocol case.

2001-08-22  Nick Garnett  <[e-mail]>

	* tests/intr0.c: 
	* tests/kintr0.c:
	Swapped order of interrupt enable/disable calls to keep kernel
	happy when assertions are enabled. Otherwise the enable call
	complains that interrupts have not been disabled.

	* src/sched/mlqueue.cxx:
	Simplified algorithm in set_need_reschedule().

	* include/smp.hxx: 
	* include/kapidata.h: Change spinlock to be a cyg_uint32, rather
	than a cyg_atomic.

	* src/intr/intr.cxx: 
	* include/intr.hxx:
	Now arrange for DSRs to be called on the same CPU as the ISR. This
	is necessary if the DSR needs to access per-CPU hardware (such as
	interrupt controllers). This is achieved by keeping a separate DSR
	list/table for each CPU.

	* tests/smp.cxx: Some modifications to make this test work in a
	real SMP environment.

	* tests/timeslice.c: 
	* cdl/kernel.cdl: Added timeslice test.

2001-08-21  Hugo Tyson  <[e-mail]>

	* src/sync/mutex.cxx (lock): Bugfix: a ceiling priority mutex
	wasn't elevated until after it had acquired the mutex.  This meant
	it slept with a low priority, and so did not run when awakened by
	the release of the mutex.  The fix is to elevate the potential
	claimant before it sleeps in contention. 

	* tests/kmutex4.c: New testcase - very similar to kmutex3 but it
	loops a load more times using different mutex priority protocols.
	This checks that dynamically set protos do in fact behave
	differently from one another and as they are each intended to.

	* tests/kmutex3.c: Remove FIXME comments - we now test dynamic
	protocol.

	* cdl/kernel.cdl: Build the new test.

2001-08-20  Jonathan Larmour  <[e-mail]>

	* include/kapidata.h: Reorganize most struct type definitions into
	macros to allow compatible layout with all G++ implementations that
	align non-POD types differently from included C structures.
	* include/kapi.h: Similarly for cyg_resolution_t.

2001-08-17  Nick Garnett  <[e-mail]>

	* src/sched/mlqueue.cxx (timeslice): Fix timeslice_count comparison.

2001-08-16  Hugo Tyson  <[e-mail]>

	* include/kapi.h (cyg_mutex_protocol): Tidy up names of mutex
	protocol type and values.  These polluted rather in 'C'.

	* src/common/kapi.cxx (cyg_mutex_set_protocol): ditto.

2001-08-15  Hugo Tyson  <[e-mail]>
2001-08-15  Andrew Lunn <[e-mail]>

	* src/common/kapi.c (cyg_thread_get_current_priority): Export
	this function into the C api.
	* include/kapi.h: Declaration of new function.

2001-08-14  Jonathan Larmour  <[e-mail]>

	* src/common/kapi.cxx (cyg_spinlock_spin_intsave): Cast to istate
	to CYG_INTERRUPT_STATE * since that's what is needed.
	(cyg_spinlock_clear_intsave): Similarly.

2001-08-10  Hugo Tyson  <[e-mail]>

	* cdl/synch.cdl: Re-organize the options for mutexes so they are
	active a bit more sensibly; place the default ceiling within
	selection of ceiling protocol, and only have a default protocol if
	there is more than one protocol active.

	* tests/mutex3.cxx: More detailed handling of the possibility of
	ceiling protocol instead of the inherit or none cases; we can run
	the test ok and treat as inherit if the ceiling prio is higher
	than 5, treat as none if lower than 15, and don't check anything
	if in between - the test runs happily.

	* tests/kmutex3.c (cyg_start): New test, a KAPI translation of the
	now-classic mutex3.cxx.

	* cdl/kernel.cdl: Build tests/kmutex3.c

2001-08-06  Hugo Tyson  <[e-mail]>

	* src/sched/sched.cxx (unlock_inner): Fix assignment to current,
	wouldn't build if stack checking after merger from SMP branch.

2001-08-06  Andrew Lunn   <[e-mail]>
2001-08-06  Hugo Tyson  <[e-mail]>

	* src/sync/mutex.cxx: (set_protocol) Added a function to set the
	priority inversion protocol for a mutex.

	* src/common/kapi.cxx: Export the new function above and
	set_ceiling into the C API.
	
	* include/mutex.hxx (class Cyg_Mutex): New member function
	set_protocol().

	* include/kapi.h (cyg_protcol): Define new emumeration for mutex
	priority protocol setting, and headers for the new function to set
	it.

2001-08-03  Nick Garnett  <[e-mail]>

	Imported from a development branch:
	
	2001-07-11  Nick Garnett  <[e-mail]>

		* src/sched/mlqueue.cxx: Changed behaviour of
		set_need_reschedule() to a better implementation of the intended
		algorithm.

		* include/kapi.h: 
		* src/common/kapi.cxx:
		Added API for controlling routing of interrupts to CPUs in SMP
		configurations.

	2001-07-03  Nick Garnett  <[e-mail]>

		* cdl/scheduler.cdl:
		* include/bitmap.hxx:
		* src/sched/bitmap.cxx:
		Fixed up bitmap scheduler so it still works within the
		SMP-modified scheduling infrastructure. The bitmap scheduler
		is not currently SMP-enabled, only single CPU configurations are
		supported - hence the CDL change to require this.

	2001-06-29  Nick Garnett  <[e-mail]>

		* src/sched/sched.cxx:
		Removed the call to Cyg_Interrupt::enable_interrupts() in
		Cyg_Scheduler::start_cpu(). This was a relic from the days when
		the interrupt enable state was not part of the thread state. Now
		it is, and loading the first thread will cause interrupts to be
		enabled.

		* src/intr/intr.cxx:
		Changed initial values of Cyg_Interrupt::disable_counter[]s to
		zero as a result of the change in Cyg_Scheduler::start_cpu().

		* include/kapi.h:
		* include/kapidata.h:
		* src/common/kapi.cxx: 
		Added API for using spinlocks. Largely so that it may be extended
		to the driver API.

		* include/mlqueue.hxx:
		* include/intr.hxx:
		* include/sched.hxx:
		Added annotations to various static variables.

	2001-06-28  Nick Garnett  <[e-mail]>

		* include/intr.hxx:
		* src/intr/intr.cxx:
		Changed behaviour of Cyg_Interrupt::disable_interrupts() and
		Cyg_Interrupt::enable_interrupts(). These now claim and release a
		spinlock in addition to disabling and enabling interrupts. The
		original interrupt state is also preserved and restored. This is
		necessary in SMP systems to allow drivers etc. to correctly
		synchronize with threads and DSRs that may be running on different
		CPUs. In the single CPU case this mechanism reduces to the
		original simple interrupt disable code.
		[Later change] Backed off addition of volatile modifier to
		interrupt_disable_state.

		* include/smp.hxx: Some minor tidies.

	2001-06-27  Nick Garnett  <[e-mail]>

		* tests/release.cxx: Added spin loop in thread1 to allow thread0
		to execute its wait. This is necessary in SMP systems where the
		threads will execute in parallel, but is also benign in single CPU
		systems.

		* tests/mutex2.cxx:
		* tests/mutex3.cxx:
		* tests/sync3.cxx: 
		* tests/thread2.cxx: 
		These tests depend on predicting the behaviour of threads at
		different priorities to pass. In an SMP system, several threads
		will run in parallel, and the execution order will not be as
		expected. These tests are therefore disabled in SMP
		configurations.

		* src/sched/mlqueue.cxx (add_thread): Moved call to
		set_need_reschedule() out of test for empty queue. In SMP systems,
		any addition to a queue may require a reschedule on another CPU.

	2001-06-22  Nick Garnett  <[e-mail]>

		* include/mlqueue.hxx:
		* src/sched/mlqueue.cxx:
		A major change to the way in which this scheduler works in SMP
		systems. The previous version removed all runnable threads from
		the run queues when they were executing. This resulted in serious
		complications and messy code, particularly when dealing with
		priority changes and timeslicing. The new version keeps running
		threads in the run queues, just like the single-CPU version. The
		main disadvantage of this is that we may have to search past
		threads running on other CPUs before we find one available to run
		on this CPU. However, the pending count array and map mean that we
		only need search one run queue, and in any case the search remains
		bounded by the number of CPUs available.
		Another change is in the way that timeslicing is handled. Now, the
		CPU that takes the clock interrupt decrements the timeslice counts
		for all CPUs and if any go zero, sends a TIMESLICE message to
		that CPU.

		* src/sched/sched.cxx (unlock_inner):
		Removed call to requeue(), no longer needed as a result of
		scheduler reorganization.

		* src/common/thread.cxx:
		Added test in Cyg_Thread::exit() to check that the thread has not
		already been killed. This is only an issue if the thread is
		calling exit() when it is kill()ed from another CPU. The test is
		redundant in single-CPU systems, but it does no harm having it.
		Added code to Cyg_Thread::set_priority() to check for reschedule
		when another thread is being changed in priority.
		Added call in idle thread constructor to scheduler to install the
		idle thread as the default current thread for a CPU.

		* include/smp.hxx:
		Added CYG_KERNEL_CPU_TIMESLICE_INTERRUPT(), did some miscellaneous
		tidying.

		* include/instrmnt.h: Added SMP_RESCHED_SEND and SMP_RESCHED_RECV
		events.

		* cdl/kernel.cdl: Added smp test program.

		* tests/smp.cxx: Added this program to test SMP functionality.

	2001-06-13  Nick Garnett  <[e-mail]>

		* src/sched/sched.cxx:
		Removed code to set up initial current thread, this is now done
		in the idle thread constructor.
		Added code here to set up interrupts for SMP inter-processor
		interrupts. This is not very tidy and may need to be