AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Linux下的系统编程——共享存储映射（十）

2024-02-06 63
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Linux下的系统编程——共享存储映射（十）

一.文件间进程通信：

打开的文件是内核中的一块缓冲区。多个无血缘关系的进程，可以同时访问该文件。

两个完全独立没有血缘关系的进程文件之间也可以完成进程间的通信

test1.c 先执行,将数据写入文件test.txt

 

/*
 * 先执行,将数据写入文件test.txt
 */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
 
#define N 5
 
int main(void)
{
    char buf[1024];
    char *str = "--------------secesuss-------------\n";
    int ret;
 
    int fd = open("test.txt", O_RDWR|O_TRUNC|O_CREAT, 0664);
 
    //直接打开文件写入数据
    write(fd, str, strlen(str));
    printf("test1 write into test.txt finish\n");
 
    sleep(N);
 
    lseek(fd, 0, SEEK_SET);
    ret = read(fd, buf, sizeof(buf));
    ret = write(STDOUT_FILENO, buf, ret);
 
    if (ret == -1) {
        perror("write second error");
        exit(1);
    }
 
    close(fd);
 
    return 0;
}

test2.c   后执行,尝试读取另外一个进程写入文件的内容

/*
 * 后执行,尝试读取另外一个进程写入文件的内容
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
 
int main(void)
{
    char buf[1024];
    char *str = "----------test2 write secesuss--------\n";
    int ret;
 
    sleep(2);   //睡眠2秒,保证test1将数据写入test.txt文件
 
    int fd = open("test.txt", O_RDWR);
 
    //尝试读取test.txt文件中test1写入的数据
    ret = read(fd, buf, sizeof(buf));   
 
    //将读到的数据打印至屏幕
    write(STDOUT_FILENO, buf, ret);
 
    //写入数据到文件test.txt中, 未修改读写位置
    write(fd, str, strlen(str));
 
    printf("test2 read/write finish\n");
 
    close(fd);
 
    return 0;
}

二、存储映射I/O：

       存储映射I/o(Memory-mapped l/o)使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成l/o操作。

       

       使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过 mmap函数来实现。

三、mmap函数： 

1.创建共享内存映射：

void mmap(void addr, size_t length, int prot, int flags, int fd, off_t offset);    

参数：

       addr：    指定映射区的首地址。通常传NULL，表示让系统自动分配

       length：  共享内存映射区的大小。（<= 文件的实际大小）

       prot：     共享内存映射区的读写属性。

       PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

       flags：   标注共享内存的共享属性。

       MAP_SHARED、MAP_PRIVATE

      fd:          用于创建共享内存映射区的那个文件的文件描述符。

       offset： 默认0，表示映射文件全部。偏移位置。需是 4k 的整数倍。

返回值：

       成功：映射区的首地址。

       失败：MAP_FAILED (void(-1))， errno

2.释放映射区：

int munmap(void addr, size_t length);        

   addr：mmap 的返回值

   length：大小

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <sys/mman.h>
#include <fcntl.h>
 
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
 
int main(int argc,char *argv[])
{
 
  char *p = NULL;
  int fd;
 
    //打开或者创建tetsmap文件
  fd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);
  if(fd == -1){
    sys_err("open error");
  }
 
  /*两个函数等价于ftruncate()函数
    lseek(fd,10,SEEK_END);
    write(fd,"\0",1);
  */
 
  ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
 
  p = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
  if(p == MAP_FAILED){
    sys_err("mmap error");
  }
 
    //使用p对文件进行读写操作
 
  strcpy(p,"hello mmap\n");
 
  printf("-------%s\n",p);//写操作
 
  int ret = munmap(p,len);
  if(ret == -1){
    sys_err("munmap error");
  }
  return 0;
}

3.使用注意事项：

语法
open()方法语法格式如下：
 
os.open(file, flags[, mode]);
 
参数
file – 要打开的文件
 
flags – 该参数可以是以下选项，多个使用 “|” 隔开：
 
