Changelog

version 1.4.44:

- Report failure to open the /dev/srripc device earlier. (CB)
- Put an ifdef around atomic_add_unless for kernels that already define it, maybe. If you run into problems compiling srr_time.c, remove the #ifdef pair starting near line 161 concerning _ASM_X86_ATOMIC_64_H. (CB)

version 1.4.43:

- Change find_task_by_pid_ns to pid_task to deal with kernels 2.6.31 and up. (AT)

version 1.4.42:

- Remove locks in the timer interrupt. Change the tracking of timers to ensure that a timer is not marked as available until it has been both deleted by the owner task and been handled by the bottom half handler. This eliminates both a point of contention (the lock) and a race (delete while bottom half handler is pending). (AT)
- Change task sleep and wake behaviour to accommodate the possibility that a valid state transition occurs before a task can completely go to sleep. Treat the transition from SEND to REPLY specially, since it should not cause a task to wake. (AT)
- Changes to protect structures on SMP systems. (AT)
- Protect mapping user memory pages by taking a read-only lock on the memory semaphore. This fixes a potential race where pages could be mapped back out before the memory copy occurs. (CB)
- Remove static buffer when allocating memory for names. This was not thread or SMP-safe. (AH)

version 1.4.41:

- Fix proc file system code to conform to new functions starting with kernel version 2.6.26. Also an independent fix for SA_SHIRQ. (LM)
- Replace deprecated kill_task with send_sig. (AT)

version 1.4.40:

- Fix SA_SHIRQ to be IRQF_SHARED for newer 2.6 kernels. (BC)
- Remove an OOPS that should not be there in the timer handling code. It in fact was wrong when running on multi-core systems. The code is OK, but the consistency test is invalid. (AT)

version 1.4.39:

- Make a slight change to Oops messages to stop a compile error on systems where Oops is a macro. (AT)

version 1.4.38:

- Modify the timers to take into account wrap-around in the kernel jiffie clock. Previously, timers that spanned the wrap-around point would fire immediately. (AT)

version 1.4.37:

- Change the work handlers to match changes made in version 2.6.20 of the Linux kernel. If you get compilation errors related to work procedures or bottom half handlers in kernels after 2.6.18, this should fix them. (AT)

version 1.4.36:

- Fix incompatible changes made somewhere in kernel 2.6.18 2.6.18 that caused the module compilation to fail. The kernel removed devfs entirely, and changed the parameter list for the flush() file operation. If you get compilation errors with kernel versions prior to 2.6.18, change the version test around the flush assignment. (AT)

version 1.4.35:

- Improve the installation scripts in the Makefile to handle the fact that systems with udev installed simply will not auto-load the SRRIPC module. The Makefile now adds an init script that starts the SRRIPC module at boot time. This is only currently activated for 2.6 kernels. Also improve udev permission configuration code for newer udev versions. (AT)
- Add support for very large messages (> 3MB). This involves a header file change that is not backward compatible with previous versions of the SRRIPC module. The change is commented out in inc/srr.h. If you choose to use large message support, you will need to recompile and relink all applications that use the SRRIPC module. Programs that you received in binary form will simply stop working. (RS)

version 1.4.34:

- Remove a possible race between the timer irq handler and the bottom half handler that would possibly cause a timer proxy to stop triggering, but the timer would continue to queue indefinitely. (AT)
- Invert the order of dequeueing a proxy and reading the proxy message buffer into user space. There was a window of opportunity where the proxy could be queued when the timer fired again, and then the proxy was dequeued with a non-zero count but the timer bottom half was not set to fire (because the proxy was still queued at the time). (AT)

version 1.4.33:

- Replace spin lock with a mutex. We need to ensure that a process can swap memory in from disk during a kernel-to-user or user-to-kernel copy, and spin locks imply atomicity in later kernels. Since swapping can cause scheduling, and scheduling is not allowed in atomic contexts, spin locks do not work. All calls that might perform a memory transfer between kernel and user space need a lock of some kind so that they do not lose their hold on the SRR module, but they cannot be running atomically. So we use a mutex, which is not atomic, but which will lock out other entries into the SRR module. As before, this is not SMP safe. (AT).

