Alexey V. Khoroshilov

Establishing linux driver verification process

This paper presents an initiative program aimed at enhancing Linux device driver designing and maintenance by launching a long-term process that will attend the OS kernel development. This process includes two adjacent lines of activity: 1) creation and replenishment of a repository of potential faults and errors that may occur in Linux device drivers, and 2) development and improvement of special-purpose verification tools for automatic detection of all errors specified in repository. We describe in some details both lines of activity, present an architecture of a perspective verification toolset, compare our project with similar work, and finally discuss the current state of art in Linux device driver verification.

Towards an open framework for c verification tools benchmarking

The paper presents a twofold verification system that aimes to be an open platform for experimentation with various verification techniques as well as an industrial-ready domain specific verification tool for Linux device drivers. We describe the architecture of the verification system and discuss a perspective to build an open benchmarking suite on top of it.

Development of formal models and conformance testing for systems with asynchronous interfaces and telecommunications protocols

There is a gap between the formal modeling and testing methods for modern protocols and asynchronous software systems: due to high complexity of such systems, attempts to include formal models in testing procedures fail. In this paper, we propose an approach to filling this gap based on a formalization of the behavior of systems with asynchronous interfaces using contract specifications followed by the use of these specifications to design adaptive test suites. This approach was used for testing various software systems including implementations of the IPv6 Internet protocols stack and implementations of the POSIX and Linux Standard Base software interfaces.

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].

Configurable toolset for static verification of operating systems kernel modules

An operating system (OS) kernel is a critical software regarding to reliability and efficiency. Quality of modern OS kernels is already high enough. However, this is not the case for kernel modules, like, for example, device drivers that, due to various reasons, have a significantly lower level of quality. One of the most critical and widespread bugs in kernel modules are violations of rules for correct usage of a kernel API. One can find all such violations in modules or can prove their correctness using static verification tools that need contract specifications describing obligations of a kernel and modules relative to each other. This paper considers present methods and toolsets for static verification of kernel modules for different OSs. A new method for static verification of Linux kernel modules is proposed. This method allows one to configure the verification process at all its stages. It is shown how it can be adapted for checking kernel components of other OSs. An architecture of a configurable toolset for static verification of Linux kernel modules that implements the proposed method is described, and results of its practical application are presented. Directions for further development of the proposed method are discussed in conclusion.

Using linux device drivers for static verification tools benchmarking

The Linux Driver Verification system is designed for static analysis of the source code of Linux kernel space device drivers. In this paper, we describe the architecture of the verification system, including the integration of third-party tools for static verification of C programs. We consider characteristics of the Linux drivers source code that are important from the viewpoint of verification algorithms and give examples of comparative analysis of different verification tools, as well as different versions and configurations of a given tool.

How to Cook an Automated System for Linux Driver Verification

We present the preliminary results of our work on designing an automatic toolset for verification of Linux kernelspace drivers. By now the toolset includes three components: • a library of verification models each model is a formal description of some safety property to be checked • a preprocessor unit it is intended for simulating an environment of a driver • a verification unit BLAST it is a general-purpose toolkit intended for automatic program verification based on Boolean abstraction and counter-example guided abstraction refinements techniques. We discuss in some details how our system operates and outline the directions for future work.

Integrating AADL-Based Tool Chain into Existing Industrial Processes

The paper presents a case study of building solution for automation of Integrated Modular Avionics system design and system integration processes within existing industrial environment on base of model driven approaches. Features of modern architecture description language are discussed and experience of building a tool chain on top of one of them is described.

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.

High-level memory model with low-level pointer cast support for Jessie intermediate language

The paper presents a target analyzable language used for verification of real-world production GNU C programs (Linux kernel modules). The language represents an extension of the existing intermediate language used by the Jessie plugin for the Frama-C static analysis framework. Compared to the original Jessie, the extension is fully compatible with the C semantics of arrays, initially supports discriminated unions and prefix (hierarchical) structure pointer casts and provides a limited, but reasonable support for low-level pointer casts (reinterpretations of the underlying bytes of memory). The paper describes the approaches to translation of the original C code into the analyzable intermediate language and of the intermediate language into Why3ML i.e. the input language of the Why3 deductive verification platform.