RDMA-VERBS开发示例

最新推荐文章于 2024-08-30 14:11:28 发布
最新推荐文章于 2024-08-30 14:11:28 发布
阅读量231 收藏 4
点赞数 3
分类专栏： 随笔 文章标签： linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NJzhenrong/article/details/140928756
版权

RDMA-VERBS开发示例

1. RDMA开发模式

远程直接内存访问(即RDMA)是一种直接内存访问技术，它将数据直接从一台计算机的内存传输到另一台计算机，无需双方操作系统的介入。RDMA最早在Infiniband传输网络上实现，后来业界厂家把RDMA移植到传统Ethernet以太网上，降低了RDMA的使用成本，推动RDMA技术普及。RDMA主流有三种实现方式：Infiniband、RoCE、iWARP。

VERBS开发接口支持IB/iWARP/RoCE三大RDMA协议，通过统一接口，让同一份RDMA程序程序可以无视底层的硬件和链路差异运行在不同的环境中。

RDMA技术的特点这里不展开讲，网上有很多很好的资料，这篇文章主要展示使用VERBS接口RC模式最简收发的代码示例，流程如下：

RDMA-RC开发流程

主要分为以下几个阶段：

  • 初始化阶段：发送端与接收端初始化QP阶段，在该阶段创建QP，并设置相应的参数；
  • 地址交换阶段：通过手工、socket、cm等其他方式交换双方的“通信地址”，包括：lid、qpn、psn、gid；
  • 连接阶段：获取到远程的地址信息，调用相应的API连接到远程的QP；
  • 数据收发阶段：调用相应的接口在QP上进行数据收发；
  • 资源回收阶段：当不需要再传输数据时，依次回收QP相关的资源。

2. 发送端代码

