CN116560805A - File system calling method and device, storage medium and processor - Google Patents

File system calling method and device, storage medium and processor Download PDF

Info

Publication number
CN116560805A
CN116560805A CN202310357520.7A CN202310357520A CN116560805A CN 116560805 A CN116560805 A CN 116560805A CN 202310357520 A CN202310357520 A CN 202310357520A CN 116560805 A CN116560805 A CN 116560805A
Authority
CN
China
Prior art keywords
file system
thread
calling
instruction message
application
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.)
Pending
Application number
CN202310357520.7A
Other languages
Chinese (zh)
Inventor
王志强
杜君
白雪松
白鹏飞
樊琳
易玲
梁昭庆
付利莉
王宪刚
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
State Grid Corp of China SGCC
Beijing Smartchip Microelectronics Technology Co Ltd
Beijing Smartchip Semiconductor Technology Co Ltd
Original Assignee
State Grid Corp of China SGCC
Beijing Smartchip Microelectronics Technology Co Ltd
Beijing Smartchip Semiconductor Technology Co Ltd
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by State Grid Corp of China SGCC, Beijing Smartchip Microelectronics Technology Co Ltd, Beijing Smartchip Semiconductor Technology Co Ltd filed Critical State Grid Corp of China SGCC
Priority to CN202310357520.7A priority Critical patent/CN116560805A/en
Publication of CN116560805A publication Critical patent/CN116560805A/en
Pending legal-status Critical Current

Links

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/465—Distributed object oriented systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/10—File systems; File servers
    • G06F16/18—File system types
    • G06F16/1865—Transactional file systems
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Abstract

The embodiment of the invention provides a file system calling method, a file system calling device, a storage medium and a processor, and belongs to the technical field of computers. The method for calling the file system is executed by a file system thread, and comprises the following steps: receiving an instruction message, wherein the instruction message is generated and sent by an application thread when file system operation is required; and calling a file system according to the instruction message. The file system is called through the message forwarding mechanism, so that consumption of an application thread stack of an operating system is saved, the application thread does not occupy larger thread stack resources, when the file system is required to be operated, only instruction information of file system operation is required to be sent to the file system thread, the use cost of the application thread stack is greatly reduced, the phenomenon of dead halt caused by insufficient use of the thread stack can be effectively avoided, meanwhile, the utilization rate of the thread stack of the application thread is improved, and the overall performance of the system is improved.

Description

