eBPF汇编指令你还不知道？看这一篇文就够了

news2024/12/25 9:08:19

【好文推荐】

一文看懂linux 内核网络中 RPS/RFS 原理

怎么在Windows下使用Makefile文件

浅析linux内核网络协议栈--linux bridge

大家好，我是你们的彦祖，今天这篇文主要介绍 eBPF 的指令系统，对于想深入理解 eBPF 的同学千万不要错过，会对你有很大的帮助。

eBPF 指令系统

参考资料：
https://www.kernel.org/doc/html/latest/networking/filter.html#ebpf-opcode-encoding

BPF 是一个通用的 RISC 指令集，最初是为了用 C 的子集编写程序而设计的，这些程序可以通过编译器后端（例如 LLVM）编译成 BPF 指令，以便内核稍后可以通过将内核 JIT 编译器转换为原生操作码，以实现内核内部的最佳执行性能。

Linux内核学习资料领取直通车：全网最详Linux内核技术解析【附视频教程和源码资料】

Linux内核系统学习直通车，点击报名可直接免费观看：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈-学习视频教程-腾讯课堂

寄存器

eBPF 由 11 个 64 位寄存器、一个程序计数器和一个 512 字节的大 BPF 堆栈空间组成。寄存器被命名为r0- r10。操作模式默认为 64 位。64位的寄存器也可作32 位子寄存器使用，它们只能通过特殊的 ALU（算术逻辑单元）操作访问，使用低32位，高32位使用零填充。

寄存器的使用约定如下：

其他：在加载和存储指令中，寄存器 R6 是一个隐式输入，必须包含指向 sk_buff 的指针。寄存器 R0 是一个隐式输出，它包含从数据包中获取的数据。

指令格式

代码实现如下：

struct bpf_insn {
 __u8 code;  /* opcode */
 __u8 dst_reg:4; /* dest register */
 __u8 src_reg:4; /* source register */
 __s16 off;  /* signed offset */
 __s32 imm;  /* signed immediate constant */
};

指令类型

其中的op字段，如下：

+----------------+--------+--------------------+
|       5 bits            |   3 bits           |
|       xxxxxx            | instruction class  |
+----------------+--------+--------------------+
(MSB)                                      (LSB)

op字段的低3位，决定指令类型。指令类型包含：加载与存储指令、运算指令、跳转指令。

顺便提下：ebpf中一个字是四个字节大小，32 bits

  • BPF_LD 和 BPF_LDX: 两个类都用于加载操作。BPF_LD用于加载双字。后者是从 cBPF 继承而来的，主要是为了保持 cBPF 到 BPF 的转换效率，因为它们优化了 JIT 代码。
  • BPF_ST 和 BPF_STX: 两个类都用于存储操作，用于将数据从寄存器到存储器中。
  • BPF_ALU 和 BPF_ALU64: 分别是32位和64位下的ALU操作。
  • BPF_JMP 和 BPF_JMP32：跳转指令。JMP32的跳转范围是32位大小(一个 word)

运算和跳转指令

当 BPF_CLASS(code) == BPF_ALU 或 BPF_JMP 时，op字段可分为三部分，如下所示：

+----------------+--------+--------------------+
|   4 bits       |  1 bit |   3 bits           |
| operation code | source | instruction class  |
+----------------+--------+--------------------+
(MSB)                                      (LSB)

其中的第四位，可以为0或者1，在linux中，使用如下宏定义：

BPF_K     0x00
BPF_X     0x08
// #define BPF_CLASS(code) ((code) & 0x07)

在 eBPF 中，这意味着：

BPF_SRC(code) == BPF_X - use 'src_reg' register as source operand
BPF_SRC(code) == BPF_K - use 32-bit immediate as source operand
// #define BPF_SRC(code)   ((code) & 0x08)

如果 BPF_CLASS(code) 等于 BPF_ALU 或 BPF_ALU64，则 BPF_OP(code) 是以下之一：

