Analyzing a decade of Linux system calls

Over the past 25 years, thousands of developers have contributed more than 18 million lines of code (LOC) to the Linux kernel. As the Linux kernel forms the central part of various operating systems that are used by millions of users, the kernel must be continuously adapted to the changing demands and expectations of these users. The Linux kernel provides its services to an application through system calls. The combined set of all system calls forms the essential Application Programming Interface (API) through which an application interacts with the kernel. In this paper, we conduct an empirical study of 8,770 changes that were made to Linux system calls during the last decade (i.e., from April 2005 to December 2014). In particular, we study the size of the changes, and we manually identify the type of changes and bug fixes that were made. Our analysis provides an overview of the evolution of the Linux system calls over the last decade. We find that there was a considerable amount of technical debt in the kernel, that was addressed by adding a number of sibling calls (i.e., 26% of all system calls). In addition, we find that by far, the ptrace() and signal handling system calls are the most challenging to maintain. Our study can be used by developers who want to improve the design and ensure the successful evolution of their own kernel APIs.

[2]  Yuanyuan Zhou,et al.  Have things changed now?: an empirical study of bug characteristics in modern open source software , 2006, ASID '06.

[3]  Qiang Tu,et al.  Growth, evolution, and structural change in open source software , 2001, IWPSE '01.

[4]  James M. Bieman,et al.  The evolution of FreeBSD and linux , 2006, ISESE '06.

[5]  Ralph E. Johnson,et al.  How do APIs evolve? A story of refactoring , 2006, J. Softw. Maintenance Res. Pract..

[6]  Diomidis Spinellis,et al.  The Evolution of C Programming Practices: A Study of the Unix Operating System 1973-2015 , 2016, 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE).

[7]  Diomidis Spinellis,et al.  A repository of Unix history and evolution , 2017, Empirical Software Engineering.

[8]  Romain Robbes,et al.  How do developers react to API deprecation?: the case of a smalltalk ecosystem , 2012, SIGSOFT FSE.

[9]  José Laerte Pires Xavier Júnior Historical and impact analysis of API breaking changes , 2017 .

[10]  Miryung Kim,et al.  An Empirical Study of API Stability and Adoption in the Android Ecosystem , 2013, 2013 IEEE International Conference on Software Maintenance.

[11]  Eleni Stroulia,et al.  API-Evolution Support with Diff-CatchUp , 2007, IEEE Transactions on Software Engineering.

[12]  Giuliano Antoniol,et al.  Analyzing cloning evolution in the Linux kernel , 2002, Inf. Softw. Technol..

[13]  Jeff H. Perkins,et al.  Automatically generating refactorings to support API evolution , 2005, PASTE '05.

[14]  Yuanyuan Zhou,et al.  Learning from mistakes: a comprehensive study on real world concurrency bug characteristics , 2008, ASPLOS.

[15]  M.M. Lehman,et al.  Programs, life cycles, and laws of software evolution , 1980, Proceedings of the IEEE.

[16]  Yuanyuan Zhou,et al.  Bug characteristics in open source software , 2013, Empirical Software Engineering.

[17]  Dror G. Feitelson,et al.  The Linux kernel as a case study in software evolution , 2010, J. Syst. Softw..

[18]  Matt Davis Creating a vDSO: the colonel's other chicken , 2011 .

[19]  Marco Tulio Valente,et al.  How do developers react to API evolution? A large-scale empirical study , 2018, Software Quality Journal.

[20]  Gabriele Bavota,et al.  API change and fault proneness: a threat to the success of Android apps , 2013, ESEC/FSE 2013.

[21]  Ralph E. Johnson,et al.  The role of refactorings in API evolution , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

[22]  Leeat Yariv Online Appendix , 2008 .

[23]  Donald E. Porter,et al.  A study of modern Linux API usage and compatibility: what to support when you're supporting , 2016, EuroSys.

[24]  Christophe Calvès,et al.  Faults in linux: ten years later , 2011, ASPLOS XVI.

[25]  Julia L. Lawall,et al.  Understanding collateral evolution in Linux device drivers , 2006, EuroSys '06.

[26]  Marco Tulio Valente,et al.  Historical and impact analysis of API breaking changes: A large-scale study , 2017, 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER).

[27]  Katsuro Inoue,et al.  Analysis of the Linux Kernel Evolution Using Code Clone Coverage , 2007, Fourth International Workshop on Mining Software Repositories (MSR'07:ICSE Workshops 2007).

[28]  Norman Cliff,et al.  Ordinal Analysis of Behavioral Data , 2003 .

[29]  Diomidis Spinellis,et al.  A Repository with 44 Years of Unix Evolution , 2015, 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories.

[30]  Ahmed E. Hassan,et al.  Predicting faults using the complexity of code changes , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[31]  Andrea C. Arpaci-Dusseau,et al.  A Study of Linux File System Evolution , 2013, FAST.

[32]  Michael W. Godfrey,et al.  Evolution in open source software: a case study , 2000, Proceedings 2000 International Conference on Software Maintenance.

[33]  Wolfgang Mauerer,et al.  Professional Linux Kernel Architecture , 2008 .

[34]  Krzysztof Czarnecki,et al.  Evolution of the Linux Kernel Variability Model , 2010, SPLC.

[35]  James D. Herbsleb,et al.  How to break an API: cost negotiation and community values in three software ecosystems , 2016, SIGSOFT FSE.

[36]  J. Henkel,et al.  CatchUp! Capturing and replaying refactorings to support API evolution , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[37]  Meir M. Lehman Programs, life cycles, and laws of software evolution , 1980 .

[38]  Giuliano Antoniol,et al.  Investigating large software system evolution: the Linux kernel , 2002, Proceedings 26th Annual International Computer Software and Applications.

[39]  Marco Tulio Valente,et al.  How do developers react to API evolution? The Pharo ecosystem case , 2015, 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME).

[40]  S. Baum,et al.  Intro , 2003, Science.

[41]  Dimitris Mitropoulos,et al.  POSIX abstractions in modern operating systems: the old, the new, and the missing , 2016, EuroSys.

[42]  Krzysztof Czarnecki,et al.  Towards a catalog of variability evolution patterns: the Linux kernel case , 2012, FOSD '12.