File system calling method and device, storage medium and processor
Technical Field
The present invention relates to the field of computer technology, and in particular, to a method for calling a file system, a device for calling a file system, a machine-readable storage medium, and a processor.
Background
A File System (FS) is a method and data structure used by an operating System to clarify files on a storage device or partition, i.e., a software mechanism that organizes, manages, and stores File information on a storage device; the method is mainly responsible for organizing and distributing the space of the file storage device, storing the file, protecting and searching the stored file and the like.
Currently, an application thread stack of an operating system is set in advance, and then the application thread directly uses an interface of a file system to operate the file system. In order to ensure that the application thread stack does not have a dead halt phenomenon, the application thread stack is often set to be large enough, however, when the current application thread performs an operation, other non-file application operations may be included, the other non-file application operations are simpler, only a small amount of thread stack resources are occupied when the current application thread performs the operation, and only a large thread stack resource support is needed when the file system operation is performed, so that the application thread is in an idle state when the current application thread performs other non-file operations, and the thread stack utilization rate of the current application thread is greatly reduced.
Therefore, in the prior art, the problem of excessive consumption of a thread stack exists in the operation of an application thread on a file system by directly using an interface of the file system.
Disclosure of Invention
An object of an embodiment of the present invention is to provide a method for calling a file system, a device for calling a file system, a machine-readable storage medium, and a processor. The calling method of the file system can reduce the consumption of the application thread stack and improve the utilization rate of the application thread stack.
In order to achieve the above object, a first aspect of the present application provides a method for invoking a file system, performed by a thread of the file system, the method comprising:
receiving an instruction message, wherein the instruction message is generated and sent by an application thread when file system operation is required;
and calling a file system according to the instruction message.
In an embodiment of the present application, the instruction message includes a message type;
the calling the file system according to the instruction message comprises the following steps:
and calling a file system interface according to the message type, and executing corresponding file system operation.
In an embodiment of the present application, the instruction message is an operation instruction for a file that can be received and identified by the file system thread.
In this embodiment of the present application, the step of generating the instruction message is performed by the application thread, and includes:
judging whether the operation information is file system operation or not;
determining the operation information as file system operation, and generating a corresponding instruction message.
In an embodiment of the present application, further includes:
determining the operation information as non-file application operation, calling a corresponding file system interface, and executing a corresponding execution action.
In an embodiment of the present application, before the execution by the file system thread, the method includes:
creating a file system thread and setting a thread stack for the file system thread.
In an embodiment of the present application, the file system thread is created at an application layer.
In an embodiment of the present application, the calling a file system according to the instruction message includes:
detecting whether an instruction message from an application thread exists or not;
and when the instruction message from the application thread is detected, calling a file system according to the instruction message.
A second aspect of the present application provides a file system calling device, for a file system thread, including:
the receiving module is used for receiving instruction information, wherein the instruction information is generated and sent by an application thread when file system operation is required;
and the calling module is used for calling the file system according to the instruction message.
In an embodiment of the present application, the instruction message includes a message type;
the calling module comprises:
and the message type unit is used for calling the file system interface according to the message type and executing corresponding file system operation.
In an embodiment of the present application, for an application thread, the method includes:
the judging module is used for judging whether the operation information is file system operation or not;
the generating module is used for determining that the operation information is file system operation and generating a corresponding instruction message.
In an embodiment of the present application, further includes:
and the execution module is used for determining that the operation information is non-file application operation, calling a corresponding file system interface and executing a corresponding execution action.
In an embodiment of the present application, the calling module includes:
the detection unit is used for detecting whether the instruction message from the application thread exists or not all the time;
and the file system calling unit is used for calling the file system according to the instruction message when the instruction message from the application thread is detected.
A third aspect of the present application provides a processor configured to perform the above-described method of invoking a file system.
A fourth aspect of the present application provides a machine-readable storage medium having stored thereon instructions that, when executed by a processor, cause the processor to be configured to perform the above-described file system invocation method.
According to the technical scheme, file operation is supported through the pre-created file system thread, when a file system is needed to be used by different application threads, the file system thread only needs to send instruction information to the file system thread, the file system thread calls the file system according to the instruction information, and subsequent file system operation is executed, so that the file system is called through a message forwarding mechanism, consumption of an application thread stack of an operating system is saved, the application thread does not need to occupy larger thread stack resources, when the file system is needed to be operated, only instruction information of one file system operation needs to be sent to the file system thread, the use cost of the application thread stack is greatly reduced, the phenomenon of dead halt caused when the thread stack is not used enough can be effectively avoided, meanwhile, the use rate of the thread stack of the application thread is improved, and the overall performance of the system is improved.
Additional features and advantages of embodiments of the invention will be set forth in the detailed description which follows.
Drawings
The accompanying drawings are included to provide a further understanding of embodiments of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain, without limitation, the embodiments of the invention. In the drawings:
FIG. 1 schematically illustrates a flow diagram of a method of invoking a file system according to an embodiment of the present application;
FIG. 2 schematically illustrates a flow diagram of a littlefs thread and an application thread using a littlefs message forwarding mechanism according to an embodiment of the present application;
FIG. 3 schematically illustrates a flow chart for sending a specific instruction message using the littlefs file system message forwarding mechanism according to an embodiment of the present application;
FIG. 4 schematically illustrates a block diagram of a file system calling device according to an embodiment of the present application;
fig. 5 schematically shows an internal structural diagram of a computer device according to an embodiment of the present application.
Description of the reference numerals
410 a receiving module; 420-calling a module; a01-a processor; a02-a network interface; a03-an internal memory; a04-a display screen; a05-an input device; a06—a nonvolatile storage medium; b01-operating system; b02-computer program.
Detailed Description
The following describes the detailed implementation of the embodiments of the present invention with reference to the drawings. It should be understood that the detailed description and specific examples, while indicating and illustrating the invention, are not intended to limit the invention.
Referring to fig. 1, fig. 1 schematically shows a flowchart of a method for calling a file system according to an embodiment of the present application. The method for calling the file system can be applied to various operating systems comprising the file system, for example: the embedded operating system is used for managing and storing the file information of the equipment, and different equipment can select different file systems for transplanting according to the own resource and function requirements. The calling method of the file system reduces the overhead of the thread stack of the operating system through a message forwarding mechanism, improves the utilization rate of the thread stack, and further improves the overall performance of the system.
The embodiment provides a file system calling method, which is executed by a file system thread, and comprises the following steps:
step 210: receiving an instruction message, wherein the instruction message is generated and sent by an application thread when file system operation is required;
step 220: and calling a file system according to the instruction message.
In this embodiment, the file system is called by the file system thread according to an instruction message from the application thread, where the instruction message is generated and sent by the application thread when the file system operation is required. The file system thread is used for supporting the operation of the file system, and the application thread can be any other application thread, and the file system thread can always detect and receive instruction messages sent by the application thread.
In some embodiments, the file system thread may be created at the application layer.
In some embodiments, the instruction message is receivable and identifiable by a file system thread, the instruction message including instructions for a file operation, such as: unloading a file system, formatting the file system, obtaining a file system state, removing a file, obtaining a file state, modifying a file name, obtaining a file descriptor state, opening a file, closing a file, controlling a file, reading file content, writing data to a file, refreshing a buffer to a disk, repositioning the displacement of the opened file, obtaining a directory entry, polling to read a file descriptor, and the like. The instruction message may be generated when the application thread needs to perform a file system operation.
In some embodiments, in order to obtain an accurate instruction message, the operation information of an application thread may be judged, and the instruction message is executed by the application thread, where the step of generating the instruction message includes the following procedures:
firstly, judging whether the operation information is file system operation or not;
then, in the case that the operation information is determined to be a file system operation, a corresponding instruction message is generated.
In this embodiment, the process of determining the operation information of the application thread may be executed in each application thread, and the operation information may be file system operation or other application operations. If the operation information is file system operation, a large thread stack resource support is needed, a corresponding instruction message is generated and sent to the file system thread. For example, if the file system operation is to unload the file system, an instruction message to unload the file system is sent to the file system thread.
Correspondingly, if the operation information is determined to be the non-file application operation, the operation is simpler, only a small amount of thread stack resources are occupied during execution, the file system interface can be directly called, and corresponding execution actions are executed to perform file system operation.
In the implementation process, the operation information is judged, and the corresponding instruction message is generated under the condition that the operation information is file system operation, so that the accurate instruction message can be obtained, and the file system can be called more accurately.
For example: referring to fig. 2, a smart meter manages and stores file information using a small Flash file system (littlefs) subject to storage resource limitations and performance requirements. A file system thread is created in advance and can be named as a littlefs thread, when the intelligent ammeter operating system application thread needs to operate a file system, whether operation information is file system operation or not can be judged, if yes, a corresponding instruction message is generated and sent to the littlefs thread.
Wherein the instruction message includes a message type; the file system is called according to the instruction message, which comprises the following steps: and calling a file system interface according to the message type, and executing corresponding file system operation.
In some embodiments, the file system thread always detects and receives instruction messages sent by other application threads, and if the instruction messages are detected, the file system thread judges the message type, and further invokes the file system interface to perform corresponding operations. After judging the message type, the file system thread executes subsequent file system operation, so that the application thread does not need to occupy larger thread stack resources.
For example: referring to fig. 2 and 3, the littlefs thread always detects and receives instruction messages sent by other threads, and if the instruction messages are detected, the type of the messages is judged in the threads, so as to call the file system interface to perform corresponding operations (as shown in fig. 2 (a)). By adopting the file system calling method provided by the embodiment, when the application thread of the intelligent ammeter operating system needs to operate the file system, only an instruction message of file system operation needs to be sent (as shown in fig. 2 (b)). Such as: a specific instruction message is sent using the littlefs file system message forwarding mechanism: the file system message is mounted, and the intelligent ammeter operating system application thread (fig. 3 (a)) is responsible for sending the message, namely sending the instruction message of the file system operation; the littlefs thread (fig. 3 (b)) is responsible for receiving messages and performing the corresponding littlefs file system operations of the messages, i.e., receiving instruction messages and performing mount file system operations.
In the implementation process, file operation is supported through the pre-created file system thread, when a file system is needed to be used by different application threads, the file system thread only needs to send instruction information to the file system thread, the file system thread calls the file system according to the instruction information, and executes subsequent file system operation, so that the file system is called through a message forwarding mechanism, consumption of an application thread stack of an operating system is saved, the application thread does not need to occupy larger thread stack resources, when the file system is needed to be operated, only instruction information of one file system operation needs to be sent to the file system thread, the use cost of the application thread stack is greatly reduced, the phenomenon of dead halt caused by insufficient use of the thread stack can be effectively avoided, the use rate of the thread stack of the application thread is improved, and the overall performance of the system is improved.
Wherein prior to said execution by the file system thread, comprises: creating a file system thread and setting a thread stack for the file system thread. In this embodiment, since the file system operation is a single file system operation, a suitable thread stack may be set so that the file system thread stack is optimally used.
FIG. 1 is a flow diagram of a method of invoking a file system in one embodiment. It should be understood that, although the steps in the flowchart of fig. 1 are shown in sequence as indicated by the arrows, the steps are not necessarily performed in sequence as indicated by the arrows. The steps are not strictly limited to the order of execution unless explicitly recited herein, and the steps may be executed in other orders. Moreover, at least some of the steps in fig. 1 may include multiple sub-steps or stages that are not necessarily performed at the same time, but may be performed at different times, nor do the order in which the sub-steps or stages are performed necessarily performed in sequence, but may be performed alternately or alternately with at least a portion of other steps or sub-steps of other steps.
The present embodiment provides a device for calling a file system, please refer to fig. 4, for a file system thread, including a receiving module 410 and a calling module 420, wherein:
a receiving module 410, configured to receive an instruction message, where the instruction message is generated and sent by an application thread when a file system operation is required;
and the calling module 420 is used for calling the file system according to the instruction message.
In the implementation process, file operation is supported through the pre-created file system thread, when a file system is needed to be used by different application threads, only instruction information needs to be sent to the file system thread, after the receiving module 410 in the file system thread receives the instruction information, the file system is called by the calling module 420 according to the instruction information to execute subsequent file system operation, so that the file system is called through a message forwarding mechanism, the consumption of an application thread stack of an operating system is saved, the application thread does not occupy larger thread stack resources, when the file system needs to be operated, only instruction information of one file system operation needs to be sent to the file system thread, the use cost of the application thread stack is greatly reduced, the dead phenomenon caused when the thread stack is not used enough can be effectively avoided, the use rate of the thread stack of the application thread is improved, and the overall performance of the system is improved.
Wherein the instruction message includes a message type;
the calling module 420 includes:
and the message type unit is used for calling the file system interface according to the message type and executing corresponding file system operation.
In some embodiments, in order to obtain an accurate instruction message, the determining may be performed on operation information of an application thread, where the determining module is configured to determine that the application thread includes:
the judging module is used for judging whether the operation information is file system operation or not;
the generating module is used for determining that the operation information is file system operation and generating a corresponding instruction message.
Wherein, still include:
and the execution module is used for determining that the operation information is non-file application operation, calling a corresponding file system interface and executing a corresponding execution action.
In the implementation process, the judging module is used for judging the operation information, and the generating module is used for generating the corresponding instruction message under the condition that the operation information is file system operation, so that the accurate instruction message can be obtained, and the file system can be conveniently and accurately called.
Wherein the calling module 420 includes:
the detection unit is used for detecting whether the instruction message from the application thread exists or not all the time;
and the file system calling unit is used for calling the file system according to the instruction message when the instruction message from the application thread is detected.
In the implementation process, the detection unit always detects whether the instruction message from the application thread exists; when detecting that the instruction message from the application thread exists, the file system calling unit calls the file system to execute subsequent file system operation according to the instruction message, so that the file system can be ensured to be called in time.
The calling device of the file system comprises a processor and a memory, the receiving module 410, the calling module 420 and the like are all stored in the memory as program units, and the processor executes the program modules stored in the memory to realize corresponding functions.
The processor includes a kernel, and the kernel fetches the corresponding program unit from the memory. The kernel can be provided with one or more than one, the consumption of the application thread stack is reduced by adjusting the kernel parameters, and the utilization rate of the thread stack of the application thread is improved.
The memory may include volatile memory, random Access Memory (RAM), and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM), among other forms in computer readable media, the memory including at least one memory chip.
Embodiments of the present invention provide a machine-readable storage medium having stored thereon a program which, when executed by a processor, implements a method of invoking a file system as described herein.
The embodiment of the invention provides a processor which is used for running a program, wherein the program runs to execute a calling method of a file system.
In one embodiment, a computer device is provided, which may be a terminal, and the internal structure of which may be as shown in fig. 5. The computer apparatus includes a processor a01, a network interface a02, a display screen a04, an input device a05, and a memory (not shown in the figure) which are connected through a system bus. Wherein the processor a01 of the computer device is adapted to provide computing and control capabilities. The memory of the computer device includes an internal memory a03 and a nonvolatile storage medium a06. The nonvolatile storage medium a06 stores an operating system B01 and a computer program B02. The internal memory a03 provides an environment for the operation of the operating system B01 and the computer program B02 in the nonvolatile storage medium a06. The network interface a02 of the computer device is used for communication with an external terminal through a network connection. The computer program, when executed by the processor a01, implements a method for invoking a file system. The display screen a04 of the computer device may be a liquid crystal display screen or an electronic ink display screen, and the input device a05 of the computer device may be a touch layer covered on the display screen, or may be a key, a track ball or a touch pad arranged on a casing of the computer device, or may be an external keyboard, a touch pad or a mouse.
It will be appreciated by those skilled in the art that the structure shown in fig. 5 is merely a block diagram of some of the structures associated with the present application and is not limiting of the computer device to which the present application may be applied, and that a particular computer device may include more or fewer components than shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, the file system calling device provided in the present application may be implemented as a computer program, which may be executed on a computer device as shown in fig. 5. The memory of the computer device may store various program modules that make up the calling means of the file system, such as the receiving module 410 and the calling module 420 shown in fig. 4. The computer program constituted by the respective program modules causes the processor to execute the steps in the calling method of the file system of the respective embodiments of the present application described in the present specification.
The computer device shown in fig. 5 may perform step 210 through the receiving module 410 in the calling device of the file system shown in fig. 4. The computer device may perform step 220 by invoking module 420.
The embodiment of the application provides equipment, which comprises a processor, a memory and a program stored on the memory and capable of running on the processor, wherein the processor executes the program to realize the following steps:
executed by a file system thread, the method comprising:
receiving an instruction message, wherein the instruction message is generated and sent by an application thread when file system operation is required;
and calling a file system according to the instruction message.
In one embodiment, the instruction message includes a message type;
the file system is called according to the instruction message, which comprises the following steps:
and calling a file system interface according to the message type, and executing corresponding file system operation.
In one embodiment, the instruction message is an operation instruction on a file that is receivable and identifiable by the file system thread.
In one embodiment, the generating of the instruction message is performed by the application thread, and the generating of the instruction message includes:
judging whether the operation information is file system operation or not;
determining the operation information as file system operation, and generating a corresponding instruction message.
In one embodiment, further comprising:
determining the operation information as non-file application operation, calling a corresponding file system interface, and executing a corresponding execution action.
In one embodiment, prior to said execution by the file system thread, comprising:
creating a file system thread and setting a thread stack for the file system thread.
In one embodiment, further comprising: the file system thread is created at the application layer.
In one embodiment, the invoking the file system according to the instruction message includes:
detecting whether an instruction message from an application thread exists or not;
and when the instruction message from the application thread is detected, calling a file system according to the instruction message.
It will be appreciated by those skilled in the art that embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, etc., such as Read Only Memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.
Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transmission media), such as modulated data signals and carrier waves.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article or apparatus that comprises an element.
The foregoing is merely exemplary of the present application and is not intended to limit the present application. Various modifications and changes may be made to the present application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc. which are within the spirit and principles of the present application are intended to be included within the scope of the claims of the present application.

