Formal Verification of Functional Correctness for Mutexes in Microkernel

Traditional embedded Real-Time Operating Systems (RTOS) or Basic Software (BSW) implementations typically require manual porting to new hardware platforms. However, this approach can be time-consuming and error-prone, especially given the frequent introduction of new or upgraded hardware architectures. In addition, traditional testing methods may not fully capture the complexity and nuances of the system, making it difficult to ensure correctness and dependability. To address these challenges, we propose a comprehensive methodology that integrates formal methods, a WCET tool, and a code generation technique. We use formal methods to create models and verify their correctness against functional and non-functional specifications or properties such as safety, liveness, and timing. We use the WCET tool as a microarchitecture analyzer to analyze the low-level binary code. The intermediate results of the tool are used to verify the correctness of the software implementation against the runtime effects of the hardware, such as data/memory race conditions. Finally, the code is generated from the formal models. Our proposed framework simplifies the maintenance of RTOS or BSW implementations while ensuring their correctness and partially automating portability to new hardware architectures.

The subject: This study focuses on improving the quality of Cyber-Physical System (CPS) software by eliminating incorrect usage of units of measurement and orientation in C/C++ programs. Incorrect usage often leads to critical errors that conventional systems cannot effectively prevent. Manual examination of code using dimensional and orientation analysis can detect these errors in physical equations, but these methods become impractical when dealing with complex physical computations. Objectives: As suggested by Siano, the proposed approach uses physical quantities and prefixes defined by the International System of Units and orientation operations on physical objects. The elaborated system incorporates dimensional and orientation analysis and metaprogramming techniques. The methods used are dimensional & orientational analysis and metaprogramming. The following results were obtained: ensuring consistency of the units, incorporating orientation operations into the programming model for accurately handling physical object rotations and alignments, and using Siano’s work to precisely manipulate object orientation, thereby reducing the likelihood of orientation-related errors. Checking physical dimensions and orientations during the compilation stage identifies potential software defects before code execution, thereby reducing debugging time and lowering the cost of addressing issues later in development. The elaborated system represents a crucial step towards safer and more dependable Cyber-Physical System applications. This approach allows us to identify approximately 90% of incorrect usage of program variables; additionally, it detects over 50% of erroneous operations during compilation and execution of large-scale programs in real-world conditions. Conclusions. Scientific novelty: it proposed and developed a specialized C++-type library for formal compile-time software verification of Cyber-Physical Systems software. The proposed C++-type library leverages dimensional and orientational analysis to enhance software quality, reliability, and real-time formal verification. Although the proposed method for formal verification is not tailor-made for cyber-physical objects and systems, given its primary focus on software-level concerns, it does exhibit adaptability for verifying general-purpose software that incorporates various physical parameters. This versatility extends to diverse domains such as educational, gaming, and simulation software.

NOTE: The first page of text has been automatically extracted and included below in lieu of an abstract Using Programming Projects in an Operating Systems Course as a Capstone Software Engineering Experience Computer Engineering Technology students at the University of Dayton take two fundamental programming courses teaching the basics of algorithmic problem solving along with the VBA and C++ syntaxes. These courses develop a strong programming foundation for the students; however, they lack the ability to introduce software programming within larger software systems. The final course related to software development is a required operating systems course. This course contains three fundamental goals: to develop the students’ understanding of key operating system concepts, to increase the students’ software engineering capabilities, and to introduce the students to the internal workings of the Linux and Windows operating systems. The operating systems course relies heavily on software programming exercises as a key instrument in teaching students the framework and applications of modern operating systems. The unique aspect of this approach is that the programming projects are designed not as standalone activities, but instead as individual components of a larger software system. Therefore, each programming project focuses not just on learning new syntax related to operating system concepts, but also in how these concepts are relevant to the software system being developed. Students develop programs for both the Microsoft Windows and Linux operating systems, working heavily with their associated application programming interfaces and investigating processes, threads, synchronization, input and output, and scheduling issues. A complete course overview and synopsis of the software programming projects will be presented along with student performance and comments from an end of the semester survey. Introduction The Computer Engineering Technology (CET) Program at the University of Dayton (UD) was started in 1999 and included two software programming courses. These courses predominately focused on teaching the fundamentals of software programming and the syntax associated with the VBA and C++ languages. Likewise, to satisfy the ABET outcome requirements for computer engineering technology programs, the ETC Program at UD also required a new 3 credit lecture course entitled “Concepts & Applications of Operating Systems” to be taken during the students’ Junior year of study.1 This course was structured to provide students hands-on exposure to the internal workings of modern operating systems. During the 2004/2005 academic year, the material being taught in the software programming was evaluated. In accordance with the Computing Curricula 2001 (CC2001) report by the Computer Society of the Institute for Electrical and Electronic Engineers (IEEE-CS) and the Association for Computing Machinery (ACM), the two software programming courses being taught fell within the traditional imperative-first approach. This approach starts students off with software programming activities without any real preparations.2 After careful review, it was found that the student population being served needed to be taught the algorithmic thought process prior to the syntax as many of the students had no prior exposure to software programming and were struggling more with defining the problem solutions than with the specific syntax being taught.3 A modified algorithms-first approach from CC2001 report was applied to these courses. Instead

