Hijack: Taking control of cots systems for real-time user-level services (2007)
Cached
Download Links
- [www.cs.bu.edu]
- [cs-pub.bu.edu]
- [www.seas.gwu.edu]
- [www.seas.gwu.edu]
- DBLP
Other Repositories/Bibliography
| Venue: | In Proc. 13th IEEE Real-Time and Embedded Technology and Applications Symposium |
| Citations: | 6 - 4 self |
BibTeX
@INPROCEEDINGS{Parmer07hijack:taking,
author = {Gabriel Parmer and Richard West},
title = {Hijack: Taking control of cots systems for real-time user-level services},
booktitle = {In Proc. 13th IEEE Real-Time and Embedded Technology and Applications Symposium},
year = {2007},
pages = {133--146},
publisher = {IEEE Computer Society Press}
}
Share
 |
 |
 |
 |
||
OpenURL
Abstract
This paper focuses on a technique to empower commercial-off-the-shelf (COTS) systems with an execution environment, and corresponding services, to support realtime and embedded applications. By leveraging COTS systems, we are able to reduce the potentially expensive maintenance and development costs of proprietary solutions. We describe a system called “Hijack ” that enables user-level services to take control of features such as CPU scheduling, interrupt handling and synchronization. In contrast to other approaches that support real-time tasks within the kernel of commodity systems such as Linux, Hijack provides the basis for predictable thread execution at user-level. No changes to the kernel source code are required to support this approach. Instead, Hijack works by using a combination of kernel module support and an interposed execution environment between traditional process address spaces and the kernel. This technique enables system calls and hardware interrupts to be intercepted with bounded latencies via the kernel module, that passes control to a user-level real-time executive. From within the executive, system-wide services and policies can be deployed to over-ride certain features of the underlying kernel, while still leveraging base kernel services where appropriate. Using this technique, we show how a vanilla Linux system can be hijacked to support predictable service execution using a series of user-defined policies. In particular, we show how to deliver and process asynchronous events with bounded latency, using interposition agents within a Hijack execution environment. Results show that for realtime streaming applications, Hijack is able to receive and process packets with significantly lower loss rates and jitter compared to using alternative application-level processes for the same task. ∗ This material is based upon work supported by the National Science Foundation under Grant No. 0615153. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science
Keyphrases
cot system real-time user-level service bounded latency execution environment user-level service proprietary solution system call predictable service execution kernel source code national science foundation kernel module predictable thread execution expensive maintenance kernel module support interposed execution environment traditional process address space loss rate interposition agent base kernel service commodity system over-ride certain feature development cost user-defined policy system-wide service vanilla linux system user-level real-time executive asynchronous event support real-time task alternative application-level process interrupt handling hijack execution environment national science cpu scheduling underlying kernel hardware interrupt realtime streaming application