int verbs_send(int dev_idx, unsigned int length)
{
    // 1. 获取设备列表
    struct ibv_device** dev_list = ibv_get_device_list(NULL);
    if (!dev_list) 
    {
        perror("Failed to get IB devices list");
        return -1;
    }
    // 2. 选择设备
    struct ibv_device* target_dev = dev_list[dev_idx];
    if (!target_dev)
    {
        fprintf(stderr, "No IB devices found\n");
        return -2;
    }
    // 3. 打开设备
    struct ibv_context* ctx = ibv_open_device(target_dev);
    if (!ctx) 
    {
        fprintf(stderr, "Couldn't get context for %s\n", ibv_get_device_name(target_dev));
        return -3;
    }
    // 4. 分配保护域PD
    struct ibv_pd* pd = ibv_alloc_pd(ctx);
    if (!pd) 
    {
        fprintf(stderr, "Couldn't allocate PD\n");
        return -4;
    }
    // 5. 注册内存区域
    unsigned int mr_size = 16 * 1048576;
    void* mr_buffer = memalign(1024, mr_size);
    struct ibv_mr* mr = ibv_reg_mr(pd, mr_buffer, mr_size, IBV_ACCESS_LOCAL_WRITE);
    if (!mr) 
    {
        fprintf(stderr, "Couldn't register MR\n");
        return -5;
    }
    // 6. 创建CQ
    unsigned int rx_depth = 500;
    struct ibv_cq* cq = ibv_create_cq(ctx, rx_depth, NULL, NULL, 0);
    if (!cq)
    {
        fprintf(stderr, "Couldn't create CQ\n");
        return -6;
    }
    // 7. 创建QP
    struct ibv_qp_init_attr init_attr = {
        .send_cq = cq,
        .recv_cq = cq,
        .cap = {
        .max_send_wr = 1,
        .max_recv_wr = rx_depth,
        .max_send_sge = 2,
        .max_recv_sge = 2
    },
        .qp_type = IBV_QPT_RC
    };
    struct ibv_qp* qp = ibv_create_qp(pd, &init_attr);
    if (!qp)
    {
        fprintf(stderr, "Couldn't create QP\n");
        return -7;
    }
    // 8. 修改QP到INIT
    unsigned char local_port_num = 1;
    struct ibv_qp_attr attr = {
        .qp_state = IBV_QPS_INIT,
        .qp_access_flags = 0,
        .pkey_index = 0,
        .port_num = local_port_num
    };
	
    int ret = ibv_modify_qp(qp,
        &attr, 
        IBV_QP_STATE | 
        IBV_QP_PKEY_INDEX |
        IBV_QP_PORT |
        IBV_QP_ACCESS_FLAGS);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to INIT\n");
        return -8;
    }
    // 查询lid信息
    struct ibv_port_attr port_attr;
    if (ibv_query_port(ctx, local_port_num, &port_attr)) 
    {
        fprintf(stderr, "Couldn't get port info\n");
        return 1;
    }
    // 输出地址
    int local_lid = port_attr.lid;
    int local_qpn = qp->qp_num;
    int local_psn = lrand48() & 0xffffff;
    int local_gidx = 0;
    union ibv_gid local_gid;
    if (ibv_query_gid(ctx, local_port_num, local_gidx, &local_gid))
    {
        fprintf(stderr, "can't read sgid of index %d\n", local_gidx);
        return 1;
    }
    printf("local address lid qpn psn gid: %04x %06x %06x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
        local_lid, qp->qp_num, local_psn, 
        local_gid.raw[0], local_gid.raw[1], local_gid.raw[2], local_gid.raw[3],
        local_gid.raw[4], local_gid.raw[5], local_gid.raw[6], local_gid.raw[7],
        local_gid.raw[8], local_gid.raw[9], local_gid.raw[10], local_gid.raw[11],
        local_gid.raw[12], local_gid.raw[13], local_gid.raw[14], local_gid.raw[15]);
    // 9. socket获取其他方式交换连接信息，包括：
    // - lid, 16 bit
    // - qpn, 24 bit
    // - psn, 24 bit
    unsigned int remote_lid = 0;
    unsigned int remote_qpn = 0;
    unsigned int remote_psn = 0;
    char remote_gidstr[33];
    union ibv_gid remote_gid;
    printf("input remote address info: ");
    scanf("%x %x %x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", 
        &remote_lid, &remote_qpn, &remote_psn, 
        remote_gid.raw + 0, remote_gid.raw + 1, remote_gid.raw + 2, remote_gid.raw + 3, 
        remote_gid.raw + 4, remote_gid.raw + 5, remote_gid.raw + 6, remote_gid.raw + 7, 
        remote_gid.raw + 8, remote_gid.raw + 9, remote_gid.raw + 10, remote_gid.raw + 11, 
        remote_gid.raw + 12, remote_gid.raw + 13, remote_gid.raw + 14, remote_gid.raw + 15);
    // 10. 修改QP状态为RTR
    unsigned char local_sl = 3;
    struct ibv_qp_attr rtr_attr = {
        .qp_state = IBV_QPS_RTR,
        .path_mtu = IBV_MTU_4096,
        .rq_psn = remote_psn,
        .dest_qp_num = remote_qpn,
        .ah_attr = {
            .dlid = (uint16_t)remote_lid,
            .sl = local_sl,
            .src_path_bits = 0,
            .is_global = 0,
            .port_num = local_port_num
        },
        .max_dest_rd_atomic = 1,
        .min_rnr_timer = 12
    };

    if (remote_gid.global.interface_id) 
    {
        rtr_attr.ah_attr.is_global = 1;
        rtr_attr.ah_attr.grh.hop_limit = 1;
        rtr_attr.ah_attr.grh.dgid = remote_gid;
        rtr_attr.ah_attr.grh.sgid_index = local_gidx;
    }
    ret = ibv_modify_qp(qp,
        &rtr_attr,
        IBV_QP_STATE |
        IBV_QP_AV |
        IBV_QP_PATH_MTU |
        IBV_QP_DEST_QPN |
        IBV_QP_RQ_PSN |
        IBV_QP_MAX_DEST_RD_ATOMIC |
        IBV_QP_MIN_RNR_TIMER);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to RTR %s\n", strerror(ret));
        return -11;
    }
    // 11. 修改QP状态为RTS状态
    struct ibv_qp_attr rts_attr = rtr_attr;
    rts_attr.qp_state = IBV_QPS_RTS;
    rts_attr.timeout = 14;
    rts_attr.retry_cnt = 7;
    rts_attr.rnr_retry = 7;
    rts_attr.sq_psn = local_psn;
    rts_attr.max_rd_atomic = 1;
    ret = ibv_modify_qp(qp,
        &rts_attr,
        IBV_QP_STATE |
        IBV_QP_TIMEOUT |
        IBV_QP_RETRY_CNT |
        IBV_QP_RNR_RETRY |
        IBV_QP_SQ_PSN |
        IBV_QP_MAX_QP_RD_ATOMIC);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to RTS\n");
        return -11;
    }
    // 12. 发送数据
    unsigned int total_count = 10000000;
    unsigned int flags = IBV_SEND_SIGNALED;
    struct ibv_sge list[2];
    list[0].length = 16;
    list[0].addr = (uint64_t)mr_buffer;
    list[0].lkey = mr->lkey;
    sprintf((char*)list[0].addr, "%s", "data from rdma ");
    memset((char*)list[0].addr, 'a', list[0].length);
    list[1].length = length;
    list[1].addr = (uint64_t)((char*)mr_buffer + 128);
    memset((char*)list[1].addr, '\0', list[1].length);
    list[1].lkey = mr->lkey;
    for (int i = 0; i < total_count; ++i)
    {
        sprintf((char*)list[1].addr, "%d", i);
        struct ibv_send_wr wr = {
            .wr_id = (uint64_t)i,
            .sg_list = list,
            .num_sge = 2,
            .opcode = IBV_WR_SEND,
            .send_flags = flags,
        };
        struct ibv_send_wr *bad_wr;
        ret = ibv_post_send(qp, &wr, &bad_wr);
        if (ret != 0)
        {
            fprintf(stderr, "ibv_post_send failed %s.\n", strerror(errno));
        }
        // 13. pool cq
        int ne = 0;
        do 
        {
            struct ibv_wc wc[1];
            ne = ibv_poll_cq(cq, 1, wc);
            if (ne < 0) 
            {
                fprintf(stderr, "poll CQ failed %d\n", ne);
                return 1;
            }
        } while (ne < 1);
    }
    return 0;
}

