CN108415736B - Method, device and equipment for marking program process by using process file system - Google Patents
Method, device and equipment for marking program process by using process file system Download PDFInfo
- Publication number
- CN108415736B CN108415736B CN201810118610.XA CN201810118610A CN108415736B CN 108415736 B CN108415736 B CN 108415736B CN 201810118610 A CN201810118610 A CN 201810118610A CN 108415736 B CN108415736 B CN 108415736B
- Authority
- CN
- China
- Prior art keywords
- program
- marking
- file
- variable
- marked
- 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.)
- Active
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/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
- G06F9/4451—User profiles; Roaming
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the invention provides a method, a device and equipment for marking program processes by using a process file system, wherein the method comprises the following steps: writing a marked variable into an environment variable for a program needing static marking before the program is started, reading the environment variable from a current process environment variable list before the marked program starts to run, reading a program process identifier from a marked variable field of the environment variable, and then starting the marked program process; for the program needing dynamic marking, loading a preset program marking code in the program, opening a marking file of a specified file name in an appointed directory through the loaded program marking code, and finding a link of the marking file in a file list opened by a process. The method can conveniently mark the program process, is not limited by the type supported by the process, has strong universality and convenient search, and can effectively mark and identify the process.
Description
Technical Field
The invention relates to the technical field of networks, in particular to a method, a device and equipment for marking program processes by using a process file system (procfs) in a linux system.
Background
Frequently, a cli program running multiple Hypertext preprocessors (PHPs) is required on a linux host, i.e., multiple PHP processes are generated. Each process has its own process identification (pid). Often, for administrative needs, it may be necessary to identify the relevant processes externally or by letting the PHP itself. Such as distinguishing between different items, etc., such a mechanism is required.
The current general method for marking the PHP process mainly comprises the following steps:
1. different user identities (uid or gid) are used to identify different processes, or different cgroups are used to identify different processes on the basis of supporting control groups (cgroups). But this approach is not ubiquitous. For example, the system does not support cgroup, or different processes cannot be identified in this way when a large number of processes are run by the same user of the system, and the like, and thus the application scenarios in this way are limited.
2. Different paths are used, and the correlation identifications are deduced by a path searching method, and different processes of the paths are considered as different processes. However, in this way, the user may invoke a chdir function (for changing the current working directory into a specified directory) or a similar mechanism for changing the current working directory, so that the corresponding relationship between the path and the process may not be unique, and thus the marking of different processes cannot be effectively implemented.
3. The related identification is stored in other places through a log or a similar method, and then is inquired through pid when the correlation is needed, so that different processes are distinguished. However, in this way, since the log has unreliability, for example, an old log may be deleted, or the log or similar service is not available when management is needed, or the log is being updated, etc., and problems such as too much log service overhead and difficult management may also occur, the marking of different processes cannot be effectively implemented.
Therefore, in the method for marking the process in the prior art, the program cannot effectively mark the process or the identifier cannot be conveniently modified after the program is started, and the table look-up mode is not very convenient to process. Therefore, there is no effective way to mark the process in the prior art, and the process cannot be effectively marked.
Disclosure of Invention
The embodiment of the invention provides a method, a device and equipment for marking a PHP process by using a process file system, which are used for solving the problem that the PHP process cannot be effectively marked in the prior art.
In one aspect, an embodiment of the present invention provides a method for marking a PHP process by using a process file system, including:
writing a marked variable into an environment variable before a program is started, reading the environment variable from a current process environment variable list before the statically marked program starts to run, reading a program process identifier from a marked variable field of the environment variable, and then starting the marked program process;
and aiming at the program needing dynamic marking, loading a preset program marking code in the program, opening a marking file with a specified file name in an appointed directory through the loaded program marking code, and searching a link of the marking file in a file list opened by the program process.
In some optional embodiments, the writing a flag variable in the environment variable before the program starts includes:
before a program is started, writing a mark variable in a key value form through a shell script; or writing a flag variable in a periodically executed work schedule crontab file; or writing the marking variable into the corresponding system daemon system configuration file.
In some optional embodiments, the loading of the preset program marker code in the program includes:
providing program marking code in advance, wherein the program marking code provides an Application Programming Interface (API) of dynamic marking and comprises at least one of creating marking and deleting marking;
and loading the program marking code provided in advance in the program.
In some optional embodiments, the method further includes:
when the marks of the program processes need to be searched, traversing all the program processes which accord with the set conditions, reading the environment variable file, and searching the program process marks written in advance;
and traversing all program processes which accord with the set conditions, reading links of the markup files of the appointed file names in the file list which is opened by the program processes, and finding the corresponding markup files of the appointed file names through the read links.
In some optional embodiments, the method further includes:
and according to the opened file list, carrying out file addressing offset operation on the opened file to find an offset address of the marked file.
The embodiment of the invention also provides a device for marking program processes by using the process file system, which comprises the following steps:
the static marking module is used for writing a marking variable into an environment variable before a program is started for the program needing the static marking, reading the environment variable from a current process environment variable list before the statically marked program starts to run, reading a program process identifier from a marking variable field of the environment variable, and then starting the marked program process;
and the dynamic marking module is used for loading a preset program marking code into the program aiming at the program needing dynamic marking, opening a marking file with a specified file name in the appointed directory through the loaded program marking code, and searching a link of the marking file in a file list opened by the program process.
In some optional embodiments, the static marking module is specifically configured to:
before a program is started, writing a mark variable in a key value form through a shell script; or writing a flag variable in a periodically executed work schedule crontab file; or writing the marking variable into the corresponding system daemon system configuration file.
In some optional embodiments, the dynamic marking module is specifically configured to:
providing program marking code in advance, wherein the program marking code provides an Application Programming Interface (API) of dynamic marking and comprises at least one of creating marking and deleting marking;
and loading the program marking code provided in advance in the program.
In some optional embodiments, the apparatus further comprises:
the identification acquisition module is used for traversing all the program processes meeting the set conditions when the identification of the program processes needs to be searched, reading the environment variable file and searching the pre-written program process identification; and traversing all program processes which accord with the set conditions, reading links of the markup files of the appointed file names in the file list which is opened by the program processes, and finding the corresponding markup files of the appointed file names through the read links.
In some optional embodiments, the dynamic marking module is further configured to:
and according to the opened file list, carrying out file addressing offset operation on the opened file to find an offset address of the marked file.
An embodiment of the present invention further provides a host device, including: means for marking program processes with a process file system as described above.
The embodiment of the invention also discloses a computer storage medium, wherein computer-executable instructions are stored in the computer storage medium and used for executing the method for marking the program process by using the process file system.
The technical scheme has the following beneficial effects:
the method can conveniently mark the program process without being limited by the type supported by the process, can effectively mark the process without controlling the ethnic group identification, does not need the log to carry out correlation query, is not influenced by log deletion and updating, has strong universality and convenient search, and can effectively mark and identify the process.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts.
FIG. 1 is a flow diagram of a method for marking program processes with a process file system in an embodiment of the invention;
FIG. 2 is a flow diagram of obtaining a program process flag in an embodiment of the invention;
FIG. 3 is a diagram illustrating an apparatus for marking program processes by using a process file system according to an embodiment of the present invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
In order to solve the problem that the program process cannot be effectively marked in the prior art, embodiments of the present invention provide a method for marking a program process by using a process file system, which can mark a program process by using procfs on linux, is not limited by types supported by the process, has strong versatility, is convenient to search, and can effectively mark and identify the process.
In many Unix-like computer systems, the process file system (procfs) contains a dummy file system that is dynamically generated at startup to access process information through the kernel. This file system is usually mounted to the/proc directory, since the/proc is not a real file system, it does not occupy storage space, but only limited memory. The present invention utilizes a process file system to mark program processes, which is described in detail below with reference to specific embodiments.
The method for marking program process by using process file system provided by the embodiment of the invention has the flow as shown in fig. 1, and comprises the following steps:
step S101: for programs that require static flags, a flag variable is written in an environment variable before the program starts.
Static marking can be conveniently and efficiently completed, and is not easily influenced by the program. Before a program is started, a mark variable in a key value form is written through a shell script, or the mark script is written in a periodically executed work schedule (crontab) file, or the mark variable is written in a corresponding system daemon (systemdemon, systemd) configuration file.
The mark variable written in the key value form through the shell script can be a bash script written in the environment variable in the key-value form.
For example: before the program starts, the process is marked using a bash script in the form of VAR _ promotion, or written directly in crontab. If the variable of VAR _ SOMEKEY exists in the environment variables, then the program to be marked is started in the environment, and the program to be marked which is just started can inherit the environment variables;
bash (Bourne-Again Shell) is a Unixshell written for the leather (GNU) program. The crontab command is commonly found in Unix and Unix-like operating systems and is used to set instructions that are executed periodically. This command reads the instruction from a standard input device and deposits it in a "crontab" file for later reading and execution.
Step S102: before the statically marked program starts to run, reading an environment variable from a current process environment variable list, reading a program process identifier from a marked variable field of the environment variable, and then starting the marked program process.
Before the marked program starts to run, the related environment variables can be read from the list/proc/< pid >/environ of the current process environment variables, and the program process identification is read from the mark variable field of the environment variables, wherein the identification parameter < pid > is replaced by the identification pid of the process. For example: if the pid replacing < pid > is 355, a file in the form of/proc/355/environ can take the aforementioned result. The marked program process is then restarted.
Step S103: and for the program needing dynamic marking, loading preset program marking codes into the program.
For a program needing to be dynamically marked, program marking codes are provided in advance, and the program marking codes provide an Application Programming Interface (API) of the dynamic marking and comprise at least one of creating marks and deleting marks; program markup code provided in advance is loaded in the program. The program markup code may be a PHP markup class.
That is, for a program requiring dynamic marking, a PHP class is provided and the program requiring marking loads such, and some APIs for providing dynamic marking such as creating and deleting marks are provided.
Step S104: and opening a markup file of a specified file name in the convention directory through the loaded program markup code, and searching a link of the markup file in a file list opened by the program process.
When the application needs to be marked, a directory with an unusual service can be appointed, and the aforementioned mark code (module) opens a file with a specific name in the directory, i.e. a link of the file can be found under/proc/< pid >/fd/, for example, the link of/tmp/nonunsedd form/abc _ social value can be opened.
The file addressing offset operation can be carried out on the opened file according to the opened file list, and the offset address of the marked file is found. That is, the offset address of the relevant markup file can be found according to the information of the opened file in the opened file list, such as: the opened file may be subjected to a file addressing offset operation to address to a specified address, i.e., an offset address of the markup file.
Unlike the prior art where the content is stored elsewhere, the file of a specific name proposed in the present application is only effective as its file name, and the file itself may not exist in the corresponding directory, and there is no need to write any content to the file itself. Therefore, the file itself does not need to be acquired, and only the name needs to be acquired, so that the operation is simple, the data storage amount is reduced, and the data transmission amount is also reduced.
Alternatively, the open file may be subjected to a file addressing offset operation to address a specified address. The offset address of the associated markup file can be found from the opened file information.
The method can mark the program process by adopting a static marking mode, can mark the program process by adopting a dynamic marking mode, or can combine the two modes. The method can effectively mark the program process and can ensure the corresponding relation between the mark and the process. The process that needs to be marked may be a PHP process or other program process.
The method for marking program process by using process file system provided by the embodiment of the invention also comprises a process of obtaining program process mark, the flow is shown as figure 2, and the method comprises the following steps:
step S201: and traversing all the program processes meeting the set conditions when the marks of the program processes need to be searched.
Because the mark information is written into the environment variable during the static mark, when the related mark needs to be searched, the program process is traversed to obtain the related mark variable information in the environment variable so as to search the program process mark.
For example: the program process meeting the set condition may be a certain mark process for specifying a certain user, and the set condition is that the process belongs to the user.
Step S202: and reading the environment variable file, and searching the program process identification written in advance.
The relevant program process is traversed, its environment variable (environ) is read, and the static mark written before starting can be read from environ.
For example: if the program uses a bash script markup in the form of VAR _ solution described in the foregoing static markup process, the contents in the form of VAR _ solution can be seen.
Another example is: if the program is marked in the way of crontab described in the static marking process, the crontab can only find the relevant content.
Step S203: and traversing all program processes meeting the set conditions.
When the dynamic marking is carried out, program marking codes are loaded in the program, so that the link of the marking file can be obtained by traversing the related program process meeting the set condition and reading the link in the fd directory. Where the fd directory contains a link to each file opened by the process.
Step S204: and reading the link of the markup file of the specified file name in the file list opened by the program process, and finding the corresponding markup file of the specified file name through the read link.
Links to the marker file can be found from the fd directory, i.e. if the program uses the markers as exemplified in the dynamic marker description above, links to/tmp/nonunseddormark/abc _ somevalue can be found.
Based on the same inventive concept, an embodiment of the present invention further provides an apparatus for marking a program process by using a process file system, where the apparatus may be disposed in a host device, and a structure of the apparatus is as shown in fig. 3, where the apparatus includes: a static marking module 301 and a dynamic marking module 302.
A static marking module 301, configured to, for a program that needs static marking, write a marking variable in an environment variable before the program is started, read the environment variable in a current process environment variable list before the statically marked program starts running, read a program process identifier from a marking variable field of the environment variable, and restart the marked program process;
the dynamic marking module 302 is configured to load a preset program marking code into a program for a program that needs dynamic marking, open a marked file with a specified file name in an appointed directory through the loaded program marking code, and search for a link of the marked file in a file list that has been opened by a program process.
Optionally, the static marking module 301 is specifically configured to:
before the program is started, a marked variable in a key value form is written in a shell script, or the marked variable is written in a periodically executed work schedule crontab file, or the marked variable is written in a corresponding system daemon system configuration file.
Optionally, the dynamic marking module 302 is specifically configured to:
providing program marking code in advance, wherein the program marking code provides an Application Programming Interface (API) of dynamic marking and comprises at least one of creating marking and deleting marking;
and loading the program marking code provided in advance in the program.
Optionally, the dynamic marking module 302 is further configured to: and according to the opened file information, carrying out file addressing offset operation on the opened file to find an offset address of the marked file.
Optionally, the apparatus further includes:
the identifier obtaining module 303 is configured to, when the identifier of the program process needs to be searched, traverse all the program processes that meet the set condition, read the environment variable file, and search for a pre-written program process identifier; and traversing all program processes which accord with the set conditions, reading links of the markup files of the appointed file names in the file list which is opened by the program processes, and finding the corresponding markup files of the appointed file names through the read links.
The embodiment of the invention also provides a computer storage medium, wherein computer-executable instructions are stored in the computer storage medium and are used for the method for marking the program process by using the process file system.
The method for marking the program process by using the process file system can realize that the program process is marked by using the procfs on linux, such as PHP process, and the related identification can be saved after fork and cannot be lost; the related identification does not affect the normal service; the method is convenient to use, can be used for programs of various languages, can process related marks by using multiple languages, and can be easily added into the crontab to enable the program to hold a specific mark when being started.
If the fork function in the fork function computer program design is successfully called once, two values are returned, the child process returns 0, and the parent process returns a child process mark; otherwise, the error returns to-1. The fork function divides the running program into 2 (almost) identical processes, each of which starts a thread that starts from the same location in the code. The threads in the two processes continue to execute as if two users started two copies of the application at the same time.
Those of skill in the art will further appreciate that the various illustrative logical blocks, units, and steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate the interchangeability of hardware and software, various illustrative components, elements, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design requirements of the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present embodiments.
The various illustrative logical blocks, or elements, described in connection with the embodiments disclosed herein may be implemented or performed with a general purpose processor, a digital signal processor, an Application Specific Integrated Circuit (ASIC), a field programmable gate array or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but in the alternative, the processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a digital signal processor and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a digital signal processor core, or any other similar configuration.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may be stored in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. For example, a storage medium may be coupled to the processor such the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC, which may be located in a user terminal. In the alternative, the processor and the storage medium may reside in different components in a user terminal.
In one or more exemplary designs, the functions described above in connection with the embodiments of the invention may be implemented in hardware, software, firmware, or any combination of the three. If implemented in software, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes both computer storage media and communication media that facilitate transfer of a computer program from one place to another. Storage media may be any available media that can be accessed by a general purpose or special purpose computer. For example, such computer-readable media can include, but is not limited to, RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to carry or store program code in the form of instructions or data structures and which can be read by a general-purpose or special-purpose computer, or a general-purpose or special-purpose processor. Additionally, any connection is properly termed a computer-readable medium, and, thus, is included if the software is transmitted from a website, server, or other remote source via a coaxial cable, fiber optic cable, twisted pair, Digital Subscriber Line (DSL), or wirelessly, e.g., infrared, radio, and microwave. Such discs (disk) and disks (disc) include compact disks, laser disks, optical disks, DVDs, floppy disks and blu-ray disks where disks usually reproduce data magnetically, while disks usually reproduce data optically with lasers. Combinations of the above may also be included in the computer-readable medium.
The above-mentioned embodiments are intended to illustrate the objects, technical solutions and advantages of the present invention in further detail, and it should be understood that the above-mentioned embodiments are merely exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (12)
1. A method for marking program processes using a process filesystem, comprising:
writing a marked variable into an environment variable before a program is started, reading the environment variable from a current process environment variable list before the statically marked program starts to run, reading a program process identifier from a marked variable field of the environment variable, and then starting the marked program process;
aiming at a program needing dynamic marking, loading a preset program marking code in the program, opening a marking file of a specified file name in an appointed directory through the loaded program marking code, and searching a link of the marking file in a file list opened by a program process; the appointed directory is a preset directory corresponding to the program needing the dynamic marking.
2. The method of claim 1, wherein writing a flag variable in an environment variable prior to program startup comprises:
before a program is started, writing a mark variable in a key value form through a shell script; or writing a flag variable in a periodically executed work schedule crontab file; or writing the marking variable into the corresponding system daemon system configuration file.
3. The method of claim 1, wherein loading a preset program marker code in the program comprises:
providing program marking code in advance, wherein the program marking code provides an Application Programming Interface (API) of dynamic marking and comprises at least one of creating marking and deleting marking;
and loading the program marking code provided in advance in the program.
4. The method of claim 1, further comprising:
when the mark of the program process needs to be searched, traversing all the program processes which accord with the set condition, reading the environment variable list, and searching the pre-written program process mark;
and traversing all program processes which accord with the set conditions, reading links of the markup files of the appointed file names in the file list which is opened by the program processes, and finding the corresponding markup files of the appointed file names through the read links.
5. The method of any of claims 1-4, further comprising:
and according to the opened file list, carrying out file addressing offset operation on the opened file to find an offset address of the marked file.
6. An apparatus for marking program processes using a process file system, comprising:
the static marking module is used for writing a marking variable into an environment variable before a program is started for the program needing the static marking, reading the environment variable from a current process environment variable list before the statically marked program starts to run, reading a program process identifier from a marking variable field of the environment variable, and then starting the marked program process;
the dynamic marking module is used for loading a preset program marking code into a program aiming at the program needing dynamic marking, opening a marking file with a specified file name in an appointed directory through the loaded program marking code, and searching a link of the marking file in a file list opened by a program process; the appointed directory is a preset directory corresponding to the program needing the dynamic marking.
7. The apparatus of claim 6, wherein the static marking module is specifically configured to:
before a program is started, writing a mark variable in a key value form through a shell script; or writing a flag variable in a periodically executed work schedule crontab file; or writing the marking variable into the corresponding system daemon system configuration file.
8. The apparatus of claim 6, wherein the dynamic labeling module is specifically configured to:
providing program marking code in advance, wherein the program marking code provides an Application Programming Interface (API) of dynamic marking and comprises at least one of creating marking and deleting marking;
and loading the program marking code provided in advance in the program.
9. The apparatus of claim 6, further comprising:
the identification acquisition module is used for traversing all the program processes meeting the set conditions when the identification of the program process needs to be searched, reading the environment variable list and searching the pre-written program process identification; and traversing all program processes which accord with the set conditions, reading links of the markup files of the appointed file names in the file list which is opened by the program processes, and finding the corresponding markup files of the appointed file names through the read links.
10. The apparatus of any of claims 6-9, wherein the dynamic labeling module is further configured to:
and according to the opened file list, carrying out file addressing offset operation on the opened file to find an offset address of the marked file.
11. A host device, comprising: apparatus for marking program processes with a process file system as claimed in any one of claims 6 to 10.
12. A computer storage medium having stored thereon computer-executable instructions for performing the method of marking a program process with a process filesystem as claimed in any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810118610.XA CN108415736B (en) | 2018-02-06 | 2018-02-06 | Method, device and equipment for marking program process by using process file system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810118610.XA CN108415736B (en) | 2018-02-06 | 2018-02-06 | Method, device and equipment for marking program process by using process file system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108415736A CN108415736A (en) | 2018-08-17 |
| CN108415736B true CN108415736B (en) | 2021-03-30 |
Family
ID=63126879
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810118610.XA Active CN108415736B (en) | 2018-02-06 | 2018-02-06 | Method, device and equipment for marking program process by using process file system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108415736B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110389878B (en) * | 2019-07-08 | 2023-10-27 | 东软集团股份有限公司 | Program monitoring method, device, system on chip and storage medium |
| CN111209058B (en) * | 2020-01-10 | 2023-06-30 | 北京字节跳动网络技术有限公司 | Method, device, medium and equipment for acquiring process name |
| CN111240949B (en) * | 2020-01-13 | 2024-04-26 | 奇安信科技集团股份有限公司 | Method and device for determining software use frequency in domestic operating system |
| CN112231753B (en) * | 2020-10-21 | 2023-09-19 | 中国银行股份有限公司 | Encryption protection method and device for sensitive information in Shell script |
| CN112817657B (en) * | 2021-01-29 | 2023-07-18 | 北京奇艺世纪科技有限公司 | Application program starting item loading method, device, system and storage medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8135764B2 (en) * | 2008-11-14 | 2012-03-13 | Hitachi, Ltd. | Configuration management server, name recognition method and name recognition program |
| CN102521150A (en) * | 2011-11-28 | 2012-06-27 | 华为技术有限公司 | Application program cache distribution method and device |
| CN102708001A (en) * | 2012-04-26 | 2012-10-03 | 深圳市九思泰达技术有限公司 | Linux embedded equipment and switching method between user mode and engineering mode |
| CN104503829A (en) * | 2014-12-23 | 2015-04-08 | 北京极科极客科技有限公司 | Method for detecting and maintaining management process |
| CN104573420A (en) * | 2014-12-26 | 2015-04-29 | 北京奇虎科技有限公司 | Method and device for preventing processes from being mistakenly killed |
| CN107277022A (en) * | 2017-06-27 | 2017-10-20 | 中国联合网络通信集团有限公司 | Processes Tag method and device |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8707161B2 (en) * | 2009-09-30 | 2014-04-22 | Facebook, Inc. | Executing server side script code specified using PHP on a server to generate dynamic web pages |
-
2018
- 2018-02-06 CN CN201810118610.XA patent/CN108415736B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8135764B2 (en) * | 2008-11-14 | 2012-03-13 | Hitachi, Ltd. | Configuration management server, name recognition method and name recognition program |
| CN102521150A (en) * | 2011-11-28 | 2012-06-27 | 华为技术有限公司 | Application program cache distribution method and device |
| CN102708001A (en) * | 2012-04-26 | 2012-10-03 | 深圳市九思泰达技术有限公司 | Linux embedded equipment and switching method between user mode and engineering mode |
| CN104503829A (en) * | 2014-12-23 | 2015-04-08 | 北京极科极客科技有限公司 | Method for detecting and maintaining management process |
| CN104573420A (en) * | 2014-12-26 | 2015-04-29 | 北京奇虎科技有限公司 | Method and device for preventing processes from being mistakenly killed |
| CN107277022A (en) * | 2017-06-27 | 2017-10-20 | 中国联合网络通信集团有限公司 | Processes Tag method and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108415736A (en) | 2018-08-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108415736B (en) | Method, device and equipment for marking program process by using process file system | |
| JP7090657B2 (en) | Methods, devices, devices and storage media for upgrading applications | |
| US9454356B2 (en) | Method of and terminal for updating library file in system application | |
| US6542167B1 (en) | System and method for flexible software linking | |
| CN103227812B (en) | Smart machine is supported method for down loading and the device of breakpoint transmission | |
| US8112745B2 (en) | Apparatus and method for capabilities verification and restriction of managed applications in an execution environment | |
| CN103559065A (en) | Method and system for OTA (Over-the-Air Technology) upgrade | |
| CN110442371B (en) | Method, device and medium for releasing codes and computer equipment | |
| CN112579202B (en) | Method, device, equipment and storage medium for editing server program of Windows system | |
| US6948059B1 (en) | Component loader for industrial control device providing resource search capabilities | |
| CN107608905B (en) | Method and device for erasing Flash data | |
| CN104461621A (en) | Attribute information updating method and device | |
| CN111078279A (en) | Processing method, device and equipment of byte code file and storage medium | |
| US9262301B2 (en) | Observability control with observability information file | |
| Meisami et al. | A comprehensive survey of upgradeable smart contract patterns | |
| CN105447040A (en) | Binary file management and update method and device, and binary file management system | |
| US11853229B2 (en) | Method and apparatus for updating cached information, device, and medium | |
| US20120222023A1 (en) | Automatic runtime dependency lookup | |
| CN112650713A (en) | File system operation method, device, equipment and storage medium | |
| CN109144948B (en) | Application file positioning method and device, electronic equipment and memory | |
| CN113342376B (en) | Method and device for upgrading operating system of Internet of things equipment | |
| CN105302604A (en) | Application version update method and apparatus | |
| CN112947991A (en) | Method and device for acquiring version difference code file, computer equipment and medium | |
| US20050149270A1 (en) | Componentware creating method, apparatus and recording medium | |
| CN111796972B (en) | File hot-repair method, device, equipment and storage medium |
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 | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20210507 Address after: Room 517, 5 / F, scientific research building, Sina headquarters, plot n-1 and n-2, Zhongguancun Software Park, Dongbei Wangxi Road, Haidian District, Beijing 100193 Patentee after: XINGCHAO SHANYAO MOBILE NETWORK TECHNOLOGY (CHINA) Co.,Ltd. Address before: 100193 7th floor, scientific research building, Sina headquarters, plot n-1, n-2, Zhongguancun Software Park, Dongbei Wangxi Road, Haidian District, Beijing, 100193 Patentee before: SINA.COM TECHNOLOGY (CHINA) Co.,Ltd. |
|
| TR01 | Transfer of patent right | ||
| CP03 | Change of name, title or address |
Address after: Room 517, 5 / F, building 8, West District, yard 10, Xibeiwang East Road, Haidian District, Beijing 100085 Patentee after: Sina Finance mobile network technology (Beijing) Co.,Ltd. Address before: Room 517, 5 / F, scientific research building, Sina headquarters, plot n-1 and n-2, Zhongguancun Software Park, Dongbei Wangxi Road, Haidian District, Beijing 100193 Patentee before: XINGCHAO SHANYAO MOBILE NETWORK TECHNOLOGY (CHINA) CO.,LTD. |
|
| CP03 | Change of name, title or address |