Interprocess Communication Mechanism Research Articles

Boosting Inter-process Communication with Architectural Support

IPC (inter-process communication) is a critical mechanism for modern OSes, including not only microkernels such as seL4, QNX, and Fuchsia where system functionalities are deployed in user-level processes, but also monolithic kernels like Android where apps frequently communicate with plenty of user-level services. However, existing IPC mechanisms still suffer from long latency. Previous software optimizations of IPC usually cannot bypass the kernel that is responsible for domain switching and message copying/remapping across different address spaces; hardware solutions such as tagged memory or capability replace page tables for isolation, but usually require non-trivial modification to existing software stack to adapt to the new hardware primitives. In this article, we propose a hardware-assisted OS primitive, XPC (Cross Process Call), for efficient and secure synchronous IPC. XPC enables direct switch between IPC caller and callee without trapping into the kernel and supports secure message passing across multiple processes without copying. We have implemented a prototype of XPC based on the ARM AArch64 with Gem5 simulator and RISC-V architecture with FPGA boards. The evaluation shows that XPC can reduce IPC call latency from 664 to 21 cycles, 14×–123× improvement on Android Binder (ARM), and improve the performance of real-world applications on microkernels by 1.6× on Sqlite3.

Security analysis of permission re-delegation vulnerabilities in Android apps

The Android platform facilitates reuse of app functionalities by allowing an app to request an action from another app through inter-process communication mechanism. This feature is one of the reasons for the popularity of Android, but it also poses security risks to the end users because malicious, unprivileged apps could exploit this feature to make privileged apps perform privileged actions on behalf of them. In this paper, we investigate the hybrid use of program analysis, genetic algorithm based test generation, natural language processing, machine learning techniques for precise detection of permission re-delegation vulnerabilities in Android apps. Our approach first groups a large set of benign and non-vulnerable apps into different clusters, based on their similarities in terms of functional descriptions. It then generates permission re-delegation model for each cluster, which characterizes common permission re-delegation behaviors of the apps in the cluster. Given an app under test, our approach checks whether it has permission re-delegation behaviors that deviate from the model of the cluster it belongs to. If that is the case, it generates test cases to detect the vulnerabilities. We evaluated the vulnerability detection capability of our approach based on 1,258 official apps and 20 mutated apps. Our approach achieved 81.8% recall and 100% precision. We also compared our approach with two static analysis-based approaches — Covert and IccTA — based on 595 open source apps. Our approach detected 30 vulnerable apps whereas Covert detected one of them and IccTA did not detect any. Executable proof-of-concept attacks generated by our approach were reported to the corresponding app developers.

Implementing Autonomous Driving Behaviors Using a Message Driven Petri Net Framework.

Most autonomous car control frameworks are based on a middleware layer with several independent modules that are connected by an inter-process communication mechanism. These modules implement basic actions and report events about their state by subscribing and publishing messages. Here, we propose an executive module that coordinates the activity of these modules. This executive module uses hierarchical interpreted binary Petri nets (PNs) to define the behavior expected from the car in different scenarios according to the traffic rules. The module commands actions by sending messages to other modules and evolves its internal state according to the events (messages) received. A programming environment named RoboGraph (RG) is introduced with this architecture. RG includes a graphical interface that allows the edition, execution, tracing, and maintenance of the PNs. For the execution, a dispatcher loads these PNs and executes the different behaviors. The RG monitor that shows the state of all the running nets has proven to be very useful for debugging and tracing purposes. The whole system has been applied to an autonomous car designed for elderly or disabled people.

CodeTracker: A Lightweight Approach to Track and Protect Authorization Codes in SMS Messages

Short message service (SMS) authorization codes play an important role in the application ecosystem, as a number of transactions (e.g., personal identification and online banking) require users to provide a code for authorization purposes. However, authorization codes in SMS messages can be stolen and forwarded by attackers, which introduces serious security concerns. In this paper, we propose CodeTracker , a lightweight approach to track and protect SMS authorization codes. Specifically, we leverage the taint tracking technique to mark the authorization code with taint tags at the origin of the incoming SMS messages (taint sources), and then, we propagate the tags in the system. To this end, we modify the related array structure, array operations, string operations, inter-process communication mechanism, and file operations for secondary storage of SMS authorization codes to ensure that the taint tags cannot be removed. When the authorization code is sent out via either SMS messages or network connections (taint sinks), we extract the taint tag of the data and enforce pre-defined security policies to prevent the code from being leaked. We have developed a prototype of CodeTracker on Android’s ART virtual machine and used 1, 218 SMS-stealing Android malware samples to evaluate the system. The evaluation results show that CodeTracker can effectively track and protect SMS authorization codes with a small performance overhead (<2% on average).

