文档章节

浅析Linux计算机进程地址空间与内核装载ELF

nop4ss
 nop4ss
发布于 2015/10/10 16:07
字数 4860
阅读 181
收藏 6
点赞 0
评论 0

简介: 本文基于Linux™系统对进程创建与加载进行分析,文中实现了Linux库函数fork、exec,剖析内核态执行过程,并进一步展示进程创建过程中进程控制块字段变化信息及ELF文件加载过程。


 

一、初识Linux进程                                                                                                                                                                             

  进程这个概念是针对系统而不是针对用户的,对用户来说,他面对的概念是程序。当用户敲入命令执行一个程序的时候,对系统而言,它将启动一个进程。但和程序不同的是,在这个进程中,系统可能需要再启动一个或多个进程来完成独立的多个任务。简单介绍下进程的结构。

  1.1 Linux下的进程查看 

  我们可以使用$ps命令来查询正在运行的进程,比如$ps -eo pid,comm,cmd,下图为执行结果:

  (-e表示列出全部进程,-o pid,comm,cmd表示我们需要PID,COMMAND,CMD信息)

  

  每一行代表了一个进程。每一行又分为三列。第一列PID(process IDentity)是一个整数,每一个进程都有一个唯一的PID来代表自己的身份,进程也可以根据PID来识别其他的进程。第二列COMMAND是这个进程的简称。第三列CMD是进程所对应的程序以及运行时所带的参数。

  (第三列有一些由中括号[]括起来的。它们是kernel的一部分功能,显示为进程的样子主要是为了方便操作系统管理。)

  我们看第一行,PID为1,名字为init。这个进程是执行/bin/init这一文件(程序)生成的。当Linux启动的时候,init是系统创建的第一个进程,这一进程会一直存在,直到我们关闭计算机。

  1.2 Linux下进程的结构

  Linux下一个进程在内存里有三部分的数据,就是"代码段"、"堆栈段"和"数据段"。其实学过汇编语言的人一定知道,一般的CPU都有上述三种段寄存器,以方便操作系统的运行。这三个部分也是构成一个完整的执行序列的必要的部分。

  "代码段",顾名思义,就是存放了程序代码的数据,假如机器中有数个进程运行相同的一个程序,那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量,常数以及动态数据分配的数据空间(比如用malloc之类的函数取得的空间)。系统如果同时运行数个相同的程序,它们之间就不能使用同一个堆栈段和数据段。

  1.3 Linux进程描述符

  在Linux中每一个进程都由task_struct 数据结构来定义.task_struct就是我们通常所说的PCB.它是对进程控制的唯一手段也是最有效的手段. 当我们调用fork() 时,系统会为我们产生一个task_struct结构。然后从父进程,那里继承一些数据, 并把新的进程插入到进程树中,以待进行进程管理。

  以下是进程描述符的源码:

复制代码
 1 struct task_struct {  2   volatile long state;  3   unsigned long flags;  4   int sigpending;  5   mm_segment_taddr_limit;  6   volatile long need_resched;  7   int lock_depth;  8   long nice;  9   unsigned long policy; 10   struct mm_struct *mm; 11   int processor; 12   unsigned long cpus_runnable, cpus_allowed; 13   struct list_head run_list; 14   unsigned longsleep_time; 15   struct task_struct *next_task, *prev_task; 16   struct mm_struct *active_mm; 17   struct list_headlocal_pages; 18   unsigned int allocation_order, nr_local_pages; 19   struct linux_binfmt *binfmt; 20   int exit_code, exit_signal; 21   int pdeath_signal; 22   unsigned long personality; 23   int did_exec:1; 24   pid_t pid; 25   pid_t pgrp; 26   pid_t tty_old_pgrp; 27   pid_t session; 28   pid_t tgid; 29   int leader; 30   struct task_struct*p_opptr,*p_pptr,*p_cptr,*p_ysptr,*p_osptr; 31   struct list_head thread_group; 32   struct task_struct *pid hash_next; 33   struct task_struct **pid hash_pprev; 34   wait_queue_head_t wait_chldexit; 35   struct completion *vfork_done; 36 unsigned long rt_priority; 37 unsigned long it_real_value, it_prof_value, it_virt_value; 38 unsigned long it_real_incr, it_prof_incr, it_virt_value; 39 struct timer_listreal_timer; 40 struct tmstimes; 41   unsigned long start_time; 42   long per_cpu_utime[NR_CPUS],per_cpu_stime[NR_CPUS]; 43   uid_t uid,euid,suid,fsuid; 44   gid_t gid,egid,sgid,fsgid; 45   int ngroups; 46   gid_t groups[NGROUPS]; 47   kernel_cap_tcap_effective, cap_inheritable, cap_permitted; 48   int keep_capabilities:1; 49   struct user_struct *user; 50   struct rlimit rlim[RLIM_NLIMITS]; 51   unsigned shortused_math; 52   charcomm[16]; 53   int link_count, total_link_count; 54   struct tty_struct*tty; 55   unsigned int locks; 56   struct sem_undo*semundo; 57   struct sem_queue *semsleeping; 58   struct thread_struct thread; 59   struct fs_struct *fs; 60   struct files_struct *files; 61   spinlock_t sigmask_lock; 62   struct signal_struct *sig; 63   sigset_t blocked; 64   struct sigpendingpending; 65   unsigned long sas_ss_sp; 66   size_t sas_ss_size; 67   int (*notifier)(void *priv); 68   void *notifier_data; 69   sigset_t *notifier_mask; 70   u32 parent_exec_id; 71   u32 self_exec_id; 72   spinlock_t alloc_lock; 73   void *journal_info; 74 };