Claims (15)

1. A method of invoking a file system, performed by a file system thread, the method comprising:
receiving an instruction message, wherein the instruction message is generated and sent by an application thread when file system operation is required;
and calling a file system according to the instruction message.
2. The method of claim 1, wherein the instruction message comprises a message type;
the file system is called according to the instruction message, which comprises the following steps:
and calling a file system interface according to the message type, and executing corresponding file system operation.
3. The method of claim 1, wherein the instruction message is an operation instruction on a file that can be received and identified by the file system thread.
4. The method of claim 1, wherein the step of generating the instruction message is performed by the application thread, and wherein the step of generating the instruction message includes:
judging whether the operation information is file system operation or not;
determining the operation information as file system operation, and generating a corresponding instruction message.
5. The method of invoking a file system according to claim 4, further comprising:
determining the operation information as non-file application operation, calling a corresponding file system interface, and executing a corresponding execution action.
6. The method of claim 1, comprising, prior to said executing by a file system thread:
creating a file system thread and setting a thread stack for the file system thread.
7. The method of claim 1, wherein the file system thread is created at an application layer.
8. The method for calling a file system according to claim 1, wherein the calling the file system according to the instruction message includes:
detecting whether an instruction message from an application thread exists or not;
and when the instruction message from the application thread is detected, calling a file system according to the instruction message.
9. A file system calling device for a file system thread, comprising:
the receiving module is used for receiving instruction information, wherein the instruction information is generated and sent by an application thread when file system operation is required;
and the calling module is used for calling the file system according to the instruction message.
10. The file system calling device of claim 9, wherein the instruction message comprises a message type;
the calling module comprises:
and the message type unit is used for calling the file system interface according to the message type and executing corresponding file system operation.
11. The file system calling device of claim 9, wherein the means for applying a thread comprises:
the judging module is used for judging whether the operation information is file system operation or not;
the generating module is used for determining that the operation information is file system operation and generating a corresponding instruction message.
12. The file system calling device of claim 11, further comprising:
and the execution module is used for determining that the operation information is non-file application operation, calling a corresponding file system interface and executing a corresponding execution action.
13. The file system calling device of claim 9, wherein the calling module comprises:
the detection unit is used for detecting whether the instruction message from the application thread exists or not all the time;
and the file system calling unit is used for calling the file system according to the instruction message when the instruction message from the application thread is detected.
14. A processor configured to perform the method of invoking the file system according to any of claims 1 to 8.
15. A machine-readable storage medium having instructions stored thereon, which when executed by a processor cause the processor to be configured to perform a method of invoking a file system according to any of claims 1 to 8.
CN202310357520.7A 2023-04-04 2023-04-04 File system calling method and device, storage medium and processor Pending CN116560805A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202310357520.7A CN116560805A (en) 2023-04-04 2023-04-04 File system calling method and device, storage medium and processor

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202310357520.7A CN116560805A (en) 2023-04-04 2023-04-04 File system calling method and device, storage medium and processor