Interprocess Communication with Java in a Microsoft Windows Environment

The Java programming language provides a comprehensive set of multithreading programming techniques but currently lacks interprocess communication (IPC) facilities, other than slow socket-based communication mechanisms (which are intended primarily for distributed systems, not interprocess communication on a multicore or multiprocessor system). This is problematic due to the ubiquity of modern multicore processors, and the widespread use of Java as a programming language throughout the software development industry. This work aimed to address this problem by utilising Microsoft Windows’ native IPC mechanisms through a framework known as the Java Native Interface. This enabled the use of native C code that invoked the IPC mechanisms provided by Windows, which allowed successful synchronous communication between separate Java processes. The results obtained illustrate the performance dichotomy between socket-based communication and native IPC facilities, with Windows’ facilities providing significantly faster communication. Ultimately, these results show that there are far more effective communication structures available. In addition, this work presents generic considerations that may aid in the eventual design of a generic, platform-independent IPC system for the Java programming language. The fundamental considerations include shared memory with semaphore synchronisation, named pipes and a socket communication model.

An Novel Architecture and Inter-process Communication Scheme to Adapt Chromium Based on Docker Container

In this paper, firstly we propose a novel architecture called DBCSUEE to adapt embedded Chromium browser with Docker container virtualization as its sandboxing mechanism to isolate processes. Using this kind of container-level virtualization in browsers guarantees web applications operate in a secure environment, and gives the browser a more efficient resource management scheme applicable to multi-application situation. Secondly, when implementing the scheme, communication among applications running in their own containers becomes a problem and needs to be solved. Chromium's existing inter-process communication mechanism cannot be used. Thus, we propose a new communication scheme based on named pipe, which allows two web applications to communicate with each other without closing their containers.

Research and Design of the Communication Middleware for the Distributed System

This article on inter-process communication mechanism has conducted in-depth research and analysis of traditional UNIX system under the environment of the inter process communication mechanism and existing mechanisms for process communication in distributed environment. And on that basis propose new interprocess communication mechanism in distributed environment. Given interprocess communication semaphores and Message Queuing design ideas and implementation details, and compare it with the traditional way, we concluded that in the case of performance does not deteriorate, provides better user interfaces and location transparency and access higher transparency.

The Software Architecture for Efficient Distributed Interprocess Communication in Mobile Distributed Systems

The mobile distributed computing applications execute in heterogeneous and dynamic network environments and require efficient as well as reliable interprocess communication (IPC) mechanism. In general, the kernel-level IPC mechanisms offer improved performance as compared to middleware-based systems. This paper proposes the design and implementation of composite software architecture within monolithic kernel to realize high-performance and reliable mobile distributed IPC mechanism supporting mobile computing applications in heterogeneous and dynamic network environments. The performance of software architecture is measured in geographically distributed computing systems executing mobile computing applications. The experimental results illustrate that the proposed software architecture offers significantly improved performance in Ethernet (629 μs/25 Byte ~ 2929 μs/5 KB) as well as in wireless networks (34528 μs/25 Byte ~ 42511 μs/5 KB). The architecture successfully reduces distributed IPC latency in Ethernet (0.899 μs/Byte) and in wireless networks (92.628 μs/Byte). The comparative analysis illustrates that the composite architecture achieves performance enhancements in the range of 12.73 % to 75.84 % as compared to middleware-based IPC mechanisms. The proposed composite software architecture does not require any specific network topology and any specialized communication hardware.

Research on Model Checking for SELinux Inter-Process Communication

SELinux (Security Enhanced Linux) inherited the basic design of LINUX, and it is a high secure operating system. It is important to know how to make the IPC (Inter-Process Communication) for this kind of multi-task and multi-user system. In this paper, Finite State Automaton is used to verify the security of IPC mechanisms of SELinux. Finally, IPC mechanisms are verified with SPIN model checker.

Research for the Control Software of Six-Freedom Simulation Platform Based on RTX

This paper proposes a kind of design and realization method of real time control system that based on the Windows real time extension module RTX, which can meet the requirement of six-freedom Stewart platform control system to the real time. The design of the control system was divided into real-time layer and non-real-time layer according to the requirements of various functions to the real-time, and the data communication was realized by means of inter-process communication mechanism. The analysis conclusion to experiments data indicates that the control system is stable in operation and good in real-time performance.

An Improved Method of Windows Inter-process Communication Based on Shared Memory

