producción de demonios

1. ¿Qué es un proceso demonio?

        El proceso daemon, también conocido como proceso Daemon, es un proceso de servicio en segundo plano en Linux. Es un proceso de larga duración que suele ser independiente del terminal controlador y periódicamente realiza determinadas tareas o espera el procesamiento de determinados eventos. Los demonios a menudo se inician cuando se inicia el sistema y finalizan cuando se apaga el sistema. Hay muchos procesos demonio en los sistemas Linux y la mayoría de los servicios se implementan mediante procesos demonio. En Linux, la interfaz a través de la cual cada sistema se comunica con los usuarios se llama terminal. Cada proceso que comienza a ejecutarse desde esta terminal se conectará a esta terminal. Esta terminal se llama terminal de control de estos procesos. Cuando la terminal de control está cerrada, los correspondientes Todos los procesos se cerrarán automáticamente. El proceso demonio puede superar esta limitación: comienza a ejecutarse desde el momento en que se ejecuta y no sale hasta que se apaga todo el sistema. Si desea que un proceso no se vea afectado por el usuario o el terminal u otros cambios, debe convertir este proceso en un proceso demonio.

2. Ver demonios del sistema de uso común

        

父进程ID ：      PPID
 进程ID ：       PID
 进程组ID ：     PGID
 会话期ID ：     SID
 终端ID ：       TTY
 终端进程组ID ： TPGID
 状态 ：         STAT
 用户 ：         UID
 运行时间 ：     TIME
 指令：          COMMAND

3. Proceso de producción del proceso demonio

---

Código:

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include<syslog.h>
void deamon_init(void);
int main(){
	deamon_init();
	openlog("opening",LOG_PID,LOG_DAEMON);
	int fd = open("1.txt",O_RDWR|O_CREAT|O_TRUNC,0666);
	if(fd<0){
		syslog(LOG_ERR,"open error");
		exit(-1);
	    }
	char buf[50]="hello，this is deamo\n";
	while(1){
		sleep(3);
		write(fd,buf,strlen(buf));
		syslog(LOG_INFO,"%s",buf);
	}
	closelog();
	return 0;
}

void deamon_init(void){
	if(fork()!=0)
		exit(0);
	
	if(setsid()<0){
		perror("setsid:");
		exit(-1);
		
	}
	if(fork()!=0)
		exit(0);
	
	int i; 
	for(i = 0;i <= sysconf(_SC_OPEN_MAX);i++)
		close(i);
	chdir("/home/pm");
	umask(0);
	int fd = open("/dev/null",O_RDWR);
	dup(0);
	dup(0);
	
}

4. Preparación del proceso del demonio.

paso:

1. Cree un proceso hijo y elimine el proceso padre:

        Preparación para realizar un proceso terminal: el proceso del líder del grupo no puede convertirse en un terminal 

//创建子进程，exit结束父进程，fork返回值是父进程pid且大于0    
 if(fork()!=0)
            exit(0);

2. Configure el proceso hijo actual como terminal:

        Para deshacerse de la relación de control del terminal original.

//设置子进程为终端，返回值为0没有参数      
  if(setsid()<0){
            perror("setsid");
            exit(-1);
        }   

3. Cree un proceso hijo y elimine el proceso padre:

        Se ha convertido por completo en el prototipo de un proceso demonio que no puede verse afectado por los conceptos de gestión de procesos y terminales de control.

再次创建子进程杀死父进程，让新创建的子进程完全成为摆脱终端关系的进程 
   if(fork()!=0)
            exit(0); 
       //此时，守护进程雏形已完成，剩下的操作，子进程2(守护进程雏形)做

4. Cierre todos los descriptores de archivos:

        Prepárate para el punto siete

 int i;
for(i=0;i<=sysconf(_SC_OPEN_MAX);i++)//for里面写表达式并不好:容易出现bug
       close(i);                     //不要再for里写任何表达式，引以为戒

5. Cambie el directorio de ejecución:

        Para evitar que el demonio afecte las operaciones de eliminación y movimiento del directorio de origen

//执行目录更改到根目录下，运行时记得添加sudo 
chdir("/");

6. Modificar la máscara:

        Para evitar que las operaciones del proceso demonio se vean afectadas por los permisos

 umask(0);

