Free arm software for linux

mod_arm provides a simple, seamless, and application independent interface to ARM (Application Response Measurement).

mod_arm allows system administrators to get an accurate idea of how long an application takes on a running server - for a single instance or as a step in a multi-tier transaction. This is definitely a work in progress.

Configuration Directives

Arm

Syntax: Arm state
When state is on, ARM measurements will be taken for this directory
When state is application, ARM measurements will be controlled by the application scripting language such as PHP (not yet implemented)
When state is off, no measurements are taken for this directory

ArmApplication

Syntax: ArmApplication application_name
Specifies the application name to use for this directory. If non is specified, the default value of "Apache" is used.

ArmUser

Syntax: ArmUser user_name
Specifies the user name for the transaction. If none is specified, the default value of "*" is used

ArmTransaction

Syntax: ArmTransaction transaction_name
Specifies the name of the transaction. If none is specified, the default value will be the URI of the object requested.

ArmTransactionInfo

Syntax: ArmTransactionInfo transaction_info
This is an informational string used to descibe the transaction, primarily for use by transaction correlators. If not specifed, the default value is "Apache web page".

Small Arms Ballistics is, as the name says, a ballistics calculator for small arms fire. It is a terminal application written using curses.
Small Arms Ballistics is derived from smallball, which was written by Ole-Hj. Kristensen. I have pretty much rewritten the entire program, but smallball got me started. All major
trajectory calculations have been implemented, and a variety of bullet drag models are available.
The program needs a color capable terminal, otherwise it wont run.
Enhancements:
- distribution didnt include saballistics.lsm.in

