Vladimir V. Rubanov

Runtime Verification of Linux Kernel Modules Based on Call Interception

Verification of Linux kernel modules and especially device drivers is a critically important task. However, due to the special nature of the kernel operation, it is very challenging to perform runtime analysis of particular kernel modules of interest without adverse influence on the rest of the kernel. Methods and tools for addressing this challenge are the main subject of this paper. The basic method for low-influence runtime analysis of interacting software modules is call interception. Shadow state techniques represent another method. In this paper, we discuss these methods including three different approaches to implement call interception. Conclusions are made about the most suitable ways for runtime analysis of kernel modules. Finally, we present KEDR framework, an extensible runtime analysis system for Linux kernel modules, which deploys these approaches to perform different types of analysis. The system can be used by the developers of kernel modules and, in particular, may be useful for building automated driver verification systems.

Formal methods in industrial software standards enforcement

The article presents an approach to development of software standards usage infrastructure. The approach is based on formalization of standards and automated conformance test derivation from the resulting formal specifications. Strong technological support of such a process in its engineering aspects makes it applicable to software standards of real-life complexity. This is illustrated by its application to Linux Standard Base. The work stands in line with goals of international initiative Grand Challenge 6: Dependable Systems Evolution [1].

Automation of broad sanity test generation

The technology for the broad generation of sanity tests for complex software developed in the Institute for System Programming (Russian Academy of Sciences) is presented. This technology is called Azov; it is based on using a database containing structured information about the interface operations of the system under test and on a procedure for enriching this information by refining constraints imposed on parameter types and results of operations. Results of a practical application of this technology prove its high efficiency in generating sanity tests for systems with a large number of functions.

Backward compatibility of software interfaces: Steps towards automatic verification

This paper discusses problems of ensuring backward compatibility between new and old versions of software components (e.g., libraries). The Linux environment is considered as the main example. Breach of the compatibility in a new version of a software component may result in crashing or incorrect behavior (at the binary level) or inability to build (at the source level) applications targeted at a previous version of the component when the applications are used with the new version of the component. The paper describes typical issues that cause backward compatibility problems at the binary level and presents a new method for automatic detection of such issues in the course of the component development, with the main attention being focused on changes in structure of interfaces. The C and C++ languages are used to exemplify the approach, although it can be applied to other languages, such as Java or C#, as well. Unlike the existing means, the suggested method can verify a broad spectrum of backward compatibility problems by comparing function signatures and type definitions obtained from the component’s header files in addition to analyzing symbols in the component’s binaries. This paper also describes an automated checker tool that implements the suggested method together with some results of its practical usage. In conclusion, further improvements of automatic means for backward compatibility verification are discussed.

Automated Formal Testing of C API Using T2C Framework

A problem of automated test development for checking basic functionality of program interfaces (API) is discussed. Different technologies and corresponding tools are surveyed. And T2C technology developed in ISPRAS is presented. The technology and associated tools facilitate development of ”medium quality” (and ”medium cost”) tests. An important feature of T2C technology is that it enforces that each check in a developed test is explicitly linked to the corresponding place in the standard. T2C tools provide convenient means to create such linkage. The results of using T2C are considered by example of a project for testing interfaces of Linux system libraries defined by the LSB standard.

A combined technique for automatic detection of backward binary compatibility problems

This paper discusses the problem of ensuring backward compatibility between new and old versions of software components (e.g., libraries). Linux environment is considered as the main example. Breakage of the compatibility in a new version of a software component may result in crashing or incorrect behavior (at binary level) or inability to build (at source level) of applications targeted at a previous version of the component when the applications are used with the new version of the component. The paper describes typical issues that cause backward compatibility problems at binary level and presents a new method for automatic detection of such issues during component development (focusing on changes in structure of interfaces). C/C++ language is used as the main example. Unlike the existing means, the suggested method can verify a broad spectrum of backward compatibility problems by comparing function signatures and type definitions obtained from the components header files in addition to analyzing symbols in the components binaries. Also, this paper describes an automated checker tool that implements the suggested method with some results of its practical usage.

Automatic backward compatibility analysis of software component binary interfaces

This paper discusses a problem of ensuring backward compatibility when developing software components (e.g., libraries) and their consistent combinations (software platforms). Linux environment is considered as the main example. Breakage of the compatibility may result in crashing or incorrect behavior (at binary level) or inability to build (at source level) of applications targeted at an old version of a dependent software component when the applications are used with a new version of the component. The paper describes typical issues that cause compatibility problems (focusing on binary level problems) and presents a new method for automated verification for such issues (focusing on changes in structure of interfaces) for components developed in C/C++. Existing means can detect only a small fraction of all possible backward compatibility problems while the suggested method can verify a broad spectrum of them. The method is based on comparison of function signatures and type definitions obtained from library header files in addition to analyzing symbols in library binaries. This paper also describes an automated verification tool that implements the suggested method and presents some results of its practical usage.

Automated Verification of Shared Libraries for Backward Binary Compatibility

This paper discusses a problem of ensuring backward binary compatibility when developing shared libraries. Linux (and GCC environment) is used as the main example. Breakage of the compatibility may result in crashing or incorrect behavior of applications built with an old version of a library when they are running with a new one. The paper describes typical issues that cause binary compatibility problems and presents a new method for library verification for such issues. Existing tools can detect only a small fraction of all possible backward compatibility problems while the suggested method can verify a broad spectrum of them. The method is based on comparison of function signatures and type definitions obtained from library header files in addition to analyzing symbols in library binaries. This paper also describes an automated verification tool that implements the suggested method and presents some results of its practical usage.

Specific optimization features in a C compiler for DSPs

The survey describes specific features of digital signal processors (DSPs) and the related optimization techniques that can be implemented in C compilers. Optimization algorithms and the mutual influence of different optimizations are considered.

A system for backward binary compatibility analysis of shared libraries in Linux

This paper discusses a problem of ensuring backward binary compatibility of Linux shared libraries. Breakage of the compatibility may result in crashing or incorrect behavior of applications built with an old version of a library when it is running with a new one. Existing tools may detect only a small part of all possible backwards compatibility problems. This paper presents a new fully automated method for checking backward binary compatibility and detecting a broad spectrum of possible problems. This method is based on comparison of function signatures and type definitions obtained from library header files. This paper also describes structure of a lightweight tool that implements the proposed method.