version 1.4.32:

- Add SrrRelay, and the QNX4-compatible Relay() function. (LM)

version 1.4.31:

- Reinstate spin locks around code that wakes other tasks. Kernel behaviour has changed to include the implication that waking a task will also call the scheduler. In the past, it just marked the task for later scheduling. Please look out for warnings about paging while in a protected mode (signals turned off, etc.) and report them to Cogent. (AT)

version 1.4.30:

- Add code to implement clock_getres(). The header had a macro defined, but there was no actual function. (AT)

version 1.4.29:

- Remove some OOPS messages that are in reality just informational. The condition they signalled was normal (proxy fired, but non-existent) due to scheduling between normal processes and the timer bottom-half handler. (AT)

version 1.4.28:

- Fix a bug in Sendmx() where success would return the number of bytes transferred instead of returning zero. (AT)

version 1.4.27:

- Remove spin locks entirely. They were not working, and up until Linux 2.6.11, they were macros that resolved to nothing on uniprocessor systems. Starting at 2.6.11 they cause a kernel panic. (AT)
- Fix a makefile bug for some versions of 2.6 kbuild that would cause the include path to be incorrectly set. (AT)
- Add udev permissions to the installation. If you are using udev and the permissions are not set, it defaults to only allowing root access to the SRRIPC module. (AT)

version 1.4.26:

- Fix a pattern bug where a 2.4 kernel could be mistaken for a 2.6 kernel in the Makefile. (AT)
- Fix the makefile to use the same CFLAGS as the original kernel build. This fixes a problem where the SRR module crashed on load in some distributions (Fedora Core 3, Suse 9). (AT)
- Remove spin lock code that was supposedly protecting timer interrupt handler and bottom half handler. This was not correct in any sense. (AT)
- Remove spin_lock_irq_save, spin_lock_irq code. This was turning off all IRQs for substantial periods of time, without actually being necessary. All interesting IRQ processing is handled in the bottom half, which is not run at IRQ time. This improves overall system responsiveness, but reduces determinism. The SRR module, and Linux generally, is not deterministic anyway, so you should already have accepted non-deterministic behaviour. (AT)
- Changed IRQ handling to generate a proxy every time the IRQ fires, rather than every time the bottom half handler fires. If IRQs are quick the bottom half runs less frequently than the IRQ handler. This is common. (AT)

version 1.4.25:

- Change the "make load" test for devfs and udev to be more exact in its match. usbdevfs was matching, causing the "make load" to not create /dev/srripc. (AT)
- Added the total trigger count for proxies, and total number of top and bottom half calls for IRQ handlers. These are visible in the /proc/srripc filesystem. (AT)
- *** NOTE *** This is a major functionality change that will affect virtually nobody. You need to read this only if you are calling exec() and expecting blocked tasks and allocated names to survive the exec() call. ***
        Make the SRR file descriptor close in a child spawned using a
        call to exec().  This partially addresses a serious problem
        when using a threaded process to spawn child processes with
        fork/exec.  It's like this:
            Linux has the odd behaviour that a multi-threaded program
            in Linux closes its file descriptors in a sub-thread, even
            if the file descriptor was originally opened in the main
            thread.  This has the effect of mis-leading the SRR module
            into believing that the main thread is still running.
            Even with this mis-leading information, everything works
            fine, until you spawn a child process from the sub-thread
            without ever making an SRR call in that sub-thread.  The
            child process inherits the subthread's SRR file descriptor
            (which was itself inherited from the main thread), so it
            can hold this file descriptor open indefinitely.  If the
            child process survives beyond the termination of the main
            thread, several things can happen:
              1) names are held open after a process dies
              2) there can be a kernel panic in flush_signals
              3) there can be a kernel "Oops" when a timer expires on
                 a process that has already terminated.
            There may be other effects.
            In general, this problem appears not to be solvable.
            There is no information offered by the kernel to reliably
            determine that a process has died in truth.  We have only
            the file descriptor to go by.
            In most cases, the problem IS solvable.  The SRR module
            now sets the FD_CLOEXEC flag on the SRR file descriptor by
            default.  This is technically a break from the behaviour
            of QNX, which will allow a process to call exec() without
            releasing names or unblocking blocked senders.  This case
            is very rare, however.  For people who need this
            behaviour, there is a new function call, SrrSurviveExec()
            with no arguments, that will give the QNX-like behaviour.
            It must be called once per thread within a program.
            If you need both the QNX-like exec behaviour and the safer
            child process behaviour, you will have to change one or
            the other.  If you are calling fork+exec in succession to
            spawn a process, you definitely do not need the QNX-like
            behaviour.
        The slightly more technical explanation is this:
        
            Parent mainline (P) starts thread (T), which fork/exec's
            child (C) which makes no SRR calls.  If C survives the
            death of P, then it will hold open P's file descriptor
            (FD).  In Linux, FD is closed in the parent by T, not by
            P, so SRR cannot tell that P has died.  It uses the final
            close of FD as evidence that P has died, but C is holding
            FD open, so P appears to still be active.  P does not
            appear to die until C dies.  If P is holding a name, the
            name will appear to still be active.  When C dies, the
            cleanup code for P could attempt to access a now defunct
            kernel task structure, which will cause a panic.
        If you really want the SRR file descriptor to survive an exec
        call, make a call to SrrSurviveExec() prior to calling exec(),
        (but after fork() if you are using it).  You would only do
        this if you wanted to allocate a name to a process that you
        subsequently spawned, or expected to have processes blocked on
        the program when the exec call is made, and you want them to
        continue to block.   You must call SrrSurviveExec once in each
        thread that will call exec().  (AT)