O_RDONLY: 以只读的方式打开
O_WRONLY: 以只写的方式打开
O_RDWR : 以读写的方式打开
O_NONBLOCK: 打开时不阻塞
O_APPEND: 以追加的方式打开
O_CREAT: 创建并打开一个新文件
O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限）
O_EXCL: 如果指定的文件存在，返回错误
O_SHLOCK: 自动获取共享锁
O_EXLOCK: 自动获取独立锁
O_DIRECT: 消除或减少缓存效果
O_FSYNC : 同步写入
O_NOFOLLOW: 不追踪软链接
 
 
 
1）PROT_READ：表示内存段内的内容可写；
 
2）PROT_WRITE：表示内存段内的内容可读；
 
3）PROT_EXEC：表示内存段中的内容可执行；
 
4）PROT_NONE：表示内存段中的内容根本没法访问。

 （1）. 用于创建映射区的文件大小为 0，实际指定非0大小创建映射区，出 “总线错误”。

  fd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);  //O_RDWR : 以读写的方式打开
  if(fd == -1){
    sys_err("open error");
  }
 
    //ftruncate(fd,20);
  //int len = lseek(fd,0,SEEK_END);
 
  int len = 20;
 
    //PROT_READ：表示内存段内的内容可写；   PROT_WRITE：表示内存段内的内容可读
 
    p = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);      //可读可写

   （2） 用于创建映射区的文件大小为 0，实际制定0大小创建映射区， 出 “无效参数”。

  fd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);    //O_RDWR : 以读写的方式打开
  if(fd == -1){
    sys_err("open error");
  }
    
    //ftruncate(fd,20);
  //int len = lseek(fd,0,SEEK_END);
 
  int len = 0;
 
    //PROT_READ：表示内存段内的内容可写；   PROT_WRITE：表示内存段内的内容可读
 
    p = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);      //可读可写

 

   （3）. 用于创建映射区的文件读写属性为，只读。映射区属性为 读、写。 出 “无效参数”。

  fd = open("testmap",O_RDONLY|O_CREAT|O_TRUNC,0644);    //O_RDONLY: 以只读的方式打开
  if(fd == -1){
    sys_err("open error");
  }
 
  ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
 
  //int len = 0;
 
    //PROT_READ：表示内存段内的内容可写；   PROT_WRITE：表示内存段内的内容可读
 
    p = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);      //可读可写

   （4）. 创建映射区，需要read权限。当访问权限指定为 “共享”MAP_SHARED是， mmap的读写权限，应该 <=文件的open权限。    只写不行。

  //fd = open("testmap",O_RDONLY|O_CREAT|O_TRUNC,0644);
  fd = open("testmap",O_WRONLY);    //文件的只写
  if(fd == -1){
    sys_err("open error");
  }
  ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
 
  //int len = 0;
 
  p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);  //文件只写

fd = open("testmap",O_RDWR);    //文件的读写

注意：当文件是读写的时候可以写，当文件是只读的时候可以是只读。当文件是只写的时候不能写

   （5）. 文件描述符fd，在mmap创建映射区完成即可关闭。后续访问文件，用地址访问。

  //fd = open("testmap",O_RDONLY|O_CREAT|O_TRUNC,0644);
  fd = open("testmap",O_RDWR);
  if(fd == -1){
    sys_err("open error");
  }
  ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
 
  //int len = 0;
 
  p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);//文件只写
  if(p == MAP_FAILED){
    sys_err("mmap error");
  }
  
  close(fd);    //创建映射区完成即可关闭

 （6）. offset 必须是 4096的整数倍。（MMU 映射的最小单位 4k ）

p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,1000);

p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,4096);

   （7）. 对申请的映射区内存，不能越界访问。 

p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);
 
               .......
 
strcpy(p+len+4096*4,"hello mmap\n");

 

   （8）. munmap用于释放的地址，必须是mmap申请返回的地址。

p = mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);
 
               .......
 
strcpy(p++,"hello mmap\n");

 