Inter-process communication is significant to software developing nowadays. However, interprocess communication mechanisms existing can not perform well with communication between applications become more and more frequent. Through analysis and study of existing inter-process communication mechanisms, this paper proposes an improved inter-process communication method. It adopts a method with two-level shared memory and integrated with other technologies such as multithread to improve efficiency of communication. The experimental result shows that this method achieves better effects than traditional mechanisms in function and performance, and it can basically meet the demand of inter-process communication in current applications.

Research on android malware detection and interception based on behavior monitoring

Focusing on the sensitive behaviors of malware, such as privacy stealing and money costing, this paper proposes a new method to monitor software behaviors and detect malicious applications on Android platform. According to the theory and implementation of Android Binder interprocess communication mechanism, a prototype system that integrates behavior monitoring and intercepting, malware detection, and identification is built in this work. There are 50 different kinds of samples used in the experiment of malware detection, including 40 normal samples and 10 malicious samples. The theoretical analysis and experimental result demonstrate that this system is effective in malware detection and interception, with a true positive rate equal to 100% and a false positive rate less than 3%.

The software architecture for designing interactive mobile computing applications

In general, the mobile computing applications based on mobile-client/server model require the synchrony and reliability of Remote Procedure Call (RPC) as well as Inter-Process Communication (IPC) mechanisms. In case of interactive mobile applications, the mobile processes executing at mobile clients coordinate with corresponding server processes through IPC. These interactive mobile computing applications require an integrated framework supporting distributed RPC and IPC mechanisms. This paper proposes novel software architecture integrating IPC and RPC mechanisms in mobile-client/server model to support interactive mobile computing applications offering location transparency and scalability. The software architecture is successfully implemented and evaluated in real-life mobile computing environment.

ISIPC: Instant Synchronous Interprocess Communication

Interprocess communication (IPC) is often used to exchange data between cooperative processes, and the performance of IPC largely determines the processing time of application programs. Moreover, it is used for most of the kernel calls in a microkernel-based operating system (OS). Therefore, the performance of IPC affects the performance of the OS. In addition, the completion of the messagepassing mechanism has to be indicated by executing a receive operation in order to maintain synchronization. Thus, two operations are required in this mechanism to complete the communication. On the other hand, no receive operation is required to indicate the completion of the communication in the case of asynchronous communication; however, in this case, no proof of the data being received is provided to the sender process. In this paper, we propose an instant synchronous interprocess communication (ISIPC) mechanism that can achieve both instantaneous communication and data synchronization. ISIPC has two functions: push function and sack function. We describe the design of the ISIPC mechanism and also its implementation on the Tender operating system. In addition, we present the evaluation results for the ISIPC mechanism.

A platform independent distributed IPC mechanism in support of programming heterogeneous distributed systems

Interprocess communication (IPC) is a well-known technique commonly used by programs running on homogeneous distributed systems. However, it cannot be used readily and efficiently by programs running on heterogeneous distributed systems. This is because it must be given a uniform interface either by a set of middleware or more efficiently properly ported to the kernel of all varieties of open source and closed source proprietary operating systems running on heterogeneous nodes of distributed systems. This is particularly problematic to achieve when the kernel code of closed source operating systems are inaccessible to third parties. We propose an alternative nonproprietary approach to enable the use of IPC in heterogeneous distributed systems by wrapping IPC calls from the kernel of closed source operating systems, and converting them into equivalent IPC calls that are efficiently implemented inside the kernel code of open source operating systems. To show the superiority of our approach, we developed a wrapper for converting MS-Windows IPC calls into equivalent Linux IPC calls and benched our approach on a hybrid computer cluster running both types of operating systems.

A Surgical Assistant Workstation (SAW) Application for Teleoperated Surgical Robot System

The Surgical Assistant Workstation (SAW) modular software framework provides integrated support for robotic devices, imaging sensors, and a visualization pipeline for rapid prototyping of telesurgical research systems. Subsystems of a telesurgical system, such as the master and slave robots and the visualization engine, form a distributed environment that requires an efficient inter-process communication (IPC) mechanism. This paper describes the extension of the component-based framework provided by the cisst libraries, on which the SAW depends, from a multi-threaded (local) to a multi-process (networked) environment. The current implementation uses the Internet Communication Engine (ICE) middleware package, but the design does not depend on ICE and can accomodate other middleware choices. A telesurgical robot system based on the da Vinci hardware platform is used as a test case, with a research application that requires coordination between the left and right robot arms (a bimanual knot tying task). Performance measurements on this platform indicate minimal overhead due to the networking.

XMem