Publications (1)

Publication Number Publication Date
CN116560805A true CN116560805A (en) 2023-08-08

Family

ID=87493680

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202310357520.7A Pending CN116560805A (en) 2023-04-04 2023-04-04 File system calling method and device, storage medium and processor

Country Status (1)

Country Link
CN (1) CN116560805A (en)

Similar Documents

Publication Publication Date Title
CN110865888B (en) Resource loading method and device, server and storage medium
CN107832100B (en) APK plug-in loading method and terminal thereof
EP4145286A1 (en) Memory management method and electronic device
JP6992012B2 (en) Data processing method and device
CN108628688B (en) Message processing method, device and equipment
CN108512715B (en) Load pressure test method of service link and related device
CN108717374B (en) Method and device for preheating during starting of Java virtual machine and computer equipment
CN113032099B (en) Cloud computing node, file management method and device
CN104239156A (en) External service call method and system
WO2015067189A1 (en) Method and apparatus for installing application
WO2023087875A1 (en) Process scheduling method and terminal device
CN113595773B (en) Information processing method, device, electronic equipment and storage medium
US9678765B2 (en) Extending JAVA application functionality
CN115827506A (en) Data writing method, data reading method, device, processing core and processor
WO2024078348A1 (en) Method and apparatus for processing registry operation in application porting environment, and medium
CN114356591A (en) Inter-process communication method and device, Internet of things operating system and Internet of things equipment
WO2020135129A1 (en) Method and device for loading plug-in of application, and terminal
CN116560805A (en) File system calling method and device, storage medium and processor
CN114860473A (en) Message processing method, processor and storage medium
CN114490266A (en) Data acquisition method, device, equipment and storage medium
CN114374657A (en) Data processing method and device
CN114138444A (en) Task scheduling method, device, equipment, storage medium and program product
CN112559565A (en) Abnormity detection method, system and device
CN112738181A (en) Method, device and server for cluster external IP access
US20100217941A1 (en) Improving the efficiency of files sever requests in a computing device

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