- Add SrrNameAttach and SrrNameLocate tests to exe/pthread2.c (AT)
- Simplify un-queuing of proxies with multiple trigger counts so that there is no window of time where the trigger count is temporarily zero. This should have no visible effect. (AT)
- Add many options to exe/pthread2.c for testing purposes. (AT)
- Modify make file in ./exe to avoid linking to an absolute path for libsrr.so. (AT)
- Replace kill_proc_info calls with kill_proc. kill_proc_info is no longer exported by the kernel as of version 2.6.10. (AT)

version 1.4.24:

- Fix an error where MX calls were not returning the correct sizes in the MX records. In some cases, consecutive MX calls were also working with an incorrect size, which could cause message corruption. (AT)
- Make _setmx macro similar in syntax to QNX4 macro so that porting is easier. (AT)
- Make Creceivemx, Receivemx and Sendmx into functions rather than macros so that they can behave the same as their QNX4 counterparts. They no longer alter the length fields of the MX records. (AT)
- Alter the pthread2.c test program to optionally use the MX versions of functions for transferring test data. (AT)
- Add a new function / system call SrrGetpid(), which returns the real process ID of the calling thread. Threads in Linux are assigned unique process IDs, but the getpid() call in later kernel versions (post 2.6.3?) returns the process ID of the thread parent. This makes sense in many cases, but not for SRRIPC. (AT)
- Fix a QNX4 incompatibility with timers where in QNX4 a timer will be disabled when it_value is zero, but in SRR the timer would only be disabled when both it_value and it_interval were set to zero. (AT)

version 1.4.23:

- Rewrite the code that maps pages into memory prior to a copy. It made some false assumptions about how memory is organized that failed with large buffers in global static memory. (AT)
- Put version number in log message on startup. (AT)
- Produce a log message if /proc filesystem support is not present in the kernel. (AT)
- Add a new test program, exe/pthread2, that generates many messages among many threads of random sizes and random source/destination pairs. (AT)

version 1.4.22:

- Clean up the load and test targets in the Makefile, and clean up the INSTALL instructions to match. (AT)
- Change static structure initializers to use designated initializers to help protect from differences in structure contents across kernel versions. (AT)
- Change the memory bounds check to generate an Oops message rather than a stack dump, and to return EINVAL to the calling task. (AT)
- Improve error reporting when there is not sufficient kernel memory to allocate buffers for a Send() call. This now generates ENOMEM consistently. (AT)

version 1.4.21:

- Force user data into memory before transferring between kernel space and user space. Kernels prior to 2.6.6 appear to hold the user data in memory anyway, but after 2.6.6 buffers appear to be commonly swapped out even when main memory is available. (AT)

version 1.4.20:

- Modify timer code again to be more robust in the face of unpredictable integer types for struct timeval, time_t and others. We do not want to rely on future versions having signed integers for values that really should not be negative. This was motivated by a rare bug where interval timers sometimes stop running, even with the changes in 1.4.19 (possibly fixed now). (AT)
- Modify the output from /proc/srripc/timers to present data in seconds, and to present the accurate time or next trigger for a timer. (AT)

version 1.4.19:

- Fix a math error and race condition in the timer code where a timer that is set to expire in the past would be promoted to a distant future date, or not queued to fire at all. (AT)
- Add code to deal with the possibility that a process does not clean up its own file descriptors. This was caused by tasks using the pthread library terminating abnormally. Linux allows another thread to clean up on behalf of the thread that created the file descriptor, which seems like bad design. The effect was that task death messages were not sent to PPF_INFORMed tasks in this case, which caused (for example) Cogent's nserve and qserve not to update their running process knowledge correctly. (AT)

version 1.4.18:

- Fix a bug where a timer with no proxy or signal set (sigev_signo is zero in the sigevent structure) would not generate an event. This case should act like an alarm() call to be compatible with QNX 4. (MC)
- Fix error "unknown file linux/tqueue.h" in build on kernel version 2.6.0 and up when no kernel 2.4 has ever been installed on the machine. (GPW)

version 1.4.17:

- Change the build process for 2.6 kernels to match the kernel build mechanism. (GB)
- Fix a prototype error. (GB)
- Add module information for modinfo. Change load and unload for kernel version 2.6.x compatibility. (GB)
- Add a structure member for 2.6.1+ kernels. (GB)

version 1.4.16:

- Fixes to support 2.6 kernels with work tasks instead of tasklets. We cannot use tasklets because they cause their bottom half handlers to run at interrupt time, which is a race. Remove all code relating to tasklets. (AT)

version 1.4.15:

- Remove the need to link programs that do not explicitly use pthreads with the -lpthreads library. That is handled by the linkage in the libsrr.so. (AT)
- Remove the need to call SrrUsePthreads(1) at the start of a program using pthreads. You still have to ensure that the registration order (first SRR module call) of the various threads is consistent with the communication profile among them. It is wise to call SrrReg() or some other SRR library function in the main thread before creating any child threads. (AT)
- Make multi-threading the default.
- Make some library functions re-try interrupted system calls. (AT)
- Put task death determination back into the flush() event, since that is where it actually should be. release() is too late. (AT)
- Make the build process create and install a dynamic library (.so) as well as the static library. This allows us to create a library with multi-threading built in without having to link all clients against -lpthread. It also helps with future upgrades. Clients need to be re-linked to use the dynamic library. (AT)
- Fix some bugs in the library introduced with the multi-threading code. (AT)
- Remove the /proc/srripc/srr entry. It was generating bad output. We need to find a better way of buffering the output to the /proc filesystem. (AT)

version 1.4.14:

- Clear up some oddness where the "flush" event was being used as evidence that the module was being closed. This is only true in pre-2.4.something kernels. After that, we use "release". In 2.4 kernels this caused a harmless oops message after a fork() by the client. (AT)
- Make the SRR library thread-aware. This will only work so long as the kernel implements threads as separate process IDs, since the underlying communication model is based on process ID. To compile with thread support, you need the pthread library installed. Then compile the SRRIPC module with: make -k SRRTHREAD=y All programs linked to this library must also be linked to -lpthread Your program must call: SrrUsePthreads(1); prior to any other SRRIPC call. To test whether the pthread support is working, run the program: srr/exe/pthread This addition is experimental. Please send us your feedback. (AT)

version 1.4.13:

- Make all timer and IRQ bottom half handlers run in process context instead of interrupt context. This fixes a race that could cause the proxy table to become inconsistent under some conditions. (AT)
- Make all proxy count and task queue count operations into atomic operations. This now does no good (or harm) since the bottom half handlers run from the scheduler. (AT)
- Add several Oops messages to improve tracking of unexpected errors. (AT)

version 1.4.12:

- Fix a bug in Reply that caused the size of the previous Send to be reported for the reply length when using SrrSend. (AT)

version 1.4.11:

- Add support for Linux kernels 2.6.0 (and higher?). Note that kernel module auto-loading may or may not work for you with Linux 2.6.0. (AT)

version 1.4.10:

- Fix a pointer error when checking spin locks. (AT)

version 1.4.9:

- Try to guess only a single kernel source include directory instead of relying on include order. Try to guess whether recalc_sigpending() takes an argument based on a regular expression grep in the sched.h file. (AT)

version 1.4.8:

- Change the way proxies with multiple fire counts are handled so that the proxy goes to the back of the wait queue on its target every time the target does a Receive on the proxy. This allows other clients on the target to get a chance to deliver an event even if a proxy has a permanent non-zero count. (AT)

version 1.4.7:

- Fix a problem with timers where the bottom half handler might run concurrently with the timer interrupt, causing a Trigger on the time's proxy to be missed. Added numerous debugging statements in the timer code. (AT)
- Modified the SrrTaskSleep family of functions to accept the processor flags from the spin lock as input. This closes a window of opportunity for task state to change as the task is going to sleep and reduces the number of spin lock actions. It turns out that this modification will not work on SPARC architectures (you must call spin_unlock_irqsave in the same function that called spin_lock_irqsave on SPARC). We need a better solution. A huge macro, maybe. (AT)

version 1.4.6:

- Changed the way signals are flushed. This should be more robust going forward (and is how it should have been done in the past). The old method does not work in 2.4.20, causing a crash whenever a PPF_INFORM'd task is running when another is killed using a signal. (AT)
- Changed the default debugging status to true when SRRDEBUG=1 is specified on the make line. (AT)
- Moved the point at which IRQs are detached when a process is cleaned up. (AT)

version 1.4.5:

- Insert the GPL license into the module to remove the insmod warning about the module tainting the kernel. (AT)
- Add two new files, version and irq, to the /proc/srripc directory to dump the current module version and the set of tasks that have mapped IRQs. (AT)

version 1.4.4:

- Changed some prototypes from returning int to returning pid_t. (AT)

version 1.4.3:

- Change the name of timeval_to_timespec to avoid a name collision with some kernel distributions (SuSE for example). (AT)

version 1.4.2:

- Fix a bug where task death messages were not being delivered if a signal occurred on the target while the system was trying to deliver the task death notification. (AT)

version 1.4.1:

- Change _setmx macro to remove spaces that confuse the preprocessor. How did this ever work? (AT)
- Change API license terms to the GPL, rather than LGPL. See the README file under "Copyright" for more details.

version 1.4.0:

- Added the ability for SRRIPC to attach an interrupt due to a user request, and to trigger a proxy in response to that interrupt. (AT)
= Added spin locks around critical code that could be pre-empted by an interrupt or timer. This is not good enough for SMP systems, but it is good enough for interrupts on a uniprocessor system, since the only call that an interrupt handler will make is to trigger a proxy. (AT)
- Added code to implement a simple byte-code interpreter that can be run from within an interrupt handler. This allows a user program to perform simple operations on ports and memory at interrupt time and then schedule a proxy to be fired to let him complete the "bottom half" of his interrupt handling in user space in response to that proxy. The idea is to perform the minimum number of operations to clear the interrupt for the particular device at interrupt time and then do all the real processing in response to the proxy. See mod/bytecode.txt for more information. (AT)
- Cause Receive to return -EAGAIN when the sender is unblocked due to a signal before the Receive actually gets the data. Changed the library to retry the Receive when it sees the -EAGAIN response. (AT)
- Changed the library Makefile to compile position-independent code in case you are linking the SRRIPC module against a shared object. We should really produce a shared library as well as a static library. (AT)

version 1.3.18:

- Fix a bug introduced in the previous patch where the return value from ioctl was being forced to zero in the library. This caused Receive to always return 0 on success. This also caused tserver to fail. (AT)

version 1.3.17:

- Fix a bug where the name table is uninitialized before use. Added static initialization. (SF)
- Fix a bug in the API library where an error return from srr_name_attach and srr_name_locate was returning EINVAL instead of returning -1 and setting errno to EINVAL. (SF)

version 1.3.16:

- Fix a bug with srr_name_attach where it was returning an invalid value of SRR_MAX_NAMES. Changed to return the name id so it can be used as input to srr_name_detach. (SF)

version 1.3.15:

- Changed the make files to give a choice whether to build without the kernel source present, thereby creating a module that will compile and run, but gives "unresolved symbol" errors from insmod or depmod. Attempt to automatically determine whether there is kernel source present. (AST)
- Fixed accidental make problem introduced with 1.3.14 that would allow the module to compile if make was run in the ./mod subdirectory, but not from the top level. (AST)

version 1.3.14:

- Fixed a bug in the API library where Creceive was being implemented as Creceivemx. This pointed out a bug in the module where the mx functions were not using the correct numbers for the sent message length, causing some messages to come back with zero data. (AST)
- Fixed the ambiguous naming in SrrBuf, where size and len were being used interchangeably in the code. (AST)

version 1.3.13:

- Add a macro to srr.h, NO_KERNEL_ITIMERSPEC, which tries to solve the unsolvable problem of whether your particular kernel headers define struct itimerspec. From one vendor and revision to the next this might change. Use this module to force one or the other. (AST)
- Noted that the macro on line 119 of srr_sys.c might need to be altered to be < KERNEL_VERSION(2,2,14) from < KERNEL_VERSION(2,2,16) for some versions of kernel 2.2.something. Frustrating, but true. (AST)

version 1.3.12:

- Fix macro bug that sometimes causes Send and Sendmx to report failure even if they succeed (caused by changes to 1.3.10). (AST)

version 1.3.11:

- Added the missing sendmx.h file to the Manifest. (AST)

version 1.3.10:

- Changed all the fundamental function names to SrrSomething to remove QNX-specific names from the basic API. QNX calls are now macros mapping to the Srr calls. (AST)
- Add code in the kernel module that allows receive and send functions to get back the length of the message. Not tested. (AST)

version 1.3.9:

- Sigh. Changed timer_t to srr_timer_t and clockid_t to srr_clockid_t to deal with the ever-expanding ring of confusion around the POSIX timer and clock support in the Linux kernel. You are now unable to use both the linux kernel versions and the srr versions in the same program. (AST)

version 1.3.8:

- Added ifdefs around timer_t and clockid_t to resolve a conflict with time.h. (AST)
- Fix a bug in qnx_name_locate causing it to fail if it is the first SRR call after a fork(). (AST)
- Moved the _mxfer_entry information into the main exported header file instead of having them it in a separate file. (AST)

version 1.3.7:

- Added Sendmx, Replymx, Receivemx calls by John Green. It is possible to implement Send, Receive and Reply in terms of these, but they turn out to be about 10% slower. That doesn't make sense, but there you have it. (JG)
- Modified the srr_lib.c to remove the slightly confusing recursive calls. They didn't actually recurse more than once, but now it is a little bit easier to read. (JG)
- Added code to return the actual number of bytes copied in Send and Receive (well, Send anyway), and then commented it out again because this could break existing applications. It would be nice to know this information at some point. (AST)

version 1.3.6:

- Fix incompatibility with the 2.2.16 kernel that is shipped with Redhat 7.0. People keep messing with the signal representation in the task structure. (AST)
- Fix incompatibility with the RedHat 7.0 header organization where you cannot compile without the kernel source installed. You may have to modify the INCLUDEDIR line of mod/Makefile to compile on your installation. (AST)
- Selectively remove the ability to use versioned kernel symbols. There is a header dependency cycle that I have not been able to solve. Removing the versioned kernel symbols means that depmod will complain about undefined symbols, but everything will work just fine. (AST)

version 1.3.5:

- Fix incompatibility with the 2.4.0 release kernel. There was a change to how signal sets were stored in the task structure that stopped srripc from compiling. (AST)
- We have a patch that I apologize is not yet included in this release. Would anybody care to try to incorporate it? Please let me know: andrew@cogent.ca. - Direct process-to-process copy, removing the need to cache in the kernel. This improves overall throughput, and is probably the Right Thing To Do. By Frederic Rossi.

