Hongliang Tian
Research Subjects
Hongliang Tian has a total of 53 co-authors. Here are the top co-authors by number of shared publications:
- Shoumeng Yan
Ant Group
7 shared publications - Hui Xu
School of Computer Science, Fudan University, Shanghai, China
2 shared publications - Jiahong Xiang
Southern University of Science and Technology, China
2 shared publications - Kui Ren
Zhejiang University
2 shared publications - Kun Yang
The State Key Laboratory of Blockchain and Data Security, Zhejiang University, Hangzhou, Zhejiang, China
2 shared publications - Weijie Liu
Nankai University, Tianjin, China
2 shared publications
Latest Publications
- Open Access
- 30 June 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (FSE) , 678-699
Empowering Autonomous Debugging Agents with Efficient Dynamic Analysis
Autonomous agents for automated program repair represent a promising frontier in software engineering, yet their effectiveness is often hindered by reliance on post-mortem, coarse-grained execution feedback. While integrating traditional interactive debuggers seems a natural solution, their low-level, line-by-line interaction paradigm turns to be cost-inefficient for LLM-based agents, leading to exhausted budgets and unproductive loops. To mitigate this, we introduce Agent-centric Debugging Interface (ADI), a novel agent-centric debugging interface designed for cost-efficient, end-to-end autonomous interaction. Specifically, Agent-centric Debugging Interface realizes a function-level interaction paradigm, powered by our Frame Lifetime Trace—a comprehensive data structure encapsulating a function's stateful execution trace—and a set of high-level navigational commands. Our extensive evaluation on the SWE-bench benchmark demonstrates the effectiveness and efficiency of ADI. By simply equipping a basic agent with ADI, it successfully resolves 63.8% of the tasks on the SWE-bench Verified set, even slightly outperforming the highly-optimized and high-investment Claude-Tools agent, at an average cost of $1.28 per task with Claude-Sonnet-3.7. Furthermore, we demonstrate ADI's generality by integrating it as a plug-and-play component into the existing SOTA agents, delivering consistent gains ranging from 6.2% to 18.5% on the resolved tasks. These results indicate that Agent-centric Debugging Interface could achieve a general and efficient enhancement for the existing autonomous agents.
- 30 June 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (FSE) , 678-699
Open AccessEmpowering Autonomous Debugging Agents with Efficient Dynamic Analysis
Autonomous agents for automated program repair represent a promising frontier in software engineering, yet their effectiveness is often hindered by reliance on post-mortem, coarse-grained execution feedback. While integrating traditional interactive debuggers seems a natural solution, their low-level, line-by-line interaction paradigm turns to be cost-inefficient for LLM-based agents, leading to exhausted budgets and unproductive loops. To mitigate this, we introduce Agent-centric Debugging Interface (ADI), a novel agent-centric debugging interface designed for cost-efficient, end-to-end autonomous interaction. Specifically, Agent-centric Debugging Interface realizes a function-level interaction paradigm, powered by our Frame Lifetime Trace—a comprehensive data structure encapsulating a function's stateful execution trace—and a set of high-level navigational commands. Our extensive evaluation on the SWE-bench benchmark demonstrates the effectiveness and efficiency of ADI. By simply equipping a basic agent with ADI, it successfully resolves 63.8% of the tasks on the SWE-bench Verified set, even slightly outperforming the highly-optimized and high-investment Claude-Tools agent, at an average cost of $1.28 per task with Claude-Sonnet-3.7. Furthermore, we demonstrate ADI's generality by integrating it as a plug-and-play component into the existing SOTA agents, delivering consistent gains ranging from 6.2% to 18.5% on the resolved tasks. These results indicate that Agent-centric Debugging Interface could achieve a general and efficient enhancement for the existing autonomous agents.
- 4 May 2026
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Computers
- Vol. 75 (8) , 2857-2869
Keystone-Vault: Hardware-Assisted Efficient Intra-Enclave Isolation for RISC-V TEEs
RISC-V’s open architecture provides an ideal platform for customizable security features, particularly in trusted execution environments (TEEs). However, existing RISC-V TEEs such as Keystone adopt a monolithic model where applications run with all dependencies in a single isolation domain, leading to bloated trusted computing bases (TCBs). When trusted applications grow large, vulnerabilities in any third-party library can compromise the entire enclave’s security. To address these challenges, we propose Keystone-Vault, which enables fine-grained isolation within RISC-V enclaves. Keystone-Vault reimplements and improves the Donky memory protection key mechanism and introduces a hardware-software co-designed isolation framework. The core idea is to partition each enclave into multiple regions, called Vaults, to isolate specific portions of code and data with hardware-assisted access control. Mean-while, our lightweight vault-switching mechanism runs entirely in user mode, making it more lightweight than existing RISC-V TEE designs that rely on Physical Memory Protection (PMP) to enforce security-domain partitioning. Proof-of-concept (PoC) experiments based on a prototype of Keystone-Vault implemented on the QEMU emulation platform demonstrate that Keystone-Vault successfully defends against attacks from a malicious OS and confines security risks from untrusted libraries within their respective vaults. Evaluation on realistic and complex workloads further demonstrates that, compared with baseline Keystone, Keystone-Vault introduces only 3%–7% additional performance overhead.
- 4 May 2026
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Computers
- Vol. 75 (8) , 2857-2869
Keystone-Vault: Hardware-Assisted Efficient Intra-Enclave Isolation for RISC-V TEEs
RISC-V’s open architecture provides an ideal platform for customizable security features, particularly in trusted execution environments (TEEs). However, existing RISC-V TEEs such as Keystone adopt a monolithic model where applications run with all dependencies in a single isolation domain, leading to bloated trusted computing bases (TCBs). When trusted applications grow large, vulnerabilities in any third-party library can compromise the entire enclave’s security. To address these challenges, we propose Keystone-Vault, which enables fine-grained isolation within RISC-V enclaves. Keystone-Vault reimplements and improves the Donky memory protection key mechanism and introduces a hardware-software co-designed isolation framework. The core idea is to partition each enclave into multiple regions, called Vaults, to isolate specific portions of code and data with hardware-assisted access control. Mean-while, our lightweight vault-switching mechanism runs entirely in user mode, making it more lightweight than existing RISC-V TEE designs that rely on Physical Memory Protection (PMP) to enforce security-domain partitioning. Proof-of-concept (PoC) experiments based on a prototype of Keystone-Vault implemented on the QEMU emulation platform demonstrate that Keystone-Vault successfully defends against attacks from a malicious OS and confines security risks from untrusted libraries within their respective vaults. Evaluation on realistic and complex workloads further demonstrates that, compared with baseline Keystone, Keystone-Vault introduces only 3%–7% additional performance overhead.
- Open Access
- 26 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 311-327
Pyramid: A Secure, Resource-Efficient, and Pluggable Kubernetes for Multi-Tenancy
- 26 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 311-327
Open AccessPyramid: A Secure, Resource-Efficient, and Pluggable Kubernetes for Multi-Tenancy
- Open Access
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 805-817
Evaluating and Improving Automated Repository-Level Rust Issue Resolution with LLM-based Agents
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 805-817
Open AccessEvaluating and Improving Automated Repository-Level Rust Issue Resolution with LLM-based Agents
- Open Access
- 12 October 2025
- Published by Association for Computing Machinery (ACM)
- p. 1082-1098
CortenMM: Efficient Memory Management with Strong Correctness Guarantees
- 12 October 2025
- Published by Association for Computing Machinery (ACM)
- p. 1082-1098
Open AccessCortenMM: Efficient Memory Management with Strong Correctness Guarantees
- Open Access
- 4 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 31-37
Framekernel: A Safe and Efficient Kernel Architecture via Rust-based Intra-kernel Privilege Separation
This paper introduces the framekernel architecture, a novel approach to operating system (OS) design that utilizes safe language-based, intra-kernel privilege separation. This architecture combines the security advantages of microkernels with the performance efficiencies of monolithic kernels. A framekernel is composed of a privileged OS Framework and de-privileged OS Services. The Framework encapsulates all low-level, unsafe operations into high-level, safe abstractions, thereby enabling the Services to implement a wide array of functionalities in a safe language. The primary challenge in designing framekernels lies in maintaining a minimal Trusted Computing Base (TCB)-the Framework- while supporting extensive functionalities. This paper outlines the design principle and rules that facilitate this balance. Our Rust-based framekernel prototype, Asterinas, validates the framekernel concept by supporting over 130 Linux system calls and a broad range of OS features and device drivers, based on a significantly reduced TCB.
- 4 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 31-37
Open AccessFramekernel: A Safe and Efficient Kernel Architecture via Rust-based Intra-kernel Privilege Separation
This paper introduces the framekernel architecture, a novel approach to operating system (OS) design that utilizes safe language-based, intra-kernel privilege separation. This architecture combines the security advantages of microkernels with the performance efficiencies of monolithic kernels. A framekernel is composed of a privileged OS Framework and de-privileged OS Services. The Framework encapsulates all low-level, unsafe operations into high-level, safe abstractions, thereby enabling the Services to implement a wide array of functionalities in a safe language. The primary challenge in designing framekernels lies in maintaining a minimal Trusted Computing Base (TCB)-the Framework- while supporting extensive functionalities. This paper outlines the design principle and rules that facilitate this balance. Our Rust-based framekernel prototype, Asterinas, validates the framekernel concept by supporting over 130 Linux system calls and a broad range of OS features and device drivers, based on a significantly reduced TCB.
- 13 August 2024
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 50 (9) , 2472-2484
rCanary: Detecting Memory Leaks Across Semi-Automated Memory Management Boundary in Rust
Rust is an effective system programming language that guarantees memory safety via compile-time verifications. It employs a novel ownership-based resource management model to facilitate automated deallocation. This model is anticipated to eliminate memory leaks. However, we observed that user intervention drives it into semi-automated memory management and makes it error-prone to cause leaks. In contrast to violating memory-safety guarantees restricted by the unsafe keyword, the boundary of leaking memory is implicit, and the compiler would not emit any warnings for developers. In this paper, we present rCanary, a static, non-intrusive, and fully automated model checker to detect leaks across the semi-automated boundary. We design an encoder to abstract data with heap allocation and formalize a refined leak-free memory model based on boolean satisfiability. It can generate SMT-Lib2 format constraints for Rust MIR and is implemented as a Cargo component. We evaluate rCanary by using flawed package benchmarks collected from the pull requests of open-source Rust projects. The results indicate that it is possible to recall all these defects with acceptable false positives. We further apply our tool to more than 1,200 real-world crates from crates.io and GitHub, identifying 19 crates having memory leaks. Our analyzer is also efficient, that costs 8.4 seconds per package.
- 13 August 2024
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 50 (9) , 2472-2484
rCanary: Detecting Memory Leaks Across Semi-Automated Memory Management Boundary in Rust
Rust is an effective system programming language that guarantees memory safety via compile-time verifications. It employs a novel ownership-based resource management model to facilitate automated deallocation. This model is anticipated to eliminate memory leaks. However, we observed that user intervention drives it into semi-automated memory management and makes it error-prone to cause leaks. In contrast to violating memory-safety guarantees restricted by the unsafe keyword, the boundary of leaking memory is implicit, and the compiler would not emit any warnings for developers. In this paper, we present rCanary, a static, non-intrusive, and fully automated model checker to detect leaks across the semi-automated boundary. We design an encoder to abstract data with heap allocation and formalize a refined leak-free memory model based on boolean satisfiability. It can generate SMT-Lib2 format constraints for Rust MIR and is implemented as a Cargo component. We evaluate rCanary by using flawed package benchmarks collected from the pull requests of open-source Rust projects. The results indicate that it is possible to recall all these defects with acceptable false positives. We further apply our tool to more than 1,200 real-world crates from crates.io and GitHub, identifying 19 crates having memory leaks. Our analyzer is also efficient, that costs 8.4 seconds per package.
- Open Access
- 30 November 2023
- Published by Association for Computing Machinery (ACM)
- p. 733-744
OOM-Guard: Towards Improving the Ergonomics of Rust OOM Handling via a Reservation-Based Approach
Out of memory (OOM) is an exceptional system state where any further memory allocation requests may fail. Such allocation failures would crash the process or system if not handled properly, and they may also lead to an inconsistent program state that cannot be recovered easily. Current mechanisms for preventing such hazards highly rely on the manual effort of the programmers themselves. This paper studies the OOM issues of Rust, which is an emerging system programming language that stresses the importance of memory safety but still lacks handy mechanisms to handle OOM well. Even worse, Rust employs an infallible mode of memory allocations by default. As a result, the program written by Rust would simply abort itself when OOM occurs. Such crashes would lead to critical robustness issues for services or modules of operating systems. We propose OOM-Guard, a handy approach for Rust programmers to handle OOM. OOM-Guard is by nature a reservation-based approach that aims to convert the handlings for many possible failed memory allocations into handlings for a smaller number of reservations. In order to achieve efficient reservation, OOM-Guard incorporates a subtle cost analysis algorithm based on static analysis and a proxy allocator. We then apply OOM-Guard to two well-known Rust projects, Bento and rCore. Results show that OOM-Guard can largely reduce developers' efforts for handling OOM and incurs trivial overhead in both memory space and execution time.
- 30 November 2023
- Published by Association for Computing Machinery (ACM)
- p. 733-744
Open AccessOOM-Guard: Towards Improving the Ergonomics of Rust OOM Handling via a Reservation-Based Approach
Out of memory (OOM) is an exceptional system state where any further memory allocation requests may fail. Such allocation failures would crash the process or system if not handled properly, and they may also lead to an inconsistent program state that cannot be recovered easily. Current mechanisms for preventing such hazards highly rely on the manual effort of the programmers themselves. This paper studies the OOM issues of Rust, which is an emerging system programming language that stresses the importance of memory safety but still lacks handy mechanisms to handle OOM well. Even worse, Rust employs an infallible mode of memory allocations by default. As a result, the program written by Rust would simply abort itself when OOM occurs. Such crashes would lead to critical robustness issues for services or modules of operating systems. We propose OOM-Guard, a handy approach for Rust programmers to handle OOM. OOM-Guard is by nature a reservation-based approach that aims to convert the handlings for many possible failed memory allocations into handlings for a smaller number of reservations. In order to achieve efficient reservation, OOM-Guard incorporates a subtle cost analysis algorithm based on static analysis and a proxy allocator. We then apply OOM-Guard to two well-known Rust projects, Bento and rCore. Results show that OOM-Guard can largely reduce developers' efforts for handling OOM and incurs trivial overhead in both memory space and execution time.
- Open Access
- 15 November 2023
- Published by Association for Computing Machinery (ACM)
- p. 3063-3077
Lost along the Way: Understanding and Mitigating Path-Misresolution Threats to Container Isolation
Filesystem isolation enforced by today's container technology has been found to be less effective in the presence of host-container interactions increasingly utilized by container tools. This weakened isolation has led to a type of path misresolution (Pamir) vulnerabilities, which have been considered to be highly risky and continuously reported over the years. In this paper, we present the first systematic study on the Pamir risk and the existing fixes to related vulnerabilities. Our research reveals that in spite of significant efforts being made to patch vulnerable container tools and address the risk, the Pamir vulnerabilities continue to be discovered, including a new vulnerability (CVE-2023-0778) we rediscovered from patched software. A key insight of our study is that the Pamir risk is inherently hard to prevent at the level of container tools, due to their heavy reliance on third-party components. While security inspections should be applied to all components to mediate host-container interactions, third-party component developers tend to believe that container tools should perform security checks before invoking their components, and are therefore reluctant to patch their code with the container-specific protection. Moreover, due to the large number of components today's container tools depend on, re-implementing all of them is impractical. Our study shows that kernel-based filesystem isolation is the only way to ensure isolation always in place during host-container interactions. In our research, we design and implement the first such an approach that extends the filesystem isolation to dentry objects, by enforcing access control on host-container interactions through the filesystem. Our design addresses the fundamental limitation of one-way isolation characterizing today's container, uses carefully-designed policies to ensure accurate and comprehensive interaction control, and implants the protection into the right kernel location to minimize the performance impact. We verify our approach using model checking, which demonstrates its effectiveness in eliminating the Pamir risk. Our evaluation further shows that our approach incurs negligible overheads, vastly outperforming all existing Pamir patches, and maintains compatibility with all mainstream container tools. We have released our code and filed a request to incorporate our technique into the Linux kernel.
- 15 November 2023
- Published by Association for Computing Machinery (ACM)
- p. 3063-3077
Open AccessLost along the Way: Understanding and Mitigating Path-Misresolution Threats to Container Isolation
Filesystem isolation enforced by today's container technology has been found to be less effective in the presence of host-container interactions increasingly utilized by container tools. This weakened isolation has led to a type of path misresolution (Pamir) vulnerabilities, which have been considered to be highly risky and continuously reported over the years. In this paper, we present the first systematic study on the Pamir risk and the existing fixes to related vulnerabilities. Our research reveals that in spite of significant efforts being made to patch vulnerable container tools and address the risk, the Pamir vulnerabilities continue to be discovered, including a new vulnerability (CVE-2023-0778) we rediscovered from patched software. A key insight of our study is that the Pamir risk is inherently hard to prevent at the level of container tools, due to their heavy reliance on third-party components. While security inspections should be applied to all components to mediate host-container interactions, third-party component developers tend to believe that container tools should perform security checks before invoking their components, and are therefore reluctant to patch their code with the container-specific protection. Moreover, due to the large number of components today's container tools depend on, re-implementing all of them is impractical. Our study shows that kernel-based filesystem isolation is the only way to ensure isolation always in place during host-container interactions. In our research, we design and implement the first such an approach that extends the filesystem isolation to dentry objects, by enforcing access control on host-container interactions through the filesystem. Our design addresses the fundamental limitation of one-way isolation characterizing today's container, uses carefully-designed policies to ensure accurate and comprehensive interaction control, and implants the protection into the right kernel location to minimize the performance impact. We verify our approach using model checking, which demonstrates its effectiveness in eliminating the Pamir risk. Our evaluation further shows that our approach incurs negligible overheads, vastly outperforming all existing Pamir patches, and maintains compatibility with all mainstream container tools. We have released our code and filed a request to incorporate our technique into the Linux kernel.