BPF_ADD   0x00
BPF_SUB   0x10
BPF_MUL   0x20
BPF_DIV   0x30
BPF_OR    0x40
BPF_AND   0x50
BPF_LSH   0x60
BPF_RSH   0x70
BPF_NEG   0x80
BPF_MOD   0x90
BPF_XOR   0xa0
BPF_MOV   0xb0  /* eBPF only: mov reg to reg */
BPF_ARSH  0xc0  /* eBPF only: sign extending shift right */
BPF_END   0xd0  /* eBPF only: endianness conversion */

如果 BPF_CLASS(code) 等于 BPF_JMP 或 BPF_JMP32，则 BPF_OP(code) 是以下之一：

BPF_JA    0x00  /* BPF_JMP only */
BPF_JEQ   0x10
BPF_JGT   0x20
BPF_JGE   0x30
BPF_JSET  0x40
BPF_JNE   0x50  /* eBPF only: jump != */
BPF_JSGT  0x60  /* eBPF only: signed '>' */
BPF_JSGE  0x70  /* eBPF only: signed '>=' */
BPF_CALL  0x80  /* eBPF BPF_JMP only: function call */
BPF_EXIT  0x90  /* eBPF BPF_JMP only: function return */
BPF_JLT   0xa0  /* eBPF only: unsigned '<' */
BPF_JLE   0xb0  /* eBPF only: unsigned '<=' */
BPF_JSLT  0xc0  /* eBPF only: signed '<' */
BPF_JSLE  0xd0  /* eBPF only: signed '<=' */

加载和存储指令

当 BPF_CLASS(code) 等于 BPF_LD 或 BPF_ST 时，op字段可分为三部分，如下所示：

+--------+--------+-------------------+
| 3 bits | 2 bits |   3 bits          |
|  mode  |  size  | instruction class |
+--------+--------+-------------------+
(MSB)                             (LSB)

其中的size在linux中的有如下宏定义：

BPF_W   0x00    /* word=4 byte */
BPF_H   0x08    /* half word */
BPF_B   0x10    /* byte */
BPF_DW  0x18    /* eBPF only, double word */

mode在linux中的有如下宏定义：

BPF_IMM     0x00  /* used for 32-bit mov in classic BPF and 64-bit in eBPF */
BPF_ABS     0x20
BPF_IND     0x40
BPF_MEM     0x60
BPF_LEN     0x80  /* classic BPF only, reserved in eBPF */
BPF_MSH     0xa0  /* classic BPF only, reserved in eBPF */
BPF_ATOMIC  0xc0  /* eBPF only, atomic operations */
【文章福利】小编在群文件上传了一些个人觉得比较好得学习书籍、视频资料，有需要的可以进群 【977878001】领取！！！额外赠送一份价值699的内核资料包（含视频教程、电子书、实战项目及代码）

内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

学习直通车（免费报名）：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

ebpf指令集编程

eBPF编程有三种方式：BPF指令集编程、BPF C编程、BPF前端(BCC、bpftrace)。

为了演示指令，我们阅读一段指令集方式编程的代码。

代码

代码来源：sample/bpf/sock_example.c

代码逻辑：

  • popen()函数通过创建管道、fork和来打开进程调用shell。由于管道的定义是单向的，因此类型参数只能指定读或写，不能同时指定两者；这里，使用IPv4，ping主机5次，结果可以读取。
  • 创建一个BPF_MAP_TYPE_ARRAY类型的map。
  • 使用eBPF指令集进行编程，指令存放在prog中。关于这些指令代码的阅读，见下一节。
  • 将这些指令加载到内核中，指令程序的类型为BPF_PROG_TYPE_SOCKET_FILTER。
  • open_raw_sock返回一个原生套接字。通过该套接字，可以直接读取lo网络接口数据链路层的数据。
  • 附加eBPF程序到套接字(用作过滤器)。
  • 打印map中的一些信息。