As the increasing of system performance and computing power, embedded systems are more complicated and interactive. Therefore, operating system (OS) plays a more important role in embedded systems to utilize various hardware and software resources. However, no OS can meet all requirements of various embedded systems. Due to the advance of reconfigurable processors, system requirements can be more dynamic. Embedded OS has becoming more critical in the development of embedded systems and thus there is a strong need of configurable embedded OS to better and faster build up the target system. In this paper, we propose a configurable OS, called COS, based on SOA (service-oriented architecture) for embedded SoC (system on a chip) systems to build an application specific OS according to the system requirements. COS can be easily configured to better utilize the resources of the target embedded platform and have better support to the embedded application. Moreover, the COS can easily extend new features or functionalities of other OSes and even be adapted to the designs of other OSes. We implement COS on an ARM platform to prove its configurability and also evaluate its overhead. We believe that COS can be configured to meet the various requirements in embedded SoC systems and help to speed up the embedded system development process

Bugs in memory management of Operating Systems may lead to crashing. This paper presents a case study of formal verification on the buddy memory allocation component of the Zephyr RTOS kernel. The algorithm of the component allows memory blocks of 4-power sizes to be dynamically allocated by efficiently partitioning larger blocks into smaller ones, and then be released supporting immediate and automatic combining of smaller blocks. The execution of memory allocation is preemptive, which means that the allocation may invoke rescheduling when there is no block available for memory requests. In this paper, we provide a fine-grained formal specification of buddy memory allocation and formally verify its safety via invariants and functional correctness. The specification covers all the elements of the data structure as well as all statements of memory initialization, allocation, and release presented in the C source code. During the formal verification, we found a functional flaw in the C code. To the best of our knowledge, this paper is the first effort of formal verification at a fine-grained level on buddy memory allocation in Operating Systems.

Information Technology has evolved over a period of time from Electronic Data Processors (EDP) to Cloud based technologies. Software is a critical component in this industry. The core product component in software is the set of instructions in the form of source code. During inception of the industry, source code was accessible at no cost. In the next era of information technology (1970's & 1980's), programs which were earlier available free of cost were sold at a price through licensing. During mid and early 1980's open source and hardware integrated software emerged. Similar trend was visible in system software market, especially in the operating system software market. Over a period of time Microsoft operating system emerged as one of the dominant players in the market. However, in the recent past Microsoft has considerably lost its market share in operating system products from 94.38% in June 2007 to 84% in May 2014. This paper captures the trend in operating system software market and analyses customers' preference to switch over from the current operating system. The trend in the market was analyzed through secondary data on market share and the customer preference to switch over was captured through a survey of engineers at various multinational IT firms in Bangalore. The study identified that the current trend could be moving towards open source or hardware integrated operating system from proprietary operating software. The survey identified that higher percentage of users preferred to switch over from the current operating system on desktops, laptops and workstations to either open source or hardware integrated operating system except servers.

An important goal of software security is to ensure sensitive/secret data owned by a program shall be exclusively accessible by the program. An obstacle to such security goal is that modern commodity operating systems (OS) for the sake of speed and flexibility have a unified linear address space--any OS kernel program can access all the linear addresses. As a result, rootkits or malicious system software are able to control the OS virtual address space, harvest the sensitive data used by software programs on the compromised computer, and report the data to remote entities controlled by hackers.In this paper, we present a holistic approach against sophisticated malware. Instead of focusing on the security of various abstraction layers of OS, we utilize the hardware techniques to directly provide the trust services to software programs. Without modifying OS, we leverage the virtual machine monitor technologies to create a lightweight hypervisor for fine-grain software runtime memory protection. As a result, a program's memory could be hidden from other high privilege system software in a single commodity OS. In addition, we propose the data locker component in the hypervisor, which prevents the sensitive data of software program in persistent storage from leaking to rootkits or other malware. For the performance evaluation, the implementation based on hardware-assisted x86 virtualization technology is presented and experimental results are reported.

As a standard of operating system in automotive industry, OSEK/VDX is applied on dozens of mature industrial operating systems and widely installed on the products of major automotive manufacturers. In this empirical report, we introduce our experience on verifying OSEK/VDX real-time operating system. From both source code and binary code level, the OSEK/VDX operating system is verified based on approaches comprising Hoare Logic, Communicating Sequential Processes, Binary Code Analysis and Discrete-Time Markov Chains model checking. Based on our approach, a commercial OSEK/VDX standard automotive operating system is verified and it is proved to be of great help to the development of software.

