Linux Ptrace 详解

转 https://blog.csdn.net/u012417380/article/details/60470075

Linux Ptrace 详解

2017年03月05日 18:59:58

阅读数：6331

一、系统调用

操作系统提供一系列系统调用函数来为应用程序提供服务。关于系统调用的详细相关知识，可以查看<<程序员的自我修养》第十二章。

对于x86操作系统来说，用中断命令“int 0x80”来进行系统调用，系统调用前，需要将系统调用号放入到%EAX寄存器中，将系统的参数依次放入到寄存器%ebx、%ecx、%edx以及%esi和%edi中。

以write系统调用为例：

write(2,"Hello",5);
  • 1

在32位系统中会转换成：

movl $1,%eax
movl $2,%ebx
movl $hello,%ecx
movl $5,%edx
int $0x80
  • 1
  • 2
  • 3
  • 4
  • 5

其中1为write的系统调用号，所有的系统调用号定义在unistd.h文件中，$hello 表示字符串“Hello”的地址；32位Linux系统通过0x80中断来进行系统调用。

64位系统用户应用层用整数寄存器%rdi ,%rsi,%rdx,%rcx, %r8以及 %r9来传参。而内核接口用%rdi ,%rsi,%rdx,%r10,&r8以及%r10来传参，并且用syscall指令而不是80中断进行系统调用。

x86和x64都用寄存器rax来保存调用号和返回值。

二、ptrace 函数简介

#include <sys/ptrace.h>

long ptrace（enum _ptrace_request request,pid_t pid,void * addr ,void *data）;
  • 1
  • 2
  • 3

ptrace()系统调用函数提供了一个进程（the “tracer”）监察和控制另一个进程（the “tracee”）的方法。并且可以检查和改变“tracee”进程的内存和寄存器里的数据。它可以用来实现断点调试和系统调用跟踪。

tracee首先需要被附着到tracer。在多线程进程中，每个线程都可以被附着到一个tracer。ptrace命令总是以ptrace(PTARCE_foo,pid,..)的形式发送到tracee进程。pid是tracee线程ID。

当一个进程可以开始跟踪进程通过调用fork函数创建子进程并让子进程执行PTRACE_TRACEME,然后子进程再调用execve()（如果当前进程被ptrace,execve()成功执行后 SIGTRAP信号量会被发送到该进程）。一个进程也可以使用”PTRACE_ATTACH”或者”PTRACE_SEIZE”来跟踪另一个进程。

当进程被跟踪后，每当信号量传来，甚至信号量会被忽略时，tracee会暂停。tracer会在下次调用waitpid（wstatus）(或者其它wait系统调用)处被通知。该调用会返回一个包含tracee暂停原因信息的状态码。当tracee暂停后，tracer可以使用一系列ptrace请求来查看和修改tracee中的信息。tracer接着可以让tracee继续执行。tracee传递给tracer中的信号量通常被忽略。

当PTRACE_O_TRACEEXEC项未起作用时，所有成功执行execve()的tracee进程会被发送一个 SIGTRAP信号量后暂停，在新程序执行之前，父进程将会取得该进程的控制权。

当tracer结束跟踪后，可以通过调用PTRACE_DETACH继续让tracee执行。

prace更多相关信息可以查看http://man7.org/linux/man-pages/man2/ptrace.2.html官方文档。

三、示例

1.ptrace追踪子进程执行exec()