/* eBPF example program:
 * - creates arraymap in kernel with key 4 bytes and value 8 bytes
 *
 * - loads eBPF program:
 *   r0 = skb->data[ETH_HLEN + offsetof(struct iphdr, protocol)];
 *   *(u32*)(fp - 4) = r0;
 *   // assuming packet is IPv4, lookup ip->proto in a map
 *   value = bpf_map_lookup_elem(map_fd, fp - 4);
 *   if (value)
 *        (*(u64*)value) += 1;
 *
 * - attaches this program to loopback interface "lo" raw socket
 *
 * - every second user space reads map[tcp], map[udp], map[icmp] to see
 *   how many packets of given protocol were seen on "lo"
 */
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <linux/bpf.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <stddef.h>
#include <bpf/bpf.h>
#include "bpf_insn.h"
#include "sock_example.h"

char bpf_log_buf[BPF_LOG_BUF_SIZE];

static int test_sock(void)
{
 int sock = -1, map_fd, prog_fd, i, key;
 long long value = 0, tcp_cnt, udp_cnt, icmp_cnt;

 map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(key), sizeof(value),
    256, 0);
 if (map_fd < 0) {
  printf("failed to create map '%s'\n", strerror(errno));
  goto cleanup;
 }

 struct bpf_insn prog[] = {
  BPF_MOV64_REG(BPF_REG_6, BPF_REG_1),
  BPF_LD_ABS(BPF_B, ETH_HLEN + offsetof(struct iphdr, protocol) /* R0 = ip->proto */),
  BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* *(u32 *)(fp - 4) = r0 */
  BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
  BPF_LD_MAP_FD(BPF_REG_1, map_fd),
  BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
  BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
  BPF_MOV64_IMM(BPF_REG_1, 1), /* r1 = 1 */
  BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0), /* xadd r0 += r1 */
  BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 */
  BPF_EXIT_INSN(),
 };
 size_t insns_cnt = sizeof(prog) / sizeof(struct bpf_insn);

 prog_fd = bpf_load_program(BPF_PROG_TYPE_SOCKET_FILTER, prog, insns_cnt,
       "GPL", 0, bpf_log_buf, BPF_LOG_BUF_SIZE);
 if (prog_fd < 0) {
  printf("failed to load prog '%s'\n", strerror(errno));
  goto cleanup;
 }

 sock = open_raw_sock("lo");

 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_BPF, &prog_fd,
         sizeof(prog_fd)) < 0) {
  printf("setsockopt %s\n", strerror(errno));
  goto cleanup;
 }

 for (i = 0; i < 10; i++) {
  key = IPPROTO_TCP;
  assert(bpf_map_lookup_elem(map_fd, &key, &tcp_cnt) == 0);

  key = IPPROTO_UDP;
  assert(bpf_map_lookup_elem(map_fd, &key, &udp_cnt) == 0);

  key = IPPROTO_ICMP;
  assert(bpf_map_lookup_elem(map_fd, &key, &icmp_cnt) == 0);

  printf("TCP %lld UDP %lld ICMP %lld packets\n",
         tcp_cnt, udp_cnt, icmp_cnt);
  sleep(1);
 }

cleanup:
 /* maps, programs, raw sockets will auto cleanup on process exit */
 return 0;
}

int main(void)
{
 FILE *f;

 f = popen("ping -4 -c5 localhost", "r");
 (void)f; //为什么代码中有这一行？

 return test_sock();
}

eBPF指令编程代码阅读

我们把这部分代码领出来，单独阅读下。

我在下面的连续的指令中，联系连续指令的上下文，注释了这些指令的含义。

在后续的内容中，逐个解释指令的含义，由于的单个指令，只解释其含义(不联系上下文解释其作用)。

 struct bpf_insn prog[] = {
  BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), /* R6 = R1*/ /* R6指向数据包地址 */
  BPF_LD_ABS(BPF_B, ETH_HLEN + offsetof(struct iphdr, protocol) /* R0 = ip->proto */), /*R6作为隐式输入，R0作为隐式输出。结果R0报错IP协议值*/
  BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* *(u32 *)(fp - 4) = r0 */ /* 将协议值保存在栈中*/
  BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /*R10只读寄存器，指向栈帧。复制一份到R2中*/
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ /* 内核bpf_map_lookup_elem函数的第二个参数key的内存地址放在R2中 */
  BPF_LD_MAP_FD(BPF_REG_1, map_fd), /* 内核bpf_map_lookup_elem函数的第一个参数map_fd放在R1中 */
  BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), /* 函数的返回值为value所在内存的地址，放在R0寄存器中*/
  BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2), /* 如果返回的内存地址为0，则向下跳两个指令 */
  BPF_MOV64_IMM(BPF_REG_1, 1), /* r1 = 1 */
  BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0), /* xadd r0 += r1 */ /* value的值加一；结果R0存储1，R1存储value地址 */
  BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 */
  BPF_EXIT_INSN(), /* R0作为返回值，返回零 */
 };

