DOCSLIB.ORG

Testing Error Handling Code in Device Drivers Using Characteristic

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Testing Error Handling Code in Device Drivers Using Characteristic Testing Error Handling Code in Device Drivers Using Characteristic Fault Injection Jia-Ju Bai, Yu-Ping Wang, Jie Yin, and Shi-Min Hu, Tsinghua University https://www.usenix.org/conference/atc16/technical-sessions/presentation/bai This paper is included in the Proceedings of the 2016 USENIX Annual Technical Conference (USENIX ATC ’16). June 22–24, 2016 • Denver, CO, USA 978-1-931971-30-0 Open access to the Proceedings of the 2016 USENIX Annual Technical Conference (USENIX ATC ’16) is sponsored by USENIX. Testing Error Handling Code in Device Drivers Using Characteristic Fault Injection Jia-Ju Bai, Yu-Ping Wang, Jie Yin, and Shi-Min Hu Department of Computer Science and Technology, Tsinghua University Abstract tion [34]. For example, “bad address” (EFAULT) is a Device drivers may encounter errors when communi- common error should be handled, but it happens only cating with OS kernel and hardware. However, error when the memory or I/O address is invalid. Another handling code often gets insufficient attention in driver example is hardware error, which happens only when development and testing, because these errors rarely the hardware malfunctions. Triggering these errors in occur in real execution. For this reason, many bugs are real environment is very hard and uncontrollable. hidden in error handling code. Previous approaches for To simulate software and hardware errors at runtime, testing error handling code often neglect the characteris- software fault injection (SFI) is often used in driver tics of device drivers, so their efficiency and accuracy testing. This technique mutates the code to inject specif- are limited. In this paper, we first study the source code ic errors into the program, and enforces error handling of Linux drivers to find useful characteristics of error code to be executed at runtime. Linux Fault Injection handling code. Then we use these characteristics in fault Capabilities Infrastructure (LFICI) [43] is a well-known injection testing, and propose a novel approach named project integrated in Linux kernel. It can simulate com- EH-Test, which can efficiently test error handling code mon errors, such as memory-allocation failures and bad in drivers. To improve the representativeness of injected data requests. Inspired by LFICI, other fault injection faults, we design a pattern-based extraction strategy to approaches [7, 13, 23, 32] have been proposed in recent automatically and accurately extract target functions years, and they have shown promising results in driver which can actually fail and trigger error handling code. testing and bug detection. However, these approaches During execution, we use a monitor to record runtime still have some limitations in practical use. information and pair checkers to check resource usages. The representativeness of injected faults is often We have evaluated EH-Test on 15 real Linux device neglected, and most injected faults are random or drivers and found 50 new bugs in Linux 3.17.2. The manually selected. Random faults can not reflect code coverage is also effectively increased. Comparison real errors well. Manually selected faults often omit experiments to previous related approaches also show representative injected faults. the effectiveness of EH-Test. Numerous redundant test cases are generated. In fact, many generated test cases may cover the same error handling code, but they all need to be actually 1. Introduction tested at runtime. For this reason, they often spend As important components of the operating system, de- much time in runtime testing. vice drivers control hardware and provide fundamental Only several kinds of faults can be injected, such as supports for high-level programs. During driver execu- memory-allocation failures. But these faults can not tion, different kinds of occasional errors may occur, cover most error handling code in drivers. such as kernel exceptions and hardware malfunctions Much manual effort is needed. The kinds and plac- [31]. Therefore, device drivers need error handling code es of injected faults are often manually decided. to assure reliability. But in some drivers, error handling In fact, previous fault injection approaches aim to code is incorrect or even missed. In these drivers, seri- support general software, but they neglect the character- ous problems like system crashes and hangs may occur istics of target programs. To relieve their limitations, we when occasional errors are triggered. According to our should consider the key driver characteristics in SFI. study on Linux driver patches, more than 40% of ac- For example, because drivers are often written in C, so cepted patches add or update corresponding error han- built-in error handling mechanisms (such as “try-catch”) dling code. It shows that error handling code in device are not supported. For this reason, the developers often drivers is not reliable enough, so testing error handling use an if check to decide whether the error handling code and detecting bugs inside are very necessary. code should be triggered in device drivers. This charac- A challenge of testing error handling code is that oc- teristic can help to decide which functions can actually casional errors are infrequent to happen in real execu- fail and should be fault-injected. 1 USENIX Association 2016 USENIX Annual Technical Conference 635 n his aer, e firs sudy inux drier code, and 4) High automation and scalability. os orking ind hree useul characerisics in error handling code procedure o H-Tes is auomaed, including arge- function return value trigger few branches and check funcion eracion, aul injecion and es-case eecu decision. hen ased on hese characerisics and SFI, ion. nd i can suppor many inds of eising driers. we ropose a racical aproach named EH-Tes 1 o In his aer, e mae he following conriuions: eficienl es error handling code and deec ugs in We sudy he source code of inux deice driers, side irsly, EH-Tes uses a pattern-based extraction and ind hree useul characerisics in error han strategy o eract arge uncions hich can fail rom dling code he capured runime races of normal eecuion. This Based on he paerns of error handling code in srategy can auomaicall and accurael eract real driers, e design a paern-based eracion srae arge funcions o improve he reresenaieness of gy o auomaicall and accurael real arge func injec auls Then, we generae es cases by corrupting ions as reresenaie injeced auls. he reurn values of arge functions. et, e run each Based on he characerisics, e design a pracical es case on he real hardare and use a monior o rec aproach named EH-Tes which can eficienl es ord runime informaion and air checkers o check re error handling code in deice driers and deec source-usage violaions. hese air checers conain he bugs inside basic informaion of resource-acquiring and resource- We ealuae EH-Tes on 15 deice driers in inux releasing uncions, hich can be obained from specii 3.1. and .17.2, and reseciel find 32 and 50 caion mining echniues 18, 38] and user con bugs. All he deeced bugs in .17.2 hae been figuraion. During drier eecuion sysem crashes and confirmed y deelopers. he code coverage is also hangs can e easil ideniied hrough kernel crash logs efeciel increased in runime esing e also or user observaion. Afer drier eecuion, H-Tes perform comparison eperimens o preious ap- can reor resource-release omissions. We hae imple proaches, and ind ha EH-Tes can deect the ugs mened H-Tes using LLVM, and ealuaed i on 15 which are missed y hem. he eperimenal resuls Linux driers o hree classes. he resuls show ha show ha EH-Tes can eficienl erform drier esing and accurael ind real ugs. EH-Tes can accurael ind real bugs in error handling The res of his aer is organied as ollows. ecion code and improve code coverage in runime esing. 2 inroduces he moiaion ecion presens he hree Comarison eperimens o reious aproaches also characerisics of deice driers found y our sudy on sho is efecieness. Linux drier code ecion 4 presens our aern-based Compared o reious I aproaches or esing exracion sraegy. ecion inroduces EH-Tes in driers, our aproach hae our advanages deail ecion shows our ealuation on 5 Linu de 1) Representative injected faults. We design a at- vice driers and comarison eperiments o reious ern-based eracion sraegy o auomaicall and ac aproaches ecion 7 inroduces he relaed ork and curael eract real arge functions as reresenaie ecion 8 concludes his paer. injeced auls. uses code paerns o decide wheher a funcion can acuall fail in drier eecuion. This srat- 2. Motivation eg can largel improve the efecieness of I. 2) Efficient test cases. According o our sudy, many To ensure he reliailiy of deice driers, error han driers hae fe ranches in error handling code so dling code should be correcl implemened o handle injecting a single faul in each es case is enough o diferen inds of occasional errors. u in act error cover mos error handling code oreoer, our paern- handling code is incorrec or een missed in some driv- based eracion sraegy can iler many unreresenta ers so hard-o-find ugs ma occur during eecuion. n ie injeced auls. herefore he es cases generaed his secion, e irst reeal his roblem using a con b H-Tes are eficien and he ime usage of runime cree eample and our sudy on inux drier aches esing can e largel shortened. and hen e skech he software faul injecion ech 3) Accurate bug detection. By injecing reresenta nique used in his aer ie fauls, H-Tes can realisicall simulae differen 2.1 Motivating Example kinds of occasional errors o cover error handling code We firs moiae our ork using a real Linux drier oreover, H-Tes runs on he real hardware and uses bnx2 his drier manages roadcom eXreme I eac eecuion informaion o perform analsis.
Load more

Recommended publications
  • Using Fault Injection to Increase Software Test Coverage 
    Using Fault Injection to Increase Software Test Coverage James M. Bieman Daniel Dreilinger Lijun Lin Computer Science Department Colorado State University Fort Collins, Colorado 80523 [email protected] To appear in Proc. International Symposium on Software Reliability (ISSRE'96) Abstract must be recompiled and then tested. This process can be too labor and time intensive for practical use in the general test- During testing, it is nearly impossible to run all statments ing of commercial software. or branches of a program. It is especially dif®cult to test Our hypothesis is that fault injection can be effective the code used to respond to exceptional conditions. This when it is directed towards solving speci®c testing prob- untested code, often the error recovery code, will tend to be lems. In particular, we use fault injection to force the exe- an error prone part of a system. We show that test cover- cution of dif®cult to reach program paths. To avoid the need age can be increased through an ªassertion violationº tech- for recompilation, we mutate program state rather than pro- nique for injecting software faults during execution. Using gram text. our prototype tool, Visual C-Patrol (VCP), we were able to To be practical, any fault injection mechanism must be substantially increase test branch coverage in four software inexpensive and be able to model a wide variety of fault systems studied. types. Much of the fault injection should be automated. Al- though a practical approach requires a limited fault model, Keywords: software testing, software test coverage, fault we want to simulate as many faults as possible.
    [Show full text]
  • Improving Software Fault Injection
    Improving Software Fault Injection Ph.D. Thesis Erik van der Kouwe Vrije Universiteit Amsterdam, 2016 This work was funded in part by European Research Council under ERC Advanced Grant 227874. Copyright © 2016 by Erik van der Kouwe. ISBN XXX-XX-XXXX-XXX-X Printed by XXX. VRIJE UNIVERSITEIT IMPROVING SOFTWARE FAULT INJECTION ACADEMISCH PROEFSCHRIFT ter verkrijging van de graad Doctor aan de Vrije Universiteit Amsterdam, op gezag van de rector magnificus prof. dr. Vinod Subramaniam, in het openbaar te verdedigen ten overstaan van de promotiecommissie van de Faculteit der Exacte Wetenschappen op X XXX 2016 om X.XX uur in de aula van de universiteit, De Boelelaan 1105 door ERIK VAN DER KOUWE geboren te Leidschendam, Nederland promotor: prof.dr. A.S. Tanenbaum “TODO add quote.” TODO add quote source. Contents Contents vii List of Figures xi List of Tables xiii Publications xv 1 Introduction 1 2 Finding fault with fault injection An Empirical Exploration of Distortion in Fault Injection Experiments 7 2.1 Introduction . 7 2.2 Related work . 12 2.3 Fidelity . 14 2.4 Approach . 16 2.5 Programs and workloads . 17 2.6 Results . 19 2.6.1 Coverage . 19 2.6.2 Execution count . 26 2.6.3 Relationship between execution count and coverage . 30 2.6.4 Relationship between faults and execution . 31 2.7 Threats to validity . 33 2.8 Recommendations . 35 2.9 Conclusion . 36 vii viii 3 On the Soundness of Silence Investigating Silent Failures Using Fault Injection Experiments 39 3.1 Introduction . 39 3.2 Approach . 41 3.2.1 Fault injection .
    [Show full text]
  • Evaluating Software Systems Via Runtime Fault-Injection and Reliability, Availability and Serviceability (RAS) Metrics and Models
    The 7U Evaluation Method: Evaluating Software Systems via Runtime Fault-Injection and Reliability, Availability and Serviceability (RAS) Metrics and Models Rean Griffith Submitted in partial fulfillment of the Requirements for the degree of Doctor of Philosophy in the Graduate School of Arts and Sciences COLUMBIA UNIVERSITY 2008 c 2008 Rean Griffith All Rights Reserved Abstract The 7U Evaluation Method: Evaluating Software Systems via Runtime Fault-Injection and Reliability, Availability and Serviceability (RAS) Metrics and Models Rean Griffith Renewed interest in developing computing systems that meet additional non-functional requirements such as reliability, high availability and ease-of-management/self-management (serviceability) has fueled research into developing systems that exhibit enhanced reliability, availability and serviceability (RAS) capabilities. This research focus on enhancing the RAS capabilities of computing systems impacts not only the legacy/existing systems we have today, but also has implications for the design and development of next generation (self- managing/self-*) systems, which are expected to meet these non-functional requirements with minimal human intervention. To reason about the RAS capabilities of the systems of today or the self-* systems of tomorrow, there are three evaluation-related challenges to address. First, developing (or identifying) practical fault-injection tools that can be used to study the failure behavior of computing systems and exercise any (remediation) mechanisms the system has available for mitigating or resolving problems. Second, identifying techniques that can be used to quantify RAS deficiencies in computing systems and reason about the efficacy of individual or combined RAS-enhancing mechanisms (at design-time or after system deployment). Third, developing an evaluation methodology that can be used to objectively compare systems based on the (expected or actual) benefits of RAS-enhancing mechanisms.
    [Show full text]
  • Formal Fault Injection Vulnerability Detection in Binaries: a Software
    Formal fault injection vulnerability detection in binaries : a software process and hardware validation Nisrine Jafri To cite this version: Nisrine Jafri. Formal fault injection vulnerability detection in binaries : a software process and hard- ware validation. Cryptography and Security [cs.CR]. Université Rennes 1, 2019. English. NNT : 2019REN1S014. tel-02385208 HAL Id: tel-02385208 https://tel.archives-ouvertes.fr/tel-02385208 Submitted on 28 Nov 2019 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. T HÈSE DE DOCTORAT DE L’UNIVERSITE DE RENNES 1 COMUE UNIVERSITE BRETAGNE LOIRE Ecole Doctorale N°601 Mathèmatique et Sciences et Technologies de l’Information et de la Communication Spécialité : Informatique Par « Nisrine JAFRI » « Formal Fault Injection Vulnerability Detection in Binaries » «A Software Process and Hardware Validation» Thèse présentée et soutenue à RENNES , le 25 mars 2019 Unité de recherche : Inria, TAMIS team Thèse N°: Rapporteurs avant soutenance : Marie-Laure POTET, Professeur des Universités, ENSIMAG Jean-Yves MARION, Professeur des Universités, Université de Lorraine Composition du jury : Président : Pierre-Alain FOUQUE, Professeur des Universités, Université Rennes 1 Examinateurs : Leijla BATINA, Professeur des Université s, Université Radboud de Nimegue Shivam BHASIN, Chercheur, Université technologique de Singapour Sylvain GUILLEY, Professeur des Universités, Télécom ParisTech Annelie HEUSER, Chercheur, CNRS Dir.
    [Show full text]
  • Experimental Assessment of Cloud Software Dependability Using Fault Injection
    Experimental Assessment of Cloud Software Dependability Using Fault Injection Lena Herscheid(), Daniel Richter, and Andreas Polze Hasso Plattner Institute, Potsdom, Germany {lena.herscheid,daniel.richter,andreas.polze}@hpi.de Abstract. In modern cloud software systems, the complexity arising from fea- ture interaction, geographical distribution, security and configurability require- ments increases the likelihood of faults. Additional influencing factors are the impact of different execution environments as well as human operation or con- figuration errors. Assuming that any non-trivial cloud software system contains faults, robustness testing is needed to ensure that such faults are discovered as early as possible, and that the overall service is resilient and fault tolerant. To this end, fault injection is a means for disrupting the software in ways that un- cover bugs and test the fault tolerance mechanisms. In this paper, we discuss how to experimentally assess software dependability in two steps. First, a model of the software is constructed from different runtime observations and configu- ration information. Second, this model is used to orchestrate fault injection ex- periments with the running software system in order to quantify dependability attributes such as service availability. We propose the architecture of a fault in- jection service within the OpenStack project. Keywords: Fault injection · Dependability · Distributed systems · Cloud sys- tems · Availability 1 Introduction Fault tolerance is an essential dependability requirement especially in distributed and cloud software systems, where components can fail in arbitrary ways, but a high availability or reliability of the service is nevertheless required. To evaluate the dependability of complex software systems, a sufficiently realistic dependability model of the system needs to be built.
    [Show full text]
  • RESEARCH INSIGHTS – Modern Security Vulnerability Discovery
    RESEARCH INSIGHTS Modern Security Vulnerability Discovery NCC Group CONTENTS Author 3 Introduction 4 Manual analysis 6 Dynamic analysis 9 Static code analysis 14 Static software composition analysis 17 Fuzzing 19 Test case management 21 Closing summary 27 Thanks 26 NCC Group Research Insights 2 All Rights Reserved. © NCC Group 2016 AUTHOR NCC Group This paper is the combined effort of numerous individuals within NCC Group across various disciplines and offices. • Aaron Adams • Pete Beck • Jeremy Boone • Zsolt Imre • Greg Jenkins • Edward Torkington • Ollie Whitehouse • Peter Winter-Smith • David Wood NCC Group Research Insights 3 All Rights Reserved. © NCC Group 2016 INTRODUCTION The identification of vulnerabilities and understanding what is This paper is intended for individuals with a technical background involved in their exploitation has numerous applications in both who are responsible for identifying, understanding, mitigating or the attack and defence side of cyber security. The way in which responding to security vulnerabilities in software. The paper is software vulnerabilities are discovered has evolved considerably technical in nature, although high level, and is intended to provide over the last 20 years in terms of techniques, efficiency and the a view on modern vulnerability discovery approaches in 2016. complexity of the issues found. What was once a mostly manual process has, over time, become increasingly automated and augmented to facilitate not only discovery, but also triage and sometimes exploitation. However, while this automation and augmentation has helped the process of vulnerability discovery considerably, it has not addressed all the challenges faced with increasingly esoteric1 weaknesses being discovered by highly skilled individuals. These often subtle logic bugs are challenging to find in an automated fashion and typically rely on a large body of knowledge and experience being applied to a particular set of circumstances.
    [Show full text]
  • Etfids: Efficient Transient Fault Injection and Detection System
    ETFIDS: EFFICIENT TRANSIENT FAULT INJECTION AND DETECTION SYSTEM by NINGHAN TIAN Submitted in partial fulfillment of the requirements for the degree of Master of Science Department of Electrical Engineering and Computer Science CASE WESTERN RESERVE UNIVERSITY January, 2019 CASE WESTERN RESERVE UNIVERSITY SCHOOL OF GRADUATE STUDIES We hereby approve the thesis of Ninghan Tian candidate for the degree of Master of Science*. Committee Chair Dr. Daniel G. Saab Committee Member Dr. Christos Papachristou Committee Member Dr. Francis Merat Date of Defense December, 12th, 2018 *We also certify that written approval has been obtained for any proprietary material contained therein. Contents List of Tables iii List of Figures iv Abstract vi 1 Introduction 1 2 Fault Injection Techniques 5 2.1 Hardware-implemented fault injection . .5 2.1.1 Injection with contact . .6 2.1.2 Injection without contact . .6 2.1.3 Hardware implemented fault injection tools . .7 2.2 Software-implemented fault injection (SWIFI) . .9 2.2.1 Compile-time injection . 11 2.2.2 Runtime injection . 11 2.2.3 SWIFI tools . 12 2.3 The significance of SWIFI . 19 3 ETFIDS 21 3.1 Motivation . 21 3.2 The overall approach . 22 i CONTENTS 3.3 The lower level operating principle of ETFIDS . 29 3.4 Fault injection control flow . 32 3.5 Fault outcome analysis . 34 4 Fault Injection Experiments using ETFIDS 40 4.1 Typical fault injection target and experiment configuration . 40 4.2 Fault injection experiment results . 43 4.3 Performance . 45 5 Conclusion 52 ii List of Tables 2.1 Characteristics of fault injection methods.
    [Show full text]
  • Efficient Testing of Recovery Code Using Fault Injection
    Efficient Testing of Recovery Code Using Fault Injection PAUL D. MARINESCU and GEORGE CANDEA, Ecole´ Polytechnique Fed´ erale´ de Lausanne (EPFL), Switzerland 11 A critical part of developing a reliable software system is testing its recovery code. This code is traditionally difficult to test in the lab, and, in the field, it rarely gets to run; yet, when it does run, it must execute flawlessly in order to recover the system from failure. In this article, we present a library-level fault injec- tion engine that enables the productive use of fault injection for software testing. We describe automated techniques for reliably identifying errors that applications may encounter when interacting with their envi- ronment, for automatically identifying high-value injection targets in program binaries, and for producing efficient injection test scenarios. We present a framework for writing precise triggers that inject desired faults, in the form of error return codes and corresponding side effects, at the boundary between applica- tions and libraries. These techniques are embodied in LFI, a new fault injection engine we are distributing http://lfi.epfl.ch. This article includes a report of our initial experience using LFI. Most notably, LFI found 12 serious, previously unreported bugs in the MySQL database server, Git version control system, BIND name server, Pidgin IM client, and PBFT replication system with no developer assistance and no access to source code. LFI also increased recovery-code coverage from virtually zero up to 60% entirely automatically without requiring new tests or human involvement. Categories and Subject Descriptors: D.4.5 [Operating Systems]: Reliability—Fault-tolerance; D.2.5 [Software Engineering]: Testing and Debugging—Testing tools General Terms: Reliability Additional Key Words and Phrases: Fault injection, automated testing ACM Reference Format: Marinescu, P.
    [Show full text]
  • Fault Injection for Software Certification
    Fault Injection for Software Certification Domenico Cotroneo and Roberto Natella Universit`adegli Studi di Napoli Federico II and Critiware s.r.l. http://www.critiware.com Abstract As software becomes more and more pervasive and complex, it is increasingly important to assure that a system will be safe even in the presence of residual software faults (\bugs"). Software Fault In- jection consists in the deliberate introduction of software faults for assessing the impact of faulty software on the system and improving fault-tolerance. Software Fault Injection has been included as a recom- mended practice in recent safety standards, and it has therefore gained interest among practitioners, but it is still unclear how it can be ef- fectively used for certification purposes. In this paper, we discuss the adoption of Software Fault Injection in the context of safety certifica- tion, present a tool for the injection of realistic software faults, namely SAFE (SoftwAre Fault Emulator), and show the usage of the tool in the evaluation and improvement of robustness of a RTOS adopted in the avionic domain. Keywords: Software Fault-Tolerance; Fault Injection; Software De- pendability Assessment; Software Faults; Safety Certification; SW- FMEA; Software RAMS; SAFE tool Contact info: Email: [email protected], [email protected] Postal address: Universit`adegli Studi di Napoli Federico II, diparti- mento DIETI, Via Claudio 21, ed. 3, 80125, Naples, Italy Phone: +39 081 676770 Fax: +39 081 676574 IEEE Security & Privacy, special issue on Safety-Critical Systems: The Next Generation, vol. 11, no. 4, pp. 38-45, July/August 2013, http://dx.doi.org/10.1109/MSP.2013.54 1 1 Introduction We are witnessing the increasing importance of software in safety-critical applications, and the increasing demand for techniques and tools for assuring that software can fulfill its functions in a safe manner.
    [Show full text]
  • NUREG/CR-7151 Vol 1 "Development of a Fault Injection
    NUREG/CR-7151, Vol. 1 Development of a Fault Injection-Based Dependability Assessment Methodology for Digital I&C Systems Volume 1 Office of Nuclear Regulatory Research AVAILABILITY OF REFERENCE MATERIALS IN NRC PUBLICATIONS NRC Reference Material Non-NRC Reference Material As of November 1999, you may electronically access Documents available from public and special technical NUREG-series publications and other NRC records at libraries include all open literature items, such as books, NRC’s Public Electronic Reading Room at journal articles, transactions, Federal Register notices, http://www.nrc.gov/reading-rm.html. Publicly released Federal and State legislation, and congressional reports. records include, to name a few, NUREG-series Such documents as theses, dissertations, foreign reports publications; Federal Register notices; applicant, and translations, and non-NRC conference proceedings licensee, and vendor documents and correspondence; may be purchased from their sponsoring organization. NRC correspondence and internal memoranda; bulletins and information notices; inspection and investigative Copies of industry codes and standards used in a reports; licensee event reports; and Commission papers substantive manner in the NRC regulatory process are and their attachments. maintained at— The NRC Technical Library NRC publications in the NUREG series, NRC Two White Flint North regulations, and Title 10, “Energy,” in the Code of 11545 Rockville Pike Federal Regulations may also be purchased from one Rockville, MD 20852–2738 of these two sources. 1. The Superintendent of Documents These standards are available in the library for reference U.S. Government Printing Office Mail Stop SSOP use by the public. Codes and standards are usually Washington, DC 20402–0001 copyrighted and may be purchased from the originating Internet: bookstore.gpo.gov organization or, if they are American National Standards, Telephone: 202-512-1800 from— Fax: 202-512-2250 American National Standards Institute nd 2.
    [Show full text]
  • What's Wrong with Fault Injection As a Benchmarking Tool?
    Workshop on Dependability Benchmarking/DSN 2002, Washington DC, June 25, 2002 What’s Wrong With Fault Injection As A Benchmarking Tool? Philip Koopman ECE Department & ICES Carnegie Mellon University Pittsburgh, PA, USA [email protected] Abstract Fault injection, especially software-based fault injection, is a reasonably convenient and effective way to evaluate sys- This paper attempts to solidify the technical issues tems. However, it is not always clear what fault injection involved in the long-standing debate about the representativeness of fault injection as a tool for measuring results mean for fielded systems. Proposing the use of fault the dependability of general-purpose software systems. injection to benchmark system dependability typically trig- While direct fault injection seems appropriate for gers vigorous debate, often with polarized viewpoints. evaluating fault tolerant computers, most current software This paper seeks to identify a possible source of the large systems are not designed in a way that makes injection of faults directly into a module under test relevant for gap between opposing views in the debate on fault injection dependability benchmarking. Approaches that seem more representativeness as well as place into perspective some of likely to create representative faults are ones that induce the strengths and weaknesses of fault injection approaches. exceptional operating conditions external to a module While this paper presents opinions rather than scientific under test in terms of exceptional system state, exceptional facts, it is based on experiences from extensive interactions parameters/return values at an API, failed system components, or exceptional human interface inputs. with industry and the technical community as part of the Ballista robustness testing project as well as two years as co-chair of the IFIP 10.4 WG SIG on Dependability 1.
    [Show full text]
  • Dependability Assessment of the Android OS Through Fault Injection Domenico Cotroneo, Antonio Ken Iannillo, Roberto Natella, Stefano Rosiello
    1 Dependability Assessment of the Android OS through Fault Injection Domenico Cotroneo, Antonio Ken Iannillo, Roberto Natella, Stefano Rosiello Abstract—The reliability of mobile devices is a challenge product. Fault injection sounds very attractive but, regrettably, for vendors, since the mobile software stack has significantly developers hardly put this approach in practice, since it comes grown in complexity. In this paper, we study how to assess with high costs and many ambiguities. In particular, it is the impact of faults on the quality of user experience in the Android mobile OS through fault injection. We first address the difficult for them to define what faults to inject (fault model) problem of identifying a realistic fault model for the Android OS, [15]–[17], due to the large number and heterogeneity of by providing to developers a set of lightweight and systematic hardware and software components in a modern mobile device. guidelines for fault modeling. Then, we present an extensible fault Our assessment methodology aims to support developers injection tool (AndroFIT) to apply such fault model on actual, at defining, conducting, and analyzing fault injection tests in commercial Android devices. Finally, we present a large fault injection experimentation on three Android products from major a systematic and efficient way. Towards this goal, the paper vendors, and point out several reliability issues and opportunities presents the following novel contributions: for improving the Android OS. • A lightweight fault modeling approach. The approach guides developers at defining fault models through an archi- tectural review of the mobile OS, by combining systematic, I. INTRODUCTION lightweight guidelines with experts’ knowledge in order to Reliability is a major factor that affects the quality of the be applicable in large software systems.
    [Show full text]