Cyberattacks are typically preceded by a reconnaissance phase in which attackers aim at collecting valuable information about the target system, including network topology, service dependencies, operating systems (OSs), and unpatched vulnerabilities. Unfortunately, when system configurations are static, given enough time, attackers can always acquire accurate knowledge about the target system through a variety of tools—including OS and service fingerprinting—and engineer effective exploits. To address this important problem and increase the resiliency of systems against known and unknown attacks, many techniques have been devised to dynamically and periodically change some aspects of a system’s configuration in order to introduce uncertainty for the attacker. However, these techniques, commonly referred to as moving target defenses, may introduce a significant overhead for the defender. To address this limitation, we present a graph-based approach for manipulating the attacker’s view of a system’s attack surface, which does not require altering the actual configuration of a system. To achieve this objective, we first formalize the notions of system view and distance between views and then define a principled approach to manipulating responses to attacker’s probes so as to induce an external view of the system that satisfies certain desirable properties. In particular, we propose efficient algorithmic solutions to two classes of problems, namely, (i) inducing an external view that is at a minimum distance from the internal view while minimizing the cost for the defender and (ii) inducing an external view that maximizes the distance from the internal view, given an upper bound on the cost for the defender. In order to demonstrate practical applicability of the proposed approach, we present deception-based techniques for defeating an attacker’s effort to fingerprint OSs and services on the target system. These techniques consist in manipulating outgoing traffic so that it resembles traffic generated by a completely different system. Experimental results show that our approach can efficiently and effectively deceive an attacker.

Abstract—During the Covid-19 pandemic, all learning activities were carried out online. Many learning media and software are used in online learning. One of them is the Open Source Operating System which is currently widely used in online learning systems. This makes the operating system much attention by the world of education, researchers, government organizations, individuals, even large software companies such as Google and others who are very interested in developing Open Source software, especially the Linux Operating System. This makes the authors interested in knowing how to develop an operating system based on open source software in online learning systems and disseminate the use of open source software to the public.

Performance analyses for embedded software construction with existing components require knowledge of performance characteristics of both application software and operating system (OS) services, especially those services that are critical for real-time applications. Since end users normally do not control the structure and implementation of OS services, but have to use them to meet the system-level performance constraints, it is essential and critical to characterize the performance of OS services with measurements. As such measurements are taken for performance analysis, not for comparison, the measurement methods should be different from those traditionally, used for comparison. In this paper we present an end-to-end method for measuring the performance of timing and scheduling services in selected real-time OSs for the performance modeling and analysis. The proposed method takes the factors of both OS implementations and application configurations into account to obtain the measured performance close to what applications will experience at runtime. The results have shown that the performance characteristics of OS services can be measured without instrumenting the kernel source code, and hence, can be reused for the analysis of a family of applications.

Operating System is an important software in computer system. For personal and office use the operating system is sufficient. However, to critical mission applications such as nuclear power plants and braking system on the car (auto braking system) which need a high level of reliability, it requires operating system which operates in real time. The study aims to assess the implementation of the Linux-based operating system on a Single Board Computer (SBC) ARM-based, namely Pandaboard ES with the Dual-core ARM Cortex-A9, TI OMAP 4460 type. Research was conducted by the method of implementation of the General Purpose OS Ubuntu 12:04 OMAP4-armhf-RTOS and Linux 3.4.0-rt17 + on PandaBoard ES. Then research compared the latency value of each OS on no-load and with full-load condition. The results obtained show the maximum latency value of RTOS on full load condition is at 45 uS, much smaller than the maximum value of GPOS at full-load at 17.712 uS. The lower value of latency demontrates that the RTOS has ability to run the process in a certain period of time much better than the GPOS.

Many people use numerous operating systems to do a variety of tasks in today's hectic world. While using Linux for programming and coding, someone may utilize Windows for some document editing. There are no major problems faced while dual booting two operating systems aside from the fact that in order to dual boot, one has to open the boot menu every time in order to select which operating system is to be booted. This process of opening the boot menu and selecting the operating system each time is a very redundant task. Hence, the idea of a hardware-based switch that would help in switching the operating system without opening the boot menu every time was born. Initial thoughts for the switch included using a control board such as the Raspberry Pi for programming the switch. Even modification of the bootloader source code in order to create some hardware-based controller was attempted. However, after several days of research and testing, it was concluded that even though previous attempts had been made to create a dual booting switch using control boards, and were successful to an extent, those solutions were too complex for the value they provided. Hence, work was started on creating a dual booting switch without using a control board and with minimum modifications to the bootloader.

Tele-Lab “IT-Security” on CD: portable, reliable and safe IT security training

The Internet of Things (IoT) is becoming an increasingly common paradigm. As IoT usage scenarios have increased, many challenges in IoT operating systems’ safety and adaptability have remained. According to the programming model, IoT operating systems can be categorized into three types: multithreading, event-driven, and hybrid. Different operating system models are applied in different scenarios depending on the real-time requirements or resource richness. The safety of IoT operating systems is critical; hence, formal verification is an important method of detecting potential vulnerabilities and providing safety guarantees. This paper proposes a hybrid model for an IoT operating system and employs the Event-B method for modeling and verification. We rewrite the requirements and divide the Event-Bus hybrid operating system model into eight levels for refinement. The safety and liveness properties of Event-Bus are guaranteed by generating and proving the proof obligations at each model level. A large proportion of the proof obligations (91%) are automatically proven on the Rodin platform to simplify the development process.