下面我们对上面代码逐行指令进行分享：

  1. 第一条指令
/* Short form of mov, dst_reg = src_reg */

#define BPF_MOV64_REG(DST, SRC)           \
  ((struct bpf_insn) {                    \
    .code  = BPF_ALU64 | BPF_MOV | BPF_X, \
    .dst_reg = DST,                       \
    .src_reg = SRC,                       \
    .off     = 0,                         \
    .imm     = 0 })

可以看到，这条指令是将源寄存器R1的值移动到R6寄存器中。其中，R1指向数据包的起始地址。

  1. 第二条指令
/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */

#define BPF_LD_ABS(SIZE, IMM)                     \
  ((struct bpf_insn) {                            \
    .code    = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS, \
    .dst_reg = 0,                                 \
    .src_reg = 0,                                 \
    .off     = 0,                                 \
    .imm     = IMM })

在加载和存储指令中，寄存器 R6 是一个隐式输入，寄存器 R0 是一个隐式输出。(？我要这 dst_reg 和 src_reg 有何用？)

可以需要明白数据包的格式，可以参考：MAC首部、IP首部、TCP首部 介绍。

根据偏移量，读取IP协议类型，例如，TCP 的协议号为 6，UDP 的协议号为 17，ICMP 的协议号为 1。其中，协议字段占8位。

所以，这条指令表示，将 IP 协议放入 R0 寄存器。

  1. 第三条指令
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */

#define BPF_STX_MEM(SIZE, DST, SRC, OFF)         \
  ((struct bpf_insn) {                           \
    .code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
    .dst_reg = DST,                              \
    .src_reg = SRC,                              \
    .off     = OFF,                              \
    .imm     = 0 })

R10是唯一的只读寄存器，包含用于访问 BPF 堆栈空间的帧指针地址。(关于栈帧结构可以参考：gdb调试之栈帧信息)

所以这里，将R0寄存器中的内容(上一步保存了协议类型)，保存到栈中。需要注意的是，这里是 BPF_W，只保存了 R0寄存器 中的第32位。

  1. 第四条指令

因为栈向下生长了。所以这里使用了 R2寄存器 指向栈顶。

至于 BPF_ALU64_IMM 的宏展开，这里不列出了，自行在 samples/bpf/bpf_insn.h 中查看。

这些宏展开数字在 include/uapi/linux/bpf.h 中查看。

这样，上面的指令展开，便是一个64位的二进制数，是不是很神奇~

  1. 第五条指令

这条指令比较有意思，我们看下。

/* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */

#define BPF_LD_IMM64(DST, IMM)           \
  BPF_LD_IMM64_RAW(DST, 0, IMM)

#define BPF_LD_IMM64_RAW(DST, SRC, IMM)  \
  ((struct bpf_insn) {                   \
    .code    = BPF_LD | BPF_DW | BPF_IMM,\
    .dst_reg = DST,                      \
    .src_reg = SRC,                      \
    .off     = 0,                        \
    .imm     = (__u32) (IMM) }),         \
  ((struct bpf_insn) {                   \
    .code    = 0,                        \
    .dst_reg = 0,                        \
    .src_reg = 0,                        \
    .off     = 0,                        \
    .imm     = ((__u64) (IMM)) >> 32 })

#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD 1
#endif

/* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */
#define BPF_LD_MAP_FD(DST, MAP_FD)    \
  BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)

可以看到，这条指令是将 map_fd 的值，保存到R1寄存器中。这时候，我们可能会好奇，这中间有 src_reg 什么事情？

上面我们可以看到，如果只是单纯将一个立即数保存到寄存器中，则 src_reg=0；如果这个立即数表示是一个 map_fd，则则 src_reg=1；

