Computer architectures have made a dramatic turn in the past few years away from improving single-thread performance and towards improved parallel performance. This semester, the systems seminar will focus on the implications for operating systems. We will discuss a variety of topics including the implications for OS structure and concurrent/parallel programming models. This first meeting will provide background on the trends in computer architecture leading to this dramatic change and preview research on future architectures.

Following the multi-core theme of this semester's system-seminar, this talk presents my work on understanding, detecting, and exposing concurrency bugs. Part of this talk (the `detecting' part) is similar to my job talk in last spring.

Driven by the hardware shift to multi-core architectures, concurrency is being brought into mainstream software development. Unfortunately, concurrent programs are prone to concurrency bugs. Concurrency bugs' non-deterministic property brings a lot of trouble to developers. Improving the reliability of concurrent programs is a critical and urgent task.

This talk first briefly discusses a characteristics study of real-world concurrency bugs. It then presents two techniques that detect concurrency bugs (atomicity violation bugs and multi-variable concurrency bugs) from the perspective of programmers' synchronization intention. At the end, it discusses a recent work on testing concurrent programs.

K42 is a research operating system. It is designed to scale up to thousands of processors, and it scales down to embedded devices. Object-oriented languages and techniques make the system both faster and easier to modify. K42 is part microkernel and part exokernel. Every program can have its own resource policies, and it can change those policies when things change. K42 can run linux applications un-modified.

At this week's Systems Seminar, we will review the K42 operating system and its contributions as a scalable operating system, as a Linux test-bed, and as a platform for operating systems research.

Kernel rootkits are considered one of the most stealthy types of computer malware and pose a significant threat to the integrity of computer systems. In this talk, I will present an integrated, VMM-based framework for the prevention and profiling of kernel rootkits. The first component of the framework, NICKLE, prevents the execution of injected rootkit code at the kernel level. This is achieved by a mechanism called memory shadowing which involves guest-transparent re-routing of kernel code fetch to a shadow memory where only authenticated kernel code can be found.

The second component of the framework, PoKeR, generates multi- aspect kernel rootkit profiles which include rootkit hooking behavior, targeted kernel objects (both static and dynamic), user-level impacts, and kernel rootkit code executed. This is a joint work with Xuxian Jiang (NC State University) and our Ph.D. student Ryan Riley.

Bio: Dongyan Xu is an associate professor in the Department of Computer Science at Purdue University. His current research focuses on developing advanced virtualization technologies for two areas: computer malware defense and virtual distributed computing. He obtained his Ph.D. in computer science from UIUC in 2001. He received a CAREER Award from the NSF, Seed for Success Awards from Purdue University, and the Best Paper Award from the 11th International Symposium on Recent Advances in Intrusion Detection (RAID08).

This is a practice academic job talk. Please come (even if you are not a system person) and provide feedback. Thanks!

Three trends will dominate the storage systems of tomorrow: users are storing increasingly massive amounts of data, storage software complexity is growing, and the use of cheap and less reliable hardware is increasing. These trends present us with a terrific challenge: How can we promise users that storage systems work robustly in spite of their massive software complexity and the broad range of disk failures that can arise? Unfortunately, current approaches describe recovery in thousands of lines of intricate, low-level C code and it is scattered throughout. As a result, current storage systems are not reliable.

In this talk, I will present how we build a new generation of more robust and reliable storage systems by adhering to the idea that complexity is the enemy of reliability. Specifically, I will present new online and offline reliability frameworks (I/O Shepherding and SQCK) that advocate a higher-level strategy where the logic of reliability policies can be described clearly and concisely. With I/O shepherding, file system administrators can write disk-failure policies (such as retry, parity, mirrors, checksums, sanity checks, and data structure repairs) in a few lines of code in a single locale. With SQCK, file system developers can separate the logic of hundreds of data structure repairs from their low-level implementation. I will also discuss other interesting findings that show how storage system reliability is difficult to achieve in current approaches.

This is my 2nd practice academic job talk (for those who cannot come on Monday, Mar 9).

See the previous entry for my abstract.