version 1.3.4:

- Fix race in proxy timers. The timer function was assumed to run in the bottom half handler of the timer interrupt, but is in fact run in the interrupt context. Triggering a proxy needs access to the task table and receive queues, so there were some windows of opportunity for corruption of receive queues, leading to lost events. Changed the timer code to run in an immediate bottom half handler, which has the side effect of damaging determinism in timers. There appears to be no choice. Signals are still delivered during the ISR, which may not be safe. Perhaps this code should also be moved to the bottom half handler. (AST)

version 1.3.3:

- Added Readmsg and Writemsg. New test program, rwmtest.c. (AS)
- Added UTIME (microsecond timer) timer code from Richard Romano. This requires the U. of Kansas UTIME kernel patches (http://www.ittc.ukans.edu/utime). This is turned on with the CONFIG_UTIME kernel configuration option. (RR)
- Fix a memory leak when destroying a task. (AS)
- Works with 2.2.x and 2.4.x Linux kernels. (AST)
- Fix undefined references during depmod. (AST)

version 1.3.2:

- fixed mod/Makefile and exe/srrmodule to properly do a test load without having to install first. (AS)
- fix KDEBUG macro to exist but be empty if compiling without debugging. (AS)
- add Readmsg() call (mirrors QNX Readmsg()) call, to read data from the current incoming message. (AS)

version 1.3.1:

- fixed bug in qnx_name_attach bug fix that would result in an infinite loop when attaching a name that is already in use.

version 1.3:

- fixed bug in memset that caused timers not to be deallocated. (AST)
- made name (qnx_name_attach) mutually exclusive. Return EBUSY if name is in use. (AST)
- change to use major 10, minor 171, to agree with official Linux device assignments. (AST)
- change name of module from srr to srripc to agree with official Linux device assignments. If you want to be compatible with old binaries, do "mknod -m0666 /dev/srr c 10 171". (AST)
- Add environment variable SRRDEV to the client library to allow more than one srripc module to be loaded at a time. This is really only useful for testing. Default: /dev/srripc (AST)
- explicitly include pod2??? scripts because different Linux distributions seem not to always have them. (AST)
- change to Makefile to insert auto module loading line in /etc/conf.modules (AST)
- NOTE: not ported back to linux 2.0.x (!AST)

version 1.2:

- rearranged source directories, and made install targets
- fixed bugs in task death notification that caused deadlock (Andrew Thomas)
- added a /proc/srr directory with a lot more information (Andrew Thomas)
- ported back to linux 2.0.x (again)

version 1.1:

- re-implemented timers in the module to more closely follow POSIX semantics
- timers can now deliver signals as well as proxies

version 1.0:

- Work around for sleep bug (see TODO), user won't see the bug, but it still bothers me.
- Fixed fork bug (but only for >2.2 kernels, see README).
- Ported to 2.2 kernel (Andrew Thomas)
- Andrew Thomas implemented (for 2.2.*, I back-ported it to 2.0.*):
- Creceive(),
- task death notification (qnx_pflags),
- proxy notification on timer expiry (timer_*), and
- select()
- Fixed bug with a proxies not having their args.pid set, despite being in a state of send blocked, which confused the task release procedure.
- Added SrrDebug() to control verbosity of debug messages in a module built with debugging compiled in.
- Fixed non-QNX names for task states (sorry, slight misunderstanding...).

version 0.4: saturday, may 01

- Fixed bug causing busy loop when module wasn't loaded.
- Can compile tserver agains FC Software's SRR emulation, but due to incompatibilities between the QNX API and their interface it will take more work to do a runnable port.
- Default build is non-debuggable and triggered by the SRRDEBUG env variable.

version 0.3: sunday, april 05

- Removed dynamic memory allocation for recv_q management.
- Added work-around for tasks being woken up when they shouldn't, don't know if it's my bug, or something I don't understand about wait queues.
- Made task structure simpler (and more like Linux's).
- tserver test now runs without problems.