这样我们便可以区分指令中的立即数是否表示一个 map_fd。后面 replace_map_fd_with_map_ptr 函数会用到这个性质。

另外我试着组合了下 .code = 0；.code = BPF_LD | BPF_W | BPF_IMM。这确实没有含义？

  1. 第六条指令
/* Raw code statement block */

#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)  \
  ((struct bpf_insn) {                          \
    .code    = CODE,                            \
    .dst_reg = DST,                             \
    .src_reg = SRC,                             \
    .off     = OFF,                             \
    .imm     = IMM })

其中BPF_FUNC_map_lookup_elem的宏展开为1。至于跳转到1的位置，在verifier后是bpf_map_lookup_elem这个函数，则是后续的问题了。可以参考：fixup_bpf_calls

这里，可以从宏的名称看出是是跳转到bpf_map_lookup_elem函数位置。

  1. 第七条指令
/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */

#define BPF_JMP_IMM(OP, DST, IMM, OFF)     \
  ((struct bpf_insn) {                     \
    .code  = BPF_JMP | BPF_OP(OP) | BPF_K, \
    .dst_reg = DST,                        \
    .src_reg = 0,                          \
    .off     = OFF,                        \
    .imm     = IMM })

这条指令表示，R0寄存器 等于0，则向下跳过两个指令。

R0寄存器 这里存储的是协议号，根据 IP 协议号列表可知，但 IP 数据包中的协议为 “IPv6逐跳选项”，则向下跳过两个指令。

  1. 第八条指令

xadd - 交换相加。

  1. 第九条指令

R0是包含 BPF 程序退出值的寄存器，设置返回值 R0=0。

  1. 第十条指令
/* Program exit */

#define BPF_EXIT_INSN()                  \
    ((struct bpf_insn) {                 \
        .code  = BPF_JMP | BPF_EXIT,     \
        .dst_reg = 0,                    \
        .src_reg = 0,                    \
        .off     = 0,                    \
        .imm     = 0 })

运行这个程序

如果你想运行下这个程序，可以拉下源码，然后编译运行下。

拉取当前linux内核版本对应的源码，可以参考：ubuntu获取源码方式

$ sudo apt source linux

接着编译下sample/bpf目录下的bpf程序，可以参考：运行第一个bpf程序

$ make M=samples/bpf

运行程序，输出如下。(PS：我的lo在转发浏览器数据)（ping一次发送四个ICMP包？）

➜  bpf sudo ./sock_example
TCP 0 UDP 0 ICMP 0 packets
TCP 28 UDP 0 ICMP 4 packets
TCP 60 UDP 0 ICMP 4 packets
TCP 100 UDP 0 ICMP 8 packets
TCP 134 UDP 0 ICMP 12 packets
TCP 166 UDP 0 ICMP 16 packets
TCP 228 UDP 0 ICMP 16 packets
TCP 302 UDP 0 ICMP 16 packets
TCP 334 UDP 0 ICMP 16 packets
TCP 366 UDP 0 ICMP 16 packets

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/58660.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

实验五 计数/定时器的设计【Verilog】

实验五 计数/定时器的设计【Verilog】

实验五 计数/定时器的设计【Verilog】前言推荐实验五 计数/定时器的设计一、实验目的二、实验环境三、实验任务四、实验原理与实验步骤五、实验思考最后前言 以下内容源自Verilog实验 仅供学习交流使用 推荐 Verilog 实验五 计数/定时器的设计 一、实验目的 掌握二进制计…
阅读更多...
计时器Timing Wheel 时间轮算法

计时器Timing Wheel 时间轮算法

文章目录1. 前言2. 什么是时间轮算法&#xff1f;2.1 单层时间轮2.2 多层时间轮2.2.1 增加轮次的概念2.2.2 多层次时间轮2.3 小结3. 实现案例3.1 Kafka中的时间轮3.1.1 任务的添加3.1.2 时间轮的推进SystemTimer3.1.3 小结1. 前言 计时器对于故障恢复、基于速率的流量控制、调…
阅读更多...
[yolov5] yolo的数据标签格式

