• Djanjo是一个重量级且功能比较全面的框架，但是学习曲线相比其他两个框架要高
• Flask适合构建小中型网站后台和构建快速验证demo
• FastAPI支持OpenAPI（Swagger），适合构建不需要前端页面的API后台

关于三个框架的对比，网上有很多博客，在此不再赘述，本章分享一下FastAPI如何快速学习以及入门。

学习路线

1. Python基础语法：菜鸟教程
2. asyncio协程库 - 需要熟练掌握
3. aiohttp库 - 异步HTTP客户端，会用即可，在做异步网络请求时非常方便
4. FastAPI官方教程 - 按顺序阅读，跟着官方教程做下去即可，进阶学习可以阅读FastAPI源码

基本了解了这些就能开发出FastAPI后台代码了，剩余的在使用过程中多debug就能熟悉

FastAPI重点

开发环境安装

开发环境我选择使用基于docker的ubuntu环境，ubuntu对开发友好，开发过程中常用的库也都能使用包管理工具apt下载到，而且该docker环境支持的架构也比较多，很适合跨平台开发，支持的架构如下:

安装docker

docker的安装方法不用赘述，网上教程很多，以Ubuntu为例，这里选择docker.io安装，其他系统也有可能是Docker Desktop，安装步骤如下：

# 1.安装docker.iosudo apt-get update  # 更新源,防止源中的下载连链接失效sudo apt-get install docker.io# 2.使普通用户可以使用docker,避免输入sudosudo groupadd dockersudo usermode -aG docker $USER# 2.给docker换国内源,加速docker pullsudo mkdir -p /etc/dockerecho '{  "registry-mirrors": [          "https://docker.mirrors.ustc.edu.cn",          "http://hub-mirror.c.163.com",          "https://registry.docker-cn.com"  ]}' > daemon.jsonsudo mv daemon.json /etc/docker/# 3.重启docker daemonsudo systemctl restart docker# 4.拉取Ubuntu22.04的镜像docker pull ubuntu:22.04# 5.查看是否安装成功docker images | grep ubuntu | grep 22.04

编译内核

apt-get install wget xz-utils -y # 安装wget下载工具和xz压缩工具cd /root && wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.15.108.tar.xztar -xf linux-5.15.108.tar.xz # 解压源码#安装编译环境和依赖库apt-get install libncurses-dev flex bison bc openssl libssl-dev dkms libelf-dev libudev-dev libpci-dev libiberty-dev autoconf gcc make gnu-standards libtool gettextcd linux-5.15.108 # 进入源码目录# 生成基于文本界面的内核配置菜单,该操作依赖ncurses库# 当出现’Your display is too small to run Menuconfig!‘提示时,将终端放大重新执行这条命令即可make menuconf## 配置开启KGDB参数,然后光标选择save,将选项保存到.config文件中## Kernel hacking --->##    Compile-time checks and compiler options --->##        [*] Compile the kernel with debug info##        [*] Provide GDB scripts for kernel debugging##    Generic Kernel Debugging Instruments --->##        [*] KGDB: kernel debuggermake -j $(nproc)   # 进行编译,此处nproc变量为cpu核心的个数

制作根文件系统

# 安装依赖apt-get install cpio unzip rsync# 下载buildrootwget https://github.com/buildroot/buildroot/archive/refs/tags/2022.02.11.tar.gztar -xf buildroot-2022.02.11.tar.gzcd buildroot-2022.02.11# 配置buildrootmake menuconfig## Target options --->##     Target Architecture --->##         (X) x86_64## Toolchain --->##     Toolchain type --->##         (X) Buildroot toolchain##     C library --->##         (X) glibc##     Kernel Headers##         (X) Linux 5.15.x kernel headers##     [*] Install glibc utilities##     [*] Enable C++ support##     [*] Build cross gdb for the host##     [*] TUI support##     [*] Python support##     [*] Simulator support## Filesystem images --->##     [*] ext2/3/4 root filesystem##         ext2/3/4 variant --->##             (X) ext4## Bootloaders --->##     [*] grub2##     [ ] i386-pc##     [ ] i386-efi##     [*] x86-64-efi##     (boot linux ext4 fat squash4 part_msdos part_gpt normal efi_gop) builtin modulesmake -j $(nproc) # 开始编译

运行内核

将编译后的内核压缩文件bzImage和根文件系统rootfs.ext4拷贝至具有qemu运行环境的宿主机中运行:

mkdir kernel && cd kerneldocker cp ubuntu:/root/buildroot-2022.02.11/output/images/rootfs.ext2 .docker cp ubuntu:/root/linux-5.15.108/arch/x86/boot/bzImage .

使用qemu-system-x86_64运行内核，当有图形界面时，执行：