复制代码

主要结构分析:

volatile long state; 说明了该进程是否可以执行,还是可中断等信息

unsigned long flags; Flage 是进程号,在调用fork()时给出

int sigpending; 进程上是否有待处理的信号

mm_segment_taddr_limit; 进程地址空间,区分内核进程与普通进程在内存存放的位置不同(0-0xBFFFFFFF foruser-thead     0-0xFFFFFFFF forkernel-thread)

volatile long need_resched;调度标志,表示该进程是否需要重新调度,若非0,则当从内核态返回到用户态,会发生调度

struct mm_struct *mm; 进程内存管理信息

pid_tpid; 进程标识符,用来代表一个进程

pid_tpgrp; 进程组标识,表示进程所属的进程组

task_struct的数据成员mm指向关于存储管理的struct mm_struct结构。它包含着进程内存管理的很多重要数据,如进程代码段、数据段、未未初始化数据段、调用参数区和进程。


 

二、 如何创建一个进程                                                                                                                                                   

 

  2.1 Linux下的进程控制

  在传统的Linux环境下,有两个基本的操作用于创建和修改进程:函数fork()用来创建一个新的进程,该进程几乎是当前进程的一个完全拷贝;函数族exec( )用来启动另外的进程以取代当前运行的进程。

  关于fork()与execl(),去年写过一篇文章对部分源码进行过分析:system()和execv()函数使用详解

  2.2 fork()

  一个进程在运行中,如果使用了fork,就产生了另一个进程。下面就看看如何具体使用fork,这段程序演示了使用fork的基本框架:

复制代码
#include <stdio.h> void main()
{ int i; if ( fork() == 0 ) 
    { /* 子进程程序 */ for ( i = 1; i <1000; i ++ ) 
          printf("This is child process\n");
    } else { /* 父进程程序*/ for ( i = 1; i <1000; i ++ ) 
         printf("This is origin process\n");
    }
}
复制代码

  运行结果如下:

  从上图可以看出父进程和子进程并发运行,内核能够以任意方式交替运行它们,这里是父进程先运行,然后是子进程。但是在另外一个系统上运行时不一定是这个顺序。

  使用fork函数创建的子进程从父进程的继承了全部进程的地址空间,包括:进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设置、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端等。

  fork创建子进程,首先调用int80中断,然后将系统调用号保存在eax寄存器中,进入内核态后调用do_fork(),实际上是创建了一份父进程的拷贝,他们的内存空间里包含了完全相同的内容,包括当前打开的资源,数据,当然也包含了程序运行到的位置,也就是说fork后子进程也是从fork函数的位置开始往下执行的,而不是从头开始。而为了判别当前正在运行的是哪个进程,fork函数返回了一个pid,在父进程里标识了子进程的id,在子进程里其值为0,在我们的程序里就根据这个值来分开父进程的代码和子进程的代码。

  一旦使用fork创建子进程,则进程地址空间中的任何有效地址都只能位于唯一的区域,这些区域不能相互覆盖。编写如下代码进行测试:

复制代码
 1 #include <stdio.h>  2 #include <sys/types.h>  3 #include <unistd.h>  4  5 struct con {  6 int a;  7 };  8  9 int main() { 10  pid_t pid; 11 struct con s; 12 s.a = 2; 13 struct con* sp = &s; 14 pid = fork(); 15 if (pid > 0) { 16 printf("parent show %p, %p, a =  %d\n", sp, &sp->a, sp->a); 17 sp->a = 1; 18 sleep(10); 19 printf("parent show %p, %p, a = %d\n", sp, &sp->a, sp->a); 20 printf("parent exit\n"); 21  } 22 else { 23 printf("child show %p, %p, a = %d\n", sp, &sp->a, sp->a); 24 sp->a = -1; 25 printf("child change a to %d\n", sp->a); 26  } 27 return 0; 28 }
复制代码

获得结果如下:

  从上面的分析可以看出进程copy过程中,fork就是基于写时复制,只读代码段是可以同享的,一般CPU都是以"页"为单位来分配内存空间的,每一个页都是实际物理内存的一个映像,象INTEL的CPU,其一页在通常情况下是 4086字节大小,而无论是数据段还是堆栈段都是由许多"页"构成的,fork函数复制这两个段,物理空间上两个进程的数据段和堆栈段都还是共享着的,当有一个进程写了某个数据时,这时两个进程之间的数据才有了区别,系统就将有区别的" 页"从物理上也分开。系统在空间上的开销就可以达到最小。

   2.3 exec( )函数族

  下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve()对当前进程进行替换,替换者为一个指定的程序,其参数包括文件名(filename)、参数列表(argv)以及环境变量(envp)。exec函数族当然不止一个,但它们大致相同,在 Linux中,它们分别是:execl,execlp,execle,execv,execve和execvp,下面以execve为例。

  一个进程一旦调用exec类函数,它本身就"死亡"了,execve首先调用int80中断,然后将系统调用号保存在eax寄存器中,调用sys_exec,将可执行程序加载到当前进程中,系统把代码段替换成新的程序的代码,废弃原有的数据段和堆栈段,并为新程序分配新的数据段与堆栈段,唯一留下的,就是进程号,也就是说,对系统而言,还是同一个进程,不过已经是另一个程序了。(不过exec类函数中有的还允许继承环境变量之类的信息。)

  那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话,怎么办呢?那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序:

复制代码
1 #include <stdio.h> 2 #include <unistd.h> 3 int main(){ 4   if(!fork()) 5     execve("./test",NULL,NULL); 6   else 7     printf("origin process!\n"); 8   return 0; 9 }
复制代码

  输出结果如下:

    

  原始进程和execve创建的新进程,并发运行,exec函数在当前进程的上下文中加载并运行一个新的程序,并且不返回创建进程的函数。

  接下来,我们分析一下execve函数执行过程中,以及可执行程序的加载过程,在内核中execve()系统调用相应的入口是sys_execve(),函数首先通过 pt_regs参数检查赋值在执行该系统调用时,用户态下的CPU寄存器在核心态的栈中的保存情况。通过这个参数,sys_execve可以获得保存在用户空间的以下信息:可执行文件路径的指针(regs.ebx中)、命令行参数的指针(regs.ecx中)和环境变量的指针(regs.edx中)。

复制代码
struct pt_regs { long ebx; long ecx; long edx; long esi; long edi; long ebp; long eax; int xds; int xes; long orig_eax; long eip; int xcs; long eflags; long esp; int xss;
}
复制代码

  然后调用do_execve函数,首先查找被执行的文件,读取前128个字节,确实加载的可执行文件的类型,然后调用search_binary_handle()搜索和匹配合适的可执行文件装载处理过程,elf调用load_elf_binary();

复制代码
struct linux_binprm{ char buf[BINPRM_BUF_SIZE]; //保存可执行文件的头128字节               struct page *page[MAX_ARG_PAGES]; struct mm_struct *mm;
     unsigned long p; //当前内存页最高地址 int sh_bang; struct file * file; //要执行的文件 int e_uid, e_gid; //要执行的进程的有效用户ID和有效组ID kernel_cap_t cap_inheritable, cap_permitted, cap_effective; void *security; int argc, envc; //命令行参数和环境变量数目 char * filename; //要执行的文件的名称 char * interp; //要执行的文件的真实名称,通常和filename相同  unsigned interp_flags;
     unsigned interp_data;
     unsigned long loader, exec;
 }; 