7. Redirigir la entrada estándar, la salida estándar y la salida de error estándar al dispositivo NULL

        Las entradas, salidas y salidas de error estándar inicialmente tienen dispositivos de activación correspondientes.

//7>将标准输入、标准输出、标准错误输出重定向到设备null
      int fd=open("/dev/null",O_RDWR);
      dup(0);
      dup(0);

API学习：
                2>设置当前子进程为一个终端
                setsid 
                #include <sys/types.h>
                #include <unistd.h>
                pid_t setsid(void);
                功能： 
                        让执行该函数的进程，变成终端 
                        
                参数: 
                        无 
                        
                返回值: 
                        成功返回0 
                        失败返回-1，并设置错误码
                        
                4>关闭所有文件描述符
                    sysconf 
                    #include <unistd.h>
                    long sysconf(int name);
                    功能： 
                            找寻name选项的最大值 
                    参数:
                            name:_SC_OPEN_MAX -->找寻文件描述符的最大值
                            
                    返回值: 
                            成功找到选项的最大值 
                            失败返回-1，并设置错误码
                            
                5>更改执行目录
                    chdir
                    #include <unistd.h>
                    int chdir(const char *path);
                    功能： 
                           改变目录 
                           
                    参数: 
                           path：需要修改到的目录 

                    返回值: 
                           成功返回0 
                           失败返回-1，并设置错误码
                           
                6>修改掩码: 两种方式 
                    1>命令修改  --->适用于终端 
                    2>函数修改  --->适用于进程   ---！
                    umask   --》和命令同名
                    #include <sys/types.h>
                    #include <sys/stat.h>
                    mode_t umask(mode_t mask);
                    功能： 
                            修改某个进程当中操作的掩码
                            
                    参数: 
                            mask:掩码值
                            
                    返回值: 
                            成功返回掩码值
                            
                7>文件描述符重定向(复制)
                    dup 
                     #include <unistd.h>
                     int dup(int oldfd);
                     功能： 
                            以oldfd为模板，复制出一个新fd 
                            新fd所有的参数 都 继承 oldfd 
                            操作oldfd =  操作 新的fd
                     
                    参数;
                            oldfd:旧文件描述符 
                            
                    返回值: 
                            成功创建newfd并返回 newfd
                            失败返回-1，并设置错误码

        

---

5. Registro de procesos de demonio

Por qué iniciar sesión:

        El proceso del demonio no tiene entrada ni salida, y no informa errores. No podemos realizar un seguimiento relativamente simple del mismo, ni podemos saber qué operaciones realiza a nuestras espaldas. Entonces nosotros: usamos el sistema de registro de archivos para guardar la información de operación del proceso del demonio

sistema de registro de archivos

 ubuntu的文件系统是:Ext4 
         Ext4:两种系统: 
                 1>文件日志系统         --->保留下来
                  2>时间回溯系统        ---->快照 
                                       

 系统日志:
                1>打开日志
                    openlog
                    #include <syslog.h>
                    void openlog(const char *ident, int option, int facility);
                    功能： 
                            打开日志 
                            
                    参数: 
                            ident:标签：char * 随意
                            option:选项 
                                LOG_PID :进程信息 
                                
                            facility:
                                LOG_DAEMON :守护进程 
                                                            
                2>写日志
                    syslog
                    #include <syslog.h>
                    void syslog(int priority, const char *format, ...);
                    功能： 
                            编写日志 
                            
                    参数: 
                            priority：优先级(报文)
                                LOG_ERR:出错
                                LOG_WARNING:警告 
                                LOG_INFO:正常
                                
                            format:类似printf 
                
                3>关闭日志 
                    closelog
                    #include <syslog.h>
                    void closelog(void);
                    功能： 
                            关闭日志
                            
                4>命令:查看日志 
                    vi /var/log/syslog

6. Verifique el proceso del demonio.

ps -ajx Cuando TPGID muestra -1, indica un proceso de demonio

Ejecuta el programa:

 

 Después de la ejecución, muestra:

 El demonio no se cerrará cuando se cierre la terminal, sino que se ejecutará en segundo plano:

 Todavía hay una pantalla en el fondo.

 Reiniciar la máquina virtual matará el demonio que escribimos:

 Aparece en el directorio de inicio: el escritor que se ejecuta en el proceso del demonio.

 En este punto finaliza el proceso del demonio.