[yolov5] yolo的数据标签格式

yolov5 的标签格式 参考链接&#xff1a; https://github.com/ultralytics/yolov5/issues/9816 翻译内容 你好!。感谢您询问YOLOv5&#x1f680;数据集格式。用于分割的XY坐标与用于长方体中心的标准坐标相同。 为了正确训练&#xff0c;您的数据必须为YOLOv5格式。有关数…
阅读更多...
数据结构与算法的基本概念

数据结构与算法的基本概念

前言 技术学得再多&#xff0c;再好还不如将基础学扎实。欠下的迟早是要还的。与其在以后后悔当初不好好学&#xff0c;还不如在大学期间将该学的知识学透。《数据结构与算法》确实不好学&#xff0c;但大学四年下来&#xff0c;还怕啃不下一本书&#xff1f;&#xff1f;正是基…
阅读更多...
自动驾驶技术

自动驾驶技术

高精地图&#xff08;HD Maps&#xff09;&#xff1a;支持其他模块 定位&#xff08;Localization&#xff09;&#xff1a;讨论汽车如何确定他所处的位置&#xff0c;汽车利用激光和雷达数据&#xff0c;将这些传感器感知内容与高分辨地图进行对比&#xff0c;这种对比使得汽…
阅读更多...
Scanpy plot umap的color编码， Scanpy 的color map 如何设置？

Scanpy plot umap的color编码， Scanpy 的color map 如何设置？

Scanpy plot umap的color编码&#xff0c; Scanpy 的color map 如何设置&#xff1f;关键词palette&#xff08;调色板&#xff09; https://scanpy.readthedocs.io/en/stable/generated/scanpy.pl.umap.html?highlightpl.umap#scanpy.pl.umap https://scanpy.discourse.grou…
阅读更多...
JavaScript -- 08. 数组介绍

JavaScript -- 08. 数组介绍

文章目录数组1 数组简介1.1 创数组1.2 向数组添加元素1.3 读取数组中的元素1.4 获取数组长度2 数组的遍历2.1 使用for循环遍历2.2 for-of遍历3 数组的方法3.1 Array.isArray()3.2 at()3.3 concat()3.4 indexOf()3.5 lastIndexOf()3.6 join()3.7 slice()3.8 push()3.9 pop()3.10…
阅读更多...
Android Jetpack-Compose相关

Android Jetpack-Compose相关

Android Jetpack-Compose相关 一、什么是Compose&#xff1f; Jetpack Compose 是用于构建原生 Android 界面的新工具包。它使用更少的代码、强大的工具和直观的 Kotlin API&#xff0c;可以帮助您简化并加快 Android 界面开发&#xff0c;打造生动而精彩的应用。它可让您更快…
阅读更多...
Go学习之路-环境搭建

Go学习之路-环境搭建

默认运行设备系统&#xff1a;MacOS 安装 安装包下载地址&#xff08;下面3个都可以&#xff09;&#xff1a; https://studygolang.com/dl https://golang.google.cn/dl/ https://golang.org/dl/ 我这里选择 pkg包、一键安装、默认的安装路径 /usr/local/go 环境 设置go语言…
阅读更多...
[附源码]计算机毕业设计springboot在线图书销售系统

[附源码]计算机毕业设计springboot在线图书销售系统

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
mmap 创建共享内存映射

mmap 创建共享内存映射

所谓内存映射指的是 让一个磁盘文件与内存中的一个缓冲区相映射&#xff0c;进程访问这块内存时&#xff0c;就等同于访问文件对应映射部分&#xff0c;不必再调用 read / write 。 我们可以使用mmap函数来建立内存和文件某一部分的映射关系。 目录 一、共享内存映射的创建 /…
阅读更多...
代码审计-3 文件包含漏洞

代码审计-3 文件包含漏洞

文章目录代码审计-文件包含漏洞文件包含漏洞种类当检测到目标存在文件包含漏洞时可以怎么利用文件包含中php可使用的协议PHPCMS V9.6.3后台文件包含漏洞后台路由分析漏洞寻找代码审计-文件包含漏洞 文件包含漏洞种类 当检测到目标存在文件包含漏洞时可以怎么利用 文件包含中php…
阅读更多...
npm run dev和npm run serve