解决方法：

 char *temp = p;
 strcpy(temp++,"hello mmap\n");

 

   （9）. 映射区访问权限为 “私有”MAP_PRIVATE, 对内存所做的所有修改，只在内存有效，不会反应到物理磁盘上。

  int fdfd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);
  //fd = open("testmap",O_RDWR);
  
  if(fd == -1){
    sys_err("open error");
  }
  ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
  
 
  //int len = 0;
  p = mmap(NULL,len,PROT_WRITE|PROT_READ,MAP_PRIVATE,fd,0);//可读可写

   （10）.映射区访问权限为 “私有”MAP_PRIVATE, 需要open文件时，有读权限用于创建映射区即可。

    int fd;
  //int fd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);
  fd = open("testmap",O_RDONLY);    //O_RDONLY: 以只读的方式打开
  
  if(fd == -1){
    sys_err("open error");
  }
  //ftruncate(fd,20);
  int len = lseek(fd,0,SEEK_END);
  
 
  //int len = 0;
  p = mmap(NULL,len,PROT_WRITE|PROT_READ,MAP_PRIVATE,fd,0);//可读可写
 
  if(p == MAP_FAILED){
    sys_err("mmap error");
  }

4.mmap函数的保险调用方式：

   1. fd = open（"文件名"， O_RDWR）;

   2. mmap(NULL, 有效文件大小， PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

5.mmap父子进程通信：

       父子等有血缘关系的进程之间也可以通过 mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags:

      MAP_PRIVATE:(私有映射)父子进程各自独占映射区;

      MAP_SHARED:(共享映射)父子进程共享映射区;

 

父进程创建映射区，然后fork子进程，子进程修改映射区内容，而后，父进程读取映射区内容，查验是否共享。

思路：

父进程先创建映射区。 open（ O_RDWR） mmap( MAP_SHARED );

指定 MAP_SHARED 权限

fork() 创建子进程。

一个进程读， 另外一个进程写。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
 
//全局变量
int var = 100;
 
int main(void)
{
  int *p;
  pid_t pid;
 
  int fd;
  fd = open("temp",O_RDWR|O_CREAT|O_TRUNC,0644);
  if(fd < 0){
    perror("open error");
    exit(1);
  }
  unlink("temp");
  ftruncate(fd,4);
 
    p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);    //MAP_SHARED共享映射
  //p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);   //MAP_PRIVATE私有映射
 
  if(p == MAP_FAILED){        //注意：不是p == NULL
    perror("mapp error");
    exit(1);
  }
 
  close(fd);           //映射区建立完毕，即可关闭文件
 
  pid = fork();        //创建子进程
 
  if(pid == 0){        //子进程
    *p = 2000;       //写共享内存
    var = 1000;
    printf("child *p = %d,var = %d\n",*p,var);
  }else if(pid > 0){    //父进程
    sleep(1);
    printf("parent *p = %d,var = %d\n",*p,var);    //读共享内存
    wait(NULL);
 
    int ret = munmap(p,4);    //释放映射区
    if(ret == -1){
      perror("munmap error");
      exit(1);
    }
  }
 
  return 0;
}

//p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);    //MAP_SHARED共享映射
  p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);   //MAP_PRIVATE私有映射

6.无血缘关系进程间 mmap 通信：                  

   两个进程 打开同一个文件，创建映射区。

   指定flags 为 MAP_SHARED。

   一个进程写入，另外一个进程读出。

  【注意】：无血缘关系进程间通信。

                     mmap：数据可以重复读取。

                      fifo：数据只能一次读取。

匿名映射：只能用于血缘关系进程间通信

