User Kernel Space Communication via Shared Memory FIFO
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional programming environments for data storage devices are often static, non-expandable, and lack a common interface for integrating software components, making it difficult to develop component-oriented software and adding functionality to storage devices with different operating systems.
Innovation Solution
A scalable, common software environment that provides a unified architecture for integrated management of network attached storage (NAS) and object and storage block services, using APIs to insulate code from platform dependencies and enable execution in both user and kernel modes, facilitating inter-module communication through shared memory and system calls.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If conventional programming environments are used for data storage devices, then the system structure is simple, but the environment becomes static and non-expandable, lacking a common interface for integrating software components
Solution Approach 1:
The programming environment is segmented into distinct layers: a common software environment layer that provides platform-independent interfaces, and underlying platform-specific layers. This segmentation allows software components to be developed and integrated at the common layer without being tied to specific storage device platforms, thereby improving adaptability while managing complexity through clear architectural boundaries.
Solution Approach 2:
A common software environment acts as an intermediary layer between the host system and storage device-specific code. This intermediary provides standardized interfaces and abstraction mechanisms that enable software components to communicate uniformly across different platforms, enhancing versatility without requiring direct integration with each platform's proprietary interfaces.
2Adaptability or versatility
If additional functionality is added to storage devices with different operating systems, then the system becomes more versatile, but the difficulty of integrating software components increases
Solution Approach 1:
The common software environment implements universal interfaces and data structures that can accommodate multiple functionalities across different operating systems. By designing the architecture to be platform-agnostic at the common layer, new features can be added and integrated uniformly, making software development easier despite the diversity of underlying platforms and the need for expanded functionality.
3Adaptability or versatility
If code modules execute in both user space and kernel space, then the system becomes more flexible, but the complexity of inter-module communication increases
Solution Approach 1:
The common software environment serves as an intermediary communication layer between code modules executing in user space and those in kernel space. It provides standardized interfaces and communication protocols that abstract the complexity of cross-space interaction, allowing modules to communicate flexibly without directly managing the complexities of user-kernel transitions.
Solution Approach 2:
The architecture introduces an additional dimensional layer (the common software environment) between user space and kernel space. This intermediate dimension provides a unified interface layer that simplifies communication between modules across the user-kernel boundary, transforming a complex two-space interaction into a more manageable three-layer structure.
4Reliability
If a common software environment with unified architecture is implemented, then scalability and reliability are enhanced, but the device complexity increases
Solution Approach 1:
The software architecture is segmented into distinct functional layers with well-defined interfaces. The common software environment is separated from platform-specific code, and further segmented into modules handling different concerns (interface management, data processing, communication). This segmentation enhances reliability by isolating faults to specific modules while managing complexity through clear architectural boundaries and reduced coupling between components.
Data Source
AI summary
Described are techniques for intermodule communication between a first code module and a second code module wherein one of the first and second code modules executing in user space and the other of the first and second code modules executing in kernel space. A shared memory portion includes storage for one or more commands. A first first-in-first-out (FIFO) structure is used to send a location in the shared memory portion from the first to the second code module. A second FIFO structure is used for sending a location in the shared memory portion from the second to the first code module. The first code module stores command data for a command at a first location in the shared memory portion. A command is issued from the first to the second code module by sending the first location using the first FIFO structure.