#include <stdio.h>
#include <unistd.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/reg.h>   /* For constants ORIG_RAX etc */
int main(){
   pid_t child;
   long orig_rax;
   child=fork();
   if(child==0){
      ptrace(PTRACE_TRACEME,0,NULL,NULL);
      execl("/bin/ls","ls",NULL);
   }else{
        wait(NULL);
        orig_rax = ptrace(PTRACE_PEEKUSER,child,8*ORIG_RAX,NULL);
        printf("The child made a system call %ld\n",orig_rax);
        ptrace(PTRACE_CONT,child,NULL,NULL);
   }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

编译后输出：

The child made a system call 59
[email protected]:~/hookTest$ a.out    attach.c~  ex1.c   ex1.o  ex2.c~  ex3.c   ex3.o  ex4.c~    victim.c~
attach.c  attach.o   ex1.c~  ex2.c  ex2.o   ex3.c~  ex4.c  victim.c  victim.o
  • 1
  • 2
  • 3
  • 4

execl()函数对应的系统调用为__NR_execve，系统调用值为59。父进程通过调用fork()来创建子进程。在子进程中，先运行patrce().请求参数设为PTRACE_TRACE,来告诉内核当前进程被父进程trace，每当有信号量传递到当前进程，该进程会暂停，提醒父进程在wait()调用处继续执行。然后再调用execl()。当execl()函数成功执行后，新程序运行之前，SIGTRAP信号量会被发送到该进程，让子进程停止，这时父进程会在wait相关调用处被通知，获取子进程的控制权，可以查看子进程内存和寄存器相关信息。

当进程进行系统调用时，int会在内核栈中依次压入用户态的寄存器SS、ESP、EFLAGS、CS、EIP.中断处理程序的SAVE_ALL宏会将 依次将EAX、EBP、EDI、ESI、EDX、ECX、EBX寄存器值压入内核栈。调用ptrace(PTRACE_PEEKUSER,child,8*ORIG_RAX,NULL) 获取USER area信息时<sys/reg.h>文件定义了与内核栈寄存器数组顺序相同的下标：


#ifndef _SYS_REG_H
#define _SYS_REG_H  1

#ifdef __x86_64__
/* Index into an array of 8 byte longs returned from ptrace for
   location of the users‘ stored general purpose registers.  */

# define R15    0
# define R14    1
# define R13    2
# define R12    3
# define RBP    4
# define RBX    5
# define R11    6
# define R10    7
# define R9 8
# define R8 9
# define RAX    10
# define RCX    11
# define RDX    12
# define RSI    13
# define RDI    14
# define ORIG_RAX 15
# define RIP    16
# define CS 17
# define EFLAGS 18
# define RSP    19
# define SS 20
# define FS_BASE 21
# define GS_BASE 22
# define DS 23
# define ES 24
# define FS 25
# define GS 26
#else

/* Index into an array of 4 byte integers returned from ptrace for
 * location of the users‘ stored general purpose registers. */

# define EBX 0
# define ECX 1
# define EDX 2
# define ESI 3
# define EDI 4
# define EBP 5
# define EAX 6
# define DS 7
# define ES 8
# define FS 9
# define GS 10
# define ORIG_EAX 11
# define EIP 12
# define CS  13
# define EFL 14
# define UESP 15
# define SS   16
#endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

这样8*ORIG_RAX就找到USER area 中 ORIG_RAX 寄存器值的保存地址。ORIG_RAX保存了系统调用号。

当检查完系统调用之后，可以调用ptrace并设置参数PTRACE_CONT让子进程继续进行。

2.读取子进程系统调用参数

//64位下乌班图程序

#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/reg.h>
#include <sys/user.h>
#include <sys/syscall.h>
#include <stdio.h>
int main(){
    pid_t child;
    long orig_rax;
    int status;
    int iscalling=0;
    struct user_regs_struct regs;

    child = fork();
        if(child==0){
          ptrace(PTRACE_TRACEME,0,NULL,NULL);
      execl("/bin/ls","ls","-l","-h",NULL);
    }else{
          while(1){
        wait(&status);
                if(WIFEXITED(status))
                    break;
                orig_rax=ptrace(PTRACE_PEEKUSER,child,8*ORIG_RAX,NULL);
                if(orig_rax == SYS_write){
                    ptrace(PTRACE_GETREGS,child,NULL,&regs);
            if(!iscalling){
                iscalling =1;
                printf("SYS_write call with %lld, %lld, %lld\n",regs.rdi,regs.rsi,regs.rdx);
                        } else{
                               printf("SYS_write call return %lld\n",regs.rax);
                               iscalling = 0;
                        }                                  

                }
            ptrace(PTRACE_SYSCALL,child,NULL,NULL);
          }
       }
          return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

编译后输出：

SYS_write call with 1, 140179049189376, 14
总用量 28K
SYS_write call return 14
SYS_write call with 1, 140179049189376, 51
-rw-rw-r-- 1 user1 user1  534  2月 26 18:02 ex1.c
SYS_write call return 51
SYS_write call with 1, 140179049189376, 52
-rw-rw-r-- 1 user1 user1  534  2月 26 18:02 ex1.c~
SYS_write call return 52
SYS_write call with 1, 140179049189376, 53
-rw-rw-r-- 1 user1 user1 1.1K  3月  2 13:02 hook2.c
SYS_write call return 53
SYS_write call with 1, 140179049189376, 54
-rw-rw-r-- 1 user1 user1 1.1K  3月  2 13:02 hook2.c~
SYS_write call return 54
SYS_write call with 1, 140179049189376, 53
-rwxrwxr-x 1 user1 user1 8.6K  3月  2 13:02 hook2.o
SYS_write call return 53
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

可以看到ls -l -h 执行了六次SYS_write系统调用。

读取寄存器中的参数时，可以使用PTRACE_PEEKUSER一个字一个字读取，也可以使用PTRACE_GETREGS参数直接将寄存器的值读取到结构体user_regs_struct 中，该结构体定义在sys/user.h中

对于PTRACE_STSCALL参数，该参数会像PTRACE_CONT一样使暂停的子进程继续执行，并在子进程下次进行系统调用前或系统调后，向子进程发送SINTRAP信号量，让子进程暂停。

WIFEXITED函数(宏)函数用来检查子进程是暂停还准备退出。

3.修改子进程系统调用参数

val = ptrace(PTRACE_PEEKDATA,child,addr,NULL)
  • 1

PTRACE_PEEKDATA、PTRACE_PEEKTEXT参数是在tracee内存的addr地址处读取一个字（sizeof(long））的数据，反回值是long 型的，可多次读取addr

+i*sizeof(long)然后再合并得到最终字符串的内容。

现在，我们对系统调用write 输出的字符串参数进行反转：

#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/reg.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#define long_size sizeof(long)

void reverse(char * str)
{
    int i,j;
    char temp;
    for(i=0,j=strlen(str)-2;i<=j;++i,--j){
          temp=str[i];
          str[i]=str[j];
          str[j]=temp;
    }
}

void getdata(pid_t child,long addr,char * str,int len){
  char * laddr;
  int i,j;
  union u{
    long val;
        char chars[long_size];
  } data;
  i=0;
  j=len/long_size;
  laddr=str;
  while(i<j){
   data.val=ptrace(PTRACE_PEEKDATA,child,addr+i*long_size,NULL);
   if(data.val == -1){
     if(errno){
        printf("READ error: %s\n",strerror(errno));
     }
   }
     memcpy(laddr,data.chars,long_size);
     ++i;
     laddr +=long_size;
  };
  j=len % long_size;
  if(j!=0){
     data.val=ptrace(PTRACE_PEEKDATA,child,addr+i*long_size,NULL);
     memcpy(laddr,data.chars,j);
  }
   str[len]=‘\0‘;
}

void putdata(pid_t child,long addr,char * str,int len){
    char * laddr;
        int i,j;
        union u{
          long val;
          char chars[long_size];
       } data;
       i=0;
       j=len /long_size;
       laddr=str;
       while(i<j){
           memcpy(data.chars,laddr,long_size);
           ptrace(PTRACE_POKEDATA,child,addr +i*long_size,data.val);
           ++i;
           laddr+=long_size;
     }
     j=len%long_size;
     if(j!=0){
           //注意：由于写入时也是按字写入的，所以正确的做法是先将该字的高地址数据读出保存在data的高地址上 ，然后将该字再写入
           memcpy(data.chars,laddr,j);
           ptrace(PTRACE_POKEDATA,child,addr +i*long_size,data.val);
     }

}

int main(){
    pid_t child;
        int status;
        struct user_regs_struct regs;
        child =fork();
        if(child ==0){
          ptrace(PTRACE_TRACEME,0,NULL,NULL);
          execl("/bin/ls","ls",NULL);
       }else{
           long orig_eax;

           char *str,*laddr;
           int toggle =0;
           while(1){
             wait(&status);
             if(WIFEXITED(status))
                 break;
             orig_eax = ptrace(PTRACE_PEEKUSER,child,8*ORIG_RAX,NULL);
             if(orig_eax == SYS_write){
               if(toggle == 0){
                  toggle =1;
                 ptrace(PTRACE_GETREGS,child,NULL,&regs);

                 str=(char * )calloc((regs.rdx+1),sizeof(char));
                 getdata(child,regs.rsi,str,regs.rdx);
                 reverse(str);
                 putdata(child,regs.rsi,str,regs.rdx);
              }else{
              toggle =0;
               }
            }

         ptrace(PTRACE_SYSCALL,child,NULL,NULL);
          }
       }
      return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117

输出：

user1@user-virtual-machine:~/hookTest$ ./hook3.o
o.3kooh  ~c.3kooh  c.3kooh  o.2kooh  ~c.2kooh c.2kooh  ~c.1xe  c.1xe
  • 1
  • 2
  • 3

4.向其它程序注入指令

我们追踪其它独立运行的进程时，需要使用下面的命令：

ptrace(PTRACE_ATTACH, pid, NULL, NULL)
  • 1

使pid进程成为被追踪的tracee进程。tracee进程会被发送一个SIGTOP信号量，tracee进程不会立即停止，直到完成本次系统调用。如果要结束追踪，则调用PTRACE_DETACH即可。

debug 设置断点的功能可以通过ptrace实现。原理是ATTACH正在运行的进程使其停止。然后读取该进程的指令寄存器IR（32位x86为EIP,64w的是RIP）内容所指向的指令，备份后替换成目标指令，再使其继续执行，此时被追踪进程就会执行我们替换的指令，运行完注入的指令之后，我们再恢复原进程的IR

,从而达到改变原程序运行逻辑的目的。

tracee进程代码：

stdio.h>

int main(){
        int i=0;
    while(1){
            printf("Hello,ptrace! [pid:%d]! num is %d\n",getpid(),i++);
                sleep(2);
      }
      return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

tracer进程代码


#include<sys/ptrace.h>
#include<sys/reg.h>
#include<sys/wait.h>
#include<sys/user.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<stdio.h>

#define long_size sizeof(long)

void getdata(pid_t child, long addr ,char * str,int len){
    char * laddr =str;
    int i,j;
    union u{
          long  val;
          char   chars [long_size] ;
        } data;
    i=0;
    j=len/long_size;

     while(i<j){
           data.val=ptrace(PTRACE_PEEKDATA,child,addr + long_size*i,NULL);
           if(data.val==-1){
        if(errno){
                  printf("READ error: %s\n",strerror(errno));
                }
           }
           memcpy(laddr,data.chars,long_size);
            ++i;
           laddr=laddr+long_size;
        }

    j= len %long_size;
    if(j!=0){
      data.val=ptrace(PTRACE_PEEKDATA,child,addr + long_size*i,NULL);
      if(data.val==-1){
        if(errno){
                  printf("READ error: %s\n",strerror(errno));
                }
           }
      memcpy(laddr,data.chars,j);
    }
    str[len]=‘\0‘;
}

void putdata(pid_t child , long addr,char * str,int len){
    char * laddr =str;
    int i,j;
    j=len/long_size;
    i=0;
    union u{
           long val;
           char chars [long_size]  ;
    } data;
    while(i<j){
         memcpy(data.chars,laddr,long_size);
         ptrace(PTRACE_POKEDATA,child,addr + long_size*i,data.val);
         ++i;
         laddr=laddr+long_size;
    }
    j=len%long_size;
    if(j!=0){
        data.val= ptrace(PTRACE_PEEKDATA,child,addr + long_size*i,NULL);
        if(data.val==-1){
           if(errno){
                  printf("READ error: %s\n",strerror(errno));
                }
        }

         memcpy(data.chars,laddr,j);
         ptrace(PTRACE_POKEDATA,child,addr + long_size*i,data.val);
     }
}

int main(int argc,char * argv[]){
     if(argc!=2){
         printf("Usage: %s pid\n",argv[0]);
     }
     pid_t tracee = atoi(argv[1]);
     struct user_regs_struct regs;
     /*int 80(系统调用) int 3（断点）*/
     unsigned char code[]={0xcd,0x80,0xcc,0x00,0,0,0,0}; //八个字节，等于long 型的长度
     char backup[8]; //备份读取的指令
     ptrace(PTRACE_ATTACH,tracee,NULL,NULL);
     long inst;  //用于保存指令寄存器所指向的下一条将要执行的指令的内存地址 

      wait(NULL);
      ptrace(PTRACE_GETREGS,tracee,NULL,&regs);
     inst  =ptrace(PTRACE_PEEKTEXT,tracee,regs.rip,NULL);
      printf("tracee:RIP:0x%llx INST: 0x%lx\n",regs.rip,inst);
     //读取子进程将要执行的 7 bytes指令并备份
     getdata(tracee,regs.rip,backup,7);
     //设置断点
     putdata(tracee,regs.rip,code,7);
     //让子进程继续执行并执行“int 3”断点指令停止
     ptrace(PTRACE_CONT,tracee,NULL,NULL);

     wait(NULL);
     long rip=ptrace(PTRACE_PEEKUSER,tracee,8*RIP,NULL);//获取子进程停止时，rip的值
     long inst2=ptrace(PTRACE_PEEKTEXT,tracee,rip,NULL);
     printf("tracee:RIP:0x%lx INST: 0x%lx\n",rip,inst2);

     printf("Press Enter to continue  tracee process\n");
     getchar();
     putdata(tracee,regs.rip,backup,7); //重新将备份的指令写回寄存器
     ptrace(PTRACE_SETREGS,tracee,NULL,&regs);//设置会原来的寄存器值
      ptrace(PTRACE_CONT,tracee,NULL,NULL);
     ptrace(PTRACE_DETACH,tracee,NULL,NULL);
     return 0;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116

先运行tracee.o 文件

$  ./tracee.o
  • 1

此时tracee.o输出：

Hello,ptrace! [pid:14384]! num is 0
Hello,ptrace! [pid:14384]! num is 1
Hello,ptrace! [pid:14384]! num is 2
Hello,ptrace! [pid:14384]! num is 3
......
  • 1
  • 2
  • 3
  • 4
  • 5

再另打开一个shell运行attach.o文件

$  ./.attach.o  14384 //pid
  • 1

此时tracee.o执行到int 3断点指令停止，attach1,o输出：

tracee:RIP:0x7f48b0394f20 INST: 0x3173fffff0013d48
tracee:RIP:0x7f48b0394f23 INST: 0x8348c33100000000
Press Enter to continue  tracee process
  • 1
  • 2
  • 3
  • 4
  • 5

按任意键tracee.o恢复执行

参考：

http://www.cnblogs.com/pannengzhi/p/5203467.html

原文地址：https://www.cnblogs.com/yibutian/p/9482972.html

时间： 2024-10-13 11:59:48

Linux Ptrace 详解的相关文章

Linux 目录详解 树状目录结构图

1.树状目录结构图 2./目录 目录 描述 / 第一层次结构的根.整个文件系统层次结构的根目录. /bin/ 需要在单用户模式可用的必要命令(可执行文件):面向所有用户,例如:cat.ls.cp,和/usr/bin类似. /boot/ 引导程序文件,例如:kernel.initrd:时常是一个单独的分区[6] /dev/ 必要设备, 例如:, /dev/null. /etc/ 特定主机,系统范围内的配置文件. 关于这个名称目前有争议.在贝尔实验室关于UNIX实现文档的早期版本中,/etc 被称为

Linux信号详解

Linux信号详解 一 信号的种类 可靠信号与不可靠信号, 实时信号与非实时信号 可靠信号就是实时信号, 那些从UNIX系统继承过来的信号都是非可靠信号, 表现在信号 不支持排队,信号可能会丢失, 比如发送多次相同的信号, 进程只能收到一次. 信号值小于 SIGRTMIN的都是非可靠信号. 非可靠信号就是非实时信号, 后来, Linux改进了信号机制, 增加了32种新的信号, 这些信 号都是可靠信号, 表现在信号支持排队, 不会丢失, 发多少次, 就可以收到多少次. 信号值 位于 [SIGRTM

linux awk详解与应用

文章来自于本人个人博客: linux awk详解与应用 1.awk awk是一个强大的文本分析工具,它可以通过分析文本来生成一个数据报告.它的原理就是读取每行的输入,然后按照分隔符切分(默认是空格),再进行定制计算. awk '{print $1}' /etc/passwd   #打印出passwd文件的所有行的第一列 这是awk的基础语法,在awk中$n代表列数,即$1--第一列,$2---第二列....,但是$0代表整行 接下来我们按照指定的分隔符打印数据: awk -F ':' '{pri

Gentoo Linux安装详解--根据官方WiKi整理

1. 前期准备 远程登录: 开启ssh服务: /etc/init.d/sshd start 设置密码: passwd 以便使用putty.ssh client远程登录上传stage等(有时在线下载很慢,而局域网上传很快) 准备磁盘: 分区: fdisk /dev/sda /dev/sda1 : /boot 100M(32-100M) 设启动笔记-a/dev/sda2 : / 20G/dev/sda3 : /home 20G/dev/sda5 : /swap 1G (内存< 512 MB,分区分配

linux命令详解

一.cat主要有三大功能: 1.一次显示整个文件.$ cat filename2.从键盘创建一个文件.$ cat > filename (只能创建新文件,不能编辑已有文件)3.将几个文件合并为一个文件: $cat file1 file2 > file 参数:-n 或 --number 由 1 开始对所有输出的行数编号-b 或 --number-nonblank 和 -n 相似,只不过对于空白行不编号-s 或 --squeeze-blank 当遇到有连续两行以上的空白行,就代换为一行的空白行-v

PXE的概述及Linux使用详解

PXE的概述及使用详解 现在企业采购的很多计算机都是没光驱的,怎么安装系统呢?另外,如何能快速大规模安装Linux服务器操作系统呢,有什么好办法吗? 答案是有的,那就是本文要说的:PXE PXE(preboot execute environment,预启动执行环境)是由Intel公司开发的最新技术,工作于Client/Server的网络模式,支持工作站通过网络从远端服务器下载映像,并由此支持通过网络启动操作系统,在启动过程中,终端要求服务器分配IP地址,再用TFTP(trivial filet

Gentoo Linux安装详解

1. 前期准备 远程登录: 开启ssh服务: /etc/init.d/sshd start 设置密码: passwd 以便使用putty.ssh client远程登录上传stage等(有时在线下载很慢,而局域网上传很快) 准备磁盘: 分区: fdisk /dev/sda /dev/sda1 : /boot 100M(32-100M) 设启动笔记-a/dev/sda2 : / 20G/dev/sda3 : /home 20G/dev/sda5 : /swap 1G (内存< 512 MB,分区分配

Linux指令详解useradd groupadd passwd chpasswd chage 密码修改

创建用户.设置密码.修改用户.删除用户: useradd testuser 创建用户testuser passwd testuser 给创建的用户testuser设置密码 说明:新创建的用户会在/home下创建一个用户目录testuser usermod --help 修改用户这个命令的相关参数 userdel testuser 删除用户testuser rm -rf testuser 删除用户testuser所在目录 上面的几个命令只有root账号才可以使用,如果你不知道自己的系统上面的命令在

Linux权限详解，多用户多组各种权限配置原理

网上有太多关于Linux权限详解,这里不啰嗦那些.主要解释下这些权限是杂用的,否则知道了什么用户.组之类的权限也配不好. 一.权限分类 r:读取权限,数字代号为"4". w:写入权限,数字代号为"2". x:执行或切换权限,数字代号为"1". -:不具任何权限,数字代号为"0". linux内每一段为r+w+x的值,最大777,见下图 二.权限在何时使用 目录写权限:可以增删目录内所有内容,改文件和目录名. 目录读权限:可以l