Adrian project is a RPG using SDL and OpenGL.
Story Line:
Loacated In the deserts of Nevada, Area 51 the eternally mysterious facilities of the United States Army have been taken over by an evil scientist with the help of his genetically engineered creatures.
He plans to destroy the world using the the Intercontinental Balistic missiles (ICBMs) which have been lying unarmed in the desert since the end of cold war. He plans to arm these missiles and launch an attack on the world resulting in a Nuclear Holocaust.
The Area is heavily guarded, and attacks by air have been ruled out due to the State-of-the-art Anti Aircraft Battery.
The only hope of the world is Adrian. He has successfully completed many commando operations in Vietnam and Afghanistan.
As the Hero is dropped off, he gets the information that the ICBMs are being armed. The standard Arming and launch sequence takes some time. This is all the time Adrian has got to stop the ICBMs from lifting off from their silos. Once Launched, ICBMs cannot be recalled or destroyed.
Version restrictions:
- 1) Takes a lot of time to quit once the mission is sucessful.
- 2) The sound doensnt work properly on some of the systems :(( we are not sure about the reason.. if any of you know about it... plz.. send us...

JamVM is a new Java Virtual Machine which conforms to the JVM specification version 2 (blue book). In comparison to most other VMs (free and commercial) it is extremely small, with a stripped executable on PowerPC of only ~130K, and Intel 100K.
However, unlike other small VMs (e.g. KVM) it is designed to support the full specification, and includes support for object finalisation, the Java Native Interface (JNI) and the Reflection API.
Main features:
- Uses native threading (posix threads). Full thread implementation including Thread.interrupt()
- Object references are direct pointers (i.e. no handles)
- Supports class loaders
- Efficient thin locks for fast locking in uncontended cases (the majority of locking) without using spin-locking
- Two word object header to minimise heap overhead (lock word and class pointer)
- Execution engine supports basic switched interpreter and threaded interpreter, to minimise dispatch overhead (requires gcc value labels)
- Stop-the-world mark and sweep garbage collector
- Thread suspension uses signals to reduce suspend latency and improve performance (no suspension checks during normal execution)
- Full object finalisation support within the garbage collector (with finaliser thread)
- Garbage collector can run synchronously or asynchronously within its own thread
- String constants within class files are stored in hash table to minimise class data overhead (string constants shared between all classes)
- Supports JNI and dynamic loading for use with standard libraries
- Uses its own lightweight native interface for internal native methods without overhead of JNI
- JamVM is written in C, with a small amount of platform dependent assembler, and is easily portable to other architectures.
Enhancements:
- Re-worked thread suspension enable/disable code
- implemented a fast enable/disable suspend mechanism for critical code sections, which is now used in hash table access and heap allocation :
- much faster object allocation
- much faster primitive array allocation
- faster string interning
- removed some minor potential (as yet unseen) race conditions
- Integrated all outstanding patches
- generics branch patch, implementing VMClass.isEnum(), isAnnotation() and isSynthetic()
- Boot library path patch (support for system property gnu.classpath.boot.library.path)
- Enabled different min/max heap values for each architecture
- ARM values are back to the defaults for JamVM 1.2.5. Default max heap of 128Mb is too large for typical embedded ARM systems.
- Fixed the new compiler warnings from gcc-4.0 (under Mac OS X) related to char/signed char usage.
- Fixed compiler error on gcc-4.0 under Mac OS X 10.4 (duplicate definitions of wait).
- Fixed rare, potential dead-lock in direct.c when preparing methods
- Fixed a bug in VMClassLoader.defineClass(), where offset or length is wrong.
- Fixed bug in DCONST_1 on mixed-endian ARM architectures (this bug was fixed in JamVM 1.2.2 but it crept back in, due to the new interpreter in JamVM 1.2.5).
- Improved thread dump (produced via SIGQUIT, or ctrl-).
- Several other minor bug-fixes, and code tidy-ups.

RT is one free real-time operating system with one hardware depending part very little this can make possible the porting for other microprocessor.
The RT project Is one real-time operating system for the ARM 7 architecture. The main source can be used in any ARM 7 compatible microprocessor and the device driver can are tested using the Keil MCB2140 with the Philips LPC2148.
Main features:
- Hard real-time multi threading
- Support for semaphore and mutual exclusion
- User definable priorities from 001 to 254
- Fast memory allocation
- Free compiler.
- Asynchronous serial driver for 16550 Uart.
- Serial driver for the 8051 architecture
- Serial console.
- Sample application.
- And more ....
Current porting:
- ARM7 with GNUARM and Philips LPC2148 micro controller tested with the Keil MCB2140 evaluation board.
- 8051 using SDCC compiler tested with the J51 emulator.
Installation:
Extract the package in one new directory. Set the path for the compiler desired and the variable RT to the root of the package. Es. if the package is extracted in ~/rt-0.0 set RT=~~/rt-0.0
Directory structure relative to the root of the package.
docs - Documentation directory
efsl-x.x.x - Embedded file system library
examples - Examples source directory
obj - Precompiled example
rt - RTOS main directory
script - SCript used for linking target
sdcc - SDCC utility
makefile.inc - Include makefile from all program.
makefile.efsl - Makefile for embedded file system library
makefile.rt - Makefile for RTOS library
readme.txt - This file.

Ssh library was designed to be used by programmers needing a working SSH implementation by the mean of a library. Runs only on x86 linux, bsd and MacOS X.
libssh is a C library to access SSH 2 services from a program. It can remotely execute programs, transfer files, and serve as a secure and transparent tunnel for remote programs. Its Secure FTP implementation can play with remote files easily, without third-party programs others than libcrypto (from OpenSSL).
Main features:
- Full C library functions for manipulating a client-side SSH connection
- Lesser GPL licensing -SSH2 protocol compliant
- Fully configurable sessions
- Support for AES-128,AES-192,AES-256,blowfish, in cbc mode
- Use multiple SSH connections in a same process, at same time
- Use multiple channels in the same connection
- Thread safety when using different sessions at same time
- Basic but correct SFTP implementation (secure file transfer)
- RSA and DSS server public key supported
- Compression support (with zlib)
- Public key (RSA and DSS), password and keyboard-interactive authentication
- A complete documentation about its API
- Runs and tested under amd64, x86, arm, sparc32, ppc under Linux, Bsd, MacosX and Solaris
- A developer listening to you
Enhancements:
- Connection timeout support
- Keyboard-interactive authentication (used by Pam with SSH)
- Server public keys management
- 64 bits cpu support
- Enhanced documentation
- and of course a huge number of bugfixe

uLan Driver provides 9-bit message oriented communication protocol, which is transferred over RS-485 link.
Characters are transferred same way as for RS-232 asynchronous transfer except parity bit, which is used to distinguish between data characters and protocol control information. A physical layer consists of one twisted pair of leads and RS-485 transceivers.
Use of 9-bit character simplifies transfer of binary data and for intelligent controllers can lower the CPU load, because of the CPU need not to care about data characters send to other node. Producers of most microcontrollers for embedded applications know that and have implemented 9-bit extension in UARTs of most of todays MCUs. There is the list below to mention some of them:
- all Intel 8051 and 8096 based MCUs with UART
- members of Motorola 683xx family ( 68332, 68376, ... )
- Hitachi H8 microcontrollers
The driver is implemented as relatively independent layers and subsystems. Messages are prepared and received in the driver dedicated memory. This memory is divided into blocks with uniform size with atomic allocation routines.
When message is being stored into blocks, head of message with couple of data bytes is stored in the first allocated memory block. If all data cannot be stored in the first block, next blocks are allocated and linked together.
The message heads are linked in bidirectional linked lists of messages prepared for sending, processed messages and messages prepared for client notification. These lists or queues are main mechanism for transferring of messages between subsystems.
Link protocol is programmed as finite state automata with state stack, which state routines are executed by interrupt handler. State routine can return positive integer information, negative error notification or zero, which leads to wait for next interrupt. Information or error is used as input parameter when state routine is called.
When the state routine wants initiate transfer to another state routine it changes pointer to the actual state routine. If previous state routine returns nonzero value new routine is called immediately, in other case next interrupt invokes new state routine.
There is stack of callers of actual state routines which enables to constructs automata subsystems, which can be used in more places in main automata loop. Main purpose of this automata is to send or process messages coming in list of messages prepared for sending and if specified, move these messages onto list of messages prepared for client notification.
Received messages are put onto this list too. Subsystem is supervised by timeout handler, which can revitalize communication in case of die of other node. The interrupt and timeout handlers are fully SMP reentrant.
The automata subsystem uses pointers to chip driver routines for hardware port manipulation. This is only part dependent on used chip, today 82510, 16450 and OX16C950PCI. These routines can send and receive 9 bit character, connect to RS-485 line by the arbitration sequence, wait for specified time for character and initialize and close port.
File operation subsystem makes interface between OS kernel VFS and client message queues. It enables to prepare single or multi-frame messages and stores notifications of received or processed messages in clients private state structures. This part is heavily operating system dependent.
Enhancements:
- This release enables you to build the driver within the WDF framework for Windows.
- Updates to support the latest Linux 2.6.x kernels are included (tested to 2.6.19).
- Changes to allow stand-alone system-less build for ARM targets (LPC21xx) are included.
- The OMK has been selected as the default build.
- The "switch2std" script allows you to switch to the old build system.