npm run dev和npm run serve

npm run dev和npm run serve目录概述需求&#xff1a;设计思路实现思路分析1.npm install命令2.package.json3.npm run serve参考资料和推荐阅读Survive by day and develop by night. talk for import biz , show your perfect code,full busy&#xff0c;skip hardness,make …
阅读更多...
redis基础4——RDB持久化、AOF持久化全面深入解读

redis基础4——RDB持久化、AOF持久化全面深入解读

文章目录一、redis持久化机制1.1 持久化的背景1.2 两种持久化概念1.2.1 快照方式&#xff08;RDB&#xff09;1.2.2 文件追加方式&#xff08;AOF&#xff09;1.3 rdb持久化&#xff08;Redis Database&#xff09;1.3.1 快照原理1.3.2 触发机制1.3.2.1 手动触发1.3.2.1.1 save…
阅读更多...
最常用的python开发工具

最常用的python开发工具

有哪些值得推荐的 Python 开发工具 推荐5个非常适合Python小白的开发工具&#xff1a;1、Python TutorPython Tutor是由Philip Guo开发的一个免费教育工具&#xff0c;可帮助开发者攻克编程学习中的基础障碍&#xff0c;理解每一行源代码在程序执行时在计算机中的过程。 通过…
阅读更多...
CentOS8克隆虚拟机修改IP，错误：未知的连接 “ens160“

CentOS8克隆虚拟机修改IP，错误：未知的连接 “ens160“

关于CentOS8该如何克隆与修改IP&#xff0c;并设置成静态IP的方法&#xff0c;可以参考我的另一篇文章&#xff0c;我也是一直这么做的。 CentOS8拷贝虚拟机、修改ip、主机 但是最近我再使用我的这篇文章克隆虚拟机的时候&#xff0c;竟然报错了&#xff0c;本来想删除掉克隆…
阅读更多...
2023年天津农学院专升本专业课报名、确认缴费及准考证打印流程

2023年天津农学院专升本专业课报名、确认缴费及准考证打印流程

天津农学院2023年高职升本科专业课考试 报名、确认缴费及准考证打印操作流程 一、报名操作流程 1. 阅读报名注意事项 请考生于2022年12月5日9点—12月10日12点登录报名系统 http://gzsb.tjau.edu.cn&#xff0c;请认真阅读报名注意事项。2.报名登录 点击“报名”菜单后进入报名…
阅读更多...
LeetCode 374. 猜数字大小

LeetCode 374. 猜数字大小

&#x1f308;&#x1f308;&#x1f604;&#x1f604; 欢迎来到茶色岛独家岛屿&#xff0c;本期将为大家揭晓LeetCode 374. 猜数字大小&#xff0c;做好准备了么&#xff0c;那么开始吧。 &#x1f332;&#x1f332;&#x1f434;&#x1f434; 一、题目名称 LeetCode 374.…
阅读更多...
2023最新SSM计算机毕业设计选题大全（附源码+LW）之java高校辅导员工作管理系统82aub

2023最新SSM计算机毕业设计选题大全（附源码+LW）之java高校辅导员工作管理系统82aub

对于即将毕业或者即将做课设的同学而言&#xff0c;由于经验的欠缺&#xff0c;面临的第一个难题就是选题&#xff0c;确定好题目之后便是开题报告&#xff0c;如果选题首先看自己学习那些技术&#xff0c;不同技术适合做不同的产品&#xff0c;比如自己会些简单的Java语言&…
阅读更多...
【圣诞文】用python带你体验多重花样圣诞树

【圣诞文】用python带你体验多重花样圣诞树

前言 大家早好、午好、晚好吖 ❤ ~ 在圣诞要来临的前夕&#xff0c;我们来出一起圣诞特辑吧 &#xff08;虽说可能有一丢丢早&#xff0c;但是等要来了在准备就来不及了呀~&#xff09; 圣诞节要素 1、圣诞袜&#xff0c;最早以前是一对红色的大袜子&#xff0c;大小不拘。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023