Developers commonly build contemporary enterprise applications using type-safe, component-based platforms, such as J2EE, and architect them to comprise multiple tiers, such as a web container, application server, and database engine. Administrators increasingly execute each tier in its own managed runtime environment (MRE) to improve reliability and to manage system complexity through the fault containment and modularity offered by isolated MRE instances. Such isolation, however, necessitates expensive cross-tier communication based on protocols such as object serialization and remote procedure calls. Administrators commonly co-locate communicating MREs on a single host to reduce communication overhead and to better exploit increasing numbers of available processing cores. However, state-of-the-art MREs offer no support for more efficient communication between co-located MREs, while fast inter-process communication mechanisms, such as shared memory, are widely available as a standard operating system service on most modern platforms. To address this growing need, we present the design and implementation of XMem ? type-safe, transparent, shared memory support for co-located MREs. XMem guarantees type-safety through coordinated, parallel, multi-process class loading and garbage collection. To avoid introducing any level of indirection, XMem manipulates virtual memory mapping. In addition, object sharing in XMem is fully transparent: shared objects are identical to local objects in terms of field access, synchronization, garbage collection, and method invocation, with the only difference being that sharedto-private pointers are disallowed. XMem facilitates easy integration and use by existing communication technologies and software systems, such as RMI, JNDI, JDBC, serialization/XML, and network sockets. We have implemented XMem in the open-source, productionquality HotSpot Java Virtual Machine. Our experimental evaluation, based on core communication technologies underlying J2EE, as well as using open-source server applications, indicates that XMem significantly improves throughput and response time by avoiding the overheads imposed by object serialization and network communication.

A NEW APPROACH IN DESIGNING INTERPROCESS COMMUNICATION FOR REAL-TIME SYSTEMS

In networked and distributed environments, and in multi-tasking systems, processes run simultaneously and compete to access the system resources. Processes commonly communicate with one another. Various techniques have been adapted in designing Interprocess Communication mechanisms within operating systems such as signals and message-passing. Signals are software interrupts notifying a process that an event has occurred; they do not support data exchange between processes. Message-Passing, a widely used technique in this design, it may use pipes to allow two or more processes to exchange data. Current techniques degrade performance of Real-time Systems, where unmet time critical missions may result in catastrophic failure. This research introduces a library-based architecture for Interprocess Communication Systems (IPC). This technique supports real-time performance and can be adapted for embedded operating systems. Improved Real-time performance was achieved by running IPC as a set of library function and verified by testing on real-time embedded system.

A distributed synchronization system for the TJ-II local area network

Abstract Synchronization mechanisms for the TJ-II local area network environment have been enhanced by the development of new capabilities. The mechanisms provide “soft synchronization,” that is notification of asynchronous events for situations in which some delay between the real event and message reception is not a critical point, e.g., start of pre-pulse phase, end of discharge, availability of the discharge file after a shot, trigger simulation for data acquisition tests and so on. The synchronization system is based on a distributed architecture where event servers are arranged in a tree structure. Event servers receive messages and then send them to other servers and client computers. The system is built on a two-layered configuration. The first one, devoted to network communication, is based on a de facto standard, Berkeley sockets, thus allowing for easy integration of multi-computer environments. The transport protocol is TCP in order to ensure the reliability needed. The second layer must provide support for local inter-process communication (LIPC) mechanisms. In this way, different processes can be synchronized within a single computer. Of course, this layer is system dependent.

Performance analysis of five interprocess communication mechanisms across UNIX operating systems

The availability of a variety of UNIX implementations necessitates the evaluation of their performance with respect to specific application characteristics. This paper concentrates on the performance evaluation of five different Interprocess Communication (IPC) mechanisms––pipes, FIFOs, messages, shared memory (with semaphores), and UNIX domain sockets. Benchmark programs were created for each mechanism, simulating a simple Producer/Consumer message transfer problem. Results were obtained for six UNIX releases––Linux 2.2.5-15, Linux 2.2.17, Linux 2.4.0-test9, RTLinux v2.3, FreeBSD 4.1, and FreeBSD 4.2. The UNIX source code was rigorously examined, and additional tests were created to determine implementation differences that would explain performance variations. Identified causes for performance differences include memory allocation schemes, transfer buffer sizes, data transfer mechanisms, locking mechanism implementations, and underlying code complexity. For all IPC mechanisms with the exception of shared memory, Linux 2.2.5-15 exhibited the best performance, followed by the remaining Linux kernels, with the FreeBSD releases finishing last. When compared against each other, pipes outperformed the other mechanisms. The developed benchmarks and ancillary tests attempt to isolate each aspect of the tested IPC mechanisms to facilitate a full understanding of IPC at the source code level.