复制代码

  load_elf_binary()加载过程如下:

  a.检查ELF可执行文件的有效性,比如魔数(开头四个字节,elf文件为0x7F),段“Segment”的数量;

  b.寻找动态链接.interp段,设置动态连接器的路径;

  c.根据elf可执行文件的程序头表的描述,对elf文件进行映射;

  d.初始化elf进程环境,比如启动时候的edx寄存器地址是DT_FINI的地址;

  e.将系统调用的返回地址修改为elf可执行文件的入口点,就是e_entry所存的地址。对于动态链接的elf可执行文件就是动态连接器。


  加载完成后返回do_execve返回到exeve(),从内核态转化为用户态并返回e步所在更改的程序入口地址。即eip存储器直接跳转到elf程序的入口地址,新进程执行。


 

三、 进程虚拟地址空间与可执行程序格式                                                                                                                         

  从操作系统来看,一进程最关键的特征是它拥有独立的虚拟地址空间,一般情况下,创建过程如下:

  ①创建一个独立的虚拟空间。

  ②读取可执行文件头,并且简历虚拟空间与可执行文件的映射关系。

  ③将CPU的指令寄存器设置成可执行文件的入口地址,启动运行。

  在讨论地址空间,进程描述符以及ELF文件格式的之前,我们先介绍一点预备知识,由于第一节已经介绍了进程描述符的部分信息,在这里介绍下ELF文件格式:

  在第二节使用execve时,我们使用了test可执行程序进行测试,代码如下:

复制代码
#include <stdio.h> int main(int argc, char const *argv[])
{
    printf("%s\n","execve the new process!"); return 0;
}
复制代码

  描述“Segment”的结构叫程序头,它描述了ELF文件该如何被操作系统映射到进程的虚拟空间:

          

 

  上图共有5个Segment。从装载的角度看,我们只关心两个LOAD和DYNAMIC,其他Segment在装载过程中只具有辅助作用,映射过程中,根据读写执行权限映射到不同的虚拟内存区域

    第四行LOAD表示代码段,具有可读可执行权限,被映射到虚拟地址0x08048000,长度为0x005c4字节的虚拟存储区域中。

    第五行LOAD表示长度为0x100个字节的数据段,具有可读可写权限,被映射到开始于虚拟地址0x08049f08处,长度为0x0011c字节的虚拟存储区域中。

    DYNAMIC字段表示的是动态链接器所需要的基本信息,具有可读可写权限,被映射到开始于虚拟地址0x08049f14处,长度为0x000e8字节的虚拟存储区域中。

  

  在第二节中执行如下命令后,ELF文件正式开始加载工作,执行第二节中的加载过程:

execve("./test",NULL,NULL);

  文件在加载过程中是以elf可执行文件的形式加载,加载过程初始化时,根据elf段头部表信息,初始化bss段、代码段和数据段的起始地址和终止地址。

  然后调用mm_release释放掉当前进程所占用的内存(old_mm),并且将当前进程的内存空间替换成bprm->mm所指定的页面,而这块空间,便是新进程在初始化时暂时向内核借用的存储空间,当这段空间读取到目前进程的mm以后,事实上也就完成了旧进程到新进程的替换。这个时候bprm->mm这块内核空间也就完成了它的使命,于是被置为NULL予以回收。(bprm为中保存了读取128字节elf文件头)。

  mm指向关于存储管理的struct mm_struct结构,其包含在task_struct中。

  然后加载段地址到虚拟内存地址,映射如下:

  

  然后另一部分段映射到数据区,关系如下:

  到这里,对于elf文件的载入(包括之前对可执行文件运行环境准备工作)的分析基本上可以告一段落了。


 

 

四、进程创建中动态链接库的表现形式                                                                                                                           

 

  动态链接的基本思想是把程序按照模块拆分,运行时才将它们链接在一起形成一个完整的程序,而不是像静态链接一样把所有的程序模块都链接成一个单独的可执行文件。多个动态链接库均以ELF文件存储,执行过程中以依赖树的关系存在,并以深度优先的方式加载动态链接库,最终将可执行程序返回给用户。

  我们通过以下实例来测试动态链接库在虚拟地址及ELF文件的中表现形式:

复制代码
/* Lib.h */
#ifndef LIB_H #define LIB_H void lab(int i) #endif
复制代码

 

