Source Linux Research Articles

Pathogen-Host Analysis Tool (PHAT): an integrative platform to analyze next-generation sequencing data.

The Pathogen-Host Analysis Tool (PHAT) is an application for processing and analyzing next-generation sequencing (NGS) data as it relates to relationships between pathogens and their hosts. Unlike custom scripts and tedious pipeline programming, PHAT provides an integrative platform encompassing raw and aligned sequence and reference file input, quality control (QC) reporting, alignment and variant calling, linear and circular alignment viewing, and graphical and tabular output. This novel tool aims to be user-friendly for life scientists studying diverse pathogen-host relationships. The project is available on GitHub (https://github.com/chgibb/PHAT) and includes convenient installers, as well as portable and source versions, for both Windows and Linux (Debian and RedHat). Up-to-date documentation for PHAT, including user guides and development notes, can be found at https://chgibb.github.io/PHATDocs/. We encourage users and developers to provide feedback (error reporting, suggestions and comments).

Predicting Software Flaws with Low Complexity Models based on Static Analysis Data

Due to the constant evolution of technology, each day brings new programming languages, development paradigms, and ways of evaluating processes. This is no different with source code metrics, where there is always new metric classes. To use a software metric to support decisions, it is necessary to understand how to perform the metric collection, calculation, interpretation, and analysis. The tasks of collecting and calculating source code metrics are most often automated, but how should we monitor them during the software development cycle? Our research aims to assist the software engineer to monitor metrics of vulnerability threats present in the source code through a reference prediction model, considering that real world software have non-functional security requirements, which implies the need to know how to monitor these requirements during the software development cycle. As a first result, this paper presents an empirical study on the evolution of the Linux project. Based on static analysis data, we propose low complexity models to study flaws in the Linux source code. About 391 versions of the project were analyzed by mining the official Linux repository using an approach that can be reproduced to perform similar studies. Our results show that it is possible to predict the number of warnings triggered by a static analyzer for a given software project revision as long as the software is continuously monitored.

IOMMU protection against I/O attacks: a vulnerability and a proof of concept

Input/output (I/O) attacks have received increasing attention during the last decade. These attacks are performed by malicious peripherals that make read or write accesses to DRAM memory or to memory embedded in other peripherals, through DMA (Direct Memory Access) requests. Some protection mechanisms have been implemented in modern architectures to face these attacks. A typical example is the IOMMU (Input-Output Memory Management Unit). However, such mechanisms may not be properly configured and used by the firmware and the operating system. This paper describes a design weakness that we discovered in the configuration of an IOMMU and a possible exploitation scenario that would allow a malicious peripheral to bypass the underlying protection mechanism. The exploitation scenario is implemented for Intel architectures, with a PCI Express peripheral Field Programmable Gate Array, based on Intel specifications and Linux source code analysis. Finally, as a proof of concept, a Linux rootkit based on the attack presented in this paper is implemented.

Towards scalable configuration testing in variable software

Testing a software product line such as Linux implies building the source with different configurations. Manual approaches to generate configurations that enable code of interest are doomed to fail due to the high amount of variation points distributed over the feature model, the build system and the source code. Research has proposed various approaches to generate covering configurations, but the algorithms show many drawbacks related to run-time, exhaustiveness and the amount of generated configurations. Hence, analyzing an entire Linux source can yield more than 30 thousand configurations and thereby exceeds the limited budget and resources for build testing. In this paper, we present an approach to fill the gap between a systematic generation of configurations and the necessity to fully build software in order to test it. By merging previously generated configurations, we reduce the number of necessary builds and enable global variability-aware testing. We reduce the problem of merging configurations to finding maximum cliques in a graph. We evaluate the approach on the Linux kernel, compare the results to common practices in industry, and show that our implementation scales even when facing graphs with millions of edges.

Automatically inferring loop invariants via algorithmic learning

By combining algorithmic learning, decision procedures, predicate abstraction and simple templates for quantified formulae, we present an automated technique for finding loop invariants. Theoretically, this technique can find arbitrary first-order invariants (modulo a fixed set of atomic propositions and an underlying satisfiability modulo theories solver) in the form of the given template and exploit the flexibility in invariants by a simple randomized mechanism. In our study, the proposed technique was able to find quantified invariants for loops from the Linux source and other realistic programs. Our contribution is a simpler technique than the previous works yet with a reasonable derivation power.

Efficient CTL model-checking for pushdown systems

Pushdown systems (PDS) are well adapted to model sequential programs with (possibly recursive) procedure calls. Therefore, it is important to have efficient model checking algorithms for PDSs. We consider in this paper CTL model checking for PDSs. We consider the “standard” CTL model checking problem where whether a configuration of a PDS satisfies an atomic proposition or not depends only on the control state of the configuration. We consider also CTL model checking with regular valuations, where the set of configurations in which an atomic proposition holds is a regular language. We reduce these problems to the emptiness problem in Alternating Büchi Pushdown Systems, and we give an algorithm to solve this emptiness problem. Our algorithms are more efficient than the other existing algorithms for CTL model checking for PDSs in the literature. We implemented our techniques in a tool, and we applied it to different case studies. Our results are encouraging. In particular, we were able to confirm the existence of known bugs in Linux source code.

Efficient extraction and analysis of preprocessor-based variability

The C Preprocessor (CPP) is the tool of choice for the implementation of variability in many large-scale configurable software projects. Linux, probably the most-configurable piece of software ever, employs more than 10,000 preprocessor variables for this purpose. However, this de-facto variability tends to be "hidden in the code"; which on the long term leads to variability defects, such as dead code or inconsistencies with respect to the intended (modeled) variability of the software. This calls for tool support for the efficient extraction of (and reasoning over) CPP-based variability. We suggest a novel approach to extract CPP-based variability. Our tool transforms CPP-based variability in O(n) complexity into a propositional formula that "mimics" all valid effects of conditional compilation and can be analyzed with standard SAT or BDD packages. Our evaluation results demonstrate the scalability and practicability of the approach. A dead-block-analysis on the complete Linux source tree takes less than 30 minutes; we thereby have revealed 60 dead blocks, 2 of which meanwhile have been confirmed as new (and long-lasting) bugs; the rest is still under investigation.

Show me the money: the business models of Linux players

The major trends characterising the development of e-business platforms include increasing the performance-to-price ratio of hardware components (e.g., servers and chips), as well as the declining costs of operating systems and middleware software as organisations switch from expensive proprietary software (e.g., Microsoft Windows) to open source software (e.g., Linux). The unique origins of Linux and open source software require the adoption of new business models to allow key players to sustain themselves long-term. Using a historical review of the open software movement and a value chain analysis for the open software industry, we examine, using primary data from interviews, the business models of five Linux players (Red Hat, Novell, Navica, Open Country and SohoLaunch). Case analyses enable us to identify four open source business models that should be sustainable in the long run.

Domain Analysis of Device Drivers Using Code Clone Detection Method

Domain analysis is the process of analyzing related software systems in a domain to find their common and variable parts. In the case of device drivers, they are highly suitable for domain analysis because device drivers of the same domain are implemented similarly for each device and each system that they support. Considering this characteristic, this paper introduces a new approach to the domain analysis of device drivers. Our method uses a code clone detection technique to extract similarity among device drivers of the same domain. To examine the applicability of our method, we investigated whole device drivers of a Linux source. Results showed that many reusable similar codes can be discerned by the code clone detection method. We also investigated if our method is applicable to other kernel sources. However, the results show that the code clone detection method is not useful for the domain analysis of all kernel sources. That is, the applicability of the code clone detection method to domain analysis is a peculiar feature of device drivers.

The Technological Gaze

The Technological Gaze

Semantic patches considered helpful

Modern software development is characterized by the use of libraries and interfaces. This software architecture carries down even to the operating system level. Linux, for example, is organized as a small kernel, complemented with libraries providing generic functionalities for use in implementing network access, file management, access to physical devices, etc. Much of the Linux source code then consists of service-specific files that use these libraries. These libraries are also used by the many OS-level services that are maintained outside of the Linux source tree.

A tool for converting Linux device drivers into Solaris compatible binaries

AbstractThe Linux operating system is quickly becoming a standard, attracting a wide user community and supporting a broad variety of applications and devices. Other vendors, such as Sun, have provided Linux‐compatible system call interfaces to their kernels, but are constrained by the lack of device support. To address this problem, we present a system (called PITS) to build device drivers, in this case for Solaris x86, from Linux source code. To accomplish this goal, we designed tools and Linux kernel emulation code to handle the myriad incompatibilities. These incompatibilities require the ability to resolve symbol conflicts, emulate internal Linux kernel data structures, handle module initialization, and generate module dependencies. With our method, we show that converting Linux device drivers is possible, but has a few technical difficulties. Issues arise with sparse documentation, external user interfaces, and modular driver implementations. There are also fundamental differences between the two operating systems, such as interrupt and DMA handling. We describe each of these issues and their current solutions to build a functional driver in the Solaris environment. Using the IOzone file system benchmark, we also demonstrate comparable performance between our generated SCSI driver set and their corresponding native counterparts. Copyright © 2006 John Wiley & Sons, Ltd.

The elephant that learnt to dance [zSeries mainframes

This paper reports on the resurgence of the mainframe computer despite earlier predictions that the future lay with the smaller UNIX or Wintel servers. This fundamental shift in mainframe economics has been attributed to several factors including the lower costs per MIPS (millions of instructions per second) and the support for Linux and open source software. To address the issue of an aging workforce, IBM has initiated training programs in zSeries-related skills for IT professionals in the US as well as in other emerging markets such as China.

Investigating quality in large-scale Open Source Software

Open Source Software (OSS) development and use has increased significantly over recent years. Therefore, there is a need to analyze and understand these projects. Software quality is an important characteristic effecting overall system lifecycle cost, performance and useful life. The existing models for software quality are based on empirical analysis of propriety source software (PSS), and need to be verified in OSS. Research on PSS has revealed that software quality declines, as it ages. Part of this decline is associated with the lifecycle maintenance activities that introduce change in the size and complexity of the system, while introducing software errors into modified system. Lifecycle maintenance activities in OSS systems are processed under a very different paradigm. We are interested in investigating the effects of maintenance activities on OSS project outcomes. Linux is one of the most popular and complex OSS project available. In our research, we investigate the characteristics of Linux source code. In this position paper we present some preliminary results of the effects of various types of maintenance activities on quality of Linux software.

Reliability Against the Odds: The Lessons of Open Source Communities for Developing Reliable Software

Open source software is increasingly used in mission-critical processes of organizations, signaling its acceptance as highly reliable software. That said, the development process in open source communities differs radically from conventional approaches to reliable software development. Stronger still, open source software seems to thrive under conditions of that are orthogonal to the conventional approach: extreme fragmentation, weak planning and coordination structures and lack of control over objectives, priorities and resource allocation. Therefore, we argue that open source communities provide us with valuable and innovative lessons for managing the production of reliable software - especially since the conditions for contemporary software development increasingly resemble those of open source communities rather than those of tightly controlled corporate environments. To draw out these lessons, this paper applies concepts from High Reliability Theory (HRT) on two recent case studies of open source communities, Linux and Apache. We identify a number of important reliability-enhancing mechanisms. Understanding these mechanisms is important to a) managers of corporate software developers participating in open source communities and b) managers who want to transfer mechanisms and lessons from open source communities to their organization.

Open-Source Intrusion Detection Tools for Linux: Armed with Linux and Open Source tools, you can even keep an ISP secure.

Open-Source Intrusion Detection Tools for Linux: Armed with Linux and Open Source tools, you can even keep an ISP secure.

Linux update: an experimental ATM network

Both private and public networks increasingly use ATM to provide high bandwidth and guaranteed quality of service. The ability to use Linux in PC platforms and the ready availability of Linux source code make the PC-based Linux workstation an ideal platform for ATM multimedia development. This article describes some of Fujitsu's ATM tools for Linux and reports the results of prototyping using Fujitsu's ATM/Linux development environment.