3. 接收端代码

int verbs_receive(int dev_idx)
{
    // 1. 获取设备列表
    struct ibv_device** dev_list = ibv_get_device_list(NULL);
    if (!dev_list) 
    {
        perror("Failed to get IB devices list");
        return -1;
    }
    // 2. 选择设备
    struct ibv_device* target_dev = dev_list[dev_idx];
    if (!target_dev)
    {
        fprintf(stderr, "No IB devices found\n");
        return -2;
    }
    // 3. 打开设备
    struct ibv_context* ctx = ibv_open_device(target_dev);
    if (!ctx) 
    {
        fprintf(stderr, "Couldn't get context for %s\n", ibv_get_device_name(target_dev));
        return -3;
    }
    // 4. 分配保护域PD
    struct ibv_pd* pd = ibv_alloc_pd(ctx);
    if (!pd) 
    {
        fprintf(stderr, "Couldn't allocate PD\n");
        return -4;
    }
    // 5. 注册内存区域
    unsigned int mr_size = 16 * 1048576;
    void* mr_buffer = memalign(1024, mr_size);
    struct ibv_mr* mr = ibv_reg_mr(pd, mr_buffer, mr_size, IBV_ACCESS_LOCAL_WRITE);
    if (!mr) 
    {
        fprintf(stderr, "Couldn't register MR\n");
        return -5;
    }
    // 6. 创建CQ
    unsigned int rx_depth = 5000;
    struct ibv_cq* cq = ibv_create_cq(ctx, rx_depth, NULL, NULL, 0);
    if (!cq)
    {
        fprintf(stderr, "Couldn't create CQ\n");
        return -6;
    }
    // 7. 创建QP
    struct ibv_qp_init_attr init_attr = {
        .send_cq = cq,
        .recv_cq = cq,
        .cap = {
        .max_send_wr = 1,
        .max_recv_wr = rx_depth,
        .max_send_sge = 2,
        .max_recv_sge = 2
    },
        .qp_type = IBV_QPT_RC
    };
    struct ibv_qp* qp = ibv_create_qp(pd, &init_attr);
    if (!qp)
    {
        fprintf(stderr, "Couldn't create QP\n");
        return -7;
    }
    // 8. 修改QP到INIT
    unsigned char local_port_num = 1;
    struct ibv_qp_attr attr = {
        .qp_state = IBV_QPS_INIT,
        .qp_access_flags = 0,
        .pkey_index = 0,
        .port_num = local_port_num
    };
    int ret = ibv_modify_qp(qp,
        &attr, 
        IBV_QP_STATE | 
        IBV_QP_PKEY_INDEX |
        IBV_QP_PORT |
        IBV_QP_ACCESS_FLAGS);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to INIT\n");
        return -8;
    }
    // 9. POST RECV
    struct ibv_sge list = {
        .addr = (uint64_t)mr_buffer,
        .length = mr_size,
        .lkey = mr->lkey
    };
    struct ibv_recv_wr wr = {
        .wr_id = 1,
        .sg_list = &list,
        .num_sge = 1,
    };
    struct ibv_recv_wr *bad_wr;
    for (int i = 0; i < rx_depth; ++i)
    {
        ret = ibv_post_recv(qp, &wr, &bad_wr);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to ibv_post_recv\n");
            return -9;
        }
    }
    // 查询lid信息
    struct ibv_port_attr port_attr;
    if (ibv_query_port(ctx, local_port_num, &port_attr)) 
    {
        fprintf(stderr, "Couldn't get port info\n");
        return 1;
    }
    // 输出地址
    int local_lid = port_attr.lid;
    int local_qpn = qp->qp_num;
    int local_psn = lrand48() & 0xffffff;
    int local_gidx = 0;
    union ibv_gid local_gid;
    if (ibv_query_gid(ctx, local_port_num, local_gidx, &local_gid))
    {
        fprintf(stderr, "can't read sgid of index %d\n", local_gidx);
        return 1;
    }
    printf("local address lid qpn psn gid: %04x %06x %06x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
        local_lid, qp->qp_num, local_psn,
        local_gid.raw[0], local_gid.raw[1], local_gid.raw[2], local_gid.raw[3],
        local_gid.raw[4], local_gid.raw[5], local_gid.raw[6], local_gid.raw[7],
        local_gid.raw[8], local_gid.raw[9], local_gid.raw[10], local_gid.raw[11],
        local_gid.raw[12], local_gid.raw[13], local_gid.raw[14], local_gid.raw[15]);
    // 连接到发送端
    unsigned int remote_lid = 0;
    unsigned int remote_qpn = 0;
    unsigned int remote_psn = 0;
    union ibv_gid remote_gid;
    printf("input remote address info: ");
    scanf("%x %x %x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", 
        &remote_lid, &remote_qpn, &remote_psn, 
        remote_gid.raw + 0, remote_gid.raw + 1, remote_gid.raw + 2, remote_gid.raw + 3, 
        remote_gid.raw + 4, remote_gid.raw + 5, remote_gid.raw + 6, remote_gid.raw + 7, 
        remote_gid.raw + 8, remote_gid.raw + 9, remote_gid.raw + 10, remote_gid.raw + 11, 
        remote_gid.raw + 12, remote_gid.raw + 13, remote_gid.raw + 14, remote_gid.raw + 15);
    // 10. 修改QP为RTR
    unsigned char local_sl = 3;
    struct ibv_qp_attr rtr_attr = {
        .qp_state = IBV_QPS_RTR,
        .path_mtu = IBV_MTU_4096,
        .rq_psn = remote_psn,
        .dest_qp_num = remote_qpn,
        .ah_attr = {
            .dlid = (uint16_t)remote_lid,
            .sl = local_sl,
            .src_path_bits = 0,
            .is_global = 0,
            .port_num = local_port_num
        },
        .max_dest_rd_atomic = 1,
        .min_rnr_timer = 12
    };
    if (remote_gid.global.interface_id) 
    {
        rtr_attr.ah_attr.is_global = 1;
        rtr_attr.ah_attr.grh.hop_limit = 1;
        rtr_attr.ah_attr.grh.dgid = remote_gid;
        rtr_attr.ah_attr.grh.sgid_index = local_gidx;
    }
    ret = ibv_modify_qp(qp,
        &rtr_attr,
        IBV_QP_STATE |
        IBV_QP_AV |
        IBV_QP_PATH_MTU |
        IBV_QP_DEST_QPN |
        IBV_QP_RQ_PSN |
        IBV_QP_MAX_DEST_RD_ATOMIC |
        IBV_QP_MIN_RNR_TIMER);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to RTR %s\n", strerror(ret));
        return -11;
    }
    // 11. 修改QP状态为RTS状态
    struct ibv_qp_attr rts_attr = rtr_attr;
    rts_attr.qp_state = IBV_QPS_RTS;
    rts_attr.timeout = 14;
    rts_attr.retry_cnt = 7;
    rts_attr.rnr_retry = 7;
    rts_attr.sq_psn = local_psn;
    rts_attr.max_rd_atomic = 1;
    ret = ibv_modify_qp(qp,
        &rts_attr,
        IBV_QP_STATE |
        IBV_QP_TIMEOUT |
        IBV_QP_RETRY_CNT |
        IBV_QP_RNR_RETRY |
        IBV_QP_SQ_PSN |
        IBV_QP_MAX_QP_RD_ATOMIC);
    if (ret != 0) 
    {
        fprintf(stderr, "Failed to modify QP to RTS\n");
        return -11;
    }
    unsigned int printGap = 1;
    unsigned int count = 0;
    static uint64_t s_lastTime = 0;
    while (true)
    {
        struct ibv_wc wc[1];
        int ne = ibv_poll_cq(cq, 1, wc);
        if (ne < 0) 
        {
            fprintf(stderr, "poll CQ failed %d\n", ne);
            return 1;
        }
        if (ne == 0)
        {
            continue;
        }
        wc[0].status;
        // 依次处理wc
        if (count++ % printGap == 0)
        {
            printf("recv length %d content %s \n", wc[0].byte_len, mr_buffer);
        }
        // 9. POST RECV
        ret = ibv_post_recv(qp, &wr, &bad_wr);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to ibv_post_recv\n");
            return -9;
        }
    }
    return 0;
}