sudo qemu-system-x86_64 -kernel ./bzImage -hda rootfs.ext2 -append "root=/dev/sda console=ttyS0 nokaslr" -serial stdio

没有图形界面时，将-serial stdio替换为-nographic即可。启动成功后会在终端中输出banner和登录提示，登录名为root，密码默认为空（buildroot进行make menuconfig配置时设置），如下图所示：

使用gdb挂载调试内核

使用qemu的’-s’和’-S’参数使内核可以被gdb挂载调试，执行命令如下：

sudo qemu-system-x86_64 -kernel ./bzImage -hda rootfs.ext2 -append "root=/dev/sda console=ttyS0 nokaslr" -serial stdio -s -S

‘-s’: 让qemu监听在tcp::1234端口上，可以让gdb连接该端口进行调试
‘-S’: 让qemu启动后暂停执行，直到通过gdb传入继续执行(continue)命令

在ubuntu的容器里，安装gdb，执行以下命令挂载qemu，对内核进行调试：

root@824b1b82dfae:~# gdb /root/linux-5.15.108/vmlinux(gdb) add-auto-load-safe-path /root/linux-5.15.108/scripts/gdb/vmlinux-gdb.py(gdb) target remote 172.17.0.1:1234Remote debugging using 172.17.0.1:12340x000000000000fff0 in exception_stacks ()(gdb) cContinuing.

此处的172.17.0.1替换为qemu执行后，监听tcp 1234端口的ip。

在gdb中可以使用Ctrl + C来暂停qemu，然后就可以正常进行调试了。

1. 查看是否安装open-vm-tools
2. 查看本发行版是否具有并安装open-vm-tools-desktop
3. 普通用户权限执行vmware-user，即可解决

问题参考