p = (int )mmap(NULL, 40,PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

写端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <errno.h>
 
struct student {
    int id;
    char name[256];
    int age;
};
 
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
 
int main(int argc, char *argv[])
{
    struct student stu = {1, "xiaoming", 18};
    struct student *p;
    int fd; 
 
    fd = open("test_map", O_RDWR|O_CREAT|O_TRUNC, 0664);
//    fd = open("test_map", O_RDWR);
    if (fd == -1)
        sys_err("open error");
 
    ftruncate(fd, sizeof(stu));
 
    p = mmap(NULL, sizeof(stu), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (p == MAP_FAILED)
        sys_err("mmap error");
 
    close(fd);
 
    while (1) {
        memcpy(p, &stu, sizeof(stu));
        stu.id++;
        sleep(2);
    }
    
    munmap(p, sizeof(stu));
 
  return 0;
}

读端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <errno.h>
 
struct student {
    int id;
    char name[256];
    int age;
};
 
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
 
int main(int argc, char *argv[])
{
    struct student stu;
    struct student *p;
    int fd; 
 
    fd = open("test_map", O_RDONLY);
    if (fd == -1)
        sys_err("open error");
 
    p = mmap(NULL, sizeof(stu), PROT_READ, MAP_SHARED, fd, 0);
    if (p == MAP_FAILED)
        sys_err("mmap error");
 
    close(fd);
 
    while (1) {
        printf("id= %d, name=%s, age=%d\n", p->id, p->name, p->age);
        sleep(1);
    }
    
    munmap(p, sizeof(stu));
 
  return 0;
}

7.mmap匿名映射区：

       通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open 一个temp文件，创建好了再unlink、close掉，比较麻烦。可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

匿名映射：只能用于血缘关系进程间通信。

p = (int )mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
 
int var = 100;
 
int main(void)
{
    int *p;
    pid_t pid;
 
  /*
    int fd,ret;
  fd = open("temp", O_RDWR|O_CREAT|O_TRUNC,0644);
  if(fd == -1){
    perror("open error");
    exit(1);
  }
  
  ret = unlink("temp");
  if(ret == -1){
    perror("unlink error");
    exit(1);
  }
  
  ftruncate(fd,4);
  */
 
 
    p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(p == MAP_FAILED){    //注意:不是p == NULL
        perror("mmap error");
        exit(1);
    }
    //close(fd);
 
    pid = fork();       //创建子进程
    if(pid == 0){
       *p = 7000;               // 写共享内存
        var = 1000;
        printf("child, *p = %d, var = %d\n", *p, var);
    } else {
        sleep(1);
        printf("parent, *p = %d, var = %d\n", *p, var);     // 读共享内存
        wait(NULL);
 
        int ret = munmap(p, 4);       //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }
 
    return 0;
}

  int fd = open("/dev/zero",O_RDWR);    ///dev/zero ---》 '\0'
 
    p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    // p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(p == MAP_FAILED){    //注意:不是p == NULL
        perror("mmap error");
        exit(1);
    }
    close(fd);


文章标签：
存储
Linux
关键词：
Linux编程
Linux系统
Linux映射
Linux存储
Linux系统存储
妄北y
目录
相关文章
洛秋_
|
3天前
|
存储 缓存 监控
Linux缓存管理：如何安全地清理系统缓存
在Linux系统中，内存管理至关重要。本文详细介绍了如何安全地清理系统缓存，特别是通过使用`/proc/sys/vm/drop_caches`接口。内容包括清理缓存的原因、步骤、注意事项和最佳实践，帮助你在必要时优化系统性能。
洛秋_
110 78
bruce_xiaowei
|
7天前
|
Linux Shell 网络安全
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
本指南介绍如何利用 HTA 文件和 Metasploit 框架进行渗透测试。通过创建反向 shell、生成 HTA 文件、设置 HTTP 服务器和发送文件，最终实现对目标系统的控制。适用于教育目的，需合法授权。
bruce_xiaowei
35 9
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
蓝易云
|
3天前
|
存储 监控 Linux
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中，`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息，而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数，可以更有效地进行性能分析和资源管理。通过本文的介绍，希望能帮助您更好地理解和使用这两个函数，提高嵌入式系统编程的效率和效果。
蓝易云
35 13
oioihoii
|
4天前
|
Ubuntu Linux C++
Win10系统上直接使用linux子系统教程（仅需五步！超简单，快速上手）
本文介绍了如何在Windows 10上安装并使用Linux子系统。首先，通过应用商店安装Windows Terminal和Linux系统（如Ubuntu）。接着，在控制面板中启用“适用于Linux的Windows子系统”并重启电脑。最后，在Windows Terminal中选择安装的Linux系统即可开始使用。文中还提供了注意事项和进一步配置的链接。
oioihoii
16 0
1436047922066202
|
15天前
|
存储 Oracle 安全
服务器数据恢复—LINUX系统删除/格式化的数据恢复流程
Linux操作系统是世界上流行的操作系统之一，被广泛用于服务器、个人电脑、移动设备和嵌入式系统。Linux系统下数据被误删除或者误格式化的问题非常普遍。下面北亚企安数据恢复工程师简单聊一下基于linux的文件系统（EXT2/EXT3/EXT4/Reiserfs/Xfs） 下删除或者格式化的数据恢复流程和可行性。
1436047922066202
21 0
众所周知
|
1月前
|
Linux 网络安全 数据安全/隐私保护
Linux 超级强大的十六进制 dump 工具：XXD 命令，我教你应该如何使用！
在 Linux 系统中，xxd 命令是一个强大的十六进制 dump 工具，可以将文件或数据以十六进制和 ASCII 字符形式显示，帮助用户深入了解和分析数据。本文详细介绍了 xxd 命令的基本用法、高级功能及实际应用案例，包括查看文件内容、指定输出格式、写入文件、数据比较、数据提取、数据转换和数据加密解密等。通过掌握这些技巧，用户可以更高效地处理各种数据问题。
众所周知
95 8
土木林森
|
1月前
|
监控 Linux
如何检查 Linux 内存使用量是否耗尽？这 5 个命令堪称绝了！
本文介绍了在Linux系统中检查内存使用情况的5个常用命令：`free`、`top`、`vmstat`、`pidstat` 和 `/proc/meminfo` 文件，帮助用户准确监控内存状态，确保系统稳定运行。
土木林森
256 6
龙大吉
|
1月前
|
Linux
在 Linux 系统中，“cd”命令用于切换当前工作目录
在 Linux 系统中，“cd”命令用于切换当前工作目录。本文详细介绍了“cd”命令的基本用法和常见技巧，包括使用“.”、“..”、“~”、绝对路径和相对路径，以及快速切换到上一次工作目录等。此外，还探讨了高级技巧，如使用通配符、结合其他命令、在脚本中使用，以及实际应用案例，帮助读者提高工作效率。
龙大吉
80 3
东方睿赢
|
1月前
|
监控 安全 Linux
在 Linux 系统中，网络管理是重要任务。本文介绍了常用的网络命令及其适用场景
在 Linux 系统中，网络管理是重要任务。本文介绍了常用的网络命令及其适用场景，包括 ping（测试连通性）、traceroute（跟踪路由路径）、netstat（显示网络连接信息）、nmap（网络扫描）、ifconfig 和 ip（网络接口配置）。掌握这些命令有助于高效诊断和解决网络问题，保障网络稳定运行。
东方睿赢
72 2
冷冻工厂
|
14天前
|
Linux Shell
Linux 10 个“who”命令示例
Linux 10 个“who”命令示例
冷冻工厂
44 14
Linux 10 个“who”命令示例

热门文章

最新文章

  • 1
    linux系统常见日志采集
  • 2
    Linux基础命令---验证组文件grpck
  • 3
    Linux下建立静态库的实例讲解
  • 4
    AIX下配置NFS共享给LINUX
  • 5
    OK335xS pwm buzzer Linux driver hacking
  • 6
    linux 终端shell : zsh 配置和使用
  • 7
    linux查看文件
  • 8
    linux文件系统的目录结构
  • 9
    Linux内核-协议栈-初始化流程分析
  • 10
    深入linux内核架构读书笔记-进程管理和调度
  • 1
    Linux系统的文本处理
    87
  • 2
    Linux对MySQL语法校验
    90
  • 3
    Linux为新创建的磁盘分区添加文件系统
    68
  • 4
    如何计算 Linux 上文件中的空行数？
    81
  • 5
    服务器Linux系统配置mysql数据库主从自动备份
    215
  • 6
    Linux文件系统
    61
  • 7
    Linux内核基础知识
    77
  • 8
    Linux网络编程 网络基础知识
    73
  • 9
    Linux系统编程之文件编程常用API回顾和文件编程一般步骤
    83
  • 10
    linux静态库，动态库总结
    61

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux服务器运维基本操作
  • 计算机基础与Linux入门
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序
  • 手动部署MySQL数据库（Alibaba Cloud Linux 2）
  • 部署并使用Docker（Alibaba Cloud Linux 3）
  • 部署Linux主机管理系统WDCP

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    DataWorks