4. 总控代码

#include <infiniband/verbs.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <unistd.h>

// verbs_receive

// verbs_send

void printHelp()
{
    printf("./rdma_verbs_example r \n");
    printf("./rdma_verbs_example s length\n");
}

int main(int argc, char* argv[])
{
    if (argc < 2)
    {
        printHelp();
        return -1;
    }
    // 按照真实的环境修改
    int dev_index = 1;
    int is_send = argv[1][0] == 's';
    if (is_send)
    {
        if (argc < 3)
        {
            printHelp();
            return -1;
        }
        unsigned int length = 10240;
        sscanf(argv[2], "%u", &length);
        verbs_send(dev_index, length);
    }
    else
    {
        verbs_receive(dev_index);
    }
    return 0;
}

4. 编译运行

  • 把代码保存到rdma_example.cpp，根据自身的网卡信息，修改main函数中的dev_index;
  • g++ rdma_example.cpp -lverbs -o rdma_example
  • 接收端：./rdma_example r
  • 发送端：./rdma_example s 16384
  • 手动输入对端输出的地址
  • 观察结果

5. 参考资料

  • https://github.com/linux-rdma/rdma-core/tree/master/libibverbs/examples
  • https://docs.nvidia.com/rdma-aware-networks-programming-user-manual-1-7.pdf