1. vmware-user-suid-wrapper requires restart of vmtoolsd （未有答复)
2. VMware Workstation中客户机与主机之间无法复制文件和剪切板问题解决 (问题及解决方法）
3. VMWare拖拽与复制粘贴 (archlinux wiki)

Rust有两种数据类型：标量值（scalar）和复合值（compound）。

本篇环境为Ubuntu22.04，x86_64，Rust版本为1.60.0。

标量值

标量类型标识一个单独的值，Rust有4种主要的标量类型：整型、浮点型、布尔类型、字符类型。

这四种类型与Perl中的Scalar Literals概念类似，都是字面值，所见即所得。

Rust默认数据类型为4字节的i32，与C/C++保持一致。

整型

与C/C++中定义相同，分为有符号与无符号两种，支持加、减、乘、除、模运算。

整数除法与C/C++一致，向下取余，例如2/3 == 0。

isize和usize属于自适应类型，根据架构来决定大小，在32位架构就是4字节，64位架构为8字节，对应gcc编译器下的long和unsigned long类型，微软的msvc编译器没有这一特性，需要用宏来判断。自适应类型非常好用，尤其是在C/C++中用内存地址与指针进行互转时。

或许MSVC不支持自适应类型的原因之一就是Windows只能在有限的架构上运行？（笑）

整型表示

为了便于阅读，不用怼着屏幕数数字个数，Rust可以使用’_'字符作为数字的分隔符。

字节类型为单字节字符，仅限于u8，与Python中的Bytes完全不同。

整型溢出问题

在debug模式编译下，Rust会检查并使程序panic，而release模式下，Rust不检测溢出，会执行2的补码包装（two’s complement wrapping）操作，例如在u8类型下，值256会变成0，257变成1，即

value = value % 2^(sizeof(value)*8)

整型溢出在Rust中被认为是一种错误，但如果编程时确实需要使用溢出，可以在数字类型上使用标准库中的Wrapping功能：

• 包装所有模式：wrapping_*，例如wrapping_add
• 返回None值：checked_*
• 返回布尔值：overflowing_*，指示是否发生溢出
• 饱和处理：saturating_*，在边界上饱和处理成最大或最小值

饱和处理，对数字值进行计算时，发生上溢时返回最大值，下溢时返回最小值，无符号最小值为0，有符号时值为0 - （2^n-1）。

/* 函数签名 */pub trait Saturating {     fn saturating_add (self, v: Self) -> Self;// 返回a+b，溢出时返回该类型的最大值    fn saturating_sub (self, v: Self) -> Self;  // 返回a-b，溢出时返回该类型的最小值}

浮点型

Rust浮点类型使用IEEE-754标准表示，有两种浮点类型，f32和f64，分别占4字节和8字节，对应C/C++中的float和double，所有的浮点类型都是有符号的。

Rust认为在现代CPU上f32与f64速度相当，但精度更高，所以默认类型是f64，与Python相同（如果是在32位芯片上，个人还是建议使用f32）。

let x = 2.0;// f64let y: f32 = 3.0;// f32

布尔型

类型名称为bool，分为true和false，常用于条件表达式中。

字符型

Rust的字符型数据使用4个字节存储，表示为char，与C/C++中一样使用单引号，字符串字面值使用双引号。

字符型表示一个Unicode代码点，范围为U+0000到U+D7FF，U+E000到U+10FFFF。

有点好奇Rust中正则的用法了。

复合类型

Rust有两个原生复合类型：元组（tuple）和数组（array）。

元组类型

元组使用圆括号，是长度固定的数组（C系语言概念），可以包含一个或多个类型的值，第一个元素的索引值为0。

// 示例函数fn main() {  // 使用类型注解  let tup: (i32, f64, u8) = (500, 6.4, 1);   // 可以省略类型注解  let tup = (500, 6.4, 1);    // 使用模式匹配（pattern matching）对元组进行解构（destructure）  let (x, y, z) = tup;    // 使用点号'.'跟索引值来直接访问  let five_hundred = x.0;  let six_point_four = x.1;  let one = x.2;}

没有任何元素的元组是一种特殊类型，表示为( )，只有一个值，和表示相同，写成( )，被称为单位类型（unit type），值被称为单位值（unit value）。如果表达式没有显示地返回值，则隐式地返回该单位值。

数组类型

数组使用方括号，Rust中数组长度是固定的，并且每个值的类型都相同。

let a = [1, 2, 3, 4, 5];let a: [i32; 5] = [1, 2, 3, 4, 5];   // 带注解的数组类型写法let a = [3, 3, 3, 3, 3,];// 初始值为5个3let a = [3; 5];// 初始值为5个3，与上一行效果相同// 确定了元素个数不会改变时，建议使用数组let months = ["January", "February", "March", "April", "May", "June", "July",              "August", "September", "October", "November", "December"];// 数组是在栈上分配已知固定大小的内存块// 可以使用索引访问let first = a[0];left second = a[1];

数组的栈溢出

当数组在运行时发生索引溢出时，程序会退出并输出错误信息。Rust在使用数组时，会在编译时和运行时都检查索引是否小于数组长度，当编译时发现溢出，编译器会报错，运行发生溢出时，程序会panic。

此原则会尽量避免像C/Python/Java等语言中忘记检查输入范围而导致栈溢出漏洞情况的出现。

编译时检查:

// 示例代码main.rsfn main() {    let a = [1, 2, 3, 4, 5];        let five = a[5];    println!(        "The six value of the element at index {}",        five    );}

进行编译：

xxx@ubuntu:~/Rust/array$ cargo build   Compiling array v0.1.0 (/home/xxx/Rust/array)error: this operation will panic at runtime --> src/main.rs:5:16  |5 |     let five = a[5];  |                ^^^^ index out of bounds: the length is 5 but the index is 5  |  = note: `#[deny(unconditional_panic)]` on by defaulterror: could not compile `array` due to previous error

运行时检查:

use std::io;fn main() {    let a = [1, 2, 3, 4, 5];    println!("Please enter an array index.");    let mut index = String::new();    io::stdin()        .read_line(&mut index)        .expect("Failed to read line");    let index: usize = index        .trim()        .parse()        .expect("Index entered was not a number");    let element = a[index];    println!(        "The value of the element at index {} is: {}",        index, element    );}

当编译后运行时，输入的值为10时，报错如下：

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

在C语言中文网中关于C数组类型有三类：

已知常量大小的数组、变长度数组，以及未知大小数组。

变长度数组即本文所讨论的非常量声明，未知大小数组在函数传数组参数时较为常见，此外还有0长大小的柔性数组（C99之前依赖编译器特性）。

背景

在阅读shadowsocks-libev源码时，发现有这么一行:

// initialize listen contextlisten_ctx_t listen_ctx_list[server_num];

在以往的知识里，声明数组大小时必须是常量表达式，然而此处发现却与以往认知相左，于是便有了本文的探究。

测试

测试环境为ubuntu20.04，x86_64，gcc 9.4.0，测试代码如下:

#include <stdio.h>int main(int argc, char **argv){    int num;    scanf("%d", &num);    int array[num];    printf("%d\n", sizeof(array)/sizeof(array[0]));    return 0;}

结果:

$ gcc -o test test.c$ ./test1010$ ./test-1-1

证明此种声明方式确实有效。添加编译标志-std=gnu89，更换编译器为gcc 4.8.4，32位，都可以编译通过，并且正常运行（输入负数打印结果不一致不在本文讨论）。

在ss-libev源码中，此行代码在任何编译器宏下都能到达，意味着此方式声明数组不与特定编译器相关。

其它发现

不能在声明时初始化数组，如下代码：

int array[num] = {0};

编译器报错信息如下:

$ gcc -o test test.ctest.c:6:5: error: variable-sized object may not be initialized

那么这种变长度数组又是如何实现的呢，查看一下它的汇编。

汇编分析

使用gdb查看该段代码汇编（intel语法）：

$ gcc -o test test.c -g

   0x00000000080011ba <+49>:    lea    rax,[rbp-0x4c]      # rbp-0x4c处为变量num的地址   0x00000000080011be <+53>:    mov    rsi,rax   0x00000000080011c1 <+56>:    lea    rdi,[rip+0xe3c]        # 0x8002004   0x00000000080011c8 <+63>:    mov    eax,0x0   0x00000000080011cd <+68>:    call   0x8001090 <__isoc99_scanf@plt>=> 0x00000000080011d2 <+73>:    mov    ecx,DWORD PTR [rbp-0x4c]   # 将num值放入ecx寄存器中   0x00000000080011d5 <+76>:    movsxd rax,ecx                 # 以下算法不知作用，待补充   0x00000000080011d8 <+79>:    sub    rax,0x1   0x00000000080011dc <+83>:    mov    QWORD PTR [rbp-0x48],rax   0x00000000080011e0 <+87>:    movsxd rax,ecx   0x00000000080011e3 <+90>:    mov    r14,rax   0x00000000080011e6 <+93>:    mov    r15d,0x0   0x00000000080011ec <+99>:    movsxd rax,ecx   0x00000000080011ef <+102>:   mov    r12,rax   0x00000000080011f2 <+105>:   mov    r13d,0x0   0x00000000080011f8 <+111>:   movsxd rax,ecx   0x00000000080011fb <+114>:   lea    rdx,[rax*4+0x0]   0x0000000008001203 <+122>:   mov    eax,0x10   0x0000000008001208 <+127>:   sub    rax,0x1   0x000000000800120c <+131>:   add    rax,rdx   0x000000000800120f <+134>:   mov    edi,0x10   0x0000000008001214 <+139>:   mov    edx,0x0   0x0000000008001219 <+144>:   div    rdi                   # 以下将分配的栈与4k对齐   0x000000000800121c <+147>:   imul   rax,rax,0x10   0x0000000008001220 <+151>:   mov    rdx,rax   0x0000000008001223 <+154>:   and    rdx,0xfffffffffffff000   0x000000000800122a <+161>:   mov    rsi,rsp   0x000000000800122d <+164>:   sub    rsi,rdx   0x0000000008001230 <+167>:   mov    rdx,rsi   0x0000000008001233 <+170>:   cmp    rsp,rdx   0x0000000008001236 <+173>:   je     0x800124a <main+193>   0x0000000008001238 <+175>:   sub    rsp,0x1000           # 如果分配大于4k则栈抬高4k   0x000000000800123f <+182>:   or     QWORD PTR [rsp+0xff8],0x0   0x0000000008001248 <+191>:   jmp    0x8001233 <main+170>   0x000000000800124a <+193>:   mov    rdx,rax              # 栈4k块分配完毕   0x000000000800124d <+196>:   and    edx,0xfff   0x0000000008001253 <+202>:   sub    rsp,rdx          # 栈抬高4k以内的大小，num小于4k时就是num   0x0000000008001256 <+205>:   mov    rdx,rax         0x0000000008001259 <+208>:   and    edx,0xfff   0x000000000800125f <+214>:   test   rdx,rdx          # 当num大于4k时，   0x0000000008001262 <+217>:   je     0x8001274 <main+235>   0x0000000008001264 <+219>:   and    eax,0xfff   0x0000000008001269 <+224>:   sub    rax,0x8   0x000000000800126d <+228>:   add    rax,rsp   0x0000000008001270 <+231>:   or     QWORD PTR [rax],0x0  # 检查栈位置能否有读写权限   0x0000000008001274 <+235>:   mov    rax,rsp         0x0000000008001277 <+238>:   add    rax,0x3     # array数组4字节对齐   0x000000000800127b <+242>:   shr    rax,0x2   0x000000000800127f <+246>:   shl    rax,0x2   0x0000000008001283 <+250>:   mov    QWORD PTR [rbp-0x40],rax   # 将数组的地址放在array变量里   0x0000000008001287 <+254>:   movsxd rax,ecx      # 计算sizeof大小并准备printf的参数   0x000000000800128a <+257>:   shl    rax,0x2              0x000000000800128e <+261>:   shr    rax,0x2   0x0000000008001292 <+265>:   mov    rsi,rax   0x0000000008001295 <+268>:   lea    rdi,[rip+0xd6b]        # 0x8002007   0x000000000800129c <+275>:   mov    eax,0x0   0x00000000080012a1 <+280>:   call   0x8001080 <printf@plt>

虽然0x80011d5 - 0x800120c处不知道是什么作用， 但从其他部分代码处可以看到运行时动态分配了数组空间。

结论

在栈上动态分配数组方式确实有效，但使用时需严格注意该数组作用域。