复制代码
/* Lib.c */ #include <stdio.h> void lab(int i){
    printf("Printing from lib.so %d\n", i);
  sleep(-1);
}
复制代码

 

复制代码
/* dyn.c*/ #include "lib.h" int main(){
    lab(1); return 0;
}
复制代码

  使用gcc编译生成一个共享对象文件,然后链接dyn.c程序,生成可执行文件dyn:

gcc -fPIC -shared -o lib.so lib.c
gcc -o dyn dyn.c ./lib.so

  运行并查看进程的虚拟地址空间分布:

 

  整个进程的虚拟地址空间中,多出了几个文件的映射。dyn与lib.so一样,都被系统映射到进程的虚拟地址空间,地址与长度均不相同。由第二节可知,在映射完可执行文件之后,操作系统会先启动一个动态链接器。

  动态链接器的的位置由ELF文件中的“.interp”段决定,而段“.dynamic”为动态链接提供了:依赖哪些共享对象、动态链接符号表的位置,动态链接重定位表的位置、共享对象初始化代码的地址等。可通过readelf查看".dynamic" 段的内容:

      动态链接过程需要动态符号表来确定函数的定义和引用关系,还需要重定位表来修正导入符号的引用。初始化完成后堆栈中保存了动态连接器所需要的一些辅助信息数组(其中包括程序入口地址,程序表头地址,程序表头项数及大小)。动态链接库最后被映射到进程地址空间的共享库区域段。

  完成重定位和初始化后,所有准备工作结束,所需要的共享对象也都已经装载并且链接完成。最后将进程的控制权转交给dyn程序的入口并开始执行。

 


  以上内容均为个人理解,由于能力有限,可能会有诸多错误,希望能够和大家一起讨论修正。

本文转载自:http://www.cnblogs.com/akira90/archive/2013/05/30/3109374.html

共有 人打赏支持
nop4ss
粉丝 4
博文 30
码字总数 11175
作品 0
深圳
linux 进程地址空间的一步步探究

我们知道,在32位机器上linux操作系统中的进程的地址空间大小是4G,其中0-3G是用户空间,3G-4G是内核空间。其实,这个4G的地址空间是不存在的,也就是我们所说的虚拟内存空间。 那虚拟内存空间...

HelloRookie ⋅ 昨天 ⋅ 0

android linker 浅析

Android 的加载/链接器linker 主要用于实现共享库的加载与链接。它支持应用程序对库函数的隐式和显式调用。对于隐式调用,应用程序的编译与静态库大致相同,只是在静态链接的时候通过--dynam...

LiSteven ⋅ 2013/07/17 ⋅ 0

Linux用户态进程的内存管理

上一篇我们了解了内存在内核态是如何管理的,本篇文章我们一起来看下内存在用户态的使用情况,如果上一篇文章说是内核驱动工程师经常面对的内存管理问题,那本篇就是应用工程师常面对的问题。...

p23onzq ⋅ 04/22 ⋅ 0

kdump转储的内核实现

前面一篇文章介绍了kexec和kdump的思想,本文着重讲它们的另一个方面,就是kdump到底是如何转储垮掉内核的内存映像的。首先定义一个链表,它很重要。 static LISTHEAD(vmcorelist); unsigne...

晨曦之光 ⋅ 2012/04/10 ⋅ 0

使用 kexec 快速重启 Linux

随着计算机系统变得更快更好,系统重新启动时间也需要跟上发展。实际上,随着系统的处理器速度、存储容量和资源性能变得更加先进和复杂,重新启动的 时间竟变长了。虽然更长的重新启动时间对...

红薯 ⋅ 2009/02/19 ⋅ 0

Linux内核学习笔记(四)进程管理

进程简介 进程(Process)是Unix操作系统最基本的抽象概念之一。进程是正在执行的程序,同时也是操作系统进行资源管理的最小单位,进程需要管理打开的文件、挂起的信号、内核内部数据、处理器...

damontive ⋅ 05/09 ⋅ 0

Linux学习笔记(os)

计算机组成: 存储器:内存和外存 (CPU一般会有缓存L1 L2甚至L3,一级缓存几十k到几百k (分数据Cache和指令Cache,与CPU同频),二级缓存几百k到几m(现在一般为CPU内置,与CPU同频,若外置...

赵-猛 ⋅ 2016/01/10 ⋅ 0

linux程序的命令行参数

程序执行的时候需要命令行参数,linux中更是这样,随便在shell输入/bin/XX --help后列举出来的参数让你头晕眼花,可是这些参数是怎么进入程序的呢,我们知道程序执行的时候一般从main开始,而...

晨曦之光 ⋅ 2012/04/10 ⋅ 0

[翻译] getauxval() and the auxiliary vector

[翻译] getauxval() and the auxiliary vector @(Linux)[getauxval auxiliary] ----------[TOC] 本文公开首发于阿里聚安全博客:https://jaq.alibaba.com/community/index.htm?spm=0.0.0.0.y......

i不歪 ⋅ 2016/06/07 ⋅ 0

Windows 原生运行 Linux 的技术细节

英文原文:Details on How Linux Runs Natively on Windows Microsoft 最近宣布了将 Linux Bash 与 Windows 10 进行集成的意图,通过这种集成,Windows 10 用户将能在操作系统中原生运行 Li...

德国骨科院长 ⋅ 2016/05/03 ⋅ 44

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Springboot2 之 Spring Data Redis 实现消息队列——发布/订阅模式

一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式,这里利用redis消息“发布/订阅”来简单实现订阅者模式。 实现之前先过过 redis 发布订阅的一些基础概念和操...

Simonton ⋅ 27分钟前 ⋅ 0

error:Could not find gradle

一.更新Android Studio后打开Project,报如下错误: Error: Could not find com.android.tools.build:gradle:2.2.1. Searched in the following locations: file:/D:/software/android/andro......

Yao--靠自己 ⋅ 昨天 ⋅ 0

Spring boot 项目打包及引入本地jar包

Spring Boot 项目打包以及引入本地Jar包 [TOC] 上篇文章提到 Maven 项目添加本地jar包的三种方式 ,本篇文章记录下在实际项目中的应用。 spring boot 打包方式 我们知道,传统应用可以将程序...

Os_yxguang ⋅ 昨天 ⋅ 0

常见数据结构(二)-树(二叉树,红黑树,B树)

本文介绍数据结构中几种常见的树:二分查找树,2-3树,红黑树,B树 写在前面 本文所有图片均截图自coursera上普林斯顿的课程《Algorithms, Part I》中的Slides 相关命题的证明可参考《算法(第...

浮躁的码农 ⋅ 昨天 ⋅ 0

android -------- 混淆打包报错 (warning - InnerClass ...)

最近做Android混淆打包遇到一些问题,Android Sdutio 3.1 版本打包的 错误如下: Android studio warning - InnerClass annotations are missing corresponding EnclosingMember annotation......

切切歆语 ⋅ 昨天 ⋅ 0

eclipse酷炫大法之设置主题、皮肤

eclipse酷炫大法 目前两款不错的eclipse 1.系统设置 Window->Preferences->General->Appearance 2.Eclipse Marketplace下载【推荐】 Help->Eclipse Marketplace->搜索‘theme’进行安装 比如......

anlve ⋅ 昨天 ⋅ 0

vim编辑模式、vim命令模式、vim实践

vim编辑模式 编辑模式用来输入或修改文本内容,编辑模式除了Esc外其他键几乎都是输入 如何进入编辑模式 一般模式输入以下按键,均可进入编辑模式,左下角提示 insert(中文为插入) 字样 i ...

蛋黄Yolks ⋅ 昨天 ⋅ 0

大数据入门基础:SSH介绍

什么是ssh 简单说,SSH是一种网络协议,用于计算机之间的加密登录。 如果一个用户从本地计算机,使用SSH协议登录另一台远程计算机,我们就可以认为,这种登录是安全的,即使被中途截获,密码...

董黎明 ⋅ 昨天 ⋅ 0

web3j教程

web3j是一个轻量级、高度模块化、响应式、类型安全的Java和Android类库提供丰富API,用于处理以太坊智能合约及与以太坊网络上的客户端(节点)进行集成。 汇智网最新发布的web3j教程,详细讲解...

汇智网教程 ⋅ 昨天 ⋅ 0

谷歌:安全问题机制并不如你想象中安全

腾讯科技讯 5月25日,如今的你或许已经对许多网站所使用的“安全问题机制”习以为常了,但你真的认为包括“你第一个宠物的名字是什么?”这些问题能够保障你的帐户安全吗? 根据谷歌(微博)安...

问题终结者 ⋅ 昨天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部