NJzhenrong
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【RDMA项目】如何使用rdma-core进行调用开发一个实战项目
妄北y
07-31 328
RDMA (Remote Direct Memory Access) 是一种网络协议，可以在计算节点之间实现高效的内存数据传输，而无需CPU的干预。rdma-core 是 RDMA 的一个用户空间库，提供了一些简单易用的接口来使用 RDMA 功能。
【RDMA】技术详解（四）：RDMA之Verbs和编程步骤
小鱼菜鸟的博客
07-22 1324
目录 RDMA编程基础 什么是Verbs 相关名词解释 Verbs API Verbs API是什么 设计Verbs API的原因 Verbs API所包含的内容 使用Verbs API编写RDMA应用程序 查看接口定义 包含头文件 编写应用 编译 & 执行 官方示例程序 libibverbs librdmacm ...
如何使用rdma-core来实现RDMA操作
妄北y
07-29 1153
rdma-core 是一个开源项目，为远程直接内存访问（RDMA）提供用户空间的支持。它包括 RDMA 设备的驱动程序、库和工具，旨在简化 RDMA 应用的开发和部署。
【RDMA】rdma-core驱动源码包|ibverbs|rdmacm
bandaoyu的note
12-31 5662
目前，支持 Mellanox InfiniSwitch-III（IS3）和 InfiniSwitch-IV（IS4）。使用 RDMA CM API，更高层，封装了一些操作，使得代码更简洁易读。所使用的名称或地址必须经过RDMA设备路由。建立可靠的RDMA连接，使用librdmacm在两个节点之间。使用librdmacm在节点之间建立一组RDMA多播通信路径，可选择将数据包传输给接收节点，然后拆除通信。使用librdmacm在两个节点之间建立一组可靠的RDMA连接，可选择在节点之间传输数据，然后断开连接。
【RDMA】12. RDMA之Verbs|OFED
bandaoyu的note
01-25 4056
原文：https://zhuanlan.zhihu.com/p/329198771 Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义，规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。 举个例子，IB规范要求所有RDMA设备必须支持Create QP的行为（IB 规范11.2.5.1）： 描述： ​ 为指定的设备创建一个QP。 ​ 用户必
教你在虚拟机上把普通网卡配置成softroce设备来运行rdma-core中的示例程序
妄北y
07-30 895
在虚拟机环境中，将普通网卡配置为 SoftRoCE 设备可以帮助你在没有实际硬件 RDMA 设备的情况下测试和体验 RDMA 功能。SoftRoCE 是 RoCE（RDMA over Converged Ethernet）协议的一个软件实现。
12. RDMA之Verbs
weixin_39094034的博客
10-31 753
Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义，规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。
rdma-read/write例程
qq_38158479的博客
11-04 469
rdma read/write例程
RDMA-send/recv例程
qq_38158479的博客
11-02 309
rdma例程
rdma-core-35.0.tar.gz
03-27
3. **示例代码**：可能包含了一些演示如何使用RDMA功能的示例程序，帮助开发者理解如何集成RDMA到他们的系统中。 4. **文档**：可能会有详细的用户指南和API参考，帮助开发者理解和使用rdma-core库。 5. **配置脚本...
rdma-sample.zip
07-24
标题中的"rdma-sample.zip"表明这是一个与RDMA（Remote Direct Memory Access）技术相关的示例压缩包，可能包含了用于教学或演示如何...同时，这些示例也可以作为开发自己RDMA应用的基础，帮助开发者快速上手RDMA编程。
Linux中的常见命令——用户管理命令
qq_45569925的博客
08-27 2053
默认创建用户的时候会在home文件夹下创建一个与用户同名的文件夹【该用户的主目录】，也可以在创建用户的时候设置该用户主目录的名称。【输入的密码是不在控制台显示的，输入完之后直接按回车键即可】使用wgh用户查看root下的文件。【此时的用户是没有密码的】给创建的用户设置密码。查看某个用户是否存在。
Linux高性能服务器编程 总结索引 | 第2章：IP协议详解
AsherGu的博客
08-29 1068
IP服务的特点；IPv4头部结构；IP分片；IP路由：IP模块工作流程，路由机制，路由表更新；IP转发；重定向；IPv6头部结构：IPv6固定头部结构，IPv6扩展头部
linux 系统如何进行nfs（第五节）
最新发布
weixin_44767571的博客
08-30 389
首先是 在虚拟机中的操作。然后是在开发板上的操作。
Linux报错：make[2]: *** No rule to make target ‘/usr/local/lib/libopus.a‘
VIFIN的博客
08-27 1137
解决报错：make[2]: *** No rule to make target '/usr/local/lib/libopus.a'
Linux下，执行shell遇let:not found
janet110617的博客
08-27 677
在Linux下执行shell脚本，提示let:not found错误，文章介绍了错误原因及其解决方法
在Linux中杀死占用某个端口的进程
靖妖傩舞
08-28 615
选项表示强制终止进程，但这种方式可能会导致数据丢失或其他不良后果，所以在使用时要谨慎。确定要杀死的进程 PID。从上述步骤中获取到占用端口 9997 的进程 PID。
虚拟机Linux(Centos7)系统静态IP设置
BQ Blog
08-30 656
这篇博客介绍了在虚拟机中配置Linux系统的静态IP地址的方法，适用于通过DHCP获取IP地址导致频繁更换IP的情况。首先，用户需要将虚拟机的网络模式更改为NAT模式，并在虚拟机网络编辑器中记录子网IP、子网掩码和网关。然后，编辑相应的网络配置文件，将网络协议更改为静态，并手动设置静态IP地址、子网掩码、网关和DNS。最后，重启网络服务并验证配置是否生效。
rdma-core依赖下载
12-27
rdma-core是用于在远程直接内存访问（RDMA）技术上执行的用户态库。要下载rdma-core的依赖，首先需要检查系统上是否已经安装了必要的依赖，例如cmake、libudev、libnl等。可以使用系统包管理器（如apt、yum等）来安装这些依赖。 一旦依赖项安装完成，可以从rdma-core的官方GitHub仓库中克隆代码，然后使用cmake来构建和编译rdma-core。在构建过程中，cmake会自动检测系统上是否安装了必要的依赖，并根据需要进行配置。 在构建和编译完成后，可以使用make install来将rdma-core安装到系统中。这样，rdma-core的依赖就会被自动安装到系统的标准位置，可以被其他程序所引用和使用。 除了从源代码构建和安装外，也可以通过系统包管理器直接安装预编译的rdma-core包。这样可以更加方便地获取rdma-core及其依赖项，同时也能够通过包管理器来进行更新和卸载操作。 总之，下载rdma-core的依赖需要首先安装必要的依赖项，然后通过源代码构建或者包管理器安装rdma-core。这样就可以在系统中使用rdma-core提供的RDMA功能了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值