CN111857993A - Method for calling user mode function in kernel mode - Google Patents
Method for calling user mode function in kernel mode Download PDFInfo
- Publication number
- CN111857993A CN111857993A CN202010591531.8A CN202010591531A CN111857993A CN 111857993 A CN111857993 A CN 111857993A CN 202010591531 A CN202010591531 A CN 202010591531A CN 111857993 A CN111857993 A CN 111857993A
- Authority
- CN
- China
- Prior art keywords
- mode
- function
- kernel
- user
- thread
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/485—Task life-cycle, e.g. stopping, restarting, resuming execution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/546—Message passing systems or structures, e.g. queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/548—Queue
Abstract
The invention discloses a method for calling a user mode function in a kernel mode, which comprises the following steps: the call of the kernel mode to the user mode function is converted into the blocking and awakening of the kernel mode thread: and after the called user mode function returns a calling result, the user mode function returning result is sent to the kernel mode through ioctl message communication, and then the blocked kernel mode thread is awakened to complete the whole process of function calling. The invention realizes the calling of the kernel mode to the user mode function, and uses the blocking awakening mode to complete the transparent calling from the kernel mode to the user mode without modifying the logic of the original function.
Description
Technical Field
The invention belongs to the technical field of Linux kernels, and particularly relates to a method for calling a user mode function in a kernel mode.
Background
In a modern operating system, for the stability of the system, two execution environments of a kernel mode and a user mode are realized, the two environments have different execution authorities and different address spaces, a core part of the operating system generally runs in the kernel mode and is used for completing core functions such as task scheduling, memory management, hardware management and the like, most application layer functions run in the user mode, and a user mode thread can be trapped in the kernel mode through special system call to execute a kernel function. And the function in the kernel mode cannot call the function interface in the user mode in return. For some separately designed systems, such as modules running in both kernel mode and user mode, there is a need for mutual invocation between these modules. Existing operating systems are unable to meet this requirement.
Disclosure of Invention
Aiming at the limitation problem in the prior art, the invention provides a method for calling a user mode function by a kernel mode function, which solves the problem that the user mode function needs to be called by the kernel mode under certain conditions. The method is universal in implementation mode, the kernel logic does not need to be modified, and interfaces for realizing calling are standard interfaces of the kernel.
In order to achieve the above object, the present invention provides a method for calling a user mode function in a kernel mode, including:
the call of the kernel mode to the user mode function is converted into the blocking and awakening of the kernel mode thread: and after the called user mode function returns a calling result, the user mode function returning result is sent to the kernel mode through ioctl message communication, and then the blocked kernel mode thread is awakened to complete the whole process of function calling.
In an embodiment of the present invention, the call flow of the kernel mode calling the user mode function specifically includes:
the kernel mode thread writes information of a function to be called, including parameters, a user mode function name and a kernel mode thread id, into a calling queue, blocks the kernel mode thread, wakes up the user mode thread blocked in the kernel mode, reads the calling queue after the user mode thread is woken up, analyzes calling information, executes function calling, writes a return result of the calling function into the calling queue, wakes up the kernel mode thread according to the kernel thread id, reads the return result, fills a data structure of the function, and returns the function to an upper layer caller to continue execution.
In an embodiment of the present invention, the implementing, in the kernel mode, parameter encapsulation for a called user mode function includes:
for each user mode function to be called, a packaging function with the same prototype as the user mode function is realized in the kernel mode, the name of the user mode function is taken as a parameter in the packaging function, the parameter of the packaging function also comprises the parameter transmitted by the upper layer calling function and the id information of the kernel mode thread, and the parameter of the packaging function is stored in a calling queue.
In one embodiment of the invention, the blocking of the kernel-mode thread is realized by calling schedule _ timeout _ interrupt by the kernel-mode encapsulation function.
In an embodiment of the present invention, the ioctl is specifically implemented as follows: creating a file for ioctl in a proc file system in a kernel mode, wherein a thread in a user mode blocks the thread in the user mode by opening the proc file system file and then using a system call ioctl to wait for the call, and an ioctl command word requesting the call is distinguished from a command word of a return value.
In an embodiment of the invention, when the ioctl function checks that the call queue is empty, the user mode thread calls the schedule _ timeout _ noninterruptible function through the kernel mode ioctl to block in the kernel mode, and when the queue content is not checked to be empty, the queue message is read and the user mode analysis message content is returned, and the user mode function is searched and called through the function name.
In one embodiment of the invention, after the called user mode function returns, the user mode thread analyzes the return parameter and the return value, packages the message, packages the kernel mode thread id returned when the request is called, and calls ioctl through the command word of the return value to return to the kernel mode.
In an embodiment of the invention, after the ioctl function in the kernel state receives the execution result returned by the user state function, firstly, a linked list node which is the same as the returned kernel state thread id is searched from the call queue, then, the return result is copied to a return value data structure of the linked list, after the ioctl function is completed, the kernel state thread in the blocking state is awakened through the thread id recorded by the queue, and the user state thread continues to execute the next call request.
In one embodiment of the invention, the awakened kernel mode thread continues to read the linked list return value data structure, analyzes and processes the return value and the return parameter, analyzes the parameter content and the return value, fills the parameter content and the return value into the structure of the upper layer calling function, deletes the linked list node distributed by the thread, releases the memory, finishes the calling process and returns the function.
In one embodiment of the invention, a plurality of user mode threads are allowed to run simultaneously to read a call queue of a kernel mode, the plurality of user mode threads concurrently execute ioctl to trap in the kernel mode to check whether the call queue is empty, when the call queue has a plurality of call requests, the plurality of user mode threads can simultaneously acquire the call requests, when the call queue is read, the rest user mode threads which do not acquire the call requests can block waiting, and the plurality of user mode threads simultaneously read the call queue and need a mutual exclusion lock protection list.
Generally, compared with the prior art, the technical scheme of the invention has the following beneficial effects:
(1) the invention realizes the calling of the user mode function by the kernel mode, uses the blocking awakening mode to complete the transparent calling from the kernel mode to the user mode without modifying the logic of the original function;
(2) the bidirectional interaction between the kernel and the user mode is realized, and the convenience of kernel mode debugging is improved; the requirement of mutual calling of certain applications with separate design of kernel mode and user mode is met;
(3) the kernel development efficiency is improved, the unified deployment of kernel mode and user mode applications is realized, the flexible development of the user mode is met, and the special operation of the kernel mode is also met.
Drawings
FIG. 1 is a schematic diagram illustrating a method for kernel-mode invocation of user-mode functions according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a method for invoking a user-mode function in a kernel mode according to an embodiment of the present invention;
FIG. 3 is a flowchart illustrating a kernel-mode call of a user-mode function according to an embodiment of the present invention;
FIG. 4 is a signal flow diagram illustrating kernel-mode invocation of user-mode functions in an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. In addition, the technical features involved in the embodiments of the present invention described below may be combined with each other as long as they do not conflict with each other.
Example 1
The invention provides a method for calling a user mode function by a kernel mode, which converts the calling of the user mode function by the kernel mode into the blocking and awakening of a kernel mode thread: and after the user mode function returns a calling result, the user mode function returning result is sent to the kernel mode through ioctl message communication, and then the blocked kernel mode thread is awakened to complete the whole process of function calling.
Fig. 1 is a schematic diagram of a principle of a method for invoking a user mode function in a kernel mode in an embodiment of the present invention, which includes two part designs, namely a user mode and a kernel mode, where a function in the kernel mode is a main part, and the user mode part completes the function by invoking an interface implemented in the kernel mode. The kernel mode realizes blocking and awakening of a calling thread, maintenance of a calling queue, analysis of a return value and protection and access mutual exclusion of data.
The calling process is as follows: the kernel mode thread 1 writes information of a function to be called, including parameters, a user mode function name and a kernel mode thread id, into a calling queue, wakes up the user mode thread 1 blocked in the kernel mode, reads the calling queue after the user mode thread 1 is woken up, analyzes the calling information, executes function calling, returns to the kernel mode, writes a return result of the calling function into the calling queue, wakes up the kernel mode thread 1 according to the kernel thread id, reads the calling queue by the kernel thread 1, finds a return result, fills a data structure of the function, and returns to an upper layer caller to continue executing.
The core idea of the technical scheme is that the user mode function call of the kernel mode is converted into the awakening of a user mode thread and the blocking of a kernel caller, the calling consistency is kept through the blocking and the awakening, and the process is transparent and consistent with the common function calling process for the kernel caller; to keep consistency of awakening and blocking, certain setting needs to be made on the attribute of the thread, so that the task cannot be interrupted by various signals; awakening and blocking a queue needing kernel task management, recording the relation between a caller and a user mode awakening thread, and ensuring the consistency of awakening and blocking; in order to ensure the efficiency and the safety of calling, a read-write lock and a multi-queue multi-thread mechanism are used; the call parameters are passed using the form of parameter encapsulation and decapsulation.
Example 2
Fig. 2 is a schematic flow chart of a method for invoking a user-mode function in a kernel mode according to an embodiment of the present invention, and as shown in fig. 2, the method for invoking a user-mode function in a kernel mode according to the present invention includes the following steps:
s1, implementing the encapsulation function of the user mode primitive function in the kernel mode, for each user mode function to be called, firstly implementing an encapsulation function with the same prototype as the user mode function in the kernel mode, taking the name of the user mode function as a parameter in the encapsulation function, wherein the parameter of the encapsulation function also includes the parameter transferred by the upper layer call function, and in order to distinguish the call of different kernel mode threads by the user mode thread, the parameter of the encapsulation function also should be added with the id information of the kernel mode thread, and the parameter of the encapsulation function is stored in the call queue. The call queue is stored in a kernel state in a form of a linked list data structure, the kernel state thread needs to allocate a node of the call queue to store the parameters before the parameters are packaged, and mutual exclusion lock operation is added when the call queue node is added, so that linked list abnormity is avoided. In the scheme, a plurality of kernel mode threads can call the user mode function at the same time, and the calling of each kernel mode thread can store a set of parameter structure of the kernel mode thread.
S2, calling schedule _ timeout _ nonintergent in the encapsulation function of the kernel mode to complete the blocking of the kernel mode thread, and the kernel mode thread keeps the blocking state before the user mode thread returns.
S3, a kernel mode ioctl function is realized, which is a core interface for communication between the user mode thread and the kernel mode thread, and the user mode function obtains the call parameters and returns the result through the ioctl function.
Firstly, a file is required to be created in a proc file system in a kernel mode for ioctl, only the ioctl function of the file needs to be realized, a read function and a write function do not need to be realized, a user mode thread blocks the user mode thread by opening the proc file system file and then using a system call ioctl to wait for calling, and the ioctl command word required to be called is distinguished from the command word of a return value.
When the ioctl function checks that the call queue is empty, the user mode thread calls the schedule _ timeout _ uninterrupted function to block in the kernel mode through the kernel mode ioctl, when the queue content is checked not to be empty, the queue message is read and the message content is returned to the user mode to analyze, and the user mode function is searched and called through the function name. And after the called user mode function returns, the user mode thread analyzes the return parameter and the return value, packages the message, packages the kernel mode thread id returned when the request is called, and calls ioctl through the command word of the return value to return to the kernel mode. The method allows a plurality of user mode threads to run simultaneously to read the call queue of the kernel mode so as to improve the call efficiency. The method comprises the steps that a plurality of user mode threads concurrently execute ioctl to enter a kernel mode, whether a call queue is empty is checked, and when the call queue has a plurality of call requests, the plurality of user mode threads can simultaneously acquire the call requests. When the call queue has been read, the remaining user mode threads that have not acquired the call request may block waiting. The simultaneous reading of the call queue by multiple user mode threads requires a mutually exclusive lock protection list.
S4, after the ioctl function in kernel mode receives the execution result returned by the user mode function, firstly searching the linked list node which is the same as the returned kernel mode thread id from the call queue, then copying the return result to the return value data structure of the linked list, after the ioctl function is completed, waking up the kernel mode thread in the blocking state through the thread id recorded by the queue, after the ioctl function is completed, returning the ioctl function to user mode, and the user mode thread continues to execute the next call request.
S5, the awakened kernel mode thread continues to read the linked list return value data structure, analyzes and processes the return value and the return parameter, analyzes the parameter content and the return value, fills the parameter content and the return value into the upper layer calling structure, deletes the linked list node distributed by the kernel mode thread, releases the memory, and then returns to the upper layer calling process.
The core processing of kernel mode calling is realized by steps S2 and S4, the core idea is that the function calling is converted into blocking and awakening of a caller, so that the kernel caller can call the user mode function without perception, the transparency of function calling is realized, the whole process has two ioctl processes from the user mode to the kernel mode, and the calling parameters are read and the execution result is returned respectively.
The thread blocking in steps S2 and S3 must use an uninterrupable mode, and cannot use the interrupt, so as to ensure that the kernel-mode thread and the user-mode thread cannot be interrupted by any signal. The occurrence of uncertain invocation parameters is prevented.
Example 3
The following is a specific example illustrating the implementation of the present invention, as shown in fig. 3 and 4, in which: the kernel-mode thread kprocB calls a user-mode function funA, the user-mode function funA is realized in a user-mode thread procA, the procA function prototype in the user-mode thread is int procA (int arg), and the implementation process comprises the following steps:
s11, an encapsulation function kfun of the user mode function funA is realized in the kernel mode (the function is an encapsulation function, and the prototype is the same as the user mode thread procA), and the internal realization of the encapsulation function kfun is to put the function names of the parameters arg and procA and the thread id of kprocB into a data structure;
s12, the kernel mode thread kprocB calls a kernel mode packaging function kfuan to complete the parameter packaging of the step 1, after the parameter packaging is completed by the kfunc, the parameter data structure is added into a calling queue (the calling queue is a global queue of a linked list structure), and the kernel mode thread kprocB is set to be in a blocking state TASK _ UNINTERRUPTIBLE. The parameters stored by each node in the call queue include: the function name of the user mode function funA, the arg parameter value, the id of the kernel mode thread kprocB and a return value space;
S13, the user mode thread procA accesses the kernel mode through ioctl, reads the call queue in the step S12, analyzes parameters of nodes in the call queue, finds out the user mode function identification and parameters to be called, in this example, finds out the function name and arg parameters of the user mode function funA, calls funA, and after execution is finished, returns the execution result to the kernel mode ioctl through the ioctl function.
In addition, as shown in the figure, the thread procA and the thread procA are user mode threads of two different called functions, and the method can allow a plurality of user mode threads to run simultaneously to read the kernel mode call queue so as to improve the call efficiency.
S14, after the kernel mode ioctl receives the execution result returned by the user mode thread procA, firstly, the node corresponding to the call queue is found according to the returned kernel mode thread id (the returned kernel mode thread id is consistent with the thread id of the linked list node), then the returned parameter is added into the return value structure of the linked list node, and the kernel thread is awakened. In this example, the return value of the procA function is added to the linked list node, and the kernel-mode thread kprocB is then awakened.
S15, after the kernel mode thread kprocB is awakened, the packaging function kfonnA continues to execute and analyzes the return value structure of the calling queue node, finds the return value and the return parameter, deletes the chain table node, and then sends the returned execution result to the upper layer calling function calling the kernel mode thread kprocB.
It will be understood by those skilled in the art that the foregoing is only a preferred embodiment of the present invention, and is not intended to limit the invention, and that any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (10)
1. A method for calling a user mode function in a kernel mode is characterized by comprising the following steps:
the call of the kernel mode to the user mode function is converted into the blocking and awakening of the kernel mode thread: and after the called user mode function returns a calling result, the user mode function returning result is sent to the kernel mode through ioctl message communication, and then the blocked kernel mode thread is awakened to complete the whole process of function calling.
2. The method for kernel mode call of user mode function according to claim 1, wherein the call flow for kernel mode call of user mode function is specifically:
the kernel mode thread writes information of a function to be called, including parameters, a user mode function name and a kernel mode thread id, into a calling queue, blocks the kernel mode thread, wakes up the user mode thread blocked in the kernel mode, reads the calling queue after the user mode thread is woken up, analyzes calling information, executes function calling, writes a return result of the calling function into the calling queue, wakes up the kernel mode thread according to the kernel thread id, reads the return result, fills a data structure of the function, and returns the function to an upper layer caller to continue execution.
3. The method for kernel-mode calling of user-mode functions according to claim 1 or 2, wherein the parameter encapsulation of the called user-mode functions is implemented in the kernel mode, and comprises:
for each user mode function to be called, a packaging function with the same prototype as the user mode function is realized in the kernel mode, the name of the user mode function is taken as a parameter in the packaging function, the parameter of the packaging function also comprises the parameter transmitted by the upper layer calling function and the id information of the kernel mode thread, and the parameter of the packaging function is stored in a calling queue.
4. The method for kernel-mode call of user-mode function according to claim 1 or 2, wherein blocking of kernel-mode thread is achieved by kernel-mode wrapper function call schedule _ timeout _ interrupt.
5. A method for kernel-mode invocation of user-mode functions according to claim 1 or 2, characterized in that ioctl is implemented specifically as: creating a file for ioctl in a proc file system in a kernel mode, wherein a thread in a user mode blocks the thread in the user mode by opening the proc file system file and then using a system call ioctl to wait for the call, and an ioctl command word requesting the call is distinguished from a command word of a return value.
6. The method for kernel mode call of user mode function as claimed in claim 2 wherein when the ioctl function checks that the call queue is empty, the user mode thread blocks the kernel mode by the kernel mode ioctl call of schedule _ timeout _ uninterruptible function, when checking that the queue content is not empty, the queue message is read and returned to the user mode parsing message content, and the user mode function is searched and called by function name.
7. The method for calling the user mode function by the kernel mode according to claim 1 or 2, characterized in that after the called user mode function returns, the user mode thread analyzes the return parameter and the return value, packages the message, packages the kernel mode thread id returned when the request is called, and calls ioctl through the command word of the return value to return to the kernel mode.
8. The method for invoking the user mode function by the kernel mode according to claim 7, wherein after the ioctl function of the kernel mode receives the execution result returned by the user mode function, firstly, the linked list node which is the same as the returned kernel mode thread id is searched from the invocation queue, then the return result is copied to the return value data structure of the linked list, after the completion, the ioctl function wakes up the kernel mode thread in the blocking state through the thread id recorded by the queue, and the user mode thread continues to execute the next invocation request.
9. The method for kernel mode call of user mode function as claimed in claim 8, wherein the awakened kernel mode thread continues to read the linked list return value data structure, analyzes and processes the return value and the return parameter, analyzes the parameter content and the return value, fills the parameter content and the return value into the structure of the upper layer call function, deletes the linked list node allocated by itself, releases the memory, ends the call process, and returns the function.
10. The method for kernel-mode call of user-mode functions as claimed in claim 6, wherein the call queue of kernel-mode is allowed to be read by running multiple user-mode threads simultaneously, the multiple user-mode threads concurrently execute ioctl to trap into kernel-mode to check whether the call queue is empty, when there are multiple call requests in the call queue, the multiple user-mode threads can simultaneously obtain the call requests, when the call queue has been read, the remaining user-mode threads that have not obtained the call requests will block waiting, and the multiple user-mode threads simultaneously read the call queue and need the mutually exclusive lock protection list.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010591531.8A CN111857993B (en) | 2020-06-24 | 2020-06-24 | Method for calling user mode function in kernel mode |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010591531.8A CN111857993B (en) | 2020-06-24 | 2020-06-24 | Method for calling user mode function in kernel mode |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111857993A true CN111857993A (en) | 2020-10-30 |
| CN111857993B CN111857993B (en) | 2022-07-08 |
Family
ID=72988121
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010591531.8A Active CN111857993B (en) | 2020-06-24 | 2020-06-24 | Method for calling user mode function in kernel mode |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111857993B (en) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112346390A (en) * | 2020-11-24 | 2021-02-09 | 杭州迪普信息技术有限公司 | Optical module control method, device, equipment and computer readable storage medium |
| CN112463662A (en) * | 2020-12-16 | 2021-03-09 | 福州创实讯联信息技术有限公司 | Method and terminal for controlling I2C equipment by user mode |
| CN112835836A (en) * | 2021-01-29 | 2021-05-25 | 郑州信大捷安信息技术股份有限公司 | Method and device for information interaction between host and smart card |
| WO2022206226A1 (en) * | 2021-03-30 | 2022-10-06 | 阿里巴巴（中国）有限公司 | Interface processing method and apparatus |
| CN115460470A (en) * | 2022-08-19 | 2022-12-09 | 武汉烽火技术服务有限公司 | Multicast data forwarding method, device, equipment and readable storage medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102541984A (en) * | 2011-10-25 | 2012-07-04 | 曙光信息产业(北京)有限公司 | File system of distributed type file system client side |
| CN107577539A (en) * | 2016-07-05 | 2018-01-12 | 阿里巴巴集团控股有限公司 | The shared drive structure communicated for kernel state and User space and its application |
| CN108427640A (en) * | 2018-01-25 | 2018-08-21 | 南京翼辉信息技术有限公司 | A method of debugging driver under User space |
| US20180239657A1 (en) * | 2017-02-21 | 2018-08-23 | Crowdstrike, Inc. | Symmetric bridge component for communications between kernel mode and user mode |
| US20190294537A1 (en) * | 2018-03-21 | 2019-09-26 | Microsoft Technology Licensing, Llc | Testing kernel mode computer code by executing the computer code in user mode |
| CN110532106A (en) * | 2019-07-16 | 2019-12-03 | 华为技术有限公司 | The means of communication, device, equipment and storage medium between process |
-
2020
- 2020-06-24 CN CN202010591531.8A patent/CN111857993B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102541984A (en) * | 2011-10-25 | 2012-07-04 | 曙光信息产业(北京)有限公司 | File system of distributed type file system client side |
| CN107577539A (en) * | 2016-07-05 | 2018-01-12 | 阿里巴巴集团控股有限公司 | The shared drive structure communicated for kernel state and User space and its application |
| US20180239657A1 (en) * | 2017-02-21 | 2018-08-23 | Crowdstrike, Inc. | Symmetric bridge component for communications between kernel mode and user mode |
| CN108427640A (en) * | 2018-01-25 | 2018-08-21 | 南京翼辉信息技术有限公司 | A method of debugging driver under User space |
| US20190294537A1 (en) * | 2018-03-21 | 2019-09-26 | Microsoft Technology Licensing, Llc | Testing kernel mode computer code by executing the computer code in user mode |
| CN110532106A (en) * | 2019-07-16 | 2019-12-03 | 华为技术有限公司 | The means of communication, device, equipment and storage medium between process |
Non-Patent Citations (1)
| Title |
|---|
| LITWORLD: "内核态调用用户态函数的方法", 《HTTPS://BLOG.CSDN.NET/LITWORLD/ARTICLE/DETAILS/8927964》 * |
Cited By (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112346390A (en) * | 2020-11-24 | 2021-02-09 | 杭州迪普信息技术有限公司 | Optical module control method, device, equipment and computer readable storage medium |
| CN112463662A (en) * | 2020-12-16 | 2021-03-09 | 福州创实讯联信息技术有限公司 | Method and terminal for controlling I2C equipment by user mode |
| CN112463662B (en) * | 2020-12-16 | 2024-04-05 | 福州创实讯联信息技术有限公司 | Method and terminal for user mode control of I2C equipment |
| CN112835836A (en) * | 2021-01-29 | 2021-05-25 | 郑州信大捷安信息技术股份有限公司 | Method and device for information interaction between host and smart card |
| CN112835836B (en) * | 2021-01-29 | 2022-04-08 | 郑州信大捷安信息技术股份有限公司 | Method and device for information interaction between host and smart card |
| WO2022206226A1 (en) * | 2021-03-30 | 2022-10-06 | 阿里巴巴（中国）有限公司 | Interface processing method and apparatus |
| CN115460470A (en) * | 2022-08-19 | 2022-12-09 | 武汉烽火技术服务有限公司 | Multicast data forwarding method, device, equipment and readable storage medium |
| CN115460470B (en) * | 2022-08-19 | 2024-03-26 | 烽火通信科技股份有限公司 | Multicast data forwarding method, device, equipment and readable storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111857993B (en) | 2022-07-08 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111857993B (en) | Method for calling user mode function in kernel mode | |
| EP0945797B1 (en) | Method and apparatus for object-oriented interrupt system | |
| EP0767938B1 (en) | Method for enforcing a hierarchical invocation structure in real time asynchronous software applications | |
| US20020046230A1 (en) | Method for scheduling thread execution on a limited number of operating system threads | |
| US6732138B1 (en) | Method and system for accessing system resources of a data processing system utilizing a kernel-only thread within a user process | |
| US5129084A (en) | Object container transfer system and method in an object based computer operating system | |
| JP2003186746A (en) | Hardware execution control method of access to memory in computer using hardware execution semaphore and other similar hardware execution serializing and prioritizing mechanisms | |
| JPH0687222B2 (en) | Intercommunication system and method between application and database management system | |
| US9378069B2 (en) | Lock spin wait operation for multi-threaded applications in a multi-core computing environment | |
| JPH0816412A (en) | Microkernel-architecture data processing system | |
| US20200409841A1 (en) | Multi-threaded pause-less replicating garbage collection | |
| FR2816730A1 (en) | Method of securing deterministic real time execution of multitask applications by calculating function of acquired parameter and comparing to set threshold value | |
| US8943516B2 (en) | Mechanism for optimized intra-die inter-nodelet messaging communication | |
| CN107729050B (en) | Real-time system based on LET programming model and task construction method | |
| CN115658277B (en) | Task scheduling method and device, electronic equipment and storage medium | |
| WO2023011249A1 (en) | I/o multiplexing method, medium, device and operation system | |
| CN113946445A (en) | Multithreading module based on ASIC and multithreading control method | |
| JPH1021094A (en) | Real-time control system | |
| WO2021120693A1 (en) | Kbroker distributed operating system with new and old codes running together | |
| CN108958903B (en) | Embedded multi-core central processor task scheduling method and device | |
| JP7346649B2 (en) | Synchronous control system and method | |
| US8510757B2 (en) | Gathering pages allocated to an application to include in checkpoint information | |
| US7043565B1 (en) | System and method for transferring data over an external transmission medium | |
| CN113961364A (en) | Large-scale lock system implementation method and device, storage medium and server | |
| Itoh et al. | Concurrent object-oriented device driver programming in apertos operating system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |