【Linux】Fedora 上手配置

2026-03-02T00:00:00+00:00

公司给了个 ThinkBook 14, 原装是 Windows 11, 可能是用的人多了，系统糊成狗屎一样，难用的要死，用户名还是之前人的名字，感觉很诡异。正好因为要用 Ubuntu 的系统盘，索性装个 Fedora 吧。

下载不用多说什么了，直接上官网，下载最新的 Fedora Workstation 版本的 ISO 镜像就行了。下载完成后，使用 Rufus 或者 balenaEtcher 之类的软件将 ISO 镜像写入到一个 USB 闪存盘中，制作成可启动的安装盘。（只可惜我用的 Ventoy）

我下载的 Fedora Cinnamon Desktop Spins，这个用的多，以前就用 Arch Linux 的时候也用过，感觉还不错。安装过程和其他 Linux 发行版差不多，选择语言、键盘布局、磁盘分区等，按照提示一步步操作就行了。

注意一点是，用户目录保持英文的问题。我是安装的时候选英文，后面再进系统换回中文的，这样用户目录就不会变成中文了。因为如果用户目录是中文的，很多软件可能会因为路径问题而出错。

安装完成后看看系统配置：

现在就可以马克擦车了：

sudo dnf makecache

为什么不运行 sudo dnf update 呢？因为 Fedora 的更新可能会比较大，尤其是第一次更新，可能会下载很多包，耗时较长。运行 sudo dnf makecache 可以先更新软件包缓存，这样在后续安装软件时会更快。（其实就是以前用 Arch 的时候滚动更新滚怕了，前一天在公司把电脑合上，第二天上班的时候进不去系统报 Kernel Panic……）

下面就是安装输入法了，这个我走了弯路。原本想用 ibus-rime 的，结果安装之后发现 ibus 在 Electron 应用里有问题，输入法无法正常使用。后来换成了 fcitx5-rime，安装之后就没有问题了。

sudo dnf install fcitx5-rime

然后配合使用东风破（Plum）安装雾凇拼音：

# 请先安装 git 和 bash，并加入环境变量
# 请确保和 github.com 的连接稳定
cd ~
git clone https://github.com/rime/plum.git plum
# 卸载 plum 只需要删除 ~/plum 文件夹即可

接着：

cd ~/plum
rime_frontend=fcitx5-rime bash rime-install iDvel/rime-ice:others/recipes/full

再次重新部署 Rime，使用 Ctrl + ~ 键，来选择雾凇拼音。

插入一个小插曲：我想直接用 fcitx5 的，然后把 ibus 卸载。结果卸载 ibus 的时候用了 sudo dnf remove ibus*，我是万万没想到现在都在往 Wayland 方向发展，我还以为还在用 X11,卸载的时候没看直接 y 了，整个桌面都没了。只能说我被 Arch 鞭打太多次了已经习惯了，直接 sudo dnf install @cinnamon-desktop-environment 重新安装 Cinnamon 桌面环境，重启之后 sudo systemctl enable lightdm.service && sudo systemctl start lightdm.service 就好了。

然后就是安装 WPS，切忌切忌安装外版的 WPS，国内的广告满天飞（你是把雷军他妈的骨灰盒打包放进去了吗？），直接上国外的版本，安装包里没有广告，安装完成后就没有了。

wget https://wdl1.pcfg.cache.wpscdn.com/wpsdl/wpsoffice/download/linux/11723/wps-office-11.1.0.11723.XA-1.x86_64.rpm

sudo rpm -ivh --nodigest --nosignature ./wps-office-11.1.0.11723.XA-1.x86_64.rpm

别问为什么 RPM 安装要带那么多参数，问就是傻X WPS 程序员写得烂，安装包里没有签名和摘要，所以必须加上 --nodigest --nosignature 参数才能安装成功。

还有就是老生常谈的 WPS 缺字体的问题了。参考dv-anomaly/ttf-wps-fonts这个项目或者xChen16/wps-fonts或者owlman/wps_fonts就行。

但是主界面还是有方框，解决方案如下：

sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
sudo dnf makecache
sudo dnf install google-noto-sans-cjk-vf-fonts
sudo dnf install wqy-microhei-fonts
sudo dnf install wqy-zenhei-fonts
sudo dnf install langpacks-zh_CN
sudo dnf install google-noto-sans-cjk-fonts google-noto-serif-cjk-fonts wqy-zenhei-fonts wqy-microhei-fonts
sudo dnf remove libreoffice-core

不记得是哪个了，反正一套连招下来显示正常了。

然后就是喜闻乐见的 Typora 安装了。Typora 官方没给 RPM 包，只有 DEB 包，所以我找了个 GitHub 项目来搞定这个安装：

sudo dnf install pandoc
git clone https://github.com/RPM-Outpost/typora.git
cd typora/
chmod +x create-package.sh
./create-package.sh

好像就这么些了。

【博客搭建】Jekyll 语法高亮配置

2026-01-23T00:00:00+00:00

一个月前看 X 上有人分享了一个很简约的网站，U.S. Graphics Company，想着自己需要一个简约的主题，于是顺手扒了他们网页研究一下做个 Jekyll 主题出来。前前后后一个月的时间，把主题做出来了。但总感觉差强人意：

代码高亮很难受！

代码高亮要做层叠样式，很烦。还好 Jekyll 中默认的语法高亮是 Rouge。

markdown: kramdown
kramdown:
  input: GFM
  hard_wrap: false
  syntax_highlighter: rouge

搂了一下文档，发现这个可以直接生成层叠样式文件！

首先得确保安装了 Rouge：

gem install rouge

安装完成后，可以看看自带的样式有哪些：

rougify help style

会告诉你有如下样式：

PS Z:\tomato\Codes\Web\Blog> rougify help style
usage: rougify style [<theme-name>] [<options>]

Print CSS styles for the given theme.  Extra options are
passed to the theme. To select a mode (light/dark) for the
theme, append '.light' or '.dark' to the <theme-name>
respectively. Theme defaults to thankful_eyes.

options:
  --scope       (default: .highlight) a css selector to scope by
  --tex         (default: false) render as TeX
  --tex-prefix  (default: RG) a command prefix for TeX
                implies --tex if specified

available themes:
  base16, base16.dark, base16.light, base16.monokai, base16.monokai.dark, base16.monokai.light, base16.solarized, base16.solarized.dark, base16.solarized.light, bw, colorful, github, github.dark, github.light, gruvbox, gruvbox.dark, gruvbox.light, igorpro, magritte, molokai, monokai, monokai.sublime, pastie, thankful_eyes, tulip

那么有聪明的小伙伴要问了，番茄哥，它那么多样式，到底哪个适合呢？

我推荐个在线预览网站：Rouge Theme Preview Page。

看上哪个样式，就直接生成对应的层叠样式文件：

rougify style base16.solarized > assets/css/syntax-base16-solarized.css

比如我就生成了 base16.solarized 这个样式的层叠样式文件。

然后就该把生成的层叠样式文件引入到网页中了，在 _includes/head.html 里加一行：

<link rel="stylesheet" href="/assets/css/syntax-base16-solarized.css"/>

当然，你要是不想生成，可以直接去那个在线预览网站对应的 GitHub 仓库里下载对应的层叠样式文件。

看看效果吧！

Java

int total = 0;
for(int i = 0; i < list.length; i++)
{	total += list[i];
System.out.println( list[i] );
}
return total;

Scala

  def findNums(n: Int): Iterable[(Int, Int)] = {

    // a for comprehension using two generators
    for (i <- 1 until n;
         j <- 1 until (i-1);
         if isPrime(i + j)) yield (i, j)
  }

C++

#include <iostream>
using namespace std;

int main() 
{    
    cout << "Size of char: " << sizeof(char) << " byte" << endl;
    cout << "Size of int: " << sizeof(int) << " bytes" << endl;
    cout << "Size of float: " << sizeof(float) << " bytes" << endl;
    cout << "Size of double: " << sizeof(double) << " bytes" << endl;

    return 0;
}

Python

# line comment
v = 1
s = "string"

for i in range(-10, 10):
    print(i + 1)

class LinkedList(object):
    def __init__(self, x):
        self.val = x
        self.next = None

【Linux】Inline assembly for x86 in Linux

2026-01-10T00:00:00+00:00

If you’re a Linux kernel developer, you probably find yourself coding highly architecture-dependent functions or optimizing a code path pretty often. And you probably do this by inserting assembly language instructions into the middle of C statements (a method otherwise known as inline assembly). Let’s take a look at the specific usage of inline assembly in Linux. (We’ll limit our discussion to the IA32 assembly.)

GNU assembler syntax in brief
Inline assembly
Examples of common inline assembly usage
Use of specific register constraints
Using matching constraints
Use of memory operand constraint
Using clobbered registers
Conclusion
Resources

GNU assembler syntax in brief

Let’s first look at the basic assembler syntax used in Linux. GCC, the GNU C Compiler for Linux, uses AT&T assembly syntax. Some of the basic rules of this syntax are listed below. (The list is by no means complete; I’ve included only those rules pertinent to inline assembly.)

Register naming

Source and destination ordering

In any instruction, source comes first and destination follows. This differs from Intel syntax, where source comes after destination.

    mov %eax, %ebx, transfers the contents of eax to ebx.

Size of operand

The instructions are suffixed by b, w, or l, depending on whether the operand is a byte, word, or long. This is not mandatory; GCC tries provide the appropriate suffix by reading the operands. But specifying the suffixes manually improves the code readability and eliminates the possibility of the compilers guessing incorrectly.

    movb %al, %bl -- Byte move
	movw %ax, %bx -- Word move
	movl %eax, %ebx -- Longword move

Immediate operand

An immediate operand is specified by using $.

    movl $0xffff, %eax -- will move the value of 0xffff into eax register.

Indirect memory reference

Any indirect references to memory are done by using ( ).

 movb (%esi), %al -- will transfer the byte in the memory 
                     pointed by esi into al  register

Inline assembly

GCC provides the special construct “asm” for inline assembly, which has the following format:

	asm ( assembler template
	    : output operands			 	(optional)
	    : input operands			 	(optional)
	    : list of clobbered registers 	  	(optional)
	    );	

In this example, the assembler template consists of assembly instructions. The input operands are the C expressions that serve as input operands to the instructions. The output operands are the C expressions on which the output of the assembly instructions will be performed.

    asm ("movl %%cr3, %0\n" :"=r"(cr3val));

  a	    %eax
  b 	%ebx
  c 	%ecx
  d 	%edx
  S	    %esi
  D	    %edi

Memory operand constraint(m)

When the operands are in the memory, any operations performed on them will occur directly in the memory location, as opposed to register constraints, which first store the value in a register to be modified and then write it back to the memory location. But register constraints are usually used only when they are absolutely necessary for an instruction or they significantly speed up the process. Memory constraints can be used most efficiently in cases where a C variable needs to be updated inside “asm” and you really don’t want to use a register to hold its value. For example, the value of idtr is stored in the memory location loc:

     ("sidt %0\n" : :"m"(loc));

Matching(Digit) constraints

In some cases, a single variable may serve as both the input and the output operand. Such cases may be specified in “asm” by using matching constraints.

    asm ("incl %0" :"=a"(var):"0"(var));

In our example for matching constraints, the register %eax is used as both the input and the output variable. var input is read to %eax and updated %eax is stored in var again after increment. “0” here specifies the same constraint as the 0th output variable. That is, it specifies that the output instance of var should be stored in %eax only. This constraint can be used:

In cases where input is read from a variable or the variable is modified and modification is written back to the same variable
In cases where separate instances of input and output operands are not necessary

The most important effect of using matching restraints is that they lead to the efficient use of available registers.

Examples of common inline assembly usage

The following examples illustrate usage through different operand constraints. There are too many constraints to give examples for each one, but these are the most frequently used constraint types.

“asm” and the register constraint “r”

Let’s first take a look at “asm” with the register constraint ‘r’. Our example shows how GCC allocates registers, and how it updates the value of output variables.

int main(void)
{
	int x = 10, y;
	
	asm ("movl %1, %%eax;
	     "movl %%eax, %0;"
		:"=r"(y)	/* y is output operand */
		:"r"(x)		/* x is input operand */
		:"%eax");	/* %eax is clobbered register */
}

In this example, the value of x is copied to y inside “asm”. x and y are passed to “asm” by being stored in registers. The assembly code generated for this example looks like this:

    main:
        pushl %ebp
        movl %esp,%ebp
        subl $8,%esp
        movl $10,-4(%ebp)	 
        movl -4(%ebp),%edx	/* x=10 is stored in %edx */
#APP	/* asm starts here */	
        movl %edx, %eax		/* x is moved to %eax */
        movl %eax, %edx		/* y is allocated in edx and updated */

#NO_APP	/* asm ends here */
        movl %edx,-8(%ebp)	/* value of y in stack is updated with 
				   the value in %edx */ 

GCC is free here to allocate any register when the “r” constraint is used. In our example it chose %edx for storing x. After reading the value of x in %edx, it allocated the same register for y.

Since y is specified in the output operand section, the updated value in %edx is stored in -8(%ebp), the location of y on stack. If y were specified in the input section, the value of y on stack would not be updated, even though it does get updated in the temporary register storage of y(%edx).

And since %eax is specified in the clobbered list, GCC doesn’t use it anywhere else to store data.

Both input x and output y were allocated in the same %edx register, assuming that inputs are consumed before outputs are produced. Note that if you have a lot of instructions, this may not be the case. To make sure that input and output are allocated in different registers, we can specify the & constraint modifier. Here is our example with the constraint modifier added.

	int main(void)
{
	int x = 10, y;
	
	asm ("movl %1, %%eax;
	     "movl %%eax, %0;"
		:"=&r"(y)	/* y is output operand, note the	
				   & constraint modifier. */
		:"r"(x)		/* x is input operand */
		:"%eax");	/* %eax is clobbered register */
}

And here is the assembly code generated for this example, from which it is evident that x and y have been stored in different registers across “asm”.

Use of specific register constraints

Now let’s take a look at how to specify individual registers as constraints for the operands. In the following example, the cpuid instruction takes the input in the %eax register and gives output in four registers: %eax, %ebx, %ecx, %edx. The input to cpuid (the variable “op”) is passed to “asm” in the eax register, as cpuid expects it to. The a, b, c, and d constraints are used in the output to collect the values in the four registers, respectively.

    asm ("cpuid"
                : "=a" (_eax),
                  "=b" (_ebx),
                  "=c" (_ecx),
                  "=d" (_edx)
                : "a" (op));

And below you can see the generated assembly code for this (assuming the _eax, _ebx, etc…. variables are stored on stack):

    movl -20(%ebp),%eax	/* store 'op' in %eax -- input */
#APP
        cpuid
#NO_APP
        movl %eax,-4(%ebp)	/* store %eax in _eax -- output */
        movl %ebx,-8(%ebp)	/* store other registers in
        movl %ecx,-12(%ebp)	   respective output variables */  
        movl %edx,-16(%ebp)

The strcpy function can be implemented using the “S” and “D” constraints in the following manner:

    asm ("cld\n
	      rep\n
	      movsb"
	      : /* no input */
	      :"S"(src), "D"(dst), "c"(count));

The source pointer src is put into %esi by using the “S” constraint, and the destination pointer dst is put into %edi using the “D” constraint. The count value is put into %ecx as it is needed by rep prefix.

And here you can see another constraint that uses the two registers %eax and %edx to combine two 32-bit values and generate a 64-bit value:

#define rdtscll(val) \
     __asm__ __volatile__ ("rdtsc" : "=A" (val))

The generated assembly looks like this (if val has a 64 bit memory space).

#APP
        rdtsc
#NO_APP
        movl %eax,-8(%ebp)	/* As a result of A constraint 
        movl %edx,-4(%ebp)	   %eax and %edx serve as outputs */

Note here that the values in %edx:%eax serve as 64 bit output.

Using matching constraints

Here you can see the code for the system call, with four parameters:

#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
        : "=a" (__res) \
        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
          "d" ((long)(arg3)),"S" ((long)(arg4))); \
__syscall_return(type,__res); \
}

In the above example, four arguments to the system call are put into %ebx, %ecx, %edx, and %esi by using the constraints b, c, d, and S. Note that the “=a” constraint is used in the output so that the return value of the system call, which is in %eax, is put into the variable _res. By using the matching constraint “0” as the first operand constraint in the input section, the syscall number __NR##name is put into %eax and serves as the input to the system call. Thus %eax serves here as both input and output register. No separate registers are used for this purpose. Note also that the input (syscall number) is consumed (used) before the output (the return value of syscall) is produced.

Use of memory operand constraint

Consider the following atomic decrement operation:

    __asm__ __volatile__(
                "lock; decl %0"
                :"=m" (counter)
                :"m" (counter));

The generated assembly for this would look something like this:

    #APP
	lock
	decl -24(%ebp) /* counter is modified on its memory location */
#NO_APP.

You might think of using the register constraint here for the counter. If you do, the value of the counter must first be copied on to a register, decremented, and then updated to its memory. But then you lose the whole purpose of locking and atomicity, which clearly shows the necessity of using the memory constraint.

Using clobbered registers

Consider an elementary implementation of memory copy.

	asm ("movl $count, %%ecx;
	      up: lodsl;	
	      stosl;
	      loop up;"
		: 			/* no output */
		:"S"(src), "D"(dst)	/* input */
		:"%ecx", "%eax" );	/* clobbered list */	

While lodsl modifies %eax, the lodsl and stosl instructions use it implicitly. And the %ecx register explicitly loads the count. But GCC won’t know this unless we inform it, which is exactly what we do by including %eax and %ecx in the clobbered register set. Unless this is done, GCC assumes that %eax and %ecx are free, and it may decide to use them for storing other data. Note here that %esi and %edi are used by “asm”, and are not in the clobbered list. This is because it has been declared that “asm” will use them in the input operand list. The bottom line here is that if a register is used inside “asm” (implicitly or explicitly), and it is not present in either the input or output operand list, you must list it as a clobbered register.

Conclusion

On the whole, inline assembly is huge and provides a lot of features that we did not even touch on here. But with a basic grasp of the material in this article, you should be able to start coding inline assembly on your own.

Resources

Refer to the Using and Porting the GNU Compiler Collection (GCC) manual.
Refer to the GNU Assembler (GAS) manual.
Check out Brennan’s Guide to Inline Assembly.

【Linux】Linux 汇编语言开发指南

2026-01-01T00:00:00+00:00

汇编语言的优点是速度快，可以直接对硬件进行操作，这对诸如图形处理等关键应用是非常重要的。Linux 是一个用 C 语言开发的操作系统，这使得很多程序员开始忘记在 Linux 中还可以直接使用汇编这一底层语言来优化程序的性能。本文为那些在Linux 平台上编写汇编代码的程序员提供指南，介绍 Linux 汇编语言的语法格式和开发工具，并辅以具体的例子讲述如何开发实用的Linux 汇编程序。

简介
Linux 汇编语法格式
Hello World!
Linux 汇编工具
系统调用
命令行参数
GCC 内联汇编
小结
参考资料

简介

作为最基本的编程语言之一，汇编语言虽然应用的范围不算很广，但重要性却勿庸置疑，因为它能够完成许多其它语言所无法完成的功能。就拿 Linux 内核来讲，虽然绝大部分代码是用 C 语言编写的，但仍然不可避免地在某些关键地方使用了汇编代码，其中主要是在 Linux 的启动部分。由于这部分代码与硬件的关系非常密切，即使是 C 语言也会有些力不从心，而汇编语言则能够很好扬长避短，最大限度地发挥硬件的性能。

大多数情况下 Linux 程序员不需要使用汇编语言，因为即便是硬件驱动这样的底层程序在 Linux 操作系统中也可以用完全用 C 语言来实现，再加上 GCC 这一优秀的编译器目前已经能够对最终生成的代码进行很好的优化，的确有足够的理由让我们可以暂时将汇编语言抛在一边了。但实现情况是 Linux 程序员有时还是需要使用汇编，或者不得不使用汇编，理由很简单：精简、高效和 libc 无关性。假设要移植 Linux 到某一特定的嵌入式硬件环境下，首先必然面临如何减少系统大小、提高执行效率等问题，此时或许只有汇编语言能帮上忙了。

汇编语言直接同计算机的底层软件甚至硬件进行交互，它具有如下一些优点：

能够直接访问与硬件相关的存储器或 I/O 端口；
能够不受编译器的限制，对生成的二进制代码进行完全的控制；
能够对关键代码进行更准确的控制，避免因线程共同访问或者硬件设备共享引起的死锁；
能够根据特定的应用对代码做最佳的优化，提高运行速度；
能够最大限度地发挥硬件的功能。

同时还应该认识到，汇编语言是一种层次非常低的语言，它仅仅高于直接手工编写二进制的机器指令码，因此不可避免地存在一些缺点：

编写的代码非常难懂，不好维护；
很容易产生 bug，难于调试；
只能针对特定的体系结构和处理器进行优化；
开发效率很低，时间长且单调。

Linux 下用汇编语言编写的代码具有两种不同的形式。第一种是完全的汇编代码，指的是整个程序全部用汇编语言编写。尽管是完全的汇编代码，Linux 平台下的汇编工具也吸收了 C 语言的长处，使得程序员可以使用 #include、#ifdef 等预处理指令，并能够通过宏定义来简化代码。第二种是内嵌的汇编代码，指的是可以嵌入到C语言程序中的汇编代码片段。虽然 ANSI 的 C 语言标准中没有关于内嵌汇编代码的相应规定，但各种实际使用的 C 编译器都做了这方面的扩充，这其中当然就包括 Linux 平台下的 GCC。

Linux 汇编语法格式

绝大多数 Linux 程序员以前只接触过DOS/Windows 下的汇编语言，这些汇编代码都是 Intel 风格的。但在 Unix 和 Linux 系统中，更多采用的还是 AT&T 格式，两者在语法格式上有着很大的不同：

在 AT&T 汇编格式中，寄存器名要加上 ‘%’ 作为前缀；而在 Intel 汇编格式中，寄存器名不需要加前缀。例如：

AT&T 格式 Intel 格式

pushl %eax push eax
在 AT&T 汇编格式中，用 ‘$’ 前缀表示一个立即操作数；而在 Intel 汇编格式中，立即数的表示不用带任何前缀。例如：

AT&T 格式 Intel 格式

pushl $1 push 1
AT&T 和 Intel 格式中的源操作数和目标操作数的位置正好相反。在 Intel 汇编格式中，目标操作数在源操作数的左边；而在 AT&T 汇编格式中，目标操作数在源操作数的右边。例如：

AT&T 格式 Intel 格式

addl $1, %eax add eax, 1
在 AT&T 汇编格式中，操作数的字长由操作符的最后一个字母决定，后缀’b’、’w’、’l’分别表示操作数为字节（byte，8 比特）、字（word，16 比特）和长字（long，32比特）；而在 Intel 汇编格式中，操作数的字长是用 “byte ptr” 和 “word ptr” 等前缀来表示的。例如：

AT&T 格式 Intel 格式

movb val, %al mov al, byte ptr val
在 AT&T 汇编格式中，绝对转移和调用指令（jump/call）的操作数前要加上’*‘作为前缀，而在 Intel 格式中则不需要。

AT&T 格式	Intel 格式
pushl %eax	push eax

AT&T 格式	Intel 格式
pushl $1	push 1

AT&T 格式	Intel 格式
addl $1, %eax	add eax, 1

AT&T 格式	Intel 格式
movb val, %al	mov al, byte ptr val

远程转移指令和远程子调用指令的操作码，在 AT&T 汇编格式中为 “ljump” 和 “lcall”，而在 Intel 汇编格式中则为 “jmp far” 和 “call far”，即：

AT&T 格式	Intel 格式
ljump $section, $offset	jmp far section:offset8
lcall $section, $offset	call far section:offset

与之相应的远程返回指令则为：

AT&T 格式	Intel 格式
lret $stack_adjust	ret far stack_adjust

在 AT&T 汇编格式中，内存操作数的寻址方式是

section:disp(base, index, scale)

而在 Intel 汇编格式中，内存操作数的寻址方式为：

section:[base + index*scale + disp]

由于 Linux 工作在保护模式下，用的是 32 位线性地址，所以在计算地址时不用考虑段基址和偏移量，而是采用如下的地址计算方法：

disp + base + index * scale

下面是一些内存操作数的例子：

AT&T 格式	Intel 格式
movl -4(%ebp), %eax	mov eax, [ebp - 4]
movl array(, %eax, 4), %eax	mov eax, [eax*4 + array]
movw array(%ebx, %eax, 4), %cx	mov cx, [ebx + eax*4 + array]
movb $4, %fs:(%eax)	mov fs:eax, 4

Hello World!

真不知道打破这个传统会带来什么样的后果，但既然所有程序设计语言的第一个例子都是在屏幕上打印一个字符串 “Hello World!”，那我们也以这种方式来开始介绍 Linux 下的汇编语言程序设计。

在 Linux 操作系统中，你有很多办法可以实现在屏幕上显示一个字符串，但最简洁的方式是使用 Linux 内核提供的系统调用。使用这种方法最大的好处是可以直接和操作系统的内核进行通讯，不需要链接诸如 libc 这样的函数库，也不需要使用 ELF 解释器，因而代码尺寸小且执行速度快。

Linux 是一个运行在保护模式下的 32 位操作系统，采用 flat memory 模式，目前最常用到的是 ELF 格式的二进制代码。一个 ELF 格式的可执行程序通常划分为如下几个部分：.text、.data 和 .bss，其中 .text 是只读的代码区，.data 是可读可写的数据区，而 .bss 则是可读可写且没有初始化的数据区。代码区和数据区在 ELF 中统称为 section，根据实际需要你可以使用其它标准的 section，也可以添加自定义 section，但一个 ELF 可执行程序至少应该有一个 .text 部分。下面给出我们的第一个汇编程序，用的是 AT&T 汇编语言格式：

例1. AT&T 格式

#hello.s 
.data                    # 数据段声明
        msg : .string "Hello, world!\\n" # 要输出的字符串
        len = . - msg                   # 字串长度
.text                    # 代码段声明
.global _start           # 指定入口函数
        
_start:                  # 在屏幕上显示一个字符串
        movl $len, %edx  # 参数三：字符串长度
        movl $msg, %ecx  # 参数二：要显示的字符串
        movl $1, %ebx    # 参数一：文件描述符(stdout) 
        movl $4, %eax    # 系统调用号(sys_write) 
        int  $0x80       # 调用内核功能
        
                         # 退出程序
        movl $0,%ebx     # 参数一：退出代码
        movl $1,%eax     # 系统调用号(sys_exit) 
        int  $0x80       # 调用内核功能

初次接触到 AT&T 格式的汇编代码时，很多程序员都认为太晦涩难懂了，没有关系，在 Linux 平台上你同样可以使用 Intel 格式来编写汇编程序：

例2. Intel 格式

; hello.asm 
section .data            ; 数据段声明
        msg db "Hello, world!", 0xA     ; 要输出的字符串
        len equ $ - msg                 ; 字串长度
section .text            ; 代码段声明
global _start            ; 指定入口函数
_start:                  ; 在屏幕上显示一个字符串
        mov edx, len     ; 参数三：字符串长度
        mov ecx, msg     ; 参数二：要显示的字符串
        mov ebx, 1       ; 参数一：文件描述符(stdout) 
        mov eax, 4       ; 系统调用号(sys_write) 
        int 0x80         ; 调用内核功能
                         ; 退出程序
        mov ebx, 0       ; 参数一：退出代码
        mov eax, 1       ; 系统调用号(sys_exit) 
        int 0x80         ; 调用内核功能

上面两个汇编程序采用的语法虽然完全不同，但功能却都是调用 Linux 内核提供的 sys_write 来显示一个字符串，然后再调用 sys_exit 退出程序。在 Linux 内核源文件 include/asm-i386/unistd.h 中，可以找到所有系统调用的定义。

Linux 汇编工具

Linux 平台下的汇编工具虽然种类很多，但同 DOS/Windows 一样，最基本的仍然是汇编器、链接器和调试器。

汇编器

汇编器（assembler）的作用是将用汇编语言编写的源程序转换成二进制形式的目标代码。Linux 平台的标准汇编器是 GAS，它是 GCC 所依赖的后台汇编工具，通常包含在 binutils 软件包中。GAS 使用标准的 AT&T 汇编语法，可以用来汇编用 AT&T 格式编写的程序

as -o hello.o hello.s

Linux 平台上另一个经常用到的汇编器是 NASM，它提供了很好的宏指令功能，并能够支持相当多的目标代码格式，包括 bin、a.out、coff、elf、rdf 等。NASM 采用的是人工编写的语法分析器，因而执行速度要比 GAS 快很多，更重要的是它使用的是 Intel 汇编语法，可以用来编译用 Intel 语法格式编写的汇编程序：

nasm -f elf hello.asm
链接器

由汇编器产生的目标代码是不能直接在计算机上运行的，它必须经过链接器的处理才能生成可执行代码。链接器通常用来将多个目标代码连接成一个可执行代码，这样可以先将整个程序分成几个模块来单独开发，然后才将它们组合(链接)成一个应用程序。 Linux 使用 ld 作为标准的链接程序，它同样也包含在 binutils 软件包中。汇编程序在成功通过 GAS 或 NASM 的编译并生成目标代码后，就可以使用 ld 将其链接成可执行程序了：

ld -s -o hello hello.o
调试器

有人说程序不是编出来而是调出来的，足见调试在软件开发中的重要作用，在用汇编语言编写程序时尤其如此。Linux 下调试汇编代码既可以用 GDB、DDD 这类通用的调试器，也可以使用专门用来调试汇编代码的 ALD(Assembly Language Debugger)。

从调试的角度来看，使用 GAS 的好处是可以在生成的目标代码中包含符号表(symbol table)，这样就可以使用 GDB 和 DDD 来进行源码级的调试了。要在生成的可执行程序中包含符号表，可以采用下面的方式进行编译和链接：

as --gstabs -o hello.o hello.s ld -o hello hello.o

执行 as 命令时带上参数 –gstabs 可以告诉汇编器在生成的目标代码中加上符号表，同时需要注意的是，在用 ld 命令进行链接时不要加上 -s 参数，否则目标代码中的符号表在链接时将被删去。

在 GDB 和 DDD 中调试汇编代码和调试 C 语言代码是一样的，你可以通过设置断点来中断程序的运行，查看变量和寄存器的当前值，并可以对代码进行单步跟踪。下图是在 DDD 中调试汇编代码时的情景：

汇编程序员通常面对的都是一些比较苛刻的软硬件环境，短小精悍的ALD可能更能符合实际的需要，因此下面主要介绍一下如何用ALD来调试汇编程序。首先在命令行方式下执行ald命令来启动调试器，该命令的参数是将要被调试的可执行程序：

$ ald hello
Assembly Language Debugger 0.1.3
Copyright (C) 2000-2002 Patrick Alken
hello: ELF Intel 80386 (32 bit), LSB, Executable, Version 1 (current)
Loading debugging symbols...(15 symbols loaded)
ald>

当 ALD 的提示符出现之后，用 disassemble 命令对代码段进行反汇编：

ald> disassemble -s .text
Disassembling section .text (0x08048074 - 0x08048096)
08048074  BA0F000000                 mov edx, 0xf
08048079  B998900408                 mov ecx, 0x8049098
0804807E  BB01000000                 mov ebx, 0x1
08048083  B804000000                 mov eax, 0x4
08048088  CD80                       int 0x80
0804808A  BB00000000                 mov ebx, 0x0
0804808F  B801000000                 mov eax, 0x1
08048094  CD80                       int 0x80

上述输出信息的第一列是指令对应的地址码，利用它可以设置在程序执行时的断点：

ald> break 0x08048088
Breakpoint 1 set for 0x08048088

断点设置好后，使用 run 命令开始执行程序。ALD 在遇到断点时将自动暂停程序的运行，同时会显示所有寄存器的当前值：

ald> run
Starting program: hello
Breakpoint 1 encountered at 0x08048088
eax = 0x00000004 ebx = 0x00000001 ecx = 0x08049098 edx = 0x0000000F
esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000
ds  = 0x0000002B es  = 0x0000002B fs  = 0x00000000 gs  = 0x00000000
ss  = 0x0000002B cs  = 0x00000023 eip = 0x08048088 eflags = 0x00000246
Flags: PF ZF IF
08048088  CD80                       int 0x80

如果需要对汇编代码进行单步调试，可以使用 next 命令：

ald> next
Hello, world!
eax = 0x0000000F ebx = 0x00000000 ecx = 0x08049098 edx = 0x0000000F
esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000
ds  = 0x0000002B es  = 0x0000002B fs  = 0x00000000 gs  = 0x00000000
ss  = 0x0000002B cs  = 0x00000023 eip = 0x0804808F eflags = 0x00000346
Flags: PF ZF TF IF
0804808F  B801000000                 mov eax, 0x1

若想获得 ALD 支持的所有调试命令的详细列表，可以使用 help 命令：

ald> help
Commands may be abbreviated.
If a blank command is entered, the last command is repeated.
Type `help <command>' for more specific information on <command>.
General commands
attach         clear          continue       detach         disassemble
enter          examine        file           help           load
next           quit           register       run            set
step           unload         window         write
Breakpoint related commands
break          delete         disable        enable         ignore
lbreak         tbreak

系统调用

即便是最简单的汇编程序，也难免要用到诸如输入、输出以及退出等操作，而要进行这些操作则需要调用操作系统所提供的服务，也就是系统调用。除非你的程序只完成加减乘除等数学运算，否则将很难避免使用系统调用，事实上除了系统调用不同之外，各种操作系统的汇编编程往往都是很类似的。

在 Linux 平台下有两种方式来使用系统调用：利用封装后的 C 库（libc）或者通过汇编直接调用。其中通过汇编语言来直接调用系统调用，是最高效地使用 Linux 内核服务的方法，因为最终生成的程序不需要与任何库进行链接，而是直接和内核通信。

和 DOS 一样，Linux 下的系统调用也是通过中断（int 0x80）来实现的。在执行 int 80 指令时，寄存器 eax 中存放的是系统调用的功能号，而传给系统调用的参数则必须按顺序放到寄存器 ebx，ecx，edx，esi，edi 中，当系统调用完成之后，返回值可以在寄存器 eax 中获得。

所有的系统调用功能号都可以在文件 /usr/include/bits/syscall.h 中找到，为了便于使用，它们是用 SYS_ 这样的宏来定义的，如 SYS_write、SYS_exit 等。例如，经常用到的 write 函数是如下定义的：

ssize_t write(int fd, const void *buf, size_t count);

该函数的功能最终是通过 SYS_write 这一系统调用来实现的。根据上面的约定，参数 fb、buf 和 count 分别存在寄存器 ebx、ecx 和 edx 中，而系统调用号 SYS_write 则放在寄存器 eax 中，当 int 0x80 指令执行完毕后，返回值可以从寄存器 eax 中获得。

或许你已经发现，在进行系统调用时至多只有 5 个寄存器能够用来保存参数，难道所有系统调用的参数个数都不超过 5 吗？当然不是，例如 mmap 函数就有 6 个参数，这些参数最后都需要传递给系统调用 SYS_mmap：

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

当一个系统调用所需的参数个数大于 5 时，执行int 0x80 指令时仍需将系统调用功能号保存在寄存器 eax 中，所不同的只是全部参数应该依次放在一块连续的内存区域里，同时在寄存器 ebx 中保存指向该内存区域的指针。系统调用完成之后，返回值仍将保存在寄存器 eax 中。

由于只是需要一块连续的内存区域来保存系统调用的参数，因此完全可以像普通的函数调用一样使用栈(stack)来传递系统调用所需的参数。但要注意一点，Linux 采用的是 C 语言的调用模式，这就意味着所有参数必须以相反的顺序进栈，即最后一个参数先入栈，而第一个参数则最后入栈。如果采用栈来传递系统调用所需的参数，在执行int 0x80 指令时还应该将栈指针的当前值复制到寄存器 ebx中。

命令行参数

在 Linux 操作系统中，当一个可执行程序通过命令行启动时，其所需的参数将被保存到栈中：首先是 argc，然后是指向各个命令行参数的指针数组 argv，最后是指向环境变量的指针数据 envp。在编写汇编语言程序时，很多时候需要对这些参数进行处理，下面的代码示范了如何在汇编代码中进行命令行参数的处理：

例3. 处理命令行参数

# args.s
.text
.globl _start
        
_start:
        popl	%ecx		# argc
vnext:
        popl	%ecx		# argv
        test 	%ecx, %ecx      # 空指针表明结束
        jz	exit
        movl	%ecx, %ebx
        xorl	%edx, %edx
strlen:
        movb	(%ebx), %al
        inc	%edx
        inc	%ebx
        test	%al, %al
        jnz	strlen
        movb	$10, -1(%ebx)
        movl	$4, %eax        # 系统调用号(sys_write) 
        movl	$1, %ebx        # 文件描述符(stdout) 
        int	$0x80
        jmp	vnext
exit:
        movl	$1,%eax         # 系统调用号(sys_exit) 
        xorl	%ebx, %ebx      # 退出代码
        int 	$0x80
		
        ret

GCC 内联汇编

用汇编编写的程序虽然运行速度快，但开发速度非常慢，效率也很低。如果只是想对关键代码段进行优化，或许更好的办法是将汇编指令嵌入到 C 语言程序中，从而充分利用高级语言和汇编语言各自的特点。但一般来讲，在 C 代码中嵌入汇编语句要比”纯粹”的汇编语言代码复杂得多，因为需要解决如何分配寄存器，以及如何与C代码中的变量相结合等问题。

GCC 提供了很好的内联汇编支持，最基本的格式是：

__asm__("asm statements");

例如：

__asm__("nop"); 

如果需要同时执行多条汇编语句，则应该用”\n\t”将各个语句分隔开，例如：

__asm__( "pushl %%eax \\n\\t"
         "movl $0, %%eax \\n\\t"
         "popl %eax");

通常嵌入到 C 代码中的汇编语句很难做到与其它部分没有任何关系，因此更多时候需要用到完整的内联汇编格式：

__asm__("asm statements" : outputs : inputs : registers-modified);

插入到 C 代码中的汇编语句是以”:”分隔的四个部分，其中第一部分就是汇编代码本身，通常称为指令部，其格式和在汇编语言中使用的格式基本相同。指令部分是必须的，而其它部分则可以根据实际情况而省略。

在将汇编语句嵌入到C代码中时，操作数如何与C代码中的变量相结合是个很大的问题。GCC采用如下方法来解决这个问题：程序员提供具体的指令，而对寄存器的使用则只需给出”样板”和约束条件就可以了，具体如何将寄存器与变量结合起来完全由GCC和GAS来负责。

在GCC内联汇编语句的指令部中，加上前缀’%’的数字(如%0，%1)表示的就是需要使用寄存器的”样板”操作数。指令部中使用了几个样板操作数，就表明有几个变量需要与寄存器相结合，这样GCC和GAS在编译和汇编时会根据后面给定的约束条件进行恰当的处理。由于样板操作数也使用’%’作为前缀，因此在涉及到具体的寄存器时，寄存器名前面应该加上两个’%’，以免产生混淆。

紧跟在指令部后面的是输出部，是规定输出变量如何与样板操作数进行结合的条件，每个条件称为一个”约束”，必要时可以包含多个约束，相互之间用逗号分隔开就可以了。每个输出约束都以’=’号开始，然后紧跟一个对操作数类型进行说明的字后，最后是如何与变量相结合的约束。凡是与输出部中说明的操作数相结合的寄存器或操作数本身，在执行完嵌入的汇编代码后均不保留执行之前的内容，这是GCC在调度寄存器时所使用的依据。

输出部后面是输入部，输入约束的格式和输出约束相似，但不带’=’号。如果一个输入约束要求使用寄存器，则GCC在预处理时就会为之分配一个寄存器，并插入必要的指令将操作数装入该寄存器。与输入部中说明的操作数结合的寄存器或操作数本身，在执行完嵌入的汇编代码后也不保留执行之前的内容。

有时在进行某些操作时，除了要用到进行数据输入和输出的寄存器外，还要使用多个寄存器来保存中间计算结果，这样就难免会破坏原有寄存器的内容。在GCC内联汇编格式中的最后一个部分中，可以对将产生副作用的寄存器进行说明，以便GCC能够采用相应的措施。

下面是一个内联汇编的简单例子：

例4. 内联汇编

/* inline.c */
int main()
{
    int a = 10, b = 0;
    __asm__ __volatile__("movl %1, %%eax;\\n\\r"
                         "movl %%eax, %0;"
                         :"=r"(b)      /* 输出 */    
                         :"r"(a)       /* 输入 */
                         :"%eax");     /* 不受影响的寄存器 */
    
    printf("Result: %d, %d\\n", a, b);
}

上面的程序完成将变量a的值赋予变量b，有几点需要说明：

变量b是输出操作数，通过%0来引用，而变量a是输入操作数，通过%1来引用。
输入操作数和输出操作数都使用r进行约束，表示将变量a和变量b存储在寄存器中。输入约束和输出约束的不同点在于输出约束多一个约束修饰符’=’。
在内联汇编语句中使用寄存器eax时，寄存器名前应该加两个’%’，即%%eax。内联汇编中使用%0、%1等来标识变量，任何只带一个’%’的标识符都看成是操作数，而不是寄存器。
内联汇编语句的最后一个部分告诉GCC它将改变寄存器eax中的值，GCC在处理时不应使用该寄存器来存储任何其它的值。
由于变量b被指定成输出操作数，当内联汇编语句执行完毕后，它所保存的值将被更新。

在内联汇编中用到的操作数从输出部的第一个约束开始编号，序号从0开始，每个约束记数一次，指令部要引用这些操作数时，只需在序号前加上’%’作为前缀就可以了。需要注意的是，内联汇编语句的指令部在引用一个操作数时总是将其作为32位的长字使用，但实际情况可能需要的是字或字节，因此应该在约束中指明正确的限定符：

限定符	意义
“m”、”v”、”o”	内存单元
“r”	任何寄存器
“q”	寄存器eax、ebx、ecx、edx之一
“i”、”h”	直接操作数
“E”和”F”	浮点数
“g”	任意
“a”、”b”、”c”、”d”	分别表示寄存器eax、ebx、ecx和edx
“S”和”D”	寄存器esi、edi
“I”	常数（0至31）

小结

Linux操作系统是用C语言编写的，汇编只在必要的时候才被人们想到，但它却是减少代码尺寸和优化代码性能的一种非常重要的手段，特别是在与硬件直接交互的时候，汇编可以说是最佳的选择。Linux提供了非常优秀的工具来支持汇编程序的开发，使用GCC的内联汇编能够充分地发挥C语言和汇编语言各自的优点。

参考资料

在网站 linuxassembly.org 上可以找到大量的Linux汇编资源。
软件包binutils提供了as和ld等实用工具，其相关信息可以在网站 sources.redhat.com/binutils/ 上找到。
NASM是Intel格式的汇编器，其相关信息可以在网站 nasm.sourceforge.net 上找到。
ALD是一个短小精悍的汇编调试器，其相关信息可以在网站 dunx1.irt.drexel.edu/~psa22/ald.html 上找到。
intel2gas是一个能够将Intel汇编格式转换成AT&T汇编格式的小工具，其相关信息可以在网站 www.niksula.cs.hut.fi/~mtiihone/intel2gas/ 上找到。

【搞机小子】Airpi AP3000M 5G CPE 使用体验

2025-10-01T00:00:00+00:00

书接上回，我在淘宝买了个RM530N-GL模块，配合微雪 USB 3.2 Gen1 5G DONGLE 来给笔电上 5G。

不过，USB 设备总觉得有点别扭，尤其是我这种经常出差的人，插拔总觉得不方便。

很久之前在淘宝上看到一款手搓的 5G CPE，叫 Airpi AP3000M，用的 MT7981 芯片，AX3000 的 Wi-Fi，1GB RAM + 16GB ROM，不带 5G 模块才 439。

样子还硬派的，于是果断下单。

拿到手之后是散件，需要自己动手装。（没拍装机过程，可以找店家要安装视频，本人比较头铁，自己安的）

装好之后，插上电源，等 1 分钟左右，等到侧面的红色指示灯常亮之后，就可以用手机或者电脑连接 Wi-Fi 了。

（按理说是没有密码的，我这个是时候截图的时候被我设置了密码）

或者者直接用网线连接 CPE 的 LAN 口。（LAN口是离电源口最远的那个）

打开浏览器，输入 192.168.88.1，就可以进入管理界面了。

默认用户名是 root，密码是 admin。

进入管理界面之后，找到 移动网络 -> 其他设定，找到 USB 设备信息 /lsusb，可以看到识别出来的 5G 模块：Bus 002 Device 002: ID 2c7c:0801 Quectel RM530N-GL

然后找到找到 移动网络 -> 串口调试，选择模组的 AT 口，发送以下命令：

ATE1 # 设置回显
AT+QCFG="usbnet",3 # 设置为 RNDIS 模式
AT+CFUN=1,1 # 重启模组

（别问我为什么不用 MBIM 模式，我也不知道，反正 RNDIS 模式能用就行）

然后可以进入 网络选项 -> 接口配置，添加一个新的移动网络接口，名字可以叫 WWAN，选择 eth2 作为接口。协议选择 DHCP客户端。（eth0 是 LAN 口，eth1 是 WAN 口，eth2 是 5G 模块）

也可以添加IPv6的DHCP客户端。

就可以上网了。

也可以养小猫咪：

最后用中科大测速：

【赛博丁真】让你的笔电也加入 5G

2025-09-04T00:00:00+00:00

~~都说 2019 年是 5G 商用元年，但我一直都有点困惑，4G 已经够快了，5G 到底有什么用呢？~~

手机和 Pad 上都有 5G，但是笔电制造商很不热衷于在笔电主板上加一个 WWAN 接口或者是直接集成，就连高通处理器的笔电很多也没有集成。

为了探究这个问题，我在 2023 年让我爸斥巨资买了个 Surface Pro 9 5G 版，来体验一下 5G 的快感。

随后在进入联想工作后，又弄了一台 ThinkPad X1 Carbon Gen 9，原装是 LTE 模块，上淘宝搜一下轻轻松松就搞到一个高通 X55 的 5G 模块，换上装 Fedora（过程还是比较麻烦的，下一期补上这个）。

先说结论，如果说模块支持修改 IMEI 的话，买个天际通流量卡，基本上就可以做到随时随地在线，办公追剧两不误。

讲真，天际通的流量卡真的很香，2000G 流量才 99 元（我直接包年，599），5G 网络覆盖也还不错。

其实能改 IMEI 的模块也不多，ThinkPad 的模块需要魔改才能暴露串口，使用 AT 指令来修改 IMEI，Surface Pro 9 的模块貌似用的广和通的，也是屏蔽了部分 COM 口。

所以，我直接在淘宝的微雪旗舰店买了个 USB 3.2 Gen1 5G DONGLE，再配上 Sub-6 GHz 和毫米波模块 RM530N-GL。

把黑盒的 USB 线接到笔电上，再在电脑上安装驱动：

看到这样就成。然后下载 QCOM，用作为修改 IMEI 的工具。

在设备管理器中，我们能看到三个 COM 口，记下 AT 指令口的 COM 号，比如我的是 Quectel USB AT Port (COM11)。

打开 QCOM，选择对应的 COM 口，波特率 115200，然后点击 Open Port；Operation 下勾选 RTS 和 Send with Enter：

输入 ATE1，回车，打开回显，看到 OK 说明串口通信正常。

输入 AT+CGSN，回车，看到返回的结果是当前的 IMEI 号。

移远模组的文档里面没写修改 IMEI 的 AT 指令，网上也有愣头青跑去移远论坛下问，结果人家说不支持修改 IMEI。微雪的文档也说不支持，乐。

国内版可能用不了，但是全球版应该会遵循3GPP TS 27.007 和 TS 27.005 标准，这两个标准规定了常见的蜂窝网络AT命令集（如拨号、短信、网络注册、信号质量查询等）。

放心大胆使用 AT+EGMR=1,7,"你的华为随身WiFi的IMEI号" 来修改 IMEI 吧。最后可以用 AT+CGSN 来查询修改后的 IMEI 号。

修改完 IMEI 之后，拔掉黑盒，插上 SIM 卡，就可以联网了。

如果要使用 MBIM 模式的话，使用以下 AT 指令：

AT+QCFG="usbnet",2
AT+CFUN=1,1

想换回 NDIS 模式的话，使用以下 AT 指令：

AT+QCFG="usbnet",1
AT+QNETDEVCTL=2,3,1
AT+CFUN=1,1

~~不觉得这很酷吗？作为一名理工男我觉得这太酷了，很符合我对未来生活的想象，科技并带着趣味。~~

突然想起来，我刚上大学的时候，在常州认识了常州创客中心的创始人，当时他就跟我说过一句话：

何同学很厉害。他做的 5G 视频你看了没有，我觉得那就是创客。

哦。啧。唉。

【玩转树莓派】VSCode 远程登录树莓派并免密登录

2025-07-20T00:00:00+00:00

安装 VSCode 及 Remote SSH 插件

安装 Visual Studio Code
安装插件：Remote - SSH

生成 SSH 密钥对（如果没有的话）

打开 PowerShell 或 CMD：

ssh-keygen

默认会保存在：

C:\Users\你的用户名\.ssh\id_rsa（私钥）
C:\Users\你的用户名\.ssh\id_rsa.pub（公钥）

直接按回车即可，不设密码。

登录树莓派并上传公钥

先用普通方式连接一次：

ssh pi@raspberrypi.local
# 或 ssh pi@192.168.x.x

然后在树莓派上执行：

mkdir -p ~/.ssh
chmod 700 ~/.ssh

然后用如下命令将 Windows 上的公钥复制进去（在 Windows 端执行）：

type $env:USERPROFILE\.ssh\id_rsa.pub | ssh pi@raspberrypi.local "cat >> ~/.ssh/authorized_keys"

再设置好权限（树莓派端）：

chmod 600 ~/.ssh/authorized_keys

编辑 SSH 配置文件（Windows）

打开：

C:\Users\你的用户名\.ssh\config

（没有就创建）

添加如下内容：

Host rpi
    HostName 192.168.x.x     # 树莓派的 IP
    User pi
    IdentityFile ~/.ssh/id_rsa

【阅板无数】使用 OpenOCD 对 Raspberry Pi CM5 进行调试

2025-07-17T00:00:00+00:00

2024年11月27日，在距第一款商用 Raspberry Pi Model B（于 2012 年 2 月 29 日推出）发布整整12年之后，Raspberry Pi 基金会发布了 Raspberry Pi Compute Module 5（CM5）。这款产品的发布标志着 Raspberry Pi 进入了一个新的阶段，特别是在工业和嵌入式应用领域。

Raspberry Pi CM5 是一款基于 Raspberry Pi 4 的计算模块，采用了更小的尺寸和更高的集成度，旨在满足工业和嵌入式应用的需求。它配备了强大的处理器、丰富的接口和扩展能力，使其成为各种应用场景的理想选择。

测试点位

废话不多说，直接进入正题，以往的 Raspberry Pi 系列产品都可以通过 JTAG 进行调试，但 CM5 的 JTAG 接口并不直接暴露出来。同时我们需要使用 OpenOCD 来对其进行调试。

根据官方提供的数据手册，我们可以看到 CM5 的 JTAG 接口位于 Wi-Fi 模块背面的测试点位，具体位置参见文档第37页。

具体焊接点位如下，橙色线和黄色线是对应原版树莓派 Debug Probe 的线的颜色：

Orange TX/SCLK (Output from Probe)
Black GND
Yellow RX/SWD (Input to Probe or I/O)

具体参见官方文档。

树莓派配置

在树莓派镜像里面找到 /boot/firmware/config.txt 文件，添加以下内容：

[all]
enable_uart=1
dtoverlay=uart0
dtoverlay=disable-bt
uart_2ndstage=1
enable_jtag_gpio=1

dtparam=fan_temp0=35000
dtparam=fan_temp0_hyst=5000
dtparam=fan_temp0_speed=175
dtparam=uart0=on

然后在 /boot/firmware/cmdline.txt 文件中修改成以下内容：

earlycon=pl011,0x107d001000,115200n8 console=tty1 console=ttyAMA0,115200 root=PARTUUID=5f127066-02 rootfstype=ext4 fsck.repair=yes rootwait quiet splash plymouth.ignore-serial-consoles cfg80211.ieee80211_regdom=CN

/boot/firmware/config.txt 文件中的 enable_jtag_gpio=1 是启用 JTAG GPIO 的关键配置。

/boot/firmware/cmdline.txt 文件中的 console=ttyAMA0,115200 原本应该是 console=serial0,115200n8，但由于树莓派 CM5 的 Serial0 默认绑定那两个焊上的测试点，我们需要把串口转到 GPIO 14 和 15 上，因此需要将其修改为 console=ttyAMA0,115200。

本人自制了一个带 3V3 的调试器，使用了树莓派官方的 Debug Probe，焊接了 3V3、GND、SWD 和 SCLK 四个引脚。

OpenOCD 配置

在电脑上安装 AArch64 GNU/Linux target (aarch64-none-linux-gnu)，可以在此处下载。如果需要裸机编程，还需要安装 AArch64 bare-metal target (aarch64-none-elf)。

Windows版的 OpenOCD 可以在此处下载。

Linux 用户可以自己编译，也可以使用包管理器安装 OpenOCD。

安装好后可以打开终端，输入以下命令来检查 OpenOCD 是否安装成功：

cd <path_to_openocd>
.\openocd.exe --version

然后检查 AArch64 GNU/Linux target (aarch64-none-linux-gnu)：

cd "C:\Program Files (x86)\Arm GNU Toolchain aarch64-none-linux-gnu\14.3 rel1\bin"
.\aarch64-none-linux-gnu-gdb.exe --version

接下来创建一个 OpenOCD 配置文件 rpi5.cfg，内容如下：

# SPDX-License-Identifier: GPL-2.0-or-later

# The Broadcom BCM2712 used in Raspberry Pi 5
# No documentation was found on Broadcom website

# Partial information is available in Raspberry Pi website:
# https://www.raspberrypi.com/documentation/computers/processors.html#bcm2712

# v1.0 initial revision - trejan on forums.raspberrypi.com

if { [info exists CHIPNAME] } {
        set  _CHIPNAME $CHIPNAME
} else {
        set  _CHIPNAME bcm2712
}

if { [info exists CHIPCORES] } {
        set _cores $CHIPCORES
} else {
        set _cores 4
}

if { [info exists USE_SMP] } {
        set _USE_SMP $USE_SMP
} else {
        set _USE_SMP 0
}

if { [info exists DAP_TAPID] } {
        set _DAP_TAPID $DAP_TAPID
} else {
        set _DAP_TAPID 0x4ba00477
}

transport select swd

swd newdap $_CHIPNAME cpu -expected-id $_DAP_TAPID -irlen 4
adapter speed 4000

dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu

# MEM-AP for direct access
target create $_CHIPNAME.ap mem_ap -dap $_CHIPNAME.dap -ap-num 0

# these addresses are obtained from the ROM table via 'dap info 0' command
set _DBGBASE {0x80010000 0x80110000 0x80210000 0x80310000}
set _CTIBASE {0x80020000 0x80120000 0x80220000 0x80320000}

set _smp_command "target smp"

for { set _core 0 } { $_core < $_cores } { incr _core } {
        set _CTINAME $_CHIPNAME.cti$_core
        set _TARGETNAME $_CHIPNAME.cpu$_core

        cti create $_CTINAME -dap $_CHIPNAME.dap -ap-num 0 -baseaddr [lindex $_CTIBASE $_core]
        target create $_TARGETNAME aarch64 -dap $_CHIPNAME.dap -ap-num 0 -dbgbase [lindex $_DBGBASE $_core] -cti $_CTINAME

        set _smp_command "$_smp_command $_TARGETNAME"
}

if {$_USE_SMP} {
        eval $_smp_command
}

# default target is cpu0
targets $_CHIPNAME.cpu0

或者使用以下内容：

# bcm2712.cfg
# SPDX-License-Identifier: GPL-2.0-or-later
# OpenOCD target config file
# This file is based on target/bcm2711.cfg
# I have checked that it works with Open On-Chip Debugger 0.12.0 
# using the Raspberry Pi Debug-Probe interface

transport select swd
adapter speed 1000

if { [info exists CHIPNAME] } {
    set  _CHIPNAME $CHIPNAME
} else {
    set  _CHIPNAME bcm2712
}

if { [info exists CHIPCORES] } {
    set _cores $CHIPCORES
} else {
    set _cores 4
}

if { [info exists USE_SMP] } {
    set _USE_SMP $USE_SMP
} else {
    set _USE_SMP 0
}

if { [info exists DAP_TAPID] } {
    set _DAP_TAPID $DAP_TAPID
} else {
    set _DAP_TAPID 0x2ba00477
}

# swj_newdap $_CHIPNAME cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id $_DAP_TAPID
swd newdap $_CHIPNAME cpu -expected-id $_DAP_TAPID
dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu

# MEM-AP for direct access
target create $_CHIPNAME.ap mem_ap -dap $_CHIPNAME.dap -ap-num 0

# these addresses are obtained from the ROM table via 'dap info 0' command
set _DBGBASE {0x80010000 0x80110000 0x80210000 0x80310000}
set _CTIBASE {0x80020000 0x80120000 0x80220000 0x80320000}

set _smp_command "target smp"

for { set _core 0 } { $_core < $_cores } { incr _core } {
    set _CTINAME $_CHIPNAME.cti$_core
    set _TARGETNAME $_CHIPNAME.cpu$_core

    cti create $_CTINAME -dap $_CHIPNAME.dap -ap-num 0 -baseaddr [lindex $_CTIBASE $_core]
    target create $_TARGETNAME aarch64 -dap $_CHIPNAME.dap -ap-num 0 -dbgbase [lindex $_DBGBASE $_core] -cti $_CTINAME

    set _smp_command "$_smp_command $_TARGETNAME"
}

if {$_USE_SMP} {
    eval $_smp_command
}

# default target is cpu0
targets $_CHIPNAME.cpu0

然后新建一个 cmsis-dap.cfg 文件，内容如下：

# SPDX-License-Identifier: GPL-2.0-or-later

#
# ARM CMSIS-DAP compliant adapter
#
# http://www.keil.com/support/man/docs/dapdebug/
#

adapter driver cmsis-dap

# Optionally specify the serial number of CMSIS-DAP usb device.
# adapter serial 02200201E6661E601B98E3B9

启动 OpenOCD 开始调试

在终端中运行以下命令来启动 OpenOCD：

cd <path_to_openocd>
.\openocd.exe --file cmsis-dap.cfg --file rpi5.cfg

如果一切正常，你应该会看到类似以下的输出：

Open On-Chip Debugger 0.12.0 (2025-07-10) [https://github.com/sysprogs/openocd]
Licensed under GNU GPL v2
libusb1 d52e355daa09f17ce64819122cb067b8a2ee0d4b
For bug reports, read
        http://openocd.org/doc/doxygen/bugs.html
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : Using CMSIS-DAPv2 interface with VID:PID=0x2e8a:0x000c, serial=0DA4770B2DB8B6AA
Info : CMSIS-DAP: SWD supported
Info : CMSIS-DAP: Atomic commands supported
Info : CMSIS-DAP: Test domain timer supported
Info : CMSIS-DAP: FW Version = 2.0.0
Info : CMSIS-DAP: Interface Initialised (SWD)
Info : SWCLK/TCK = 0 SWDIO/TMS = 0 TDI = 0 TDO = 0 nTRST = 0 nRESET = 0
Info : CMSIS-DAP: Interface ready
Info : clock speed 4000 kHz
Info : SWD DPIDR 0x2ba01477
Info : [bcm2712.ap] Examination succeed
Info : bcm2712.cpu0: hardware has 6 breakpoints, 4 watchpoints
Info : [bcm2712.cpu0] external reset detected
Info : [bcm2712.cpu0] Examination succeed    
Info : bcm2712.cpu1: hardware has 6 breakpoints, 4 watchpoints
Info : [bcm2712.cpu1] external reset detected
Info : [bcm2712.cpu1] Examination succeed
Info : bcm2712.cpu2: hardware has 6 breakpoints, 4 watchpoints
Info : [bcm2712.cpu2] external reset detected
Info : [bcm2712.cpu2] Examination succeed
Info : bcm2712.cpu3: hardware has 6 breakpoints, 4 watchpoints
Info : [bcm2712.cpu3] external reset detected
Info : [bcm2712.cpu3] Examination succeed
Info : [bcm2712.ap] gdb port disabled
Info : [bcm2712.cpu0] starting gdb server on 3333
Info : Listening on port 3333 for gdb connections
Info : [bcm2712.cpu1] starting gdb server on 3334
Info : Listening on port 3334 for gdb connections
Info : [bcm2712.cpu2] starting gdb server on 3335
Info : Listening on port 3335 for gdb connections
Info : [bcm2712.cpu3] starting gdb server on 3336
Info : Listening on port 3336 for gdb connections

使用 GDB 连接 OpenOCD

在终端中打开 GDB，使用以下命令连接到 OpenOCD：

cd <path_to_aarch64_gnu_toolchain>
.\aarch64-none-linux-gnu-gdb.exe

然后在 GDB 中输入以下命令：

target remote :3333

将会看到类似以下的输出：

Remote debugging using :3333
warning: No executable has been specified and target does not support
determining executable automatically.  Try using the "file" command. 
0xffffd06fcf183b48 in ?? ()

这表示你已经成功连接到 OpenOCD，并且可以开始调试 Raspberry Pi CM5。

更多调试命令可以参考 OpenOCD 和 GDB 的文档和手册。

参考资料

How to Connect and Debug a Raspberry Pi 5 Bare Metal - ARM Developer

【阅板无数】（Intel x86 IoT系列）Intel Quark D2000 复活记

2025-06-01T00:00:00+00:00

书接上回【阅板无数】（Intel x86 IoT系列）Intel Arduino/Genuino 101 简单测评，我们讲到在2015年1月的时候，Intel “积极”拥抱开源硬件，推出了基于 Quark SoC 的 Arduino/Genuino 101 开发板。（其实英特尔在2013年就在英特尔论坛上推出了 Quark 系列的 32 位 x86 架构微控制器，很可惜在2019年1月英特尔宣布停止Quark系列产品的生产。）

前言

站在后人的角度看待英特尔在 IoT 领域的尝试，英特尔的确是有点“心有余而力不足”，倒也不至于全产品线沦落到“出师未捷身先死”的地步。其第一款产品是单核心 32 纳米 X1000 SoC，应用在 Intel Galileo 开发板上。Intel Galileo 是基于 Intel x86 架构的 Arduino 认证开发板系列中的第一款，专为创客和教育社区而设计。

单凭这第一款产品可以看出来英特尔是想要积极拥抱开源硬件吗？如拥，用过这玩意儿的都知道，这个还要单独供电，核心非常烫手。（关于这款板子后续会有文章介绍，今天我们着重介绍 Quark D2000。）

这款代号为“薄荷峡谷（Mint Valley）”的 Intel Quark D2000 SoC 是英特尔在2015年Q3季度推出的产品，应用在 Intel Quark Microcontroller D2000 开发板上。它是英特尔在 IoT 领域的又一次尝试，旨在提供一个低功耗、低成本的解决方案，适用于物联网设备和嵌入式应用。

同时，Quark 系列也补全了英特尔在嵌入式微控制器领域的产品线。商用的 Xeon，消费级的 Core/Pentium/Celeron 系列，移动端的 Atom 系列，嵌入式的 Quark 系列。自此，英特尔补完了在微电子领域的产品线。~~EE补完计划~~

规格

产品名称	Intel Quark D2000 Series
代号	Mint Valley
垂直细分产线	嵌入式微控制器
核心架构	32 位 i586
核心数量	单核心
主频	32 MHz
L1 Cache	0 KB
GPIO	SPI, I2C, GPIO, SPI, Comparators, ADC, PWM, DMA
UART	2 个 UART
封装	LQFN40
描述	32位，单核单线程，Pentium ISA 兼容微控制器

详细规格可以参考此处 ¹。

有意思的是，虽然写的是 Pentium ISA 兼容微控制器，但是它不支持 SIMD 或 x87 浮点。（玩过 8087 的都知道，8087 是 Intel 的第一个浮点协处理器。这玩意儿运行起来十分烫手，估计是因为功耗原因没加入 x87 浮点指令集。）

结语

不过这款产品还是非常能打的，站在软件开发的角度来看，英特尔其实是想把在 CPU 端的开发经验带到嵌入式领域。毕竟到了2015年，英特尔在 CPU 领域已经有了几十年的积累，x86 架构的微控制器可以让开发者更容易地使用现有的 x86 工具链和软件库，从而降低了开发门槛。

但是这样也有缺点，英特尔历史包袱太重，放不下庞大的PC/商用市场，或者说英特尔只是想在 Maker 社区和开源硬件社区赚一波快钱。这款产品从发布到生命周期结束，英特尔都没有好好对待。首先就是开发平台就只能使用 Intel System Studio for Microcontrollers，完全看不出英特尔拥抱开源硬件的诚意（特别是 Arduino 授权，用 Arduino Uno 的 Pinout 但是不支持 Arduino IDE）。

反观 Nordic 和 Espressif 的产品，Nordic 的 nRF 系列和 Espressif 的 ESP 系列都提供了丰富的开源支持和社区资源，尤其是 Arduino，开发者可以轻松上手（Arduino 确实是为打破壁垒做出巨大贡献，让很多非电子专业的人们可以快速开发自己想要的东西）。而英特尔的 Quark D2000 开发板在这方面就显得将这些需求置若罔闻。

很重要的一点就是拥抱开源社区其实是在培养用户粘性，就好比 Espressif 的 ESP 系列产品，提供了丰富的开源支持和社区资源，尤其是 Arduino 生态系统。开发者可以轻松上手，快速开发出各种物联网应用。如果需要开发更复杂的应用，还可以使用 ESP-IDF（Espressif IoT Development Framework）进行更底层的开发。

也可能是因为时任英特尔 CEO 的布莱恩·科再奇（Brian Krzanich） ~~对下属十分热情~~ 对开源硬件的热情不够，导致英特尔在这方面的投入和支持力度不足。也可能是他在任期间，因为其战略决定，导致英特尔在研发10纳米制程芯片的进度上相比台积电及三星都要缓慢，导致市场占有率被竞争对手超微所蚕食。²

The Verge 还提到，英特尔虽然以 PC 和服务器而闻名，但其业务已被智能手机和云颠覆，而该公司似乎对人工智能和自动驾驶汽车的兴起毫无察觉。英特尔承诺推出智能耳机、英特尔驱动的智能手表、智能眼镜、英特尔电视服务、搭载英特尔芯片的无人机和自动驾驶汽车，但英特尔大约 85% 的收入仍然来自其服务器和 PC 工作。近年来，英特尔曾多次试图在 CES 上通过华丽的主题演讲重新定位自己，但这些努力没有说服力，也缺乏重点。

站在开源硬件的角度，英特尔同样不受待见。Arduino 社区从未接受 Curie，随着 Linux 驱动的 Raspberry Pi 越来越主导低端黑客板卡领域，Arduino 兼容性变得不再是必备功能。对于英特尔试图通过其 Curie 吸引的豪华智能手表供应商来说，这当然没有多大意义。

x86 社区也没有太多考虑 Quark。由于 Quark 最初仅宣布与 Pentium ISA 兼容，因此它的进展最初放缓了。当 Intel 添加 x86 兼容性时，为时已晚³。

时任 LinkedIn 半导体销售和营销小组的主持人 Bill Giovino⁴ 评价 Intel Quark D2000 的文章中提到：如今，似乎每家半导体公司都有用于物联网（IoT）的微控制器解决方案。我们看到了来自通常内核供应商的低功耗、高性能和高集成度微控制器的规格。但是，当英特尔宣布将重新进入微控制器业务，推出用于物联网的 32 位 x86 MCU 时，就像雷神拿起锤子再次参加比赛一样。

注：英特尔最早的产品是3101 SRAM，英特尔第一款微控制器是基于哈佛架构的 Intel 8048/MCS-48（1976年），其衍生版本就有著名的 8051，也就是51单片机。

只可惜，在死神面前，雷神的锤子不堪一击，甚至连锤子都被捏的粉碎。

复活雷神的锤子

上面提到了，这款产品没有适配 Arduino IDE，所以我们需要使用 Intel System Studio for Microcontrollers 来编译和烧录程序。

可笑的是，英特尔在2019年1月宣布停止Quark系列产品的生产和支持，这意味着 Intel System Studio for Microcontrollers 也不再更新了。甚至 Intel System Studio for Microcontrollers 的下载链接都失效了。英特尔只保留了 Quark D2000 的数据手册、规格说明书和一些指南。

Quark D2000 Dev Platform的一些官方和三方链接我贴在此处：

上面难得有点用的应该也就是第 3 个链接了。防止英特尔下架，我贴在我这里：

Pin Map

Pin Name

/**
    * External Pad pin identifiers
   **/ 

    QM_PIN_ID_0,  /**< Pin id 0. */
    QM_PIN_ID_1,  /**< Pin id 1. */
    QM_PIN_ID_2,  /**< Pin id 2. */
    QM_PIN_ID_3,  /**< Pin id 3. */
    QM_PIN_ID_4,  /**< Pin id 4. */
    QM_PIN_ID_5,  /**< Pin id 5. */
    QM_PIN_ID_6,  /**< Pin id 6. */
    QM_PIN_ID_7,  /**< Pin id 7. */
    QM_PIN_ID_8,  /**< Pin id 8. */
    QM_PIN_ID_9,  /**< Pin id 9. */
    QM_PIN_ID_10, /**< Pin id 10. */
    QM_PIN_ID_11, /**< Pin id 11. */
    QM_PIN_ID_12, /**< Pin id 12. */
    QM_PIN_ID_13, /**< Pin id 13. */
    QM_PIN_ID_14, /**< Pin id 14. */
    QM_PIN_ID_15, /**< Pin id 15. */
    QM_PIN_ID_16, /**< Pin id 16. */
    QM_PIN_ID_17, /**< Pin id 17. */
    QM_PIN_ID_18, /**< Pin id 18. */
    QM_PIN_ID_19, /**< Pin id 19. */
    QM_PIN_ID_20, /**< Pin id 20. */
    QM_PIN_ID_21, /**< Pin id 21. */
    QM_PIN_ID_22, /**< Pin id 22. */
    QM_PIN_ID_23, /**< Pin id 23. */
    QM_PIN_ID_24, /**< Pin id 24. */

/**
 * Pin function type. (Mode 0 ~ Mode 3)
 */
    QM_PMUX_FN_0, /* Mode 0 */
    QM_PMUX_FN_1, /* Mode 1 */
    QM_PMUX_FN_2, /* Mode 2 */
    QM_PMUX_FN_3, /* Mode 3 */

Example

/* Mux out STDOUT_UART tx/rx pins and enable input for rx. */
     qm_pmux_select(QM_PIN_ID_12, QM_PMUX_FN_2);
     qm_pmux_select(QM_PIN_ID_13, QM_PMUX_FN_2);
     qm_pmux_input_en(QM_PIN_ID_13, true);

那么你现在可能有疑问：IDE 都没有了，还有编译环境吗？有的，兄弟，有的。我们自己手动编译 IAMCU i586 的工具链。

手动编译 IAMCU i586 的工具链

英特尔十分难得地提供了 The Intel Quark MCUs Software Stack。在 QMSI（Quark Microcontroller Software Interface）中，英特尔提供了一个名为 qmsi 的目录，其中包含了 Quark D2000 和 SE C1000 的驱动和库。具体参照此链接。在自述文件中提到：

您必须首先设置 IAMCU_TOOLCHAIN_DIR 环境变量。假设工具链被解压为 $HOME/issm_2016/ 并且您可以在 $HOME/issm_2016/tools/compiler/gcc-ia/5.2.1/bin 中找到 i586-intel-elfiamcu-gcc ……

~~这不禁让人兴奋起来~~

敢情英特尔还是定制了一个 i586 的交叉编译工具链。理得佢咁多，先搞一个试试。

环境

我用的是 Ubuntu Server 18.04.6 LTS，安装了以下依赖：

sudo apt update
sudo apt install build-essential git cmake gcc-multilib g++-multilib python3-pip

这环境属实是东雪莲它妈给东雪莲开门——罕见到家了。

接着需要获取 QMSI，这是 Intel 官方早期为 Quark D2000 提供的裸机驱动层，包含 GPIO、UART、RTC、I2C 等外设支持：

git clone https://github.com/quark-mcu/qmsi.git
cd qmsi

接着是编译和安装交叉编译工具链。Intel 官方推荐的工具链是 i586-intel-elfiamcu-gcc，不过因为你完全不可能下到原始安装包，所以我们需要手动编译。

export TARGET=i586-elf
export PREFIX=/opt/cross

# 下载 Binutils 和 GCC 源码
mkdir -p ~/quark-toolchain && cd ~/quark-toolchain
wget https://ftp.gnu.org/gnu/binutils/binutils-2.36.tar.gz
wget https://ftp.gnu.org/gnu/gcc/gcc-10.2.0/gcc-10.2.0.tar.gz

tar -xvf binutils-2.36.tar.gz
tar -xvf gcc-10.2.0.tar.gz
cd gcc-10.2.0
./contrib/download_prerequisites
cd ..

# 构建 binutils
mkdir build-binutils && cd build-binutils
../binutils-2.36/configure --target=$TARGET --prefix=$PREFIX --disable-nls
make -j$(nproc)
sudo make install
cd ..

# 构建 gcc（只要 C）
mkdir build-gcc && cd build-gcc
../gcc-10.2.0/configure --target=$TARGET --prefix=$PREFIX --disable-nls --enable-languages=c --without-headers
make all-gcc -j$(nproc)
make all-target-libgcc -j$(nproc)
sudo make install-gcc
sudo make install-target-libgcc

添加交叉编译工具链到 PATH：

export PATH=/opt/cross/bin:$PATH

检查是否安装成功：

i586-elf-gcc --version

现在环境才搭一半，工具链是“裸机”版本（newlib 或 newlib-nano 未安装或未连接），无法找到标准 C 头文件，如 stdio.h、stdlib.h 等。我们需要安装 newlib。

首先下载 newlib 源码：

git clone https://sourceware.org/git/newlib-cygwin.git
cd newlib-cygwin

构建并安装 newlib：

mkdir build && cd build
../configure --target=i586-elf --prefix=/opt/cross
make all -j$(nproc)
make install
# 如果安装失败，请尝试
sudo env "PATH=$PATH" make install

接着就是魔改 QMSI 的文件。定位到 qmsi 根目录下的 base.mk ，修改以下内容：

### Tools
#PREFIX ?= arc-elf32
#TOOLCHAIN_DIR=$(ARCMCU_TOOLCHAIN_DIR)
#else
#PREFIX ?= i586-intel-elfiamcu
#TOOLCHAIN_DIR=$(IAMCU_TOOLCHAIN_DIR)
#endif

TOOLCHAIN_DIR := $(dir $(CROSS_COMPILE))
PREFIX := $(notdir $(CROSS_COMPILE))
CFLAGS += -Wno-error=implicit-fallthrough

.
.
.

ifeq ($(TARGET), sensor)
CFLAGS += -DQM_SENSOR
CFLAGS += -ffreestanding
CFLAGS += -mARCv2EM -mav2em -mno-sdata
LDFLAGS += -nostartfiles
LDLIBS += -lc -lgcc
else
#LDLIBS += -lc -lnosys -lsoftfp -lgcc
LDLIBS += -lc -lgcc

最后是编译，我们尝试编译一个 blinky：

unset IAMCU_TOOLCHAIN_DIR
cd ~/qmsi/examples/blinky
export CROSS_COMPILE=/opt/cross/bin/i586-elf
make TARGET=x86 SOC=quark_d2000 V=1

编译成功后会在 release/quark_d2000/x86/bin/blinky.bin。

注意：如果编译时候遇到编译器抛出 switch-case 函数错误 error: this statement may fall through [-Werror=implicit-fallthrough=] 的时候，请定位到报错行下方添加 __attribute__((fallthrough));。

烧录

非常幸运的是，这个板子自带 FTDI FT232HL USB 转串口芯片，所以我们可以直接使用 OpenOCD 来烧录。

首先，如果你用的是 Windows 系统，需要下载 Zadig 工具，将 FT232HL 的驱动安装为 WinUSB。如果你用的是 Linux 系统，通常不需要额外安装驱动。

我们需要下载英特尔提供的 OpenOCD 副本。点击此处下载对应操作系统的版本。解压后，进入 scripts 目录。

接着从 Intel/OpenOCD 仓库中，定位到 tcl/board/ 目录，找到 quark_d2000.cfg 和 quark_d2000_onboard.cfg 两个文件，下载到 $Intel_OpenOCD/scripts/board/ 目录下。然后定位到 tcl/target/ 目录，找到 quark_d2000.cfg 文件，下载到 $Intel_OpenOCD/scripts/target/ 目录下。

现在我们通过命令行/终端进入到 OpenOCD 的 bin 目录下。

我们还需要下载 Quark D2000 的 Bootloader。点击此处下载 1.3.0 版本的 Bootloader。

因为我准备在 Windows 上刷板子，所以还需要使用 scp 命令将 blinky.bin 复制到 OpenOCD 的 bin 目录下。

scp.exe tomato@192.168.56.108:/home/tomato/qmsi/examples/blink/release/quark_d2000/x86/bin/blinky.bin ./blinky.bin

我们现在就可以通过 OpenOCD 来烧录了。

.\openocd.exe -f ..\scripts\board\quark_d2000_onboard.cfg -c "flash_rom quark_d2000_rom.bin 0"
.\openocd.exe -f ..\scripts\board\quark_d2000_onboard.cfg -c "flash_rom blinky.bin 0x00180000"

如果是 Linux 系统，可以参考此处第24页，命令类似：

./openocd -f ../scripts/board/quark_d2000_onboard.cfg -c "init" -c "flash_rom quark_d2000_rom.bin" -c "shutdown"

在看到 All done的时候按下复位键，蓝色的 USR LED 会每隔 0.25s 闪烁一下，表示烧录成功。

或者是配合 gdb 调试。先在 OpenOCD 的 bin 目录下执行：

.\openocd.exe -f ..\scripts\board\quark_d2000_onboard.cfg

就会显示如下信息：

Open On-Chip Debugger 0.8.0-dev-ga422c7e (2016-05-23-16:57)
Licensed under GNU GPL v2
For bug reports, read
        http://openocd.sourceforge.net/doc/doxygen/bugs.html
Info : only one transport option; autoselect 'jtag'
adapter speed: 1000 kHz
trst_only separate trst_push_pull
adapter speed: 1000 kHz
trst_only separate trst_push_pull
Info : clock speed 1000 kHz
Info : JTAG tap: quark_d2000.cltap tap/device found: 0x0e786013 (mfg: 0x009, part: 0xe786, ver: 0x0)
Enabling lmt core tap
Info : JTAG tap: quark_d2000.lmt enabled

接着打开另一个终端，执行：

gbd

如果在 Windows 上运行前提是你得安装好 MSYS2。

然后在 gdb 中输入：

(gdb) target remote :3333

接着输入以下命令来烧录程序：

(gdb) monitor reset halt
(gdb) monitor load_image blinky.bin 0x00180000
(gdb) monitor reset

配置 Zephyr RTOS

(2025-06-02 更新)

Zephyr RTOS 是一个开源的实时操作系统，支持多种硬件平台，包括 Intel Quark D2000。我们可以使用 Zephyr 来开发更复杂的应用。

但是我们不能用最新的 Zephyr 版本，因为 Quark D2000 的支持在 Zephyr 2.0 之后被移除。我们需要使用 Zephyr 1.14.0 版本和 SDK 0.10.0 版本。

环境准备

回到 Ubuntu Server 18.04.6 LTS 环境，安装 Zephyr 所需的依赖：

sudo apt-get update
sudo apt-get install --no-install-recommends git cmake ninja-build gperf \
  ccache dfu-util device-tree-compiler wget \
  python3-pip python3-setuptools python3-wheel xz-utils file make gcc \
  gcc-multilib

Zephyr 需要CMake 版本 3.13.1 或更高版本。但是 Ubuntu 18.04 默认的 CMake 版本是 3.10.2，我们需要手动安装最新版本的 CMake：

sudo apt purge cmake
python3 -m pip install --upgrade pip
python3 -m pip install scikit-build==0.14.0
python3 -m pip install cmake

安装完之后可能会遇到 WARNING: The scripts cmake, cpack and ctest are installed in '/home/tomato/.local/bin' which is not on PATH. 的警告。我们需要将其添加到 PATH 中：

export PATH="$HOME/.local/bin:$PATH"
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

最后我们需要安装安装 Zephyr 软件开发工具包（SDK）：

wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.10.0/zephyr-sdk-0.10.0-setup.run
cd <sdk download directory>
sh zephyr-sdk-0.10.0-setup.run

导出 Zephyr SDK 的环境变量，默认位置在 /opt/zephyr-sdk/：

export ZEPHYR_TOOLCHAIN_VARIANT=zephyr
export ZEPHYR_SDK_INSTALL_DIR=<sdk installation directory>

下载 Zephyr 源码

使用 Bootstrap West 工具来下载 Zephyr 源码：

python3 -m pip install west

我们需要指定 Zephyr 的版本为 1.14.0：

west init zephyrproject --mr v1.14.0
cd zephyrproject
west update

安装 Python 依赖项

Zephyr 需要一些 Python 依赖项，我们可以使用 pip 来安装：

python3 -m pip install -r zephyr/scripts/requirements.txt

如果你在安装过程中遇到依赖项问题，可以把 zephyr/scripts/requirements.txt 中 hub==2.0 改成 hub==2.0.9。

构建应用程序

导航到主项目目录：

cd zephyrproject/zephyr

设置环境：

source zephyr-env.sh

构建 blinky 示例应用程序：

cd samples/basic/blinky
west build -b quark_d2000_crb .

构建完成后会在 build/zephyr/zephyr.bin 生成二进制文件。烧录方式和上面类似。烧录成功后按下复位键，蓝色的 USR LED 会每隔 1s 闪烁一下，表示烧录成功。

可以参照Zephyr 1.14.0 官方文档来了解更多关于 Zephyr 的信息。

完成

至此，我们在失去官方工具链的情况下成功复活了这个板子。

补记（2026-01-22 更新）

回顾一个我经常浏览的网站司徒的教學網站 - MCU - Intel Quark D2000，发现了司徒大佬早在2024年就发布了一个 Intel Quark D2000 的开发包，里面包含了编译所需工具。可以直接下载使用，省去了我们手动编译工具链的麻烦。

引用

【Linux 从入门到重修C语言】系统调用的一种奇技淫巧

2025-05-20T00:00:00+00:00

今天手欠手滑在赋权的时候把 chmod 的权限改成了 000，就在想怎么解决。

突然灵光乍现，没有 chmod 程序不是还有 chmod() 系统调用么，直接写个 C 代码改一下就完事了：

#include <sys/stat.h>

int main(void)
{
    chmod("/usr/bin/chmod", 0755);
    return 0;
}

编译后直接执行就可以了。

gcc ./mian.c && ./a.out

参考此处。

NAME
       chmod, fchmod, fchmodat - change permissions of a file
LIBRARY
       Standard C library (libc, -lc)
SYNOPSIS
       #include <sys/stat.h>

       int chmod(const char *pathname, mode_t mode);
       int fchmod(int fd, mode_t mode);

       #include <fcntl.h>           /* Definition of AT_* constants */
       #include <sys/stat.h>

       int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);

那有大聪明问了，如果 gcc 也 000 了怎么办？

那直接用 cc1 + as + ld 组合就可以了。系统中仍然保留有 cc1（GCC 的前端编译器）、as（汇编器）和 ld（链接器），仍可以手动完成编译流程。

gcc 在编译过程中（比如 gcc shit.c -o shit）实际上隐式做了如下几步：

预处理（cpp）：shit.c -> shit.i
编译（cc1）：shit.i -> shit.s
汇编（as）：shit.s -> shit.o
链接（ld）：shit.o -> shit

当然，嫌麻烦 clang 也可以。

看样子想学好 Linux，得先学明白C。

【玩转树莓派】制作一个口袋服务器 2

2025-05-19T00:00:00+00:00

书接上回，笔者用树莓派 Zero 2 W 制作了一个口袋服务器。用起来总觉得不得劲。

口袋做到了，服务器还是差很远。

树莓派的系统用来玩玩还行，真正可靠性还是差点意思，有些功能还是跟服务器系统差一些。

所以我想到了 Ubuntu Server。

选择Preinstalled server image。看在口袋服务器的份上，还是选择 Hard-Float 版本的。

按照常规方式烧录到TF卡上，插入树莓派，接上电源，连接串口工具，打开 PuTTY，设置波特率为 115200，数据位 8，停止位 1，无奇偶校验。然后插入TF卡，接上电源，就可以看到树莓派的启动信息了。

登录信息和树莓派OS不太一样，参考此处。

The login username is “ubuntu”, password is “ubuntu”. You will be asked to change the password on first login.

连接 Wi-Fi

依旧是轻车熟路，先连个Wi-Fi。

Ubuntu Server 20.04 之后的版本连接 Wi-Fi 的方式略显诡异。

打开：

sudo nano /etc/netplan/50-cloud-init.yaml

在文件中添加以下内容：

network:
    ethernets:
        eth0:
            dhcp4: true
            optional: true
        usb0:
            dhcp4: no
            addresses:
                - 192.168.100.2/24
    version: 2
    wifis:
        wlan0:
            optional: true
            dhcp4: true
            access-points:
                "你家Wi-Fi名称":
                    hidden: true
                    password: "你家Wi-Fi密码"

保存后，执行以下命令：

sudo netplan apply

换源

连上Wi-Fi 之后，换源。参考此处。

sudo sed -i -e 's@//ports.ubuntu.com/\? @//ports.ubuntu.com/ubuntu-ports @g' \
            -e 's@//ports.ubuntu.com@//mirrors.ustc.edu.cn@g' \
            /etc/apt/sources.list

更新软件包列表并安装 `ifupdown` 和 `dnsmasq`

sudo apt update
sudo apt install -y ifupdown dnsmasq

配置 USB 网络

首先得让 dnsmasq 监听 USB 网络接口，把原来的服务关掉。

sudo systemctl stop systemd-resolved
sudo systemctl disable systemd-resolved

然后设置接口：

sudo nano /etc/network/interfaces

然后添加以下内容：

auto lo
iface lo inet loopback

auto usb0
allow-hotplug usb0
iface usb0 inet static
        address 192.168.100.2
        netmask 255.255.255.0

allow-hotplug wlan0
iface wlan0 inet dhcp

接下来配置 /etc/dnsmasq.conf 文件，添加以下内容：

interface=usb0
dhcp-range=192.168.100.10,192.168.100.100,24h
dhcp-option=3,192.168.100.2
dhcp-option=6,223.5.5.5

新建 systemd 服务文件等待 usb0 后再启动 dnsmasq

sudo nano /etc/systemd/system/dnsmasq-usb0.service

添加以下内容：

[Unit]
Description=Delayed start of dnsmasq after usb0 is up
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
ExecStartPre=/bin/bash -c 'while ! ip link show usb0 | grep -q "state UP"; do sleep 1; done'
ExecStart=/usr/sbin/dnsmasq -k --conf-file=/etc/dnsmasq.conf
Restart=always

[Install]
WantedBy=multi-user.target

保存后，执行以下命令：

sudo systemctl daemon-reload
sudo systemctl disable dnsmasq
sudo systemctl enable --now dnsmasq-usb0.service

设置 Swap

老样子，内存不够，硬盘来凑。

sudo fallocate -l 512M /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile

设置开机自动挂载：

sudo nano /etc/fstab

添加以下内容：

/swapfile none swap sw 0 0

可以直接用命令开启 swap：

sudo swapon /swapfile

当然，也可以重启树莓派。

结语

基本上每次等能连接差不多要1~2分钟，正好在猩八课插上电脑再去拿个咖啡回来就能干活了。

番外

可以通过删除一些不需要的 Ubuntu 服务器实例来清理软件包和禁用服务。这样可以节省一些磁盘空间并释放内存。

sudo apt purge --auto-remove snapd squashfs-tools friendly-recovery apport at

删除无人值守升级

sudo apt purge --auto-remove unattended-upgrades
sudo systemctl disable apt-daily-upgrade.timer
sudo systemctl mask apt-daily-upgrade.service
sudo systemctl disable apt-daily.timer
sudo systemctl mask apt-daily.service

这将删除 unattended-upgrades 软件包和负责自动更新的关联服务软件包。

但是有些环境不能这样，可以配置 unattended-upgrades 以仅安装安全性更新。

通过注释 unattended-upgrades 的 apt 配置中的其他源来仅启用安全更新：

sudo nano /etc/apt/apt.conf.d/50unattended-upgrades

移除 Plymouth，我开机也不看那些花花绿绿的屏幕，直接铲了：

sudo apt purge --auto-remove plymouth

这个过程会非常长，可能需要 10 分钟或更长时间才能完成。（因为涉及到 update-initramfs）

删除完之后还需要修改 /boot/firmware/cmdline.txt 文件，删除以下内容：

quiet splash

然后重启树莓派。

IP 转发

晚上敲代码的时候突发奇想，这个能不能让来自 usb0 的流量转发到 wlan0 上呢？

可以的，兄弟，可以的。

首先通过编辑 /etc/sysctl.conf 文件来启用 IP 转发：

sudo nano /etc/sysctl.conf

在文件中找到以下行（找不到没关系，直接追加）：

#net.ipv4.ip_forward=1

取消注释并将其更改为：

net.ipv4.ip_forward=1

保存后，执行以下命令：

sudo sysctl -p

或者立即生效：

sudo sysctl -w net.ipv4.ip_forward=1

接下来，使用 iptables 来设置 NAT 转发：

# 让 usb0 的流量通过 wlan0 出口转发
sudo iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE

# 允许 usb0 转发出去
sudo iptables -A FORWARD -i usb0 -o wlan0 -j ACCEPT
sudo iptables -A FORWARD -i wlan0 -o usb0 -m state --state ESTABLISHED,RELATED -j ACCEPT

最后，保存 iptables 规则，防止重启后规则丢失：

sudo apt install iptables-persistent
sudo netfilter-persistent save

整体流程如下：

[电脑] --usb0--> [树莓派:192.168.100.2] --wlan0--> [Wi-Fi 路由器] --Internet
            ↕
         dnsmasq 发 IP（192.168.100.x）
         iptables 转发

（邪魅一笑）这样不就能在树莓派上面部署，咳咳，嗯。

【玩转树莓派】制作一个口袋服务器

2025-05-17T00:00:00+00:00

手头上有个闲置的树莓派 Zero 2 W，想着能不能把它做成一个口袋服务器，随时随地都能用。于是就有了这篇文章。

树莓派 Zero 2 W 是一款小巧的单板计算机，搭载了四核 ARM Cortex-A53 处理器，内存为 512MB。它的体积小巧，功耗低，非常适合用作轻量级的服务器。

同时支持 Wi-Fi 和蓝牙，可以方便地连接到网络。树莓派 Zero 2 W 的价格也非常亲民，适合 DIY 爱好者和学生使用。

树莓派的操作系统是基于 Debian 的 Raspberry Pi OS，支持多种编程语言和开发工具，非常适合用来学习和实验。

那么树莓派的优点讲完了，缺点也很明显：PWR接口和USB接口是 Micro USB，所以需要一个转换头。HDMI接口是 Mini HDMI，又要一个转换头。

看了一下官方文档，发现他们预留了测试点位，里面有一个 5V、GND、USB_DP、USB_DM 的测试点位，直接焊接上去就可以了。这样就可以用 USB 供电了。

如果嫌自己焊的太捞了，可以直接去搜树莓派USB转接器，这种产品多的很。

买到手装好之后就该开始配置了。

烧录镜像

最新的树莓派64位 Lite 镜像（笔者截稿时是2025年5月13日发行的），使用会有些问题，所以我翻了一下仓库，建议下载这个镜像raspios_lite_arm64-2022-01-28。

解压后直接烧录到TF卡上，然后需要修改 /boot/config.txt 文件，添加以下内容：

enable_uart=1

因为我们手边没有HDMI线，没办法接屏幕，所以需要通过配置串口来访问树莓派，这种叫法叫做 headless 模式。（很奇怪，中文翻译成无头模式，实际上就是不需要任何外设来启动树莓派~~开什么玩笑不是还是需要串口工具么~~）

接下来我们需要从烤箱里面拿出来一个串口工具，连接到树莓派的 UART 接口上。树莓派 Zero 2 W 的 UART 接口在下面的图中可以看到（Pin1的焊盘是方形的）：

UART 连接

连接好之后，打开 PuTTY，设置波特率为 115200，数据位 8，停止位 1，无奇偶校验。然后插入TF卡，接上电源，就可以看到树莓派的启动信息了。

以下信息可以参阅Turning your Raspberry Pi Zero into a USB Gadget - Adafruit

用户名 pi，密码 raspberry。登录后可以看到树莓派的命令行界面。

接着编辑config.txt & cmdline.txt

sudo nano /boot/config.txt

在文件末尾添加以下内容：

dtoverlay=dwc2

然后编辑 cmdline.txt 文件：

sudo nano /boot/cmdline.txt

在 rootwait 后添加一个空格，然后键入 modules-load=dwc2,g_ether。

保存并退出。

然后就是熟门熟路地进入 raspi-config，设置一下 SSH 和 Wi-Fi 的配置。

树莓派 Zero 2 W 的 Wi-Fi 是 2.4GHz 的，不能连接 5GHz 的 Wi-Fi。

配置USB网络

如果使用的是 Mac 或 Linux，则很可能已经安装了 Bonjour。在 Windows 上，需要安装 iTunes 以添加 Bonjour 支持，以便它知道如何处理 .local 名称。

关闭树莓派，把USB口插到电脑上，等待树莓派启动，电脑会有设备插入的提示音。

但是可怜的 Windows 会自动识别成串口设备，这时候我们去下载USB Ethernet/RNDIS Gadget的驱动，手动安装上，就能正常识别了。

接下来需要配置固定IP，方便我们使用。

在树莓派上执行以下命令：

sudo nano /etc/network/interfaces

在文件中添加以下内容：

allow-hotplug usb0
iface usb0 inet static
        address 192.168.100.2
        netmask 255.255.255.0
        network 192.168.100.0
        broadcast 192.168.100.255
        gateway 192.168.100.1

保存并退出。这将为 Raspberry Pi 提供 IP 地址 192.168.100.2。

然后重启网络接口

sudo ifdown usb0
sudo ifup usb0
ifconfig usb0

接着回到自己的电脑，因为我是牛马的ThinkPad用户，我安装了Windows，所以我需要打开网络和共享中心，然后单击更改适配器设置。找到 RNDIS 适配器并将其重命名为 pizero。

接着右键单击它，选择属性，然后选择 Internet 协议版本 4 (TCP/IPv4)，然后单击属性。选择使用下面的 IP 地址，并输入 192.168.100.1 作为计算机的 IP 地址和网关，子网掩码为 255.255.255.0 与树莓派的相同。（网关后来被擦除了，Adafruit的作者认为Windows是自动使用IP地址，但是我认为是电脑与树莓派之间是二层设备，二层之间不需要网关）

共享电脑网络

打开网络和共享中心，然后单击我已经连接的网络（比如我现在连接的是Wi-Fi）去更改适配器设置。右键单击 Wi-Fi 适配器，选择属性，然后选择共享选项卡。选中允许其他网络用户通过此计算机的 Internet 连接来连接的复选框，并从下拉列表中选择 pizero 适配器。然后单击确定。

使用 sudo reboot 重新启动树莓派，然后使用 ssh pi@raspberrypi.local 通过 SSH 将其重新连接到它。可以尝试 ping 百度。

IP寻址

在我们烧录的这个版本的 Raspbian 上，所有网卡的 IP 寻址都是通过名为 dhcpcd 的程序在树莓派上完成的。但是我们现在不需要 dhcpcd，所以我们需要禁用它。

sudo systemctl disable dhcpcd

注意：禁用前请使用串口工具登录树莓派。

然后设置接口：

sudo nano /etc/network/interfaces

然后添加以下内容：

auto lo
iface lo inet loopback

auto usb0
allow-hotplug usb0
iface usb0 inet static
        address 192.168.100.2
        netmask 255.255.255.0
        #network 192.168.100.0
        #broadcast 192.168.100.255
        #gateway 192.168.100.1

allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

接下来修改 /etc/wpa_supplicant/wpa_supplicant.conf 文件，添加以下内容：

network={
    scan_ssid=1
    ssid="我家的Wi-Fi"
    psk="我家的Wi-Fi密码"
    key_mgmt=WPA-PSK
}

scan_ssid=1 是因为我家的 Wi-Fi 是隐藏的，所以需要添加这个选项。

接着，我们需要安装 dnsmasq，它允许我们使用 DHCP 为连接到 Pi 上的 USB 端口的 PC 或 Mac 分配 IP 地址。如果树莓派默认的源下载速度太慢，可以参考USTC。

sudo sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list
sudo sed -i -e 's|security.debian.org/\? |security.debian.org/debian-security |g' \
            -e 's|security.debian.org|mirrors.ustc.edu.cn|g' \
            -e 's|deb.debian.org/debian-security|mirrors.ustc.edu.cn/debian-security|g' \
            /etc/apt/sources.list
sudo sed -i 's|raspbian.raspberrypi.org|mirrors.ustc.edu.cn/raspbian|g' /etc/apt/sources.list
sudo apt update

安装 dnsmasq：

sudo apt-get install -y dnsmasq

然后编辑 /etc/dnsmasq.conf 文件，添加以下内容：

dhcp-range=192.168.100.1,192.168.100.254,24h
dhcp-option=3
dhcp-option=6

DHCP 范围需要与我们分配给 usb0 接口的接口 IP 地址匹配，此选项将分配 192.168.100.2 和 .254 之间的地址，租期为 24 小时。这应该绰绰有余。如果由于某种原因需要更改 IP 范围，请确保将 usb0 的配置与这些项目匹配。我们还使用了 DHCP 选项 3 和 6 - 它们在配置文件中进行了注释，但它们阻止 dnsmaq 通告默认路由或 DNS - 在本教程中，我们不需要树莓派作为 DNS 服务器或路由器。

最后重启树莓派。就可以使用 SSH 连接我们的树莓派了：

ssh -l pi 192.168.100.2

添加 swap 分区

树莓派的内存只有 512MB，运行一些程序会很吃力，所以我们需要添加一个 swap 分区。

sudo nano /etc/fstab

看到文件末尾有以下内容：

# a swapfile is not a swap partition, no line here
#   use  dphys-swapfile swap[on|off]  for that

我就知道了，树莓派的 swap 分区是使用 dphys-swapfile 来管理的。我们可以直接使用它来创建一个 swap 分区。

sudo nano /etc/dphys-swapfile

修改以下内容：

CONF_SWAPSIZE=512

重启 dphys-swapfile 服务：

sudo systemctl restart dphys-swapfile

查看 swap 分区：

free -h

可以看到 swap 分区已经添加成功了。

降低功耗

有些电脑 USB 可能带不动，所以我们需要降低以下功耗。

sudo nano /boot/config.txt

在文件末尾添加以下内容：

dtparam=act_led_trigger=actpwr
gpu_mem=16
arm_freq=700

其中 dtparam=act_led_trigger=actpwr 是让树莓派的电源指示灯变成硬盘活动指示灯。

然后修改 /boot/cmdline.txt 文件，在 console=tty1 后面加上 maxcpus=2。

重启，这将限制树莓派的 CPU 核心数为 2 个。

定时清除 buff/cache

参见【服务器维护】时隔425天的一次维护记录 - 冰冰番茄的归档。

也可以将清理脚本 clear_cache 放在 /usr/local/bin 目录下，确保权限 +x，然后添加到 /etc/cron.d 中：

sudo nano /etc/cron.d/clear_cache

在 /etc/cron.d/clear_cache 中添加以下内容：

*/10 * * * * root /usr/local/bin/clear_cache

连接家里的 NAS

可以参考此处。

先安装必要组件：

sudo apt install cifs-utils

然后直接挂载：

mount -t cifs -o vers=1.0,username=user_name //server_name/share_name /mnt/

如果需要密码，可以使用 -o password=your_password 选项。

卸载：

sudo umount /mnt/

【服务器维护】时隔425天的一次维护记录

2025-05-12T00:00:00+00:00

删除阿里云助手Agent
阻止脚本小子偷偷撞我SSH密码
定时清扫一下 buff/cache

删除阿里云助手Agent

今天正好在玩树莓派的时候，心血来潮登录自己~~部落格~~博客的服务器看看。

熟练地 htop 一下，结果……

惊不惊喜？意不意外？

/usr/local/share/assist-daemon/assist_daemon 很扎眼，我就知道是阿里云干的事情。

首先说结论：参阅卸载云助手Agent的文档，跟着删就行。

# 停止云助手守护进程
/usr/local/share/assist-daemon/assist_daemon --stop

# 卸载云助手守护进程
/usr/local/share/assist-daemon/assist_daemon --delete

# 删除云助手守护进程目录
rm -rf /usr/local/share/assist-daemon

# 卸载云助手Agent
sudo dpkg -r aliyun-assist # Debian/Ubuntu
sudo rpm -qa | grep aliyun_assist | xargs sudo rpm -e # CentOS/RHEL

# 删除云助手Agent目录
rm -rf /usr/local/share/aliyun-assist

阻止脚本小子偷偷撞我SSH密码

跟前年hvv一样，阿里不知道从哪里找来一些野鸡选手，当时我的博客用的是硬屎极简风，用Jekyll生成的类似Apache/Nginx默认页面，具体看这。发短信告诉我80端口开了，都看到里面的文件了，很危险，需要我注意。

我请问呢？

现在看来，他们很喜欢扫 ssh 端口。抓不到漏洞急了吧？随便写一下就能输出报告？我那个时候高位端口都是开着的咋不扫一下？看ssh日志时候才发现有个IP是镇江的江苏科技大学的一直在扫我服务器，光扫5000以下的，有点难绷了兄弟。

使用 cat /var/log/auth.log |grep Failed 这个命令（文件可能是auth.log或者是auth.log.数字，可以进目录看看）看了一下登录失败的记录。

ssh登录失败的记录

蔚为壮观……

可以看看这个Treemap，可以清晰看到IP地址和源地址以及攻击手段。

自己搓了个脚本，提取 /var/log/auth.log 登录失败的IP地址，添加到 /etc/hosts.deny 里面。

#!/bin/bash

# 脚本功能：从/var/log/auth.log和/var/log/auth.log.N提取SSH失败登录的IP地址并添加到/etc/hosts.deny

# 检查是否有root权限
if [ "$(id -u)" -ne 0 ]; then
    echo "Need root!"
    exit 1
fi

# 查找所有匹配的日志文件
log_files=(/var/log/auth.log /var/log/auth.log.*)

# 检查是否找到至少一个有效的日志文件
valid_files=0
for log_file in "${log_files[@]}"; do
    if [ -f "$log_file" ]; then
        valid_files=$((valid_files+1))
    fi
done

if [ $valid_files -eq 0 ]; then
    echo "Cannot find any auth.log files"
    exit 1
fi

# 计数器
added=0
skipped=0

# 处理每个找到的日志文件
for log_file in "${log_files[@]}"; do
    # 跳过不存在的文件
    if [ ! -f "$log_file" ]; then
        continue
    fi

    echo "Processing $log_file..."
    
    # 查找包含"port"但不包含正常连接行为的记录，提取IP地址
    grep "port" "$log_file" | grep -v -E "(Accepted password|Received disconnect|Disconnected from user)" | while read -r line; do
        # 使用正则表达式提取from/by与port之间的IP地址
        if [[ $line =~ (from|by)[[:space:]]+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)[[:space:]]+port ]]; then
            ip="${BASH_REMATCH[2]}"
            
            # 检查是否已经在hosts.deny文件中
            if grep -q "sshd: $ip" /etc/hosts.deny; then
                echo "Pass $ip (exist)"
                ((skipped++))
            else
                # 将IP地址追加到hosts.deny
                echo "sshd: $ip" >> /etc/hosts.deny
                echo "Block $ip"
                ((added++))
            fi
        fi
    done
done

echo "Done! Add: $added, Exist: $skipped"

再加上定时任务，每分钟执行一次。

* * * * * /root/anti_attack.sh

尝试运行，不错，确实在自动运行

自己尝试拿手机热点登录一下，获取一个IP地址，看看能不能被封。

可以清晰看到第一次登录成功，加了deny之后封IP成功，ssh登录失败了

定时清扫一下 buff/cache

有时候服务器运行久了，内存会被占满，导致服务器变得很卡。可以使用 free -h 命令查看一下内存的使用情况。

可以看到 buff/cache 占用的内存很大。一般可以用以下命令清理一下：

# Writing to this will cause the kernel to drop clean caches, as well as
# reclaimable slab objects like dentries and inodes.  Once dropped, their
# memory becomes free.

# To free pagecache:
	echo 1 > /proc/sys/vm/drop_caches
# To free reclaimable slab objects (includes dentries and inodes):
	echo 2 > /proc/sys/vm/drop_caches
# To free slab objects and pagecache:
	echo 3 > /proc/sys/vm/drop_caches

来源：Documentation for /proc/sys/vm/*

但是有时候运行的时候会报错 Permission denied，可以用如下命令：

sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
# Or
echo 3 | sudo tee /proc/sys/vm/drop_caches

再使用 free -h 命令查看一下内存的使用情况，buff/cache已经清理掉了。

其实可以在 /etc/cron.daily 目录下，创建一个脚本 /etc/cron.daily/clear_cache.sh，内容如下：

#!/bin/sh
sync
echo 3 > /proc/sys/vm/drop_caches

然后给这个脚本加上可执行权限： chmod +x /etc/cron.daily/clear_cache.sh。

这样就可以每天定时清理缓存了。不过这个脚本会清理掉所有的缓存，包括文件系统缓存和页面缓存，所以在使用时要谨慎。

转移到 Cloudflare

2020年7月27日 19:20:00

我在阿里云上创建了这台1C512M的小水管。

阿里云ECS 创建时间

于2025年5月16日 12:00:00，转移到 Cloudflare。

别了，阿里云尼亚。

【Git】Git 取消文件跟踪

2025-05-02T00:00:00+00:00

前两天在写小程序的时候，没注意把 .vscode 文件夹给上传上去了。就在想怎么把它删掉。

明确目标

首先，我们要知道，.vscode 是存放 VS Code 的配置文件的。里面有我们的配置文件，像是 settings.json、launch.json、tasks.json 等等。这些删除之后，VS Code 每次都会自动生成新的配置文件。

所以我们要保证的是，.vscode 文件夹在本地是存在的，但是在远程仓库中是不存在的。

当我尝试使用 .gitignore 的时候，发现 .gitignore 文件并没有生效。因为 .gitignore 只会忽略那些没有被 Git 跟踪的文件。也就是说，如果你已经将 .vscode 文件夹添加到 Git 中，那么即使你在 .gitignore 中添加了它，它也不会被忽略。

在实际操作之前，我们先来理解下 Git 工作区、暂存区和版本库概念：

工作区：就是你在电脑里能看到的目录。
暂存区：英文叫 stage 或 index。一般存放在 .git 目录下的 index 文件（.git/index）中，所以我们把暂存区有时也叫作索引（index）。
版本库：工作区有一个隐藏目录 .git，这个不算工作区，而是 Git 的版本库。

工作区、暂存区和版本库之间的关系

工作区 -> 暂存区

使用 git add 命令将工作区中的修改添加到暂存区。

git add <filename>

暂存区 -> 版本库

使用 git commit 命令将暂存区中的修改提交到版本库。

git commit -m "Commit message"

版本库 -> 远程仓库

使用 git push 命令将本地版本库的提交推送到远程仓库。

git push origin <branch-name>

远程仓库 -> 本地版本库

使用 git pull 或 git fetch 命令从远程仓库获取更新。

git pull origin <branch-name>
# 或者
git fetch origin <branch-name>
git merge origin/<branch-name>

`git rm` 操作步骤

git rm 命令用于删除文件。

如果只是简单地从工作目录中手工删除文件，运行 git status 时就会在 Changes not staged for commit 的提示。

git rm 删除文件有以下几种形式：

将文件从暂存区和工作区中删除：

git rm <file>

强行从暂存区和工作区中删除修改后的文件：

git rm -f <file>

如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f。

从暂存区中删除，但是保留工作区文件：

如果想把文件从暂存区域移除，但仍然希望保留在当前工作目录中，换句话说，仅是从跟踪清单中删除，使用 –cached 选项即可：

git rm --cached <file>
# 删除目录需要带递归选项 -r
git rm -r --cached <dir>

【Calc】CASIO Graph Light Lycée 法版中文翻译

2025-04-17T00:00:00+00:00

主菜单

Calcul 计算
Stats 统计
Probabilité 概率
Tableur 表格
Graphe 图形
Tabl fonct 函数表
Équation 方程
Complexe 复数
Vecteurs 向量
Prod. crolx 叉积
Math Box 数学盒

Config 配置

Paramètre calcul 计算参数
- Saisie/Résultat 输入/结果
  - Smaths/Rmaths 自然显示/包含分数显示
  - Smaths/Rdéc 自然显示/转换成科学计数法或小数显示
  - Sligne/Rligne 线性显示/科学计数法或分数显示
  - Sligne/Rdéc 线性显示/转换成科学计数法显示
- Unité d’angle 角度单位
  - Degré 度
  - Radian 弧度
  - Grade 渐度
- Arrondi 取整
  - Fix 保留位数
  - Sci 科学计数法有效数字
  - Norm 1: 科学计数法; 2: 小数
- Forme complexe 复数形式
  - a+bi a+bi
  - r∠θ r∠θ
- Sépart chiffers 数字分隔符
  - Séparat Lecture? 读数分隔符
    - Activé 启用
    - Désactivé 禁用
- Puissance de 10 10的幂
  - ×10□ ×10□
  - ×10 ×10
Paramètre systèm 系统参数
- Contraste 对比度
  - Clair 明亮
  - Sombre 暗色
- Extinct auto 自动灭屏
  - 10 min 10分钟
  - 60 min 60分钟
- Pol multiligne 多行显示
  - Police normale 正常字体
  - Petite police 小字体
- QR Code 二维码
  - Version 3 版本3
  - Version 11 版本11
Réinitialiser 重置
- Config & données 配置和数据
  - Réinitialis OK? Config & données 重置确定?
    - Oui 是
    - Annuler 取消
- Mém variables 内存变量
  - Réinitialis OK? Mém variables 重置确定?
    - Oui 是
    - Annuler 取消
- Tout 全部
  - Réinitialis OK? Tout 重置确定?
    - Oui 是
    - Annuler 取消
Mode d’emploi 使用说明

Calcul 计算

Outils 工具

Annuler 取消
Simplifier 简化
- Automatique 自动
- Manuel 手动
Vérification 检查

Catalog 目录

Analyse fonction 解析函数
- Nb dérivé(d/dx) 导数
- Intégrale 积分
- Somme 求和
- Reste 余数
- Simplification 简化
- Logarithme base a 对数
- Logarithme(log) 对数
- Logarithme(ln) 自然对数
Probabilité 概率
- %
- Factorielle 阶乘
- Permutation 排列
- Combinaison 组合
- Nombre aléatoire 随机数
- Entier aléatoire 随机整数
Calcul numérique 数值计算
- PGCD 最大公约数
- PPCM 最小公倍数
- Valeur absolue 绝对值
- Tronc. à l’unité 截断到整数
- Arrondi 到整数
- Partie entière 整数部分
- Arrondi(,) 四舍五入
Angl/Coord/Sexag 角度/坐标/六十进制
- Degrés 度
- Radians 弧度
- Gradians 渐度
- Cartésien. à pol. 笛卡尔坐标系
- Pol. à cartésien. 极坐标系
- Degrés min sec 度分秒
Trigonmétrique 三角函数
- sin 正弦
- cos 余弦
- tan 正切
- sin⁻¹ 反正弦
- cos⁻¹ 反余弦
- tan⁻¹ 反正切
Conversion unité 单位转换
- Vitesse 速度
  - km/h→m/s km/h→m/s
  - m/s→km/h m/s→km/h
- Température 温度
  - Celsius→Fahrenheit 摄氏→华氏
  - Fahrenheit→Celsius 华氏→摄氏
Autre 其他
- Rép 重复
- Pré-Rép 预设重复
- pi 圆周率
- e 自然对数底
- e^ 自然对数底的幂
- √ 平方根
- 𝒙√ 𝒙次方根
- ^-1 反函数
- ^2 平方
- ^() 幂
- - 负号
- , 小数点
- () 括号

Stats 统计

1 variable 一个变量
2 variables 两个变量

Probabilités 概率

Binomiale P(X=) 二项分布 P(X=)
- Liste de valeurs 值列表
- Valeur unique 单值
Poisson P(X≥) 泊松分布 P(X≥)
- Liste de valeurs 值列表
- Valeur unique 单值
Binomiale P(X≤) 二项分布 P(X≤)
Densité Normale 正态分布密度
Normale P(≤X≤) 正态分布 P(≤X≤)
Inverse normale 正态分布反函数
Poisson P(X=) 泊松分布 P(X=)
- Liste de valeurs 值列表
- Valeur unique 单值
Poisson P(X≤) 泊松分布 P(X≤)
- Liste de valeurs 值列表
- Valeur unique 单值

Tableur 表格

Outils 工具

Remplir formule 填充公式
- Formul= 公式
- Plage 范围
- Confirmer 确认
Remplir valeur 填充值
- Valeur 值
- Plage 范围
- Confirmer 确认
Modifier cell 修改单元格
Espace libre 空间
- 2380 octets libre 2380字节可用
Couper & Coller 剪切和粘贴
Copier & Coller 复制和粘贴
Tout supprimer 删除所有内容
Recalculer 重新计算
Calcul auto 自动计算
- Activé 启用
- Désactivé 禁用
Afficher cell 显示单元格
- Formule 公式
- Valeur 值

Graphe 图形

f(x) 函数图像
- Modifier 修改
- Afficher/Masquer 显示/隐藏
  - Afficher 显示
  - Masquer 隐藏
- Type de ligne 线条类型
g(x) 函数图像
Tracer 绘制
- Fenêtre graphique 图形窗口
  - Pré-enregistrées 预设
    - Orthonormé 正交标准
    - Trigonométrique 三角函数
    - Standard(-10;10) 标准(-10;10)
  - 𝒙min 𝒙最小值
  - max 最大值
  - grad. 刻度
  - 𝒚min 𝒚最小值
  - max 最大值
  - grad. 刻度
- Résolution graph 图形分辨率
  - Racines 根
  - Maximum local 局部最大值
  - Minimum local 局部最小值
  - Intersection 交点
  - Ordonnée origine 原点纵坐标
  - 𝒚(image) 𝒚(因变量)
  - 𝒙(antécédent) 𝒙(自变量)
- Parcourir courbe 遍历曲线
- Zoom 缩放
  - Zoom automatique 自动缩放
  - Zoom avant 向前缩放
  - Zoom arrière 向后缩放
  - Facteur de zoom 缩放因子
    - 2× 2×
    - 3× 3×
    - 10× 10×
- Placer un point 放置一个点
- Tracer tangente 绘制切线
- Nb dérivé 导数个数
  - Activé 启用
  - Désactivé 禁用
- Affich. Fonction 函数显示
  - Activé 启用
  - Désactivé 禁用
- Arrière-plan 背景
  - Label 标签
    - Activé 启用
    - Désactivé 禁用
  - Grille 网格
    - Activé 启用
    - Désactivé 禁用
    - Ligne 线
  - Axes 轴
    - Activé 启用
    - Désactivé 禁用

Outils 工具

Fenêtre graphique 图形窗口
- Pré-enregistrées 预设
  - Orthonormé 正交标准
  - Trigonométrique 三角函数
  - Standard(-10;10) 标准(-10;10)
- 𝒙min 𝒙最小值
- max 最大值
- grad. 刻度
- point 点
- 𝒚min 𝒚最小值
- max 最大值
- grad. 刻度
Nb dérivé 导数个数
- Activé 启用
- Désactivé 禁用
Affich. Fonction 函数显示
- Activé 启用
- Désactivé 禁用
Arrière-plan 背景
- Label 标签
  - Activé 启用
  - Désactivé 禁用
- Grille 网格
  - Activé 启用
  - Désactivé 禁用
  - Ligne 线
- Axes 轴
  - Activé 启用
  - Désactivé 禁用

Tabl fonct 函数表

f(x)/g(x): Vide 函数表: 空

Outils 工具

Plage du tableau 表格范围
Défin f(x)/g(x) 定义f(x)/g(x)
- Défin f(x)
- Défin g(x)
Type de tableau 表格类型
- f(x)/g(x) 函数表
- f(x) 函数表
- g(x) 函数表
Éditer 编辑
- Insérer ligne 插入行
- Tout supprimer 删除所有内容
Recalculer 重新计算
Vérification 检查

Équation 方程

Syst équations 方程组
- 2 inconnues 2个未知数
- 3 inconnues 3个未知数
- 4 inconnues 4个未知数
Polynomiale 多项式
- a(x²)+bx+c a(x²)+bx+c
- a(x³)+bx²+cx+d a(x³)+bx²+cx+d
- a(x⁴)+bx³+cx²+dx+e a(x⁴)+bx³+cx²+dx+e
Outils 工具
- Racine complexe 复根
  - Activé 启用
  - Désactivé 禁用
- Vérification 检查
Solveur 求解
- Saisir l’équation 输入方程
Outils 工具
- Annuler 取消

Complexe 复数

Outils 工具

Annuler 取消
Vérification 检查

Vecteurs 向量

[OUTILS] pour définir un vecteur [工具] 定义向量

Outils 工具

VctA: Vide 向量A: 空

Prod. crolx 叉积

A/B=X/D 向量A/B=X/D
A/B=C/X 向量A/B=C/X

Math Box 数学盒

Lancer de dés 掷骰子
- Dés 骰子
  - 1 dé 1个骰子
  - 2 dés 2个骰子
  - 3 dés 3个骰子
- Essais 尝试
  - :5 5次
  - Confirmer 确认
- Même résult 相同结果
  - Non 同结果
  - #1 #1
  - #2 #2
  - #3 #3
- Exécuter 执行
Pile ou face 正反面
- Pièces 硬币
  - 1 pièce 1个硬币
  - 2 pièces 2个硬币
  - 3 pièces 3个硬币
- Essais 尝试
  - :5 5次
  - Confirmer 确认
- Même résult 相同结果
  - Non 同结果
  - #1 #1
  - #2 #2
- Exécuter 执行
Droite grad. 不等式区间
- A: 区间A
  - 𝒙＜𝒂
  - 𝒙≤𝒂
  - 𝒙=𝒂
  - 𝒙＞𝒂
  - 𝒙≥𝒂
  - 𝒂＜𝒙＜𝒃
  - 𝒂≤𝒙＜𝒃
  - 𝒂＜𝒙≤𝒃
  - 𝒂≤𝒙≤𝒃
- B: 区间B
- C: 区间C
- Exécuter 执行
Cercle 圆
- Type: CercleTrigo 三角函数圆
  - CercleTrigo 三角函数圆
  - Demi-cercle 半圆
  - Horloge 时钟
- θ1: θ1
- θ2: θ2
- Exécuter 执行

【老物新用】Mojo V3 FPGA 在 Ubuntu 上的开发环境搭建

2025-03-10T00:00:00+00:00

今天翻出一个12年前老物件（虽说是12年前，其实是两三年前买的），是一款 FPGA 开发板，还记得自己当时因为修这个开发板,使用烙铁风枪的水平突飞猛进。这款板子还是比较坑的，DC接口居然只能接5V，当时公司里面只有9-12V的适配器，插上去就一股电子元器件的清香。拿万用表打了一下，好家伙直接一带一路，烧掉一个稳压（AMS1117）、两个LED、一个SPI Flash、一个FPGA芯片（XC6SLX9）。很感谢当时在M5的同事，帮我找到了这么多坏的元器件，不然我还以为只是一个稳压坏了。

这老物件，生产它的公司 Embedded Micro已经无了（貌似是转生成Alchitry了，有机会把板子买过来试试），官网也无了，这些资料也只能在Internet Archive上找到，还是很感谢这个网站的存在，已经捐了10刀作为感谢，希望这个网站能继续运营下去。

对我来说，FPGA（现场可编程逻辑门阵列）一直是电气工程设计中排行老二的领域（老大是制造芯片，那个我还远远做不到），在高中的时候就开始接触，直到大学的时候第一次去Seeed Studio实习，跟同事们聊起FPGA时，我们一致认为FPGA是一个很有意思的领域，但是门槛太高，学习成本太高：

—— “我搞过FPGA”
—— “歪日，牛的，兄弟”
—— “这碉板子贵的一批”
—— “多少钱”
—— “便宜的都得好几百”
—— “……我还是琢磨公司的XIAO吧”

这玩意儿不是简单地修改代码就能运行起来的，不仅仅是“玩”，FPGA 使用自己的语言（通常是 Verilog 或 VHDL）进行编程，使用基于同步硬件的技术，并使用极其复杂的软件开发。

Mojo V3 FPGA 开发板概况

1 个 Xilinx Spartan6 FPGA
8 个可编程的 LED
84 个 I/O 引脚。
1 个 Atmel AVR 32U4 MCU。
1 个 flash memory chip 用于存储 FPGA 配置数据

XC6SLX9 FPGA 是开发板的核心，它的内部有：

9,152 个逻辑块
16 个 DSP 切片
576 KB RAM
102 个 I/O 引脚

我估摸着这应该是世界上第一个把FPGA和MCU结合在一起的开发板，之后的都是什么ARM+FPGA、ESP32+FPGA的设计，也都是参照这个设计的，让MCU可以把比特流文件从SPI Flash中烧录到FPGA里面，就不需要额外的 JTAG 线了。（赛灵思一个原厂JTAG实在是贵的不行，就相当于买一个FPGA一样，仿制的也贵的离谱）

我也想借着闲赋在家的时候，整理整理这个FPGA的基础使用方法。板子的环境搭建我就放在【老物新用】这个栏目里面，具体的知识我再另外开设一个栏目。

Xilinx ISE WebPACK 安装

AMD FPGA ISE Archive

这个软件是 Xilinx 早期的 FPGA 开发软件 ISE，现在已经不再维护了。也是神奇，之前接触FPGA还是赛灵思，转眼就被按摩店收购了。收购赛灵思之后感觉按摩店都起飞了，估计是用了不少赛灵思的IP核。

进入到这个网页，找到14.7（14.7的Win10版本就是VirtualBox虚拟机），ISE Design Suite - 14.7 Full Product Installation，Full Installer for Linux (TAR/GZIP - 6.09 GB) MD5 SUM Value : e8065b2ffb411bb74ae32efa475f9817，点击该选项，跳转到AMD登录界面，登录完成后即可下载。

下载完成后，解压到一个目录，然后进入到该目录，执行 ./xsetup，然后一路下一步，到选择产品的时候需要选择ISE WebPACK即可，等待安装完成。

注意需要添加License，这个License可以在Xilinx官网申请，也可以在网上找到，我这里就不提供了。

~~安装完之后，需要添加环境变量，打开 `/etc/environment` 文件，添加如下内容：~~ ~~```shell # Xilinx ISE WebPACK . /opt/Xilinx/14.7/ISE_DS/settings64.sh >/dev/null 2>&1 ```~~ 其中 `. /opt/Xilinx/14.7/ISE_DS/settings64.sh` 是官方给的，安装完之后会提示你运行这个命令，这个命令会设置一些环境变量，然后就可以在终端中使用 `ise` 命令打开软件了。我就是图方便加到 `.bashrc` 里面的。但是每次开终端都会有运行结果显示，所以我加了 `>/dev/null 2>&1`。

至于为什么不加到 `/etc/environment` 和 `.bashrc` 文件里面，是因为加了之后不知道为啥会影响到其他软件的运行，导致其他软件无法正常运行

建议是使用shell脚本启动环境：

# /opt/start_ise.sh
#!/bin/bash
# Xilinx ISE WebPACK
. /opt/Xilinx/14.7/ISE_DS/settings64.sh >/dev/null 2>&1
ise & >/dev/null 2>&1

然后给这个脚本添加执行权限：

sudo chmod +x /opt/start_ise.sh

Mojo Loader 和 Mojo IDE 安装

IcingTomato/MojoFPGA - GitHub

这个是我以前下载的 Mojo Loader 和 Mojo IDE 的程序，上传到了 GitHub 上留作备份。这两个程序一个是用来烧录 FPGA 的，另一个是用来编写代码的。

将 mojo-ide-B1.3.6-linux64.tgz 和 mojo-loader-1.3.0-linux64.tgz 下载到本地，解压到一个目录，然后进入到该目录，执行 ./mojo-ide 和 ./mojo-loader 即可。

要注意的是，Mojo IDE 需要JDK8，如果没有安装的话，可以使用 sudo apt install openjdk-8-jdk 安装。

我这边为了方便，把这两个程序解压到了 /opt/ 目录下，然后创建软链接：

sudo chmod +x /opt/mojo-ide-B1.3.6-linux64/mojo-ide
sudo chmod +x /opt/mojo-loader-1.3.0-linux64/mojo-loader
sudo ln -s /opt/mojo-ide-B1.3.6-linux64/mojo-ide /usr/bin/mojo-ide
sudo ln -s /opt/mojo-loader-1.3.0-linux64/mojo-loader /usr/bin/mojo-loader

这样就可以在终端中使用 mojo-ide 和 mojo-loader 命令了。

Mojo Loader 使用

打开终端，输入 mojo-loader，然后选择你的 FPGA 开发板，然后选择你的比特流文件，然后点击 Erase，等待擦除完成后即可点击 Load 将bin文件加载到Flash。

Mojo IDE 使用

建议是使用shell脚本启动环境：

# /opt/start_mojo_ide.sh
#!/bin/bash
# Xilinx ISE WebPACK
. /opt/Xilinx/14.7/ISE_DS/settings64.sh >/dev/null 2>&1
mojo_ide & >/dev/null 2>&1

然后给这个脚本添加执行权限：

sudo chmod +x /opt/start_mojo_ide.sh

补充记录

针对 ISE 和 Mojo IDE/Loader 在开始菜单的显示问题，我在后续使用的时候琢磨出来了，找到一个相对比较好的解决方案：

ISE 配置

先安装完 ISE WebPACK，打开终端，输入：

cd /usr/share/applications/

然后创建一个 ise.desktop 文件：

sudo vim ise.desktop

然后输入以下内容：

[Desktop Entry] 
Version=1.0 
Name=ISE 
Exec=bash -c "unset LANG && unset QT_PLUGIN_PATH && source /opt/Xilinx/14.7/ISE_DS/settings64.sh && ise" 
Icon=/opt/Xilinx/14.7/ISE_DS/ISE/data/images/pn-ise.png
Terminal=false 
Type=Application
Categories=Development;

保存退出。

Mojo IDE 配置

同样的，打开终端，输入：

cd /opt/MojoFPGA/mojo-ide-B1.3.6/
sudo vim mojo-ide.sh

然后输入以下内容：

#!/bin/bash
# Xilinx ISE WebPACK
. /opt/Xilinx/14.7/ISE_DS/settings64.sh >/dev/null 2>&1
exec /opt/MojoFPGA/mojo-ide-B1.3.6/mojo-ide & >/dev/null 2>&1

保存退出。

然后给这个脚本添加执行权限：

sudo chmod +x /opt/MojoFPGA/mojo-ide-B1.3.6/mojo-ide.sh

然后添加软链接：

sudo ln -s /opt/MojoFPGA/mojo-ide-B1.3.6/mojo-ide.sh /usr/sbin/mojo-ide

再回到 /usr/share/applications/ 目录，创建一个 mojo-ide.desktop 文件：

sudo vim mojo-ide.desktop

然后输入以下内容：

[Desktop Entry] 
Version=1.0 
Name=Mojo IDE 
Exec=/usr/sbin/mojo-ide
Icon=/opt/MojoFPGA/mojo-ide-B1.3.6/icon.png
Terminal=false
Type=Application
Categories=Development;

保存退出。

这样就可以在开始菜单中找到 ISE 和 Mojo IDE 了。

Mojo Loader 配置

先创建软链接：

sudo ln -s /opt/MojoFPGA/mojo-loader-1.3.0/mojo-loader /usr/sbin/mojo-loader

同样的，打开终端，输入：

cd /usr/share/applications/

然后创建一个 mojo-loader.desktop 文件：

[Desktop Entry] 
Version=1.0 
Name=Mojo Loader 
Exec=/usr/sbin/mojo-loader
Icon=/opt/MojoFPGA/mojo-loader-1.3.0/icon.png
Terminal=false
Type=Application
Categories=Development;

保存退出。

这样就可以在开始菜单中找到 Mojo Loader 了。

【家庭网络改造】QNAP NAS计划任务自动删除米家摄像头三个月前的视频文件

2024-11-27T00:00:00+00:00

去年8月29日在京东下单了一个QNAP威联通的TS-216，替换掉我家原来自己用树莓派3B+（Ubuntu Server + Samba）搭建的NAS。装了两个东芝P300 2TB的硬盘，开始组的RAID 1。后来发现家里面四五个摄像头每天的数据量大得很，没几天就把硬盘写满了。后面想想RAID 1不实在，家里没啥重要数据，今年回家的时候就格盘换成RAID 0了。但是米家摄像头数据还是很大，没几个月3.6TB就快写满了。

于是在米家APP中找到了视频存储时长设置选项，改成3个月：

改了之后NAS上面数据一点没动，应该是不会删除NAS上面的视频数据，所以就想着让NAS怎么自动删除米家摄像头三个月前的视频文件。

(以下所有操作需提前在NAS中开启SSH服务)

首先想到的是用crontab，但是QNAP的Linux系统是基于BusyBox的，crontab -e 这种命令有，但是不会运行成功，即便是加上 sudo ，也不能保存计划任务。

所以只能使用 vi 命令编辑计划任务文件，文件路径是 /etc/config/crontab ，在文件末尾加上：

0 * * * * cd /share/MiCam/xiaomi_camera_videos && bash auto_del.sh

这个命令的意思是每小时执行一次 auto_del.sh 脚本，脚本内容如下：

#!/bin/bash

# Set the base directory where random directories are located
base_directory="./"

# Calculate the date threshold for deletion (3 months ago)
date_threshold=$(date --date='-3 months' +'%Y%m%d00')

echo "Before $date_threshold will be deleted!"

# Find all random directories and process them
find "$base_directory" -maxdepth 1 -type d -name '[0-9a-f]*' | while read -r dir; do
  # Change directory to the random directory
  cd "$dir" || continue  # Skip if directory change fails
  echo "Entry $dir."

  # Find and delete directories older than the threshold
  find . -maxdepth 1 -type d -name '??????????' | while read -r subdir; do
    if [[ "$(basename "$subdir")" -lt "$date_threshold" ]]; then
      echo "Deleting directory: $subdir"
      rm -rf "$subdir"  # Remove the directory recursively
    fi
  done

  # Change back to the base directory
  cd ..
done

手动运行结果如下：

因为米家摄像头会在设置的文件夹下创建 xiaomi_camera_videos 文件夹，然后在这个文件夹下以设备序列号（？）创建的很像乱码的文件夹，每个乱码文件夹下面又以年月日时为名的文件夹，所以这个脚本的作用是删除 xiaomi_camera_videos/?????????? 文件夹下三个月前的视频文件夹。所以脚本必须放在 /目标文件夹/xiaomi_camera_videos下：

【网络基础】什么是NAT？

2024-11-22T00:00:00+00:00

NAT是一种地址转换技术，它可以将IP数据报文头中的IP地址转换为另一个IP地址，并通过转换端口号达到地址重用的目的。NAT作为一种缓解IPv4公网地址枯竭的过渡技术，由于实现简单，得到了广泛应用。

1　NAT解决了什么问题？　
2　NAT的类型　
3　NAT是如何工作的？　
4　如何使用NAT？

NAT解决了什么问题？

随着网络应用的增多，IPv4地址枯竭的问题越来越严重。尽管IPv6可以从根本上解决IPv4地址空间不足问题，但目前众多网络设备和网络应用大多是基于IPv4的，因此在IPv6广泛应用之前，使用一些过渡技术（如CIDR、私网地址等）是解决这个问题的主要方式，NAT就是这众多过渡技术中的一种。

当私网用户访问公网的报文到达网关设备后，如果网关设备上部署了NAT功能，设备会将收到的IP数据报文头中的IP地址转换为另一个IP地址，端口号转换为另一个端口号之后转发给公网。在这个过程中，设备可以用同一个公网地址来转换多个私网用户发过来的报文，并通过端口号来区分不同的私网用户，从而达到地址复用的目的。

早期的NAT是指Basic NAT，Basic NAT在技术上实现比较简单，只支持地址转换，不支持端口转换。因此，Basic NAT只能解决私网主机访问公网问题，无法解决IPv4地址短缺问题。后期的NAT主要是指网络地址端口转换NAPT（Network Address Port Translation），NAPT既支持地址转换也支持端口转换，允许多台私网主机共享一个公网IP地址访问公网，因此NAPT才可以真正改善IP地址短缺问题。

NAT的类型

根据NAT转换是对报文中的源地址进行转换还是对目的地址进行转换，NAT可以分为源NAT、目的NAT和双向NAT，下面我们分别介绍这三种NAT类型。

SNAT（源NAT）

源NAT在NAT转换时，仅对报文中的源地址进行转换，主要应用于私网用户访问公网的场景。当私网用户主机访问Internet时，私网用户主机发送的报文到达NAT设备后，设备通过源NAT技术将报文中的私网IPv4地址转换成公网IPv4地址，从而使私网用户可以正常访问Internet。

根据转换时是否同时转换源端口号，源NAT可以细分为如下几种类型，详见下图。

DNAT（目的NAT）

目的NAT在NAT转换时，仅对报文中的目的地址和目的端口号进行转换，主要应用于公网用户访问私网服务的场景。当公网用户主机发送的报文到达NAT设备后，设备通过目的NAT技术将报文中的公网IPv4地址转换成私网IPv4地址，从而使公网用户可以使用公网地址访问私网服务。

根据转换前后的地址是否存在一种固定的映射关系，目的NAT可以细分为如下几种类型，详见下图。

双向NAT

双向NAT指的是在转换过程中同时转换报文的源信息和目的信息。双向NAT不是一个单独的功能，而是源NAT和目的NAT的组合。双向NAT是针对同一条流，在其经过设备时同时转换报文的源地址和目的地址。双向NAT主要应用在同时有外网用户访问内部服务器和私网用户访问内部服务器的场景。

STUN中定义的NAT类型

在STUN标准中，根据私网IP地址和端口到NAT出口的公网IP地址和端口的映射方式，把NAT分为如下四种类型，详见下图。

Full Cone NAT（完全锥型NAT）

所有从同一个私网IP地址和端口（IP1:Port1）发送过来的请求都会被映射成同一个公网IP地址和端口（IP:Port）。并且，任何外部主机通过向映射的公网IP地址和端口发送报文，都可以实现和内部主机进行通信。

这是一种比较宽松的策略，只要建立了私网IP地址和端口与公网IP地址和端口的映射关系，所有的Internet上的主机都可以访问该NAT之后的主机。
Restricted Cone NAT（限制锥型NAT）

所有从同一个私网IP地址和端口（IP1:Port1）发送过来的请求都会被映射成同一个公网IP和端口号（IP:Port）。与完全锥型NAT不同的是，当且仅当内部主机之前已经向公网主机发送过报文，此时公网主机才能向私网主机发送报文。
Port Restricted Cone NAT（端口限制锥型NAT）

与限制锥型NAT很相似，只不过它包括端口号。也就是说，一台公网主机（IP2:Port2）想给私网主机发送报文，必须是这台私网主机先前已经给这个IP地址和端口发送过报文。
Symmetric NAT（对称NAT）

所有从同一个私网IP地址和端口发送到一个特定的目的IP地址和端口的请求，都会被映射到同一个IP地址和端口。如果同一台主机使用相同的源地址和端口号发送报文，但是发往不同的目的地，NAT将会使用不同的映射。此外，只有收到数据的公网主机才可以反过来向私网主机发送报文。

这和端口限制锥型NAT不同，端口限制锥型NAT是所有请求映射到相同的公网IP地址和端口，而对称NAT是不同的请求有不同的映射。

NAT是如何工作的？

根据前面的分类，我们分别从源NAT和目的NAT中各选一种NAT为代表，介绍其工作原理。其他类型的NAT虽然在转换时，转换的内容有细微差别，但是工作原理都相似，不再重复介绍。此外，双向NAT是源NAT和目的NAT的组合，双向NAT的工作原理也不再重复介绍。

NAPT工作原理

NAPT在进行地址转换的同时还进行端口转换，可以实现多个私网用户共同使用一个公网IP地址上网。NAPT根据端口来区分不同用户，真正做到了地址复用。

当Host访问Web Server时，设备的处理过程如下：

设备收到Host发送的报文后查找NAT策略，发现需要对报文进行地址转换。
设备根据源IP Hash算法从NAT地址池中选择一个公网IP地址，替换报文的源IP地址，同时使用新的端口号替换报文的源端口号，并建立会话表，然后将报文发送至Internet。
设备收到Web Server响应Host的报文后，通过查找会话表匹配到步骤2中建立的表项，将报文的目的地址替换为Host的IP地址，将报文的目的端口号替换为原始的端口号，然后将报文发送至Intranet。

NAT Server工作原理

使用NAT Server时，需要先在设备上配置公网地址和私网地址的固定映射关系。配置完成后，设备将会生成Server-Map表项，存放公网地址和私网地址的映射关系。该表项将一直存在除非NAT Server的配置被删除。

内部Server的私网IPv4地址为192.168.1.2/24，对外的公网IPv4地址为1.1.1.10，端口号都为80，它们之间的映射关系在设备上已提前配置好。当Host访问Server时，设备的处理过程如下：

设备收到Internet上用户访问1.1.1.10的报文的首包后，查找并匹配到Server-Map表项，将报文的目的IP地址转换为192.168.1.2。
设备建立会话表，然后将报文发送至Intranet。
设备收到Server响应Host的报文后，通过查找会话表匹配到步骤2中建立的表项，将报文的源地址替换为1.1.1.10，然后将报文发送至Internet。
后续Host继续发送给Server的报文，设备都会直接根据会话表项的记录对其进行转换，而不会再去查找Server-map表项。

如何使用NAT？

前面已经介绍了，不同的NAT类型适用于不同的应用场景。下面介绍几种典型的NAT应用，帮助用户使用NAT。

私网用户通过NAPT访问Internet

在许多小区、学校和企业的私网规划中，由于公网地址资源有限，通常给私网用户分配私网IPv4地址。此时，可以配置源NAT来实现私网用户访问Internet。用户可以根据自己拥有的公网IPv4地址的个数，选择使用NAPT或者Easy IP。

当用户拥有的公网IP地址个数较多时，配置了NAT设备出接口的IP地址和其他应用之后，还有可用的空闲公网IP地址时，可以选择NAPT。NAPT使用地址池内的IPv4地址作为私网主机转换后的公网IPv4地址。如下图所示，在设备上配置NAPT，实现私网主机访问Internet功能。

私网用户通过Easy IP访问Internet

当用户拥有的公网IPv4地址个数较少时，配置了NAT设备出接口的IPv4地址和其他应用之后，没有可用的空闲公网IPv4地址时，可以选择Easy IP。Easy IP使用出接口的IPv4地址作为私网主机转换后的公网IPv4地址。如下图所示，在设备上配置Easy IP，实现私网主机访问Internet功能。

公网用户通过NAT Server访问私网服务器

在某些场合，私网中有一些服务器需要向公网用户提供服务，比如私网中部署的一些Web服务器、FTP服务器等，NAT支持这样的应用，此时可以配置NAT Server来实现公网用户访问私网服务器。如下图所示，在设备上配置NAT Server，固定“公网IP地址＋端口号”与“私网IP地址＋端口号”间的映射关系，实现公网主机通过该映射关系访问私网服务器功能。

【WSFC 学习笔记】如何理解 Windows Server 故障转移群集的 Quorum

2024-04-20T00:00:00+00:00

前言

最近一个月一直在学高可用的东西，其中 WSFC 是其中一个重要的组成部分。在学习 WSFC 的过程中，我发现了一个很重要的概念：Quorum，这个概念网上一找全是照着微软官方文档写的仲裁配置选项。问有什么模型的时候头头是道，什么节点多数无见证啊、仅磁盘见证啊什么的，一问啥是仲裁（Quorum）和见证（Witness）的时候傻眼了。所以我决定写一篇文章来总结一下我对 Quorum 的理解。

仲裁（Quorum）是什么

仲裁（Quorum）是 WSFC 中的一个重要概念，它是用来保证群集中的节点之间能够达成一致的一个机制。在 WSFC 中，仲裁是通过仲裁资源来实现的，这个资源可以是磁盘、文件共享、或者是其他的仲裁资源。在 WSFC 中，仲裁资源的作用是用来保证群集中的节点之间能够达成一致，从而保证群集的正常运行。

依我看，Quorum 其实应该翻译成 有效参与仲裁的设备（数），因为 Quorum 本来就翻译成法定人数/出席会议最小人数，不应该直接叫仲裁。

现在涉及到 仲裁 这个法律概念，所以我们可以引入法律属于去解释。在法律中，仲裁 是指一种解决纠纷的方式，当纠纷发生时，双方可以通过仲裁的方式来解决纠纷。在法律仲裁中，仲裁员是一个独立的第三方，他们会根据法律和事实来做出裁决。但在 WSFC 中，仲裁员（节点/服务器/虚拟机）既是当事人（所有节点），又参与仲裁庭，它们会根据法律和事实（仲裁模型）来做出裁决，是用来保证群集中的节点之间能够达成一致的。

节点多数，无见证：由节点组织“合议制仲裁庭”，当事人（所有参与群集的节点/服务器）约定由奇数名仲裁员（节点）组成仲裁庭（偶数节点就使其中一个节点下线），其中一名为首席仲裁员（主节点/服务器）；如果是双节点就采取“独任制仲裁庭”，只推举一名仲裁员（一个节点做主服务器，另外一个下线）。

磁盘、文件共享见证：见证人是证人之外知道案件情况的当事人（所以磁盘、文件共享见证需要对所有节点可见，在注册表中节点文件是Cluster，见证文件是0.Cluster，可以证明见证确实是“当事人”）。见证人不参与仲裁庭，但是可以提供证据（见证文件）。

总结来说：

节点多数，无见证：
- 合议庭：集群的所有活动节点。
- 仲裁庭成员：每个节点都可以投票决定集群状态，若节点总数为偶数，可能需要让一个节点下线以避免平票。
- 首席仲裁员（主节点）：在实际的WSFC中，通常没有固定的“首席仲裁员”或主节点，所有节点理论上是平等的，但在实践中，某些节点可能因为资源位置或网络优势暂时承担更多责任。
双节点集群的“独任制”：
- 这种情况下，通常需要额外的见证（磁盘或文件共享见证），因为单纯的两个节点在一个节点失效时无法决定集群状态。如果不使用见证，确实可能会推举一个节点为主导，另一个则在主节点活跃时处于待命状态。
磁盘、文件共享见证：
- 见证人：在这种情况下，见证（文件共享或磁盘）充当了“知情人”，它存储关于集群配置的关键信息，确保在节点间的意见不一致时提供“证据”来帮助做出决策。见证的存在特别在节点数为偶数时非常关键，以避免平票问题。

但是大多数人对法律仲裁制度不了解，而且法律仲裁制度和 WSFC 中的仲裁机制有很大的不同，所以我觉得这个比喻不太合适。

所以我决定引入日常生活，比如双节点集群就像情侣之间决定晚餐吃什么，引入磁盘见证相当于三口之家中孩子的存在，这样比喻起来更加贴近生活，也更容易理解。

原文如下：

Mode	Description
Node majority (no witness) 节点多数	Only nodes have votes. No quorum witness is configured. The cluster quorum is the majority of voting nodes in the active cluster membership.
Node majority with witness (disk or file share) 节点多数+见证	Nodes have votes. In addition, a quorum witness has a vote. The cluster quorum is the majority of voting nodes in the active cluster membership plus a witness vote. A quorum witness can be a designated disk witness or a designated file share witness.
No majority (disk witness only) 仅磁盘见证	No nodes have votes. Only a disk witness has a vote. The cluster quorum is determined by the state of the disk witness. Generally, this mode is not recommended, and it should not be selected because it creates a single point of failure for the cluster.

我们可以这样理解：

仲裁模型	描述
男生女生二人决定晚餐节点多数	【双节点】男生让渡（即其中一节点下线，有一票投票权但动态见证干预其不投票），让女生（主节点/服务器/虚拟机 Owner Node）来选择点什么外卖或者出去吃什么餐馆。~~你就负责买单就行。~~ 【三节点及以上】女生带闺蜜来了，女生和闺蜜手拉手胳膊挽胳膊掌握晚餐选择主动权（即具有集群的控制权，在一个三节点集群中，通常需要至少两个节点在线并相互通信，以维持集群的正常操作）。象征性问你一下想吃什么。~~所以你还是负责买单的小丑。~~
核心家庭（三口之家）或扩展家庭（爸妈或者和爷爷奶奶外公外婆一起为节点，孩子为见证）节点多数+见证	~~爸妈想吃啥就做啥，你的意见仅供参考~~ 因为爷爷奶奶外公外婆说孩子想吃这个那个，所以爸妈做饭就做了大家都爱吃的东西。（换句话说见证也参与，而不仅仅是节点多数）
你过生日那天仅磁盘见证	~~“妈，我生日想吃开封菜。” “不行，油炸食品不健康。”~~ （别看上面的见证是你，但是这一条就不是你了）

总结

给我写乐了。宿舍停水了，舍友用我的博客洗完了澡。

【阅板无数】（Intel x86 IoT系列）Intel Arduino/Genuino 101 简单测评

2024-01-20T00:00:00+00:00

注：下文中 Intel Arduino/Genuino 101 简称为 Arduino 101

Arduino 101

Arduino/Genuino 101 的由来

2015年10月16日¹，距离世界上第一台商用可编程计算器 Olivetti Programma 101² 问世过去了整整50年。为了致敬这个伟大的项目，英特尔和 Massimo Banzi³（Arduino项目的联合创始人）在 Maker Faire 宣布推出一款新的开发板，名为Arduino/Genuino 101 —— 一款专为教育用途、创客世界和首次接触编程的人设计的开发板。

Olivetti Programma 101

Arduino/Genuino 101 的硬件和软件

Arduino 101是一款学习和开发板，以入门级价格提供英特尔® Curie™ 模块的性能和低功耗以及 Arduino 的简单性。它保留了与 UNO 相同的强大外形和外设列表，并增加了板载低功耗蓝牙®（Bluetooth Low Energy，BLE，Nordic 的 nRF512822）功能和 6 轴加速度计/陀螺仪（Bosch 的 BMI160）。

Arduino 101 使用的 Curie™ 模块属于异构双核，包含两个微型内核，一个 x86 （Quark SE，SE 即 Second Edition）和一个 32 位 ARC 架构内核，时钟频率均为 32MHz。英特尔工具链可在两个内核上以最佳方式编译 Arduino 草图，以完成要求最苛刻的任务。英特尔开发的实时操作系统（Zephyr）和框架是开源的。其中，ARC架构是一种32位的RISC处理器架构，由 Synopsys（新思科技）开发。

101 带有 14 个数字输入/输出引脚（其中 4 个可用作 PWM 输出）、6 个模拟输入、一个用于串行通信和草图上传的 USB 连接器、一个电源插孔、一个带 SPI 信号的 ICSP 接头和 I2C 专用引脚。电路板工作电压和 I/O 为 3.3V，但所有引脚均具有 5V 过压保护。

相较于标准 Arduino Uno， Arduino 101 采用的异构双核的 Curie™ 模块比 8位的 Atmel 328p 微控制器更强大，存储空间也更大（Intel 官方的 Curie 规格是 384KB Flash 与 80KB SRAM ，但相关报导写 196KB Flash 与 24KB RAM，Arduino 官网写 384KB Flash 与 80KB SRAM，但 SRAM 部分注明只有 24KB 可供应用程序 Sketch 使用。因此，推估之所以写 196KB Flash，应该也是系统占据一部分，真正可供运用的是 196KB。除此之外电路板上似乎又增设2MB Flash 可供 Curie 使用）

在2016年4月21日，英特尔发布 Arduino 101 固件源代码。包含用于 101 上 Curie 处理器的完整 BSP（板级支持包）。它允许您编译和修改核心操作系统和固件，以管理更新和引导加载程序。固件在 Curie 模块内的 x86 芯片上运行，并使用回调与 ARC 内核（运行 Arduino 程序）进行通信。x86 内核负责处理低功耗蓝牙® （BLE）和 USB 通信，从而减轻 ARC 内核的负担。⁴

技术规格⁵

Microcontroller	Intel Curie
Operating Voltage	3.3V (5V tolerant I/O)
Input Voltage (recommended)	7-12V
Input Voltage (limit)	7-17V
Digital I/O Pins	14 (of which 4 provide PWM output)
PWM Digital I/O Pins	4
Analog Input Pins	6
DC Current per I/O Pin	20 mA
Flash Memory	196 kB
SRAM	24 kB
Clock Speed	32MHz
LED_BUILTIN	13
Features	Bluetooth® Low Energy, 6-axis accelerometer/gyro
Length	68.6 mm
Width	53.4 mm
Weight	34 gr.

Arduino 代码实现

Blink

#include <Arduino.h>

void setup() 
{
    Serial.begin(9600);
    while (!Serial)
    {
        delay(10);
        // wait for serial port to connect. Needed for native USB port only
    }
    pinMode(LED_BUILTIN, OUTPUT);
}

void loop() 
{
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.println("LED ON!");
    delay(1000);
    digitalWrite(LED_BUILTIN, LOW);
    Serial.println("LED OFF!");
    delay(1000);
}

读取板载 IMU

#include <Arduino.h>
#include "CurieIMU.h"

void setup() 
{
    Serial.begin(9600);
    while (!Serial)
    {
        delay(10);
    }
    // Start the acceleromter
    CurieIMU.begin();

    // Set the accelerometer range to 2G
    CurieIMU.setAccelerometerRange(2);
}

void loop() 
{
    // read accelerometer:
    int x = CurieIMU.readAccelerometer(X_AXIS);
    int y = CurieIMU.readAccelerometer(Y_AXIS);
    int z = CurieIMU.readAccelerometer(Z_AXIS);

    Serial.print("x: ");
    Serial.print(x);
    Serial.print(" y: ");
    Serial.print(y);
    Serial.print(" z: ");
    Serial.print(z);
    Serial.println("");
}

读取板载 RTC

#include <Arduino.h>
#include <CurieTime.h>

void setup()
{
    Serial.begin(9600);
    while (!Serial)
    {
        delay(10);
    }
    setTime(1, 23, 24, 25, 1, 2024);
}

void loop()
{
    //create a character array of 16 characters for the time
    char clockTime[16];
    //use sprintf to create a time string of the hour, minte and seconds
    sprintf(clockTime, "%2d:%2d:%2d", hour(), minute(), second());

    //create a character array of 15 characters for the date
    char dateTime[16];
    //use sprintf to create a date string from month, day and year
    sprintf(dateTime, "%2d/%2d/%4d", month(), day(), year());

    //print the time and date to the serial monitor
    Serial.print(clockTime);
    Serial.println(dateTime);
    delay(1000);
}

使用板载 BLE 控制 LED

需要配合Nordic nRF Connect使用，可以在 Google Play Store 或 App Store 下载

#include <Arduino.h>
#include <CurieBLE.h>

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // BLE LED Service

// BLE LED Switch Characteristic - custom 128-bit UUID, read and writable by central
BLEUnsignedCharCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int ledPin = 13; // pin to use for the LED

void setup() 
{
    Serial.begin(9600);

    // set LED pin to output mode
    pinMode(ledPin, OUTPUT);

    // begin initialization
    BLE.begin();

    // set advertised local name and service UUID:
    BLE.setLocalName("Arduino 101");
    BLE.setAdvertisedService(ledService);

    // add the characteristic to the service
    ledService.addCharacteristic(switchCharacteristic);

    // add service
    BLE.addService(ledService);

    // set the initial value for the characeristic:
    switchCharacteristic.setValue(0);

    // start advertising
    BLE.advertise();

    Serial.println("BLE LED Peripheral");
}

void loop() 
{
    // listen for BLE peripherals to connect:
    BLEDevice central = BLE.central();

    // if a central is connected to peripheral:
    if (central) 
    {
        Serial.print("Connected to central: ");
        // print the central's MAC address:
        Serial.println(central.address());

        // while the central is still connected to peripheral:
        while (central.connected()) 
        {
            // if the remote device wrote to the characteristic,
            // use the value to control the LED:
            if (switchCharacteristic.written()) 
            {
                if (switchCharacteristic.value()) 
                {   // any value other than 0
                    Serial.println("LED on");
                    digitalWrite(ledPin, HIGH);         // will turn the LED on
                } 
                else 
                {                              // a 0 value
                    Serial.println(F("LED off"));
                    digitalWrite(ledPin, LOW);          // will turn the LED off
                }
            }
        }

        // when the central disconnects, print it out:
        Serial.print(F("Disconnected from central: "));
        Serial.println(central.address());
    }
}

后记

Arduino 101 于 2016年 Q1 季度发布。仅仅过去一年有余，在英特尔宣布 Galileo，Edison 和 Joule 模块停产一个月后，也草草停产 Curie 模块（07/17/2017）⁶，只能说是非常可惜，英特尔宏图壮志准备在 IoT 领域大展拳脚，但是却因为种种原因，最终只能黯然收场。也导致诸多使用 Curie 模块的企业被迫更换产品线，比如小米智能跑鞋。

图片源自Intel Curie Module, Arduino 101 Board Are Being Discontinued (Too) - CNX Software

《Arduino程序设计基础》的作者陈吕洲先生对 Arduino 101 抱有极高的评价：Genuino 101是一个极具特色的Arduino开发板，它基于Intel Curie模组，不仅有着和Arduino UNO一样特性和外设，还集成了低功耗蓝牙（BLE）和六轴姿态传感器（IMU）功能，借助intel Curie模组上模式匹配引擎，甚至可以进行机器学习操作。因此使用Genuino 101，可以完成一些传统单片机或者Arduino难以胜任的工作，制作更为惊艳的作品。为此他本人还专门为 Arduino 101 著书 —— 《Arduino 101 开发入门》⁷。

不过 Arduino 101 也有三点比标准 Arduino Uno 差⁸：

只有4组 PWM 脉宽调变输出，Uno 有6组；
没有任何的 EEPROM 存储，Uno 至少还有1KB可以使用；
单一 I/O 的电流驱动能力最高仅4mA，Uno 可到20mA。

所以 Curie 只是引脚排列与 Arduino 相仿，不能完全保证原有设计电路或者 Arduino Shield可完全相容（兼容）沿用、续用。

如果再与 MediaTek 的 LinkIt ONE 小比一下，LinkIt One也有效能更佳的处理器核心与更多容量的存储，且依然提供EEPROM 可用，但 PWM 方面则只有2组。当然，LinkIt ONE 强在无线通讯（日后会测评一下），如 GPRS、Wi-Fi、GPS等，Curie 略强在惯性感测。

英特尔似乎在 IoT 领域并没有取得太大的成就，但是英特尔的 x86 芯片却是世界上最流行的 CPU 架构，这也是英特尔的核心竞争力，所以英特尔在 IoT 领域的失败并不会影响到英特尔的核心业务，但是英特尔的 IoT 产品却是非常有趣的，比如 Edison、Galileo、Curie、Arduino 101 等等，这些产品都是英特尔的 IoT 产品，但是英特尔并没有将这些产品做成一个系列，而是分散在各个不同的系列中，这也是英特尔在 IoT 领域失败的一个原因。

笔者手上的 Genuino 101 是 2021年在 SeeedStudio 任职时，从 FAE 仓库里找到的，当时已经停产了，但是还是有一些库存，所以就拿了一块回来，但是一直没有时间去折腾，直到最近才拿出来玩一玩，但是发现 Arduino 101 的资料实在是太少了，所以就写了这篇文章，谨此纪念一家伟大的公司一个伟大的产品。

引用

【安卓搞机记】通过 adb 侧载低版本 SDK 的安卓应用

2024-01-16T00:00:00+00:00

前些日子翻出来自己高中写的安卓应用，安装上去看看，但是发现小米的 HyperOS 装不上去，一直报错：

安装失败 (-29) 失败原因安装包与系统不兼容

我第一反应应该是因为应用的目标 SDK 版本（19）太低了，先用 App Cloner 改改参数，改到 SDK26 看看。

还是不行，打开是能打开但是白屏。

最后看看用 adb 侧载算了：

安全性

最低可安装的目标 API 级别

从 Android 14 开始，targetSdkVersion 低于 23 的应用无法安装。要求应用满足这些最低目标 API 级别要求有助于提高用户的安全性和隐私性。

恶意软件通常会以较旧的 API 级别为目标平台，以绕过在较新版本 Android 中引入的安全和隐私保护机制。例如，有些恶意软件应用使用 targetSdkVersion 22，以避免受到 Android 6.0 Marshmallow（API 级别 23）在 2015 年引入的运行时权限模型的约束。这项 Android 14 变更使恶意软件更难以规避安全和隐私权方面的改进限制。尝试安装以较低 API 级别为目标平台的应用将导致安装失败，并且 Logcat 中会显示以下消息：

INSTALL_FAILED_DEPRECATED_SDK_VERSION: App package must target at least SDK version 23, but found 7

在升级到 Android 14 的设备上，targetSdkVersion 低于 23 的所有应用都将继续保持安装状态。

如果您需要测试以旧版 API 级别为目标平台的应用，请使用以下 ADB 命令：

adb install --bypass-low-target-sdk-block FILENAME.apk

【Git】Git 推送的配置

2023-12-22T00:00:00+00:00

Git 初次设定
Git 代理设置
Git 回滚操作
git push 到两个地址的仓库
Git 不公开邮箱账户
Git 取消文件跟踪
Git 记住密码

`Git` 初次设定

git config --global user.name "IcingTomato"
git config --global user.email ""

参阅1.6 開始 - 初次設定 Git

`Git` 代理设置

git config --global http.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
git config --global https.proxy http://proxyUsername:proxyPassword@proxy.server.com:port

`Git` 回滚操作

git reset --hard HEAD^ # 回退到上个版本。
git reset --hard HEAD^ <filename> # 回退指定文件到上个版本。
git reset --hard HEAD^^ # 回退到上上个版本。
git reset --hard HEAD~n # 回退到前n次提交之前，若n=3，则可以回退到3次提交之前。
git reset --hard <commit_sha> # 回滚到指定commit的SHA码，一般使用这种方式。

--hard 参数撤销工作区中所有未提交的修改内容，将暂存区与工作区都回到上一次版本，并删除之前的所有信息提交。 --soft 参数撤销工作区中所有未提交的修改内容，将暂存区与工作区都回到上一次版本，但保留之前的所有信息提交。

回滚完之后就可以

git push -f origin <branch_name>

`git push` 到两个地址的仓库

好比我这个博客仓库，在国内因为某些不可抗力，github 无法访问，所以我在 gitee 上也有一个仓库，这样就可以在国内访问了。但是我每次都要推送两次，很麻烦。或者要登陆 gitee 的仓库，然后按一下同步按钮，也很麻烦。

所以我就想，能不能只推送一次，然后两个仓库都更新呢？

# 原始推送地址 https://github.com/IcingTomato/icing.fun.git

# 添加第二个推送地址
git remote set-url --add origin https://gitee.com/IcingTomato/icing.fun.git

# 查看推送/拉取地址
git remote -v

# origin  https://github.com/IcingTomato/icing.fun.git (fetch)
# origin  https://github.com/IcingTomato/icing.fun.git (push)
# origin  https://gitee.com/IcingTomato/icing.fun.git (push)

# 推送
git push 

`Git` 不公开邮箱账户

之前貌似更新了什么，好像是将保密你的邮箱地址，并在执行基于 Web WebIDE 的 Git 操作中，使用 xxxx@user.noreply.xxx.com 作为你的邮箱地址。如果你希望命令行 Git 操作使用你的私人邮箱地址，你必须在 Git 中设置你的邮箱地址。

# 我经常用 GitHub 的邮箱，全局就设置成这个了
git config --global user.email "xxxx@users.noreply.github.com"

# cd 到 icing.fun 仓库目录下
git config user.email "xxxx@users.noreply.github.com"
git config user.email "xxxx@users.noreply.gitee.com"

`Git` 取消文件跟踪

参见【Git】Git 取消文件跟踪

`Git` 记住密码

在使用 git push 时，可能会遇到需要输入用户名和密码的情况。为了避免每次都输入，可以使用以下命令来记住密码：

git config --global credential.helper store

这将会在本地存储你的 Git 凭据，之后在推送时就不需要再次输入用户名和密码了。如果你希望在每次推送时都输入密码，可以使用以下命令：

git config --global credential.helper cache

这将会在内存中缓存你的凭据，默认缓存时间为 15 分钟。如果你希望更改缓存时间，可以使用以下命令：

git config --global credential.helper 'cache --timeout=3600'

这将会将缓存时间设置为 1 小时（3600 秒）。

【Git】GitHub 的三种 Pull Request

2023-12-13T00:00:00+00:00

在 GitHub 上处理 Pull Requests（PRs）时，有三种主要的合并策略：创建合并提交（Merge Commit）、挤压合并（Squash and Merge）、变基合并（Rebase and Merge）。下面简要解释每种策略的特点及其区别：

1. 创建合并提交（Merge Commit）

操作：当你选择创建合并提交时，GitHub 会创建一个新的合并提交来将 PR 的更改合并到基分支（如 main 或 master）。这个合并提交会包含一个特殊的提交信息，通常包括一个指向 PR 的引用。
结果：在基分支的提交历史中，PR 的所有提交都将被保留，并附加一个额外的合并提交。这保持了完整的历史记录和PR的独立性。
适用场景：当你想保留对 PR 的每一次单独提交的完整历史时。

2. 挤压合并（Squash and Merge）

操作：挤压合并会将 PR 中的所有提交合并成一个单独的提交，然后将这个提交合并到基分支。
结果：基分支的提交历史更简洁，因为它只包含一个代表整个 PR 的提交。但这意味着PR中原始提交的细节被压缩。
适用场景：适用于PR包含许多小的、渐进的更改，但你想在基分支上保持一份干净、未混杂的历史记录。

3. 变基合并（Rebase and Merge）

操作：变基合并首先会将 PR 的提交历史变基到目标分支的最新提交上，然后将这些提交直接加入到基分支，而不创建额外的合并提交。
结果：这在基分支上产生一条线性的提交历史，但不会保留 PR 作为独立实体的信息。
适用场景：当你希望保持线性历史且避免合并提交时。这通常适用于较小的、清晰的更改。

总结

创建合并提交保留了所有的提交历史和PR的独立性，增加了一个额外的合并提交。
挤压合并将PR的所有提交压缩成一个单独的提交，使历史更干净。
变基合并保持了线性的提交历史，但不会创建合并提交。

选择哪种策略取决于你的项目团队如何希望管理其版本控制历史的清晰度和连贯性。

【阅板无数】RaspberryPi 启动流程探究

2023-12-09T00:00:00+00:00

树莓派学习第一步，探究树莓派的启动流程。

树莓派的启动流程

相较于一般/通常的 ARM SoC 来说，树莓派1/2/3/Zero的启动流程有些不同，这里简单的记录一下。

树莓派1/2/3/Zero的启动流程

在开机时，CPU是离线的，由GPU上的一个小型RISC核心负责启动SoC，因此大部分启动组件实际上是在GPU代码上运行，而不是CPU上。

启动顺序如下：

第一阶段引导程序：用于挂载SD卡上的FAT32启动分区，以便可以访问第二阶段引导程序。它在制造树莓派时已经烧录到SoC本身，并且用户无法重新编程。
第二阶段引导程序（bootcode.bin）：用于从SD卡检索GPU固件，加载固件，然后启动GPU。
GPU固件（start.elf）：一经加载，允许GPU启动CPU。另一个文件fixup.dat用于配置GPU和CPU之间的SDRAM分区。此时，CPU从复位模式释放并转移到CPU上执行。
用户代码（User Code）：这可以是任何数量的二进制文件之一。默认情况下，它是Linux内核（通常命名为kernel.img），但它也可以是另一个引导程序（例如U-Boot）或一个简单的应用程序。 在2012年10月19日之前，曾经还有第三阶段引导程序（loader.bin），现已废除。

下面是原文elinux.org/RPi_Software

At power-up, the CPU is offline, and a small RISC core on the GPU is responsible for booting the SoC, therefore most of the boot components are actually run on the GPU code, not the CPU.

The boot order and components are as follows:

First stage bootloader - This is used to mount the FAT32 boot partition on the SD card so that the second stage bootloader can be accessed. It is programmed into the SoC itself during manufacture of the RPi and cannot be reprogrammed by a user.

Second stage bootloader (bootcode.bin) - This is used to retrieve the GPU firmware from the SD card, program the firmware, then start the GPU.

GPU firmware (start.elf) - Once loaded, this allows the GPU to start up the CPU. An additional file, fixup.dat, is used to configure the SDRAM partition between the GPU and the CPU. At this point, the CPU is release from reset and execution is transferred over.

User code - This can be one of any number of binaries. By default, it is the Linux kernel (usually named kernel.img), but it can also be another bootloader (e.g. U-Boot), or a bare-bones application.

Prior to 19th October 2012, there was previously also a third stage bootloader (loader.bin) but this is no longer required.[1]

树莓派4B（BCM2711）的启动流程

树莓派4B（BCM2711）因为某些硬件升级导致启动流程复杂了不是一丁半点[2]。

当树莓派4开机时，引导过程涉及BCM2711 VideoCore VI 处理器单元（VPU）的操作。以下是引导过程的步骤概述：

VPU核心0的初始化：
- 开机时，BCM2711芯片的VPU核心0开始运行。
- 程序计数器设置为0x60000000，映射到片上启动ROM。
VPU频率和启动ROM：
- 最初，VPU的频率设置为振荡器频率，树莓派4上为54.0 MHz。
- 这个低频率足以完成初始引导任务。
读取OTP寄存器：
- 启动ROM读取某些一次性可编程（OTP）寄存器（17/18, 66, 和 67）。
- 这些寄存器与树莓派3相比有不同的含义。更多信息可以在这个GitHub问题中找到。
引导指示引脚：
- 如果配置了“引导指示引脚”，则它会被激活几毫秒。
USB设备模式恢复：
- 如果配置了USB设备模式强制引导引脚且激活，某些步骤会被跳过。
- 这是一种从USB启动恢复的机制。
SD卡引导：
- 如果SD卡引导引脚处于激活状态或未配置，启动ROM尝试从SD卡的第一个FAT分区加载recovery.bin。
- 这种机制有助于在EEPROM损坏时恢复板子。更多细节可以在树莓派硬件文档中找到。
从EEPROM加载固件：
- BootROM尝试从EEPROM芯片加载固件，通常是通过SPI0在GPIO 40–43接口的Winbond W25X40芯片。
USB设备模式：
- 如果前面的步骤失败，芯片进入通过Type-C连接器的USB设备模式。
- 它等待从USB主机获取恢复映像，需要在主机上更新usbboot。更多信息可以在这个拉取请求中找到。
- 在这种模式下，VPU的频率提升到100 MHz。
固件映像签名：
- 需要在固件映像中附加一个20字节的签名，这是使用存储在OTP中的通用密钥的映像的HMAC-SHA1散列。
- 这个密钥无法通过树莓派提供的固件的API访问。
- 这种机制最初在树莓派3上是可选的，现在则是强制性的，尽管它并不提供安全保护，因为存在一个通用的recovery.bin映像。

这个引导过程突出显示了确保树莓派4能够成功引导并从潜在的固件问题中恢复的各种机制。

When the Raspberry Pi 4 is powered on, the BCM2711 VPU core 0 gets started. The program counter is set to 0x60000000. This address maps to the on-chip boot ROM. Note that the VPU frequency is set to the oscillator (54.0 MHz on RPi4), so it’s not very fast, but it does not do a lot of things either:

Read boot-related OTP registers (17/18, 66 and 67). Note that these registers have a different meaning than on Raspberry Pi 3. More information can be found here.

If a “boot indication pin” is configured, it is activated for some milliseconds.

If USB device-mode recovery force boot pin is configured and active, steps 4 and 5 are skipped.

If SD card boot pin is either active or not configured, the boot ROM tries to load recovery.bin from the first FAT partition. This provides a mechanism to unbrick your board if the EEPROM gets corrupted. More details can be found here.

Next, the boot ROM tries to load firmware from the EEPROM chip. This is a standard Winbond W25X40 chip, access through SPI0 on GPIO 40–43.

If everything else fails, the chip enters USB device mode (on the Type-C connector) and waits to get the recovery image from the USB host. You need an updated usbboot on the host to use this method. See also this pull request.

The VPU frequency is increased to 100 MHz for the USB device mode.

Note that a 20-byte signature must be appended to the firmware image. It is an HMAC-SHA1 hash of the image using a universal key that is also stored in the OTP, but not accessible using the Foundation firmware APIs. A similar mechanism was available as an optional feature on Raspberry Pi3. I originally assumed that the key is unique for each Raspberry Pi, but since there is one universal recovery.bin image that works for all, there must be only one key. Given that it provides no security, I’m not sure why this hash is now mandatory.

【博客搭建】Jekyll Learning

2023-12-06T00:00:00+00:00

Jekyll/Liquid 博客学习记录（连载）

Jekyll博客配置教程

我是LNMP派，因为我不会用Apache配置。

然而静态博客没必要MySQL, MariaDB, PHP。所以我们只安装Jekyll所有必需的依赖项。

sudo apt-get install ruby-full build-essential zlib1g-dev nginx
sudo apt-get install gcc g++ make
curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt-get update && sudo apt-get install yarn

然而Ubuntu 16.04太老了，ruby的版本不支持Jekyll 4。所以我们要手动安装Ruby 3.0.0。

第一步是为Ruby安装一些依赖项。一步一步运行。

sudo apt install curl
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt-get update
sudo apt-get install git-core zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev software-properties-common libffi-dev nodejs yarn

接下来，我们将使用以下三种方法之一安装Ruby。每个都有自己的好处，如今大多数人都喜欢使用rbenv，但是如果您熟悉rvm，也可以按照这些步骤进行操作。我也提供了从源代码安装的说明，但是一般而言，您需要选择rbenv或rvm。

方法一：使用rbenv安装。首先安装rbenv，然后安装ruby-build：

cd
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL

git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc
exec $SHELL

rbenv install 3.0.0
rbenv global 3.0.0
ruby -v

方法二：RVM安装

sudo apt-get install libgdbm-dev libncurses5-dev automake libtool bison libffi-dev
gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
curl -sSL https://get.rvm.io | bash -s stable
source ~/.rvm/scripts/rvm
rvm install 3.0.0
rvm use 3.0.0 --default
ruby -v

方法三：Ruby源码安装

cd
wget http://ftp.ruby-lang.org/pub/ruby/3.0/ruby-3.0.0.tar.gz
tar -xzvf ruby-3.0.0.tar.gz
cd ruby-3.0.0/
./configure
make
sudo make install
ruby -v

Ruby服务器在国外，我的博客服务器在国内，所以换个Ruby源

gem source -r https://rubygems.org/
gem source --add https://gems.ruby-china.com/
gem source -u

最后一步是安装Bundler

gem install bundler jekyll github-pages jekyll-paginate webrick

安装完之后就可以将博客从GitHub或Gitee上git clone下来了。

接着完成对nginx的配置

安装nginx

sudo apt-get install nginx

然后定位到nginx的配置文件：

sudo vim /etc/nginx/sites-enabled/default

配置文件在下面：

pi@ubuntu:~cat /etc/nginx/sites-enabled/default 
server {
	# 监听80端口，我嫌麻烦就懒得加SSL了
	listen 80 default_server;
	listen [::]:80 default_server;
  # 网页在本地的根目录
	root /var/www/html;
  # 显示的主页
	index index.html;
  # 你的域名
	server_name domain.yours;
  # 404，403配置文件
  # 主要目的是当出现404或403时直接回显200
	error_page 404 =200 /404.html;
        # 404
        location /404.html {
                root /var/www/html/;
                internal;
        }        
        # 403
        error_page 403 =200 /offline.html;
        # 404
        location /offline.html {
                root /var/www/html/;
                internal;
        }        
}

保存好之后重启nginx

sudo systemctl restart nginx

Jekyll博客维护教程

博客的维护教程修改自 Hux 和 BY_Blog

环境

如果你安装了 Jekyll，那你只需要在命令行输入jekyll serve 或 jekyll s就能在本地浏览器中输入http://127.0.0.1:4000/预览主题，对主题的修改也能实时展示（需要强刷浏览器，Ctrl+F5）。

开始

你可以通用修改 _config.yml文件来轻松的开始搭建自己的博客:

# Site settings
title: 啥玩意儿啊这                 # 你的博客网站标题
SEOTitle: 啥玩意儿 | What's this    # SEO 标题
description: "Hey"                 # 随便说点，描述一下

# SNS settings      
github_username: null     # 你的github账号

# Build settings
# paginate: 100              # 一页你准备放几篇文章

Jekyll官方网站还有很多的参数可以调，比如设置文章的链接形式…网址在这里：Jekyll - Official Site 中文版的在这里：Jekyll中文.

撰写博文

要发表的文章一般以 Markdown 的格式放在这里_posts/，你只要看看这篇模板里的文章你就立刻明白该如何设置。

yaml 头文件长这样:

---
layout:     post
title:      硕人其颀 衣锦褧衣 
subtitle:   Quark核心板的GPIO推算过程
date:       2021-02-01
author:     null
header-img: img/2021/02/01/01/title.jpg
catalog: true
tags:
    - Quark
    - GPIO
    - Linux
    - Project-Quantum
    - Nano Pi
---

侧边栏

看右边

设置是在 _config.yml文件里面的Sidebar settings那块。

# Sidebar settings
sidebar: true  #添加侧边栏
sidebar-about-description: "简单的描述一下你自己"
sidebar-avatar: /img/avatar-by.jpg     #你的大头贴，请使用绝对地址.注意：名字区分大小写！后缀名也是

侧边栏是响应式布局的，当屏幕尺寸小于992px的时候，侧边栏就会移动到底部。具体请见bootstrap栅格系统

Mini About Me

Mini-About-Me 这个模块将在你的头像下面，展示你所有的社交账号。这个也是响应式布局，当屏幕变小时候，会将其移动到页面底部，只不过会稍微有点小变化，具体请看代码。

Featured Tags

看到这个网站 Medium 的推荐标签非常的炫酷，所以我将他加了进来。这个模块现在是独立的，可以呈现在所有页面，包括主页和发表的每一篇文章标题的头上。

# Featured Tags
featured-tags: true  
featured-condition-size: 1     # A tag will be featured if the size of it is more than this condition value

唯一需要注意的是featured-condition-size: 如果一个标签的 SIZE，也就是使用该标签的文章数大于上面设定的条件值，这个标签就会在首页上被推荐。

内部有一个条件模板 ｛% if tag[1].size > ｛｛ site.featured-condition-size｝｝ %｝ 是用来做筛选过滤的.

# SNS settings
RSS: true
bilibili_username:  bilibili_uid 
zhihu_username:     username
facebook_username:  username
github_username:    username
weibo_username:     username

Friends

友链部分。这会在全部页面显示。

设置是在 _config.yml文件里面的Friends那块，自己加吧。

# Friends
friends: [
    {
        title: "huohuo",
        href: "http://null.fun/"
    },
    {
        title: "Apple",
        href: "https://apple.com/"
    }
]

Keynote Layout

HTML5幻灯片的排版：

这部分是用于占用html格式的幻灯片的，一般用到的是 Reveal.js, Impress.js, Slides, Prezi 等等.我认为一个现代化的博客怎么能少了放html幻灯的功能呢~

其主要原理是添加一个 iframe，在里面加入外部链接。你可以直接写到头文件里面去，详情请见下面的yaml头文件的写法。

---
layout:     keynote
iframe:     "http://huangxuan.me/js-module-7day/"
---

iframe在不同的设备中，将会自动的调整大小。保留内边距是为了让手机用户可以向下滑动，以及添加更多的内容。

Comment

博客不仅支持 Disqus 评论系统,还加入了 Gitalk 评论系统，支持 Markdwon 语法，cool~

Disqus

优点：国际比较流行，界面也很大气、简洁，如果有人评论，还能实时通知，直接回复通知的邮件就行了；

缺点：评论必须要去注册一个disqus账号，分享一般只有Facebook和Twitter，另外在墙内加载速度略慢了一点。想要知道长啥样，可以看以前的版本点这里最下面就可以看到。

Note：有很多人反映 Disqus 插件加载不出来，可能墙又架高了，有条件的话翻个墙就好了~

使用：

首先，你需要去注册一个Disqus帐号。

其次，你只需要在下面的 yaml 头文件中设置一下就可以了。

# 评论系统
# Disqus（https://disqus.com/）
disqus_username: 

Gitalk

优点：界面干净简洁，利用 Github issue API 做的评论插件，使用 Github 帐号进行登录和评论，最喜欢的支持 Markdown 语法，对于程序员来说真是太 cool 了。

缺点：配置比较繁琐，每篇文章的评论都需要初始化。

使用：

参考我的这篇文章：《屡顾尔仆不输尔载-Jekyll博客迁移计划：Gitalk 插件与 Google Analytics 的配置》

Analytics

网站分析，现在支持百度统计和Google Analytics。需要去官方网站注册一下，然后将返回的code贴在下面：

# Baidu Analytics
ba_track_id: 
#
# Google Analytics
ga_track_id: 'UA-'            # 你用Google账号去注册一个就会给你一个这样的id
ga_domain:                    # 默认的是 auto, 这里我是自定义了的域名，你如果没有自己的域名，需要改成auto。

Customization

如果你喜欢折腾，你可以去自定义这个模板的 Code。

如果你可以理解 _include/ 和 _layouts/文件夹下的代码（这里是整个界面布局的地方），你就可以使用 Jekyll 使用的模版引擎 Liquid的语法直接修改/添加代码，来进行更有创意的自定义界面啦！

Header Image

博客每页的标题底图是可以自己选的，看看几篇示例post你就知道如何设置了。

标题底图的选取完全是看个人的审美了。每一篇文章可以有不同的底图，你想放什么就放什么，最后宽度要够，大小不要太大，否则加载慢啊。

上传的图片最好先压缩，这里推荐 imageOptim 图片压缩软件，让你的博客起飞。

但是需要注意的是本模板的标题是白色的，所以背景色要设置为灰色或者黑色，总之深色系就对了。当然你还可以自定义修改字体颜色，总之，用github pages就是可以完全的个性定制自己的博客。

SEO Title

我的博客标题是呐啥，但是我想要在搜索的时候显示哦豁，这个就需要 SEO Title 来定义了。

其实这个 SEO Title 就是定义了 <head><title>标题</title></head> 这个里面的东西和多说分享的标题，可以自行修改的。

增加阅读时间和字数统计

注意：以下代码中出现的全角花括号要改成半角花括号。不要问我为什么，问就是这个影响我全局代码编译。

Displaying a post’s word count is rather common when creating a blog, but usually those techniques rely on JavaScript to work. The script reads the post’s text, counts the words and displays the result accordingly. That was the way I did things on this blog first as well, but then I set out to find a better way.

Showing the word count

Luckily Jekyll provides a handy liquid filter called number_of_words. So displaying the actual word count is as simple as that:

｛｛ page.content | number_of_words ｝｝

While this works just nicely it’s not very solid. You might want to hide word counts on shorter posts, for example as they’re of little value in such posts. This is a little more complex as you can not directly use Liquid filters in a conditional block.

Variables in Liquid

In Liquid there are two ways to create variables. You can ｛% assign %｝ a variable and you can ｛% capture %｝ a variable. The difference might not be obvious, but it’s simple once you get it.

Assigning a value to a variable means that you take any kind of data (e.g. a string, a number, a boolean) and Liquid knows that you want to access that exact data when you refer to this variable. An assigned variable is fixed, that means you can not use the value returned from other Liquid tags.

｛% assign awesome = true %｝

｛% if awesome %｝
  <p>Yay, awesome!</p>
｛% endif %｝

But what if you want to store a Liquid tags’s return value in a variable? That’s exactly what the ｛% capture %｝ block is for. Unlike assigned variables, captured variables can only hold strings — which will cause us some trouble later on. This is simply because Liquid tags return strings by default.

｛% capture value %｝
  ｛｛ page.title | upcase ｝｝ from ｛｛ page.date | date: "%b %d, %y" ｝｝
｛% endcapture %｝

As you can see in the above example, you can capture any number of strings into a variable, be it strings returned from a Liquid tag or fixed strings.

Making the word count conditional

Now that you know about ｛% assign %｝ and ｛% capture %｝ we can move on to store our word count in a variable. The question remains, do we assign the variable or do we capture it?

It should be clear by now that we’ll have to capture the value as it’s returned from a Liquid tag. That gives us something like this:

｛% capture words %｝
  ｛｛ page.content | number_of_words ｝｝
｛% endcapture %｝

Let’s say we considered posts that are shorter than 250 words not worthy of getting the word count. A good example for this would be ‘link list’-style post that consist of mostly a quote from the original article and a comment spanning a sentence or two. Ideally, this would be taken care of using a simple conditional block.

｛% if words > 250 %｝
  ｛｛ words ｝｝
｛% endif %｝

But you’ll soon see that this won’t work as intended as Jekyll will throw you this error an error saying you’ve attempted to compare a string (the words) with a number (250), which is entirely true, and also, sadly, entirely not possible. There is, however, a simple workaround.

｛% capture words %｝
  ｛｛  page.content | number_of_words | minus: 250 ｝｝
｛% endcapture %｝
｛% unless words contains "-" %｝
  ｛｛  words | plus: 250 ｝｝
｛% endunless %｝

You can use Liquid filters to substract your minimum number from the word count to see if it falls below 0. If it does it will contain a ‘-‘ at the beginning, which means the post is too short and won’t get the word number displayed. If our variable doesn’t contain a ‘-‘ we can simply add our minimum number back to the word count and display it. Quite simple, right?

Customising the output

Now that we finally have our word number along with the conditional to hide it from short posts we can move on to make the output a bit nicer. You do this using Liquid filters like append or prepend. For a complete list of available filters you can check Shopify’s Liquid for Designers guide.

｛｛  words | plus: 250 | append: " words" ｝｝

The above snippet results in something like ‘There are 250 words in this post’. You can go crazy with filters, they offer lots of possibilities.

Calculating the reading time

You might have noticed that I display an estimated reading time on this blog instead of just a word count. Personally, I just think this is a more useful guideline. Doing this is as easy as putting the divided_by filter into our final word count construct. The number to divide by is arbitrary, but 180 is the avarage number of words a person reads per minute.

｛｛  words | plus: 250 | divided_by: 180 | append: " minutes to read" ｝｝

Summing it up

｛% capture words %｝
  ｛｛  page.content | number_of_words | minus: 250 ｝｝
｛% endcapture %｝
｛% unless words contains "-" %｝
  ｛｛  words | plus: 250 | append: " words" ｝｝
｛% endunless %｝

｛% capture words %｝
  ｛｛  page.content | number_of_words | minus: 250 ｝｝
｛% endcapture %｝
｛% unless words contains "-" %｝
  ｛｛  words | plus: 250 | divided_by: 180 | append: " minute read" ｝｝
｛% endunless %｝

这是我用的参数

在/_include下新建read_time.html和word_count.html

<!-- Add Read Time and word count, by chiya 2021.02.06-->
｛% capture words %｝
｛｛  content | number_of_words | minus: 0 ｝｝
｛% endcapture %｝
｛% unless words contains '-' %｝
｛｛  words | plus: 200 | divided_by: 100 | append: ' minute(s)' ｝｝
｛% endunless %｝

<!-- Add Read Time and word count, chiya 2021.02.06-->
｛% capture words %｝
  ｛｛  page.content | number_of_words | minus: 10 ｝｝
｛% endcapture %｝
｛% unless words contains "-" %｝
  ｛｛  words | plus: 10 | append: " words" ｝｝
｛% endunless %｝

然后编辑./_layouts/post.html，大概在43行处。

<header class="intro-header" >
    <div class="header-mask"></div>
    <div class="container">
        <div class="row">
            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <div class="post-heading">
                    <div class="tags">
                        ｛% for tag in page.tags %｝
                        <a class="tag" href="｛｛  site.baseurl ｝｝/tags/#｛｛  tag ｝｝" title="｛｛  tag ｝｝">｛｛  tag ｝｝</a>
                        ｛% endfor %｝
                    </div>
                    <h1>｛｛  page.title ｝｝</h1>
                    ｛% comment %｝
                        always create a h2 for keeping the margin , Hux
                    ｛% endcomment %｝
                    ｛% comment %｝ if page.subtitle ｛% endcomment %｝
                    <h2 class="subheading">｛｛  page.subtitle ｝｝</h2>
                    ｛% comment %｝ endif ｛% endcomment %｝
                    <!-- Add Read Time and word count, by chiya 2021.02.06-->
                    <p class="meta">
                        <span>Posted by ｛% if page.author %｝｛｛  page.author ｝｝｛% else %｝｛｛  site.title ｝｝｛% endif %｝ on ｛｛  page.date | date: "%B %-d, %Y" ｝｝</span>
                        <span>- ｛% include word_count.html %｝, ｛% include read_time.html %｝ to read</span>
                    </p>
                </div>
            </div>
        </div>
    </div>
</header>

最终使用

如果配置好nginx和Jekyll的话

cd 文件夹
git clone 仓库地址
git pull origin master
jekyll build -d /var/www/html/

现在我单独写了个脚本用于自动拉取编译以及发布：

#!/bin/bash

cd /var/www/html/
rm -rf /var/www/html/blog/
cd /root/icing.fun
git pull origin master
jekyll build -s /root/icing.fun -d /var/www/html/blog/

然后

chmod +x deploy.sh
rvm cron setup

crontab -e

# 编辑
* * * * * /bin/bash /root/push_blog.sh

每分钟就能拉取一次编译发布。

【新品开箱】Make Windows Great Again

2023-11-29T00:00:00+00:00

补记

电源计划卓越性能，启动！

powercfg -duplicatescheme e9a42b02-d5df-448d-aa00-03f14749eb61

显示成功。但在电源计划里依然没有显示卓越性能。

此时需要修改注册表的CSEnabled值，但CSEnabled不见了(之前有的)，所以应该在管理员模式下的 cmdlet 敲

reg add HKLM\System\CurrentControlSet\Control\Power /v PlatformAoAcOverride /t REG_DWORD /d 0

问了一下 Premier 事业部的同事，他们说目前据了解20H2取消了csenable更改来设置高性能，需要指令调用。

====================================

如何优雅地使用 Windows 作为开发环境。

如何使用 WSL 在 Windows 上优雅地安装 Linux

检视你电脑的版本

必须是运行 Windows 10 版本 2004 及更高版本（内部版本 19041 及更高版本）或 Windows 11 的电脑才能优雅。其他的版本可以参阅手动安装页，但是不优雅。

安装 WSL 优雅的命令

现在，可以使用单个命令安装运行 WSL 所需的一切内容。在管理员模式下打开 PowerShell 或 Windows 命令提示符，方法是右键单击并选择“以管理员身份运行”，输入 wsl --install 命令，然后重启计算机。

wsl --install

此命令将启用运行 WSL 并安装 Linux 的 Ubuntu 发行版所需的功能。（可以更改此默认发行版）。

如果你运行的是旧版，或只是不想使用 install 命令并希望获得分步指引，请参阅旧版 WSL 手动安装步骤。

首次启动新安装的 Linux 发行版时，将打开一个控制台窗口，要求你等待将文件解压缩并存储到计算机上。未来的所有启动时间应不到一秒。

上述命令仅在完全未安装 WSL 时才有效，如果运行 wsl –install 并查看 WSL 帮助文本，请尝试运行 wsl –list –online 以查看可用发行版列表并运行 wsl –install -d 以安装发行版。若要卸载 WSL，请参阅卸载旧版 WSL 或注销或卸载 Linux 发行版。

更改默认安装的 Linux 发行版

默认情况下，安装的 Linux 分发版为 Ubuntu。可以使用 -d 标志进行更改。

若要更改安装的发行版，请输入：wsl --install -d <Distribution Name>。将 <Distribution Name> 替换为要安装的发行版的名称。
若要查看可通过在线商店下载的可用 Linux 发行版列表，请输入：wsl --list --online 或 wsl -l -o。
若要在初始安装后安装其他 Linux 发行版，还可使用命令：wsl --install -d <Distribution Name>。

如果要通过 Linux/Bash 命令行（而不是通过 PowerShell 或命令提示符）安装其他发行版，必须在命令中使用 .exe：wsl.exe --install -d <Distribution Name> 或若要列出可用发行版，则使用：wsl.exe -l -o。

~~Ubuntu 不够你用是吧？~~

将版本从 WSL 1 升级到 WSL 2

使用 wsl --install 命令安装的新 Linux 安装将默认设置为 WSL 2。

wsl --set-version 命令可用于从 WSL 2 降级到 WSL 1，或将以前安装的 Linux 发行版从 WSL 1 更新到 WSL 2。

要查看 Linux 发行版是设置为 WSL 1 还是 WSL 2，请使用命令 wsl -l -v。

要更改版本，请使用 wsl --set-version <distro name> 2 命令将 <distro name> 替换为要更新的 Linux 发行版的名称。例如，wsl --set-version Ubuntu-20.04 2 会将 Ubuntu 20.04 发行版设置为使用 WSL 2。

如果在 wsl --install 命令可用之前手动安装了 WSL，则可能还需要启用 WSL 2 所使用的虚拟机可选组件并安装内核包（如果尚未这样做）。

WSL 子系统访问宿主机的 Proxy

在 WSL 里面新建一个 setProxy.sh , 然后把这个复制进去：

#!/bin/bash
hostip=$(cat /etc/resolv.conf | grep nameserver | awk '{ print $2 }')
wslip=$(hostname -I | awk '{print $1}')
port=7890

PROXY_HTTP="http://${hostip}:${port}"

set_proxy(){
    export http_proxy="${PROXY_HTTP}"
    export HTTP_PROXY="${PROXY_HTTP}"

    export https_proxy="${PROXY_HTTP}"
    export HTTPS_PROXY="${PROXY_HTTP}"

    git config --global http.proxy "${PROXY_HTTP}"
    git config --global https.proxy "${PROXY_HTTP}"

    # 设置APT代理
    echo "Acquire::http::Proxy \"${PROXY_HTTP}\";" | sudo tee /etc/apt/apt.conf.d/95proxies > /dev/null
    echo "Acquire::https::Proxy \"${PROXY_HTTP}\";" | sudo tee -a /etc/apt/apt.conf.d/95proxies > /dev/null
}

unset_proxy(){
    unset http_proxy
    unset HTTP_PROXY

    unset https_proxy
    unset HTTPS_PROXY

    git config --global --unset http.proxy
    git config --global --unset https.proxy

    # 移除APT代理设置
    sudo rm /etc/apt/apt.conf.d/95proxies
}

test_setting(){
    echo "Host ip:" ${hostip}
    echo "WSL ip:" ${wslip}
    echo "Current proxy:" $https_proxy
}

if [ "$1" = "set" ]
then
    set_proxy

elif [ "$1" = "unset" ]
then
    unset_proxy

elif [ "$1" = "test" ]
then
    test_setting
else
    echo "Unsupported arguments."
fi

理论上是所有系统都可以这样做

然后 chmod +x setProxy.sh , 最后要设置的时候就 source ./setProxy.sh set 就行了。

PowerShell 美化

Scoop包管理器：

Scoop 是 Windows 的命令行安装程序。使用 Scoop，可以为终端安装程序和插件。

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

scoop search - 搜索软件
scoop install - 安装软件
scoop info - 查看软件详细信息
scoop list - 查看已安装软件
scoop uninstall - 卸载软件，-p删除配置文件。
scoop update - 更新 scoop 本体和软件列表
scoop update - 更新指定软件
scoop update * - 更新所有已安装的软件
scoop checkup - 检查 scoop 的问题并给出解决问题的建议
scoop help - 查看命令列表
scoop help - 查看命令帮助说明*

gsudo（提权）

gsudo 是 sudo 在 Windows 的等价物，具有与原始 Unix/Linux sudo 相似的用户体验。允许在当前控制台窗口或新控制台窗口中以提升的权限运行命令，或提升当前 shell。

只需 gsudo 将（或sudo别名）添加到您的命令中，它就会以提升的方式运行。

###GSUDO
#安装：
scoop install gsudo

#导入配置文件内$PROFILE：
# 添加以下这行
Import-Module (Get-Command 'gsudoModule.psd1').Source
# 或者运行这行命令:
Get-Command gsudoModule.psd1 | % { Write-Output "`nImport-Module `"$($_.Source)`"" | Add-Content $PROFILE }

#在PowerShell中执行notepad $PROFILE，打开文件。
#在其中添加：
Set-alias 'su' 'gsudo'
Set-alias 'sudo' 'gsudo'

.$PROFILE使配置生效

# gsudo如果用户选择启用缓存，则可以提升多次，仅显示一个 UAC 弹出窗口。
# 凭据缓存
使用 手动启动/停止缓存会话gsudo cache {on | off}。
使用 停止所有缓存会话gsudo -k。
可用的缓存模式：
Disabled:每次提权都会显示一个 UAC 弹出窗口。
Explicit:（默认）每次提权都会显示一个 UAC 弹出窗口，除非缓存会话以gsudo cache on
Auto:类似于 unix-sudo。第一个提权显示 UAC 弹出窗口并自动启动缓存会话。
使用更改缓存模式gsudo config CacheMode Disabled|Explicit|Auto

Git 和 posh-git

###SCOOP安装GIT
scoop bucket add main
scoop install git
#验证GIT安装：
git --version

#模块安装posh-git
Install-Module posh-git -Scope AllUser -Force
#notepad $PROFILE打开配置档案,添加以下：
Import-Module posh-git
#配置完成后，运行.$PROFILE,使得修改生效

# 克隆任何 GitHub 存储库，以测试在输入常用 git 命令时 posh-git的反映：
git clone https://github.com/dahlbyk/posh-git
cd posh-git

PSReadline 语法定制

PSReadLine 是微软创建的一个模块，用于自定义 PowerShell 中的命令行编辑环境。它提供了大量的定制，可以改变命令行编辑器以多种方式呈现数据的方式。

# 安装
Install-Module PSReadLine
# 配置文件：
Import-Module PSReadLine

fzf

fzf 是一个用于命令行的模糊文件查找器。

这将为当前文件夹层次结构中的文件启用搜索机制，或者能够查看您之前使用的先前命令。

要使用 PSFzf，您必须先安装 fzf。

# 首先，需要通过SCOOP安装
scoop install fzf
# 第二步，安装模块：
Install-Module PSFzf
# 配置文件：
Import-Module PSFzf
Set-PsFzfOption -PSReadLineChordProvider ‘Ctrl+f’ -PSReadLineChordReverseHistory ‘Ctrl+r’
###
#Ctrl+f您可以在当前文件夹和子文件夹中搜索文件。
#您可以通过Ctrl+r列表查看使用过的命令的历史记录。

z

z 可让您根据cd命令历史记录在 PowerShell 中快速浏览文件系统。

z 也是经常使用的模块之一，它有助于快速导航到常用目录，

Install-Module -Name z

Neovim

scoop install neovim

Powershell 升级

iex "& { $(irm https://aka.ms/install-powershell.ps1) } -UseMSI"

Git 一键推送

新建一个 git_push.ps1：

# PowerShell Script to Perform Git Operations with User-Inputted Path

# Prompt for the path to the Git repository
$repoPath = Read-Host -Prompt "Enter the path to your git repository"

# Change to the specified directory
cd $repoPath

# Update git
git pull

# Add all changes to staging
git add --all

# Prompt for a commit message
$commitMessage = Read-Host -Prompt "Enter your commit message"

# Commit the changes
git commit -m "$commitMessage"

# Push the changes to the remote repository
git push

# Back to the origin folder
cd ..

倒叙之前因后果

11月月初俺爹斥巨资给我换了个笔记本电脑

可能有人要“素质三连”了

Surface Pro 9 不是有酷睿版吗？SQ3 版不是很垃圾吗？有这个钱为什么不买苹果？

首先就是全功能 Type-C 接口，两个接口可以提供视频，音频，数据传输，更重要的是可以充电。这不比原装的那个方便？带个小米67W就可以搞定手机和电脑的充电了。酷睿版就八行，只能拿那个笨笨的充电器充电。

5G 网络说实在真的很香，之前在学校办的移动的号，大流量卡，装这个上面，基本上是全天在线，很舒服。

之前去上海面试的时候，在高铁上就可以用电脑来办公，还能追追剧。

随身WiFi稍微麻烦了点，比如我现在也在用华为的。

再来就是这个屏幕了，这个屏幕香不香我不知道，主要是能触屏，MacBook那么多年也不能触屏。（估计有人就要骂我，说苹果触控板好用，我只能说，我不喜欢，我喜欢触屏）

说它是个大号平板也不为过，我现在就是拿着它在写这篇文章，很舒服。安卓平板根本打不过，如果说我要用安卓应用，Windows还有安卓子系统。

8cx Gen 3 跑分啥的对我来说确实不重要，抛开实际体验的跑分都是耍流氓。

实际体验下来没啥用不了的应用，转译慢就慢我还能摸摸鱼。Python脚本可以跑，我用的是 Anaconda 的环境，没啥问题。IDE用的 VSCode，有原生 ARM64 版本，也没啥问题。VS也能用，还能编译x64/x86的程序，也没啥问题。

【阅板无数】LinkIt Smart 7688/Duo 考古

2023-11-28T00:00:00+00:00

【阅板无数】LinkIt™ Smart 7688/Duo 使用手册

MT7688 是一个由联发科技（MediaTek）开发的高性能无线SoC（System on Chip）。它主要用于驱动智能家居和物联网（IoT）设备。MT7688 芯片支持 802.11n Wi-Fi 标准，能够提供高速的无线连接。此外，它通常包括多种接口和功能，比如 USB、GPIO、以太网接口，以及内存和存储接口，这使得它能够灵活地应用于各种设备和应用场景中。

参考网站

讲真，Seeed 做的东西都是好东西，但是就是不好好维护

编译 OpenWRT

截至博客发布日期，我按照网上的教程编译来编译去都用不了，服了

最后通过 Internet Archive 找到了原始镜像和硬件电路图

IcingTomato/embedded_linux_dev - GitHub

# MD5 Check
51107d057bda7ac71baeac3277e6e3d1  Hardware_Schematics.zip
4e40f19c968e45aaa2cc9d36c3095f03  LinkIt_Smart_7688_Firmware_upgrade.zip
2438f95e0466a454d491c8029e509d6e  Manual.zip
1fb86b892294d3082d8a05d450108c76  MediaTek_LinkIt_Smart_7688_bootloader_v0.8.2.zip
40717f554a8f455df62b238274db1fe4  MediaTek_LinkIt_Smart_7688_firmware_v0.9.2.zip
9e8a7237d8f0c55add7e685a12cf7d12  swapsd.sh

其中 swapsd.sh 用于将系统从内置闪存切换到外置 SD 卡，并添加 swap 分区

【嵌入式实践】Amazon Alexa on M5Core2

2022-08-15T00:00:00+00:00

如何用 ESP32 制作一个语音助手

Amazon Alexa for M5Stack M5Core2(ESP32)

0. Briefing of Alexa

Amazon Alexa, also known simply as Alexa, is a virtual assistant technology largely based on a Polish speech synthesiser named Ivona, bought by Amazon in 2013. It was first used in the Amazon Echo smart speaker and the Echo Dot, Echo Studio and Amazon Tap speakers developed by Amazon Lab126. It is capable of voice interaction, music playback, making to-do lists, setting alarms, streaming podcasts, playing audiobooks, and providing weather, traffic, sports, and other real-time information, such as news. Alexa can also control several smart devices using itself as a home automation system. Users are able to extend the Alexa capabilities by installing “skills” (additional functionality developed by third-party vendors, in other settings more commonly called apps) such as weather programs and audio features. It uses automatic speech recognition, natural language processing, and other forms of weak AI to perform these tasks.

Most devices with Alexa allow users to activate the device using a wake-word (such as Alexa or Amazon); other devices (such as the Amazon mobile app on iOS or Android and Amazon Dash Wand) require the user to click a button to activate Alexa’s listening mode, although, some phones also allow a user to say a command, such as “Alexa” or “Alexa wake”.

1. Introduction

Source Code is here

Amazon Alexa on M5Core2 and M5Core2 for AWS

You can use M5Core2Alexa like using a real Amazon Echo (sometimes, not always). You can ask M5Alexa questions like “Alexa, what time is sunrise?” or ask her into Japanese 「アレクサ、今何時ですか？」, or maybe you can control your lights and fans (I don’t have any Alexa-supported IoT devices).

2. Development Setup

This sections talks about setting up your development host, fetching the git repositories, and instructions for build and flash.

2.1 Host Setup

You should install drivers and support packages for your development host. Windows, Linux and Mac OS-X, are supported development hosts. Please see Get Started for the host setup instructions.

2.2 Getting the Repositories

git clone --recursive https://github.com/espressif/esp-idf.git

cd esp-idf; git checkout release/v4.2; git submodule init; git submodule update --init --recursive;

./install.sh

cd ..

git clone https://github.com/IcingTomato/AlexaM5Core2.git

2.3 Building the Firmware

cd AlexaM5Core2/examples/amazon_alexa/ 

export ESPPORT=/dev/ttyUSB0 (or /dev/ttycu.SLAB_USBtoUART macOS or COMxx on MinGW)

export IDF_PATH=/path/to/esp-idf

. $IDF_PATH/export.sh

Set audio_board path for M5Core2 and AWS_EDUKIT_PATH:

export AUDIO_BOARD_PATH=/path/to/AlexaM5Core2/components/audio_hal/audio_board/audio_board_m5_core2_aws
export AWS_EDUKIT_PATH=/path/to/AlexaM5Core2/components/core2forAWS

Menuconfig is avaliable, also you can change some components:

idf.py menuconfig

3. Configuration Steps

Here are the steps to configure the M5Core2:

On first boot-up, the M5Core2 is in configuration mode. This is indicated by Orange LED pattern. Please ensure that the LED pattern is seen as described above, before you proceed.
Launch the phone app.
Select the option Add New Device.

A list of devices that are in configuration mode is displayed. Note that the devices are discoverable over BLE (Bluetooth Low Energy). Please ensure that the phone app has the appropriate permissions to access Bluetooth (on Android the Location permission is also required for enabling Bluetooth).

Now you can sign-in to your Amazon Alexa account. If you have Amazon Shopping app installed on the same phone, app will automatically sign-in with the account the shopping app is signed in to. Otherwise it will open a login page on the phone’s default browser. (It is recommended to install the Amazon Shopping app on your phone to avoid any other browser related errors.)

You can now select the Wi-Fi network that the M5Core2 should connect with, and enter the credentials for this Wi-Fi network.

On successful Wi-Fi connection, you will see a list of few of the voice queries that you can try with the M5Core2.

You are now fully setup. You can now say “Alexa” followed by the query you wish to ask.

4. Troubleshooting

4.1 Music and radio playback (Audible or Podcast) are not supported on this device.

According to Espressif Official, music and radio playback (Audible or Podcast) services are not supported on Non-Amazon-Official products. Unfortunately, Amazon music functionality needs whitelisted product. Only the commercial products are whitelisted by Amazon. Let us know if you are going to commercialise it.

4.2 `Alarm Dismiss` doesn’t take effect.

When the alarm on, you cannot say “Alexa, stop alarm” to dismiss the alarm. I dno’t know why… So, if you want to stop the alarm, you can touch the middle “button” on M5Core2. The middle “button” can also wake up Alexa.

【运维实践】什么是LVM？

2021-08-30T00:00:00+00:00

深入浅出讲述 Linux 上的 LVM (Logical Volume Manager 逻辑卷管理)

想象一个情况，我在网上买了个新电脑，自带 Windows 10 操作系统。512GiB 的硬盘我不想分区直接用，过了三个月：

它快满了，我就添置一块硬盘当仓库盘。但是有些文件太大我还要花时间移动到新的仓库盘上……

虽然现在传输速度很快，但是还要花时间查找能移动和不能移动的文件确实麻烦。所以现在隆重介绍 LVM 逻辑卷管理。

逻辑卷管理的重点在于 可以弹性调整 FlieSystem 的容量 而不是 注重文件传输效率和数据安全 上面。追求读写效率或者数据保护的可以使用 RAID 。

LVM 可以整合成多个物理硬盘在一起，让这些分区看起来像在一块大硬盘上。而且在将来还可以新增或者移除物理硬盘到 LVM 中。

什么是 LVM : PV, PE, VG, LV 的含义

LVM 全名 Logical Volume Manager ，大陆中文译作逻辑卷管理。台湾中文翻译成邏輯捲軸管理員。在这里我觉得用『捲軸』来解释更方便，引用一下鸟哥的解释：

之所以稱為『捲軸』可能是因為可以將 filesystem 像捲軸一樣伸長或縮短之故吧！

LVM 的做法是将几个实体的 Partitions分区 (或者 Disks硬盘) 通过软件转换成 LVM 最底层的 “块” (PV) ，然后将这些 “块” 组合成一块庞大的 “硬盘” (VG)，接着将这块巨大的 “硬盘” 分割成一个个可以格式化的 “小硬盘” (LV)，最终就能挂载使用了。但是为什么这样可以对 FileSystem 进行扩容和缩小呢？其实和一个叫 PE 的东西有关。

Physical Volume, PV, 物理卷

物理卷的理解其实很简单，可以近似看作是我们买来的实体的硬盘。但实际上物理卷(PV) 需要调整 硬盘(Disks)/分区(Partitions) 的 系统识别码(systemID) 为 8e( LVM 的识别码)，然后再经过 pvcreate 的指令将它转换成 LVM 最底层的 物理卷(PV) ，之后才能将这些 PV 加以使用。调整 systemID 的方法有三种：gdisk, fdisk 和 parted。

注：gdisk是仅为GPT分区使用，fdisk是仅为MBR分区使用，如果用错的的话主引导记录会被清空，切记切记

Volume Group, VG, 卷组

顾名思义卷组就是很多个物理卷的凑成的一个组。就好比小学的时候会分小组，小组里面的每个同学就是物理卷，几个同学组成的一个组就是卷组。同理 VG 就是 LVM 将许多个 PV 整合成的东西。那么 VG 最大可以达到多少呢？这个和 PE物理块和 LVM 的版本有关。在以前，32位的 Linux 操作系统上的 LVM(lvm1) 一个 LV 最大只能支持65534个 PE，假设使用 Linux 的默认设置(一个 PE 大小为4MiB)，那么一个 LV 的最大容量也就只有 4M*65534/(1024M/G)=256GiB。不过在64位的操作系统上 LV 几乎不存在大小限制。(主要还是和寻址有关系)

Physical Extent, PE, 物理块

LVM 预设的 PE 大小是 4MiB。它是整个 LVM 的最小存储区块，换句话说就是我们写入的每个文件都是往 PE 里面填充的。简单来说 PE 很像在机械硬盘上划分的磁道。所以调整 PE 大小会影响到 LVM 的最大容量的。但是在 CentOS/Red Hat 6 之后的操作系统普遍采用 lvm2 技术，以及64位 CPU 的出现，因此这个限制不复存在。

Logical Volume, LV, 逻辑卷

最终一大块 VG 会像切蛋糕一样分成一个个 LV ，这些被切出来的 LV 就是能吃的格式化使用的东西了。

那么问题来了：LV 可以随意划分大小吗？答案是不可以。因为 PE 是 LVM 中最小的存储单位，所以 LV 的大小和 PV 的块数相关。在 Linux 系统中，为了方便我们使用 LVM 管理磁盘，LV 通常被命名为 /dev/vg_name/lv_name 的样子。

此外，前文中提及到 LVM 可以弹性变更 FileSystem 的容量，实际上是通过 “交换PE” 来进行扩容和缩小的操作，将原本逻辑卷LV中的物理块PE移出以缩小容量，将空闲的物理块PE移入现有逻辑卷LV以扩容。如下图：

VG 内的 PE 会分给虚线部分的 LV ，如果未来这个 VG 要扩充的话，加上其他的 PV 即可。最重要的是如果 LV 要扩充的话，也可以通过加入 VG 内没有使用到的 PE 来扩充的。

Logical Extent, LE, 逻辑块

逻辑卷LV中可以分配的最小存储单元，在同一卷组VG中LE的大小和PE是相同的，并且一一相对。

LVM 工具

fdisk, gdisk 和 parted

fdisk

[student@node2 ~]## fdisk /dev/sda
欢迎使用 fdisk (util-linux 2.23.2)。

更改将停留在内存中，直到您决定将更改写入磁盘。
使用写入命令前请三思。

命令(输入 m 获取帮助)：          <==这里可以输入指令，可以按 m 来查看所有指令
命令(输入 m 获取帮助)：m
命令操作
   a   toggle a bootable flag
   b   edit bsd disklabel
   c   toggle the dos compatibility flag
   d   delete a partition                           #删除一个分区
   g   create a new empty GPT partition table
   G   create an IRIX (SGI) partition table
   l   list known partition types
   m   print this menu
   n   add a new partition                          #增加一个新分区
   o   create a new empty DOS partition table
   p   print the partition table                    #打印分区表
   q   quit without saving changes                  #不储存直接离开
   s   create a new empty Sun disklabel
   t   change a partition's system id
   u   change display/entry units
   v   verify the partition table
   w   write table to disk and exit                 #写入分区表并离开
   x   extra functionality (experts only)

命令(输入 m 获取帮助)：

gdisk

[student@node2 ~]# gdisk /dev/vda  <==仔細看，不要加上數字喔！
GPT fdisk (gdisk) version 0.8.6

Partition table scan:
  MBR: protective
  BSD: not present
  APM: not present
  GPT: present

Found valid GPT with protective MBR; using GPT.  <==找到了 GPT 的分割表！

Command (? for help):           <==这里可以输入指令，可以按 ? 来查看所有指令
Command (? for help): ?
b       back up GPT data to a file
c       change a partition's name
d       delete a partition                            #删除一个分区
i       show detailed information on a partition
l       list known partition types
n       add a new partition                           #增加一个新分区
o       create a new empty GUID partition table (GPT)
p       print the partition table                     #打印分区表 
q       quit without saving changes                   #不储存直接离开
r       recovery and transformation options (experts only)
s       sort partitions
t       change a partition's type code
v       verify disk
w       write table to disk and exit                  #写入分区表并离开
x       extra functionality (experts only)
?       print this menu
Command (? for help):  

parted

[student@node2 ~]# parted /dev/sda
GNU Parted 3.1
使用 /dev/sda
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) help                                                             
  align-check TYPE N                        check partition N for TYPE(min|opt) alignment
  help [COMMAND]                           print general help, or help on COMMAND
  mklabel,mktable LABEL-TYPE               create a new disklabel (partition table)
  mkpart PART-TYPE [FS-TYPE] START END     make a partition
  name NUMBER NAME                         name partition NUMBER as NAME
  print [devices|free|list,all|NUMBER]     display the partition table, available devices, free space, all found partitions, or a particular partition
  quit                                     exit program
  rescue START END                         rescue a lost partition near START and END
  
  resizepart NUMBER END                    resize partition NUMBER
  rm NUMBER                                delete partition NUMBER
  select DEVICE                            choose the device to edit
  disk_set FLAG STATE                      change the FLAG on selected device
  disk_toggle [FLAG]                       toggle the state of FLAG on selected device
  set NUMBER FLAG STATE                    change the FLAG on partition NUMBER
  toggle [NUMBER [FLAG]]                   toggle the state of FLAG on partition NUMBER
  unit UNIT                                set the default unit to UNIT
  version                                  display the version number and copyright information of GNU Parted
(parted)  

PV 阶段

pvcreate ：将实体partition 建立成为 PV ；
pvscan ：搜寻目前系统里面任何具有 PV 的磁盘；
pvdisplay ：显示出目前系统上面的 PV 状态；
pvremove ：将 PV 属性移除，让该partition 不具有PV 属性。

VG 阶段

vgcreate ：就是主要建立 VG 的指令；
vgscan ：搜寻系统上面是否有 VG 存在；
vgdisplay ：显示目前系统上面的 VG 状态；
vgextend ：在 VG 内增加额外的 PV ；
vgreduce ：在 VG 内移除 PV ；
vgchange ：设定 VG 是否启动(active)；
vgremove ：删除一个 VG 。

LV 阶段

lvcreate ：建立 LV ；
lvscan ：查询系统上面的 LV ；
lvdisplay ：显示系统上面的 LV 状态；
lvextend ：在 LV 里面增加容量；
lvreduce ：在 LV 里面减少容量；
lvremove ：删除一个 LV ；
lvresize ：对 LV 进行容量大小的调整。

LVM 实操流程

在这里我们就用 RHel 8 RH134 的题目来演练一下如何调整逻辑卷大小以及创建逻辑卷。

十六、调整逻辑卷大小
1）预先创建 2GiB 的分区/dev/vdb1，并用于创建卷组 testvg
2）创建大小为 200MiB 的逻辑卷/dev/testvg/vo，格式化为 xfs 文件系统，并挂载在/mnt/vo 上
3）将逻辑卷/dev/testvg/vo 及其文件系统大小调整到 300MiB，确保文件系统内容保持不变。


[student@node2 ~]# fdisk /dev/vdb
Welcome to fdisk (util-linux 2.32.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Device does not contain a recognized partition table.
Created a new DOS disklabel with disk identifier 0xae75bf0a.
Command (m for help): n
Partition type
p primary (0 primary, 0 extended, 4 free)
e extended (container for logical partitions)
Select (default p):
Using default response p.
Partition number (1-4, default 1):
First sector (2048-10485759, default 2048):
Last sector, +sectors or +size{K,M,G,T,P} (2048-10485759,default 10485759): +2G
Created a new partition 1 of type 'Linux' and of size 2 GiB.
Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.
[student@node2 ~]# pvcreate /dev/vdb1
[student@node2 ~]# vgcreate testvg /dev/vdb1
[student@node2 ~]# lvcreate -L 200M -n vo testvg
[student@node2 ~]# mkfs.xfs /dev/testvg/vo
[student@node2 ~]# mkdir /mnt/vo
[student@node2 ~]# vim /etc/fstab
/dev/testvg/vo /mnt/vo xfs defaults 0 0
[student@node2 ~]# mount -a
[student@node2 ~]# df -hT /dev/testvg/vo # 查看文件系统的类型
和大小
Filesystem Type Size Used Avail Use% Mounted on
/dev/mapper/testvg-vo xfs 195M 12M 183M 6% /mnt/vo
[student@node2 ~]# lvextend -L 300M /dev/testvg/vo
[student@node2 ~]# lvs
LV VG Attr LSize Pool Origin Data% Meta% Move Log Cpy%Sync
Convert
vo testvg -wi-ao---- 300.00m
# 扩展文件系统，ext 类型的文件系统用 resize2fs /dev/testvg/vo，后面接的是逻辑卷的路径。
[student@node2 ~]# xfs_growfs /mnt/vo # 后面接的是挂载点的路径
[student@node2 ~]# df -hT /dev/testvg/vo
Filesystem Type Size Used Avail Use% Mounted on
/dev/mapper/testvg-vo xfs 295M 13M 283M 5% /mnt/vo

十八、创建逻辑卷
根据以下要求，创建新的逻辑卷：
1）逻辑卷的名字为 mylv，属于 myvg 卷组，大小为 50 个 pe
2）卷组 myvg 中的逻辑卷的 pe 大小应当为 16MiB
3）使用 vfat 文件系统将逻辑卷 mylv 格式化
4）此逻辑卷应当在系统启动时自动挂载到/mnt/mydata 目录下

[student@node2 ~]# fdisk /dev/vdb
Welcome to fdisk (util-linux 2.32.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Command (m for help): n
Partition type
p primary (2 primary, 0 extended, 2 free)
e extended (container for logical partitions)
Select (default p):
Using default response p.
Partition number (3,4, default 3):
First sector (5244928-10485759, default 5244928):
Last sector, +sectors or +size{K,M,G,T,P} (5244928-10485759,default 10485759):
+1G
Created a new partition 3 of type 'Linux' and of size 1 GiB.
Command (m for help): w
The partition table has been altered.
Syncing disks.
[student@node2 ~]# pvcreate /dev/vdb3
[student@node2 ~]# vgcreate -s 16M myvg /dev/vdb3
[student@node2 ~]# lvcreate -l 50 -n mylv myvg
[student@node2 ~]# mkfs.vfat /dev/myvg/mylv
[student@node2 ~]# mkdir /mnt/mydata
[student@node2 ~]# vim /etc/fstab
/dev/myvg/mylv /mnt/mydata vfat defaults 0 0
[student@node2 ~]# mount -a
[student@node2 ~]# df -h /mnt/mydata/
Filesystem Size Used Avail Use% Mounted on
/dev/myvg/mylv 799M 4.0K 799M 1% /mnt/mydata

【运维实践】HTTP状态码

2021-04-16T00:00:00+00:00

当浏览者访问一个网页时，浏览者的浏览器会向网页所在服务器发出请求。当浏览器接收并显示网页前，此网页所在的服务器会返回一个包含HTTP状态码的信息头（server header）用以响应浏览器的请求。

HTTP状态码的英文为HTTP Status Code。

下面是常见的HTTP状态码：

200 - 请求成功
301 - 资源（网页等）被永久转移到其它URL
404 - 请求的资源（网页等）不存在
500 - 内部服务器错误

HTTP状态码分类

HTTP状态码由三个十进制数字组成，第一个十进制数字定义了状态码的类型，后两个数字没有分类的作用。HTTP状态码共分为5种类型：

HTTP状态码分类
分类	分类描述
1**	信息，服务器收到请求，需要请求者继续执行操作
2**	成功，操作被成功接收并处理
3**	重定向，需要进一步的操作以完成请求
4**	客户端错误，请求包含语法错误或无法完成请求
5**	服务器错误，服务器在处理请求的过程中发生了错误

HTTP状态码列表:

HTTP状态码列表
状态码	状态码英文名称	中文描述
100	Continue	继续。客户端应继续其请求
101	Switching Protocols	切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议，例如，切换到HTTP的新版本协议

200	OK	请求成功。一般用于GET与POST请求
201	Created	已创建。成功请求并创建了新的资源
202	Accepted	已接受。已经接受请求，但未处理完成
203	Non-Authoritative Information	非授权信息。请求成功。但返回的meta信息不在原始的服务器，而是一个副本
204	No Content	无内容。服务器成功处理，但未返回内容。在未更新网页的情况下，可确保浏览器继续显示当前文档
205	Reset Content	重置内容。服务器处理成功，用户终端（例如：浏览器）应重置文档视图。可通过此返回码清除浏览器的表单域
206	Partial Content	部分内容。服务器成功处理了部分GET请求

300	Multiple Choices	多种选择。请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择
301	Moved Permanently	永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替
302	Found	临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI
303	See Other	查看其它地址。与301类似。使用GET和POST请求查看
304	Not Modified	未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源
305	Use Proxy	使用代理。所请求的资源必须通过代理访问
306	Unused	已经被废弃的HTTP状态码
307	Temporary Redirect	临时重定向。与302类似。使用GET请求重定向

400	Bad Request	客户端请求的语法错误，服务器无法理解
401	Unauthorized	请求要求用户的身份认证
402	Payment Required	保留，将来使用
403	Forbidden	服务器理解请求客户端的请求，但是拒绝执行此请求
404	Not Found	服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
405	Method Not Allowed	客户端请求中的方法被禁止
406	Not Acceptable	服务器无法根据客户端请求的内容特性完成请求
407	Proxy Authentication Required	请求要求代理的身份认证，与401类似，但请求者应当使用代理进行授权
408	Request Time-out	服务器等待客户端发送的请求时间过长，超时
409	Conflict	服务器完成客户端的 PUT 请求时可能返回此代码，服务器处理请求时发生了冲突
410	Gone	客户端请求的资源已经不存在。410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置
411	Length Required	服务器无法处理客户端发送的不带Content-Length的请求信息
412	Precondition Failed	客户端请求信息的先决条件错误
413	Request Entity Too Large	由于请求的实体过大，服务器无法处理，因此拒绝请求。为防止客户端的连续请求，服务器可能会关闭连接。如果只是服务器暂时无法处理，则会包含一个Retry-After的响应信息
414	Request-URI Too Large	请求的URI过长（URI通常为网址），服务器无法处理
415	Unsupported Media Type	服务器无法处理请求附带的媒体格式
416	Requested range not satisfiable	客户端请求的范围无效
417	Expectation Failed	服务器无法满足Expect的请求头信息

500	Internal Server Error	服务器内部错误，无法完成请求
501	Not Implemented	服务器不支持请求的功能，无法完成请求
502	Bad Gateway	作为网关或者代理工作的服务器尝试执行请求时，从远程服务器接收到了一个无效的响应
503	Service Unavailable	由于超载或系统维护，服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中
504	Gateway Time-out	充当网关或代理的服务器，未及时从远端服务器获取请求
505	HTTP Version not supported	服务器不支持请求的HTTP协议的版本，无法完成处理

【Blog Build】Plan of Jekyll Blog - Episode 2: Ruby-3, Jekyll-4, Git, Ubuntu and Nginx

2021-02-19T00:00:00+00:00

This tutorial you will learn how to configure Jekyll-4 on Ubuntu 16.04/18.04.

Catalogue

Jekyll-4 Installation Ubuntu 16.04
Nginx Setup
GitHub Local Repository Setup
Git roll back to some commit
Jekyll Maintaining Tutorial
Jekyll Code Block for Liquid-Like
Finally…
My Second Jekyll Blog
Git Dual Repository Setup

Here is the blog repository: blog.old/blog.old3

Jekyll-4 Installation Ubuntu 16.04

First, we should install Ruby3.0.0 for Ubuntu 16.04/18.04:

sudo apt-get install ruby-full build-essential zlib1g-dev nginx
sudo apt-get install gcc g++ make
curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt-get update && sudo apt-get install yarn
sudo apt install curl
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list

sudo apt-get update
sudo apt-get install git-core zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev software-properties-common libffi-dev nodejs yarn

Then, we can use one of these methods to install Ruby-3:

Install rbenv

cd ~
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL

git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc
exec $SHELL

rbenv install 3.0.0
rbenv global 3.0.0
ruby -v

Install RVM

sudo apt-get install libgdbm-dev libncurses5-dev automake libtool bison libffi-dev
gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
curl -sSL https://get.rvm.io | bash -s stable
source ~/.rvm/scripts/rvm
rvm install 3.0.0
rvm use 3.0.0 --default
ruby -v

Ruby Source Codes Installation

cd
wget http://ftp.ruby-lang.org/pub/ruby/3.0/ruby-3.0.0.tar.gz
tar -xzvf ruby-3.0.0.tar.gz
cd ruby-3.0.0/
./configure
make
sudo make install
ruby -v

Caution: In some area, it’s difficult to visit RubyGems, so you might be change a Ruby Source.

gem source -r https://rubygems.org/
gem source --add https://gems.ruby-china.com/
gem source -u

Finally, install Bundler

gem install bundler jekyll github-pages jekyll-paginate webrick

After installation, you can clone your repository from GitHub or GitLab.

git clone https://github.com/IcingTomato/blog.old.git

Nginx Setup

Well, you can also use Apache which use sudo apt-get install apache2 on Debian/Ubuntu or sudo yum install httpd on CentOS/RHEL/Fedora.

First, install Nginx:

sudo apt-get isntall nginx

Then, configure nginx profile:

root@blog:~# sudo nano /etc/nginx/sites-enabled/default

server {
        listen 80 default_server;
        listen [::]:80 default_server;

        # SSL configuration
        #
        listen 443 ssl default_server;
        listen [::]:443 ssl default_server;

        # Disable SSL, because when it enabled, it blocked 80.
        #ssl on;
        ssl_certificate path/to/your_key.pem;
        ssl_certificate_key path/to/your_key.key;
        ssl_session_timeout 5m;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;

        root /var/www/html;

        # Add index.php to the list if you are using PHP
        index index.html;

        server_name your.domain;

        location / {
                # First attempt to serve request as file, then
                # as directory, then fall back to displaying a 404.
                try_files $uri $uri/ =404;
        }


        # Rewrited the 404 page to 200
        error_page 404 =200 /404.html;

        location /404.html {
                root /var/www/html/;
                internal;
        }        

        # Rewrited the 403 page to 200
        error_page 403 =200 /403.html;

        location /403.html {
                root /var/www/html/;
                internal;
        }
}

Ctrl+O and Ctrl+X to save and exit.

Finally, restart nginx.service

sudo systemctl restart nginx

# On AWS, you must use systemctl to start, stop, enable, disable, restart a service.

GitHub Local Repository Setup

git init
git add README.md
git commit -m "first commit"
git branch -M master
git remote add origin repo_address
git push -u origin master

Git roll back to some commit

git reset --hard 某个commit id
git push -f -u origin master

Jekyll Maintaining Tutorial

You can make a quick start for surfing the Jekyll blog:

git clone -b blank https://github.com/IcingTomato/blog.old.git
cd blog.old
jekyll serve # jekyll s
# => Now browse to http://localhost:4000

Setup `_config.yml`

# Site settings
title: Your Blog                        # Your blog title
SEOTitle: Jekyll | Ruby                 # SEO title
description: "Hello from Seattle"	    # Your blog description

# SNS settings      
github_username: John Doe               # GitHub account
RSS: true                               # RSS On
weibo_username:                         # Weibo  
zhihu_username:                         # Zhihu
facebook_username:                      # Facebook
bilibili_username:                      # Bilibili  
twitter_username:                       # Twitter

# Build settings
paginate: 100                          # Contents in a page

You can visit Jekyll-Docs/Jekyll中文网-文档 for more support.

On PCs, tablet devices or ultra-wide scale screen there is a sidebar to display your personal profile.

# Sidebar settings
sidebar: true                                           # Add Sidebar
sidebar-about-description: "describe yourself"          # Description
sidebar-avatar: /img/avatar.jpg                         # Your Avatar

Sidebar is a Responsive Layout*, when the display size is below 992px, the sidebar will move to the page bottom. You can visit Bootstrap3 for global CSS settings/Bootstrap 设置全局 CSS 样式

Mini About Me

This module is under your avatar. It will display all your social media account. It is also a Responsive Layout. When the screen size become small, it will move to the bottom of the page. But there is a litte change when it move to the bottom.

Featured Tags

# Featured Tags
featured-tags: true  
featured-condition-size: 15     
# A tag will be featured if the size of it is more than this condition value

featured-condition-size means if the tags’ count over 15(or the number you set), it will display on home page.

Friends

# Friends
friends: [
    {
        title: "John Doe",
        href: "http://john.doe/"
    },{
        title: "村財　師内",
        href: "https://sonzai.shinai/"
    },{
        title: "鵜祖田　陽",
        href: "https://usoda.you/"
    }
]

Comment

This Jekyll Blog supports both Disqus and Gitalk, it also supports Markdown Grammar.

Disqus

# Disqus（https://disqus.com/）
disqus_username:

Gitalk

First, we should create a new repository for saving our comments:

And then open Issues option:

Besides, register a new OAuth application:

Google Analytics

# Google Analytics
ga_track_id: 'UA-'
ga_domain:         # Default as 'auto', you can use your domain

Write your first blog

We must put the article, which named as YYYY-MM-DD-your_first_article.markdown, in _post folder. And you can change parameter in the front of the article:

---
layout:     post
title:      Your First Blog 
subtitle:   Jekyll is Хорошо
date:       1900-01-01
author:     John Doe
header-img: img/title.jpg
catalog: true
tags:
    - Jekyll
---

Jekyll Code Block for Liquid-Like

In Jekyll, some Ruby code block can’t generate perfectly.

So, we can use raw tag to avoid execute liquid or liquid-like code block:

{% raw %}

You can use {% highlight ruby %}{% endhighlight %} for code highlight.

Finally…

cd your.folder
git clone repo.address
git pull origin master
jekyll build -d /var/www/html/

My Second Jekyll Blog

Here is the blog repository: blog.old2

You can use these command line for configuring the blog:

cd <the folder>
git clone https://github.com/IcingTomato/blog.old2.git
bundle add webrick rake
bundle install --path vendor/cache
git pull origin master
bundle exec jekyll build -d /var/www/html/

First, you need to install some Dependence like webrick rake jekyll.

And then, in my case, I had a PATH problem.

Bundler::GemNotFound: Could not find rake-10.3.2 in any of the sources
~/.rvm/gems/ruby-2.0.0-p451/gems/bundler-1.6.2/lib/bundler/spec_set.rb:92:in `block in materialize'
~/.rvm/gems/ruby-2.0.0-p451/gems/bundler-1.6.2/lib/bundler/spec_set.rb:85:in `map!'
~/.rvm/gems/ruby-2.0.0-p451/gems/bundler-1.6.2/lib/bundler/spec_set.rb:85:in `materialize'
~/.rvm/gems/ruby-2.0.0-p451/gems/bundler-1.6.2/lib/bundler/definition.rb:133:in `specs'
~/.rvm/gems/ruby-2.0.0-p451/gems/bundler-1.6.2/lib/bundler/definition.rb:178:in `specs_for'
Show 28 more lines

I used gem install rake but it was no use fixing the matter.

SO, bundle install --path vendor/cache can help you fix the problem.

This command line generally fixes it as that is the more common problem. Basically, my bundler path configuration is messed up. See their documentation (first paragraph) for where to find those configurations and change them manually if needed.

Git Dual Repository Setup

Everytime I finish my blog, I have to push to two different platform: GitHub and Gitee.

Gitee is a collaboration platform for software development & code hosting in China Mainland.

Because I use Ali ECS Area Hangzhou, it’s hard to visit GitHub, so I have to use Gitee.

cd 'your-repository-path'
git remote add gitee 'your-gitee-repository-address'
git push gitee master    # Push to 'gitee'
git push origin master   # Push to 'github' 

You can also change your-repository/.git/config

[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
[remote "origin"]
	url = 'your-github-repository-address'
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
	remote = origin
	merge = refs/heads/master
[remote "gitee"]
	url = 'your-gitee-repository-address'
	fetch = +refs/heads/*:refs/remotes/gitee/*

【运维实践】网络基础知识

2021-01-30T00:00:00+00:00

The foundations of networking: switches, routers, and wireless access points. Switches, routers, and wireless access points are the essential networking basics. Through them, devices connected to your network can communicate with one another and with other networks, like the Internet.

传输介质简介

可以让设备通过网卡连接互联网的介质，如同轴电缆、双绞线和光纤等。不同的传输介质具有不同的特性，这些特性直接影响到通信的诸多方面，如线路编码方式、传输速度和传输距离等。

常见的网络传输介质

同轴电缆（Coaxial Cable）

同轴电缆是一种早期使用的传输介质，同轴电缆的标准分为两种，10BASE2和10BASE5。这两种标准都支持10Mbps的传输速率，最长传输距离分别为185米和500米。一般情况下，10Base2同轴电缆使用BNC接头，10Base5同轴电缆使用N型接头。

10BASE5和10BASE2是早期的两种以太网标准，它们均采用同轴电缆作为传输介质。10BASE5和10BASE2所使用的同轴电缆的直径分别为9.5mm和5mm，所以前者又称为粗缆，后者又称为细缆。

现在，10Mbps的传输速率早已不能满足目前企业网络需求，因此同轴电缆在目前企业网络中很少应用。

双绞线（Twisted Pair）

与同轴电缆相比双绞线（Twisted Pair）具有更低的制造和部署成本，因此在企业网络中被广泛应用。双绞线可分为屏蔽双绞线(Shielded Twisted Pair，STP)和非屏蔽双绞线(Unshielded Twisted Pair，UTP)。屏蔽双绞线在双绞线与外层绝缘封套之间有一个金属屏蔽层，可以屏蔽电磁干扰。双绞线有很多种类型，不同类型的双绞线所支持的传输速率一般也不相同。例如，3类双绞线支持10Mbps传输速率；5类双绞线支持100Mbps传输速率；超5类双绞线及更高级别的双绞线支持千兆以太网传输。双绞线使用RJ-45接头连接网络设备。为保证终端能够正确收发数据，RJ-45接头中的针脚必须按照一定的线序排列

光纤（Optical Fiber）

双绞线和同轴电缆传输数据时使用的是电信号，而光纤传输数据时使用的是光信号。光纤支持的传输速率包括10Mbps，100Mbps，1Gbps，10Gbps，甚至更高。根据光纤传输光信号模式的不同，光纤又可分为单模光纤和多模光纤。单模光纤只能传输一种模式的光，不存在模间色散，因此适用于长距离高速传输。多模光纤允许不同模式的光在一根光纤上传输，由于模间色散较大而导致信号脉冲展宽严重，因此多模光纤主要用于局域网中的短距离传输。光纤连接器种类很多，常用的连接器包括ST，FC，SC，LC连接器。

串口电缆（Serial Port Cable）

网络通信中常常会用到各种各样的串口电缆。常用的串口电缆标准为RS-232，同时也是推荐的标准。但是RS-232的传输速率有限，传输距离仅为6米。其他的串口电缆标准可以支持更长的传输距离，例如RS-422和RS-485的传输距离可达1200米。RS-422和RS-485串口电缆通常使用V.35接头，这种接头在上世纪80年代已经淘汰，但是现在仍在帧中继、ATM等传统网络上使用。V.24是RS-232标准的欧洲版。RS-232本身没有定义接头标准，常用的接头类型为DB-9和DB-25。现在，RS-232已逐渐被FireWire、USB等新标准取代，新产品和新设备已普遍使用USB标准。

什么是「网络」

网络是由若干节点和连接这些节点的链路构成，表示诸多对象及其相互联系。网络是信息传输、接收、共享的虚拟平台，通过它把各个点、面、体的信息联系到一起，从而实现这些资源的共享。网络是人类发展史来最重要的发明，提高了科技和人类社会的发展。

网络设备有什么

电脑、手机、iPad、凡是能联网的设备、提供服务的设备、路由器、交换机、防火墙、无线设备……

网卡是上网必备的工具

简单网络

两个终端，用一条能承载数据传输的物理介质（也称为传输介质）连接起来，就组成了一个最简单的网络。

网络划分为

有线网络
无线网络

双绞线的线序

T-568A

白绿 绿 白橙 蓝 白蓝 橙 白棕 棕

T-568B

白橙 橙 白绿 蓝 白蓝 绿 白棕 棕

根据网线两端的线序可分为

直通线：两端线序是一样的
交叉线：两端线序是相反的

冲突域（Collision Domain）

共享式网络中可能会出现信号冲突现象。

如图是一个10BASE5以太网，每个主机都是用同一根同轴电缆来与其它主机进行通信，因此，这里的同轴电缆又被称为共享介质，相应的网络被称为共享介质网络，或简称为共享式网络。共享式网络中，不同的主机同时发送数据时，就会产生信号冲突的问题，解决这一问题的方法一般是采用载波侦听多路访问/冲突检测技术（Carrier Sense Multiple Access/Collision Detection）。

CSMA/CD的基本工作过程如下：

终端设备不停地检测共享线路的状态。如果线路空闲，则可以发送数据；如果线路不空闲，则等待一段时间后继续检测（延时时间由退避算法决定）。

如果有另外一个设备同时发送数据，两个设备发送的数据会产生冲突。

终端设备检测到冲突之后，会马上停止发送自己的数据，并发送特殊阻塞信息，以强化冲突信号，使线路上其他站点能够尽早检测到冲突。

终端设备检测到冲突后，等待一段时间之后再进行数据发送（延时时间由退避算法决定）。

CSMA/CD的工作原理可简单总结为：先听后发，边发边听，冲突停发，随机延迟后重发。

双工模式（Duplex）

两种双工模式都支持双向数据传输。

半双工：在半双工模式（half-duplex mode）下，通信双方都能发送和接收数据，但不能同时进行。当一台设备发送时，另一台只能接收，反之亦然。对讲机是半双工的典型例子。

全双工：在全双工模式（full-duplex mode）下，通信双方都能同时接收和发送数据。电话网络是典型的全双工例子。

以太网上的通信模式包括半双工和全双工两种：

半双工模式下，共享物理介质的通信双方必须采用CSMA/CD机制来避免冲突。例如，10BASE5以太网的通信模式就必须是半双工模式。全双工模式下，通信双方可以同时实现双向通信，这种模式不会产生冲突，因此不需要使用CSMA/CD机制。例如，10BASE-T以太网的通信模式就可以是全双工模式。同一物理链路上相连的两台设备的双工模式必须保持一致。

以太网帧结构

网络中传输数据时需要定义并遵循一些标准，以太网是根据IEEE 802.3标准来管理和控制数据帧的。

网络通信协议

不同的协议栈用于定义和管理不同网络的数据转发规则。

20世纪60年代以来，计算机网络得到了飞速发展。各大厂商和标准组织为了在数据通信网络领域占据主导地位，纷纷推出了各自的网络架构体系和标准，如IBM公司的SNA协议，Novell公司的IPX/SPX协议，以及广泛流行的OSI参考模型和TCP/IP协议。同时，各大厂商根据这些协议生产出了不同的硬件和软件。标准组织和厂商的共同努力促进了网络技术的快速发展和网络设备种类的迅速增长。

网络通信中，“协议”和“标准”这两个词汇常常可以混用。同时，协议或标准本身又常常具有层次的特点。一般地，关注于逻辑数据关系的协议通常被称为上层协议，而关注于物理数据流的协议通常被称为底层协议。IEEE 802就是一套用来管理物理数据流在局域网中传输的标准，包括在局域网中传输物理数据的802.3以太网标准。除以太外，还有一些用来管理物理数据流在广域网中传输的标准，如PPP（Point-to-Point Protocol），高级数据链路控制HDLC（High-Level Data Link Control）。

分层模型-OSI

国际标准化组织ISO于1984年提出了OSI RM（Open System Interconnection Reference Model，开放系统互连参考模型）。OSI参考模型很快成为了计算机网络通信的基础模型。

OSI参考模型具有以下优点：简化了相关的网络操作；提供了不同厂商之间的兼容性；促进了标准化工作；结构上进行了分层；易于学习和操作。

OSI参考模型各个层次的基本功能如下：

物理层：在设备之间传输比特流，规定了电平、速度和电缆针脚。

数据链路层：将比特组合成字节，再将字节组合成帧，使用链路层地址（以太网使用MAC地址）来访问介质，并进行差错检测。

网络层：提供逻辑地址，供路由器确定路径。

传输层：提供面向连接或非面向连接的数据传递以及进行重传前的差错检测。

会话层：负责建立、管理和终止表示层实体之间的通信会话。该层的通信由不同设备中的应用程序之间的服务请求和响应组成。

表示层：提供各种用于应用层数据的编码和转换功能，确保一个系统的应用层发送的数据能被另一个系统的应用层识别。

应用层：OSI参考模型中最靠近用户的一层，为应用程序提供网络服务。

分层模型-TCP/IP

TCP/IP模型同样采用了分层结构，层与层相对独立但是相互之间也具备非常密切的协作关系。

TCP/IP模型将网络分为四层。TCP/IP模型不关注底层物理介质，主要关注终端之间的逻辑数据流转发。TCP/IP模型的核心是网络层和传输层，网络层解决网络之间的逻辑转发问题，传输层保证源端到目的端之间的可靠传输。最上层的应用层通过各种协议向终端用户提供业务应用。

数据封装

应用数据需要经过TCP/IP每一层处理之后才能通过网络传输到目的端，每一层上都使用该层的协议数据单元PDU（Protocol Data Unit）彼此交换信息。不同层的PDU中包含有不同的信息，因此PDU在不同层被赋予了不同的名称。如上层数据在传输层添加TCP报头后得到的PDU被称为Segment（数据段）；数据段被传递给网络层，网络层添加IP报头得到的PDU被称为Packet（数据包）；数据包被传递到数据链路层，封装数据链路层报头得到的PDU被称为Frame（数据帧）；最后，帧被转换为比特，通过网络介质传输。这种协议栈逐层向下传递数据，并添加报头和报尾的过程称为封装。

终端之间的通信

数据链路层控制数据帧在物理链路上传输。

数据包在以太网物理介质上传播之前必须封装头部和尾部信息，封装后的数据包称为数据帧，数据帧中封装的信息决定了数据如何传输。以太网上传输的数据帧有两种格式，选择哪种格式由TCP/IP协议簇中的网络层决定。

帧格式

以太网上使用两种标准帧格式。第一种是上世纪80年代初提出的DIX v2格式，即Ethernet II帧格式。Ethernet II后来被IEEE 802标准接纳，并写进了IEEE 802.3x-1997的3.2.6节。第二种是1983年提出的IEEE 802.3格式。这两种格式的主要区别在于Ethernet II格式中包含一个Type字段，标识以太帧处理完成之后将被发送到哪个上层协议进行处理，IEEE 802.3格式中，同样的位置是长度字段。

不同的Type字段值可以用来区别这两种帧的类型，当Type字段值小于等于1500（或者十六进制的0x05DC）时，帧使用的是IEEE 802.3格式。当Type字段值大于等于1536 （或者十六进制的0x0600）时，帧使用的是Ethernet II格式。以太网中大多数的数据帧使用的是Ethernet II格式。

以太帧中还包括源和目的MAC地址，分别代表发送者的MAC和接收者的MAC，此外还有帧校验序列字段，用于检验传输过程中帧的完整性。

Ethernet_II帧格式

Ethernet_II 帧类型值大于等于1536 (0x0600)，以太网数据帧的长度在64-1518字节之间。

Ethernet_II的帧中各字段说明如下：

DMAC（Destination MAC）是目的MAC地址。DMAC字段长度为6个字节，标识帧的接收者。

SMAC（Source MAC）是源MAC地址。SMAC字段长度为6个字节，标识帧的发送者。

类型字段（Type）用于标识数据字段中包含的高层协议，该字段长度为2个字节。类型字段取值为0x0800的帧代表IP协议帧；类型字段取值为0x0806的帧代表ARP协议帧。

数据字段（Data）是网络层数据，最小长度必须为46字节以保证帧长至少为64字节，数据字段的最大长度为1500字节。循环冗余校验字段（FCS）提供了一种错误检测机制。该字段长度为4个字节。

IEEE802.3帧格式

IEEE802.3帧长度字段值小于等于1500 (0x05DC)。

IEEE802.3帧格式类似于Ethernet_II帧，只是Ethernet_II帧的Type域被802.3帧的Length域取代，并且占用了Data字段的8个字节作为LLC和SNAP字段。

Length字段定义了Data字段包含的字节数。

逻辑链路控制LLC（Logical Link Control）由目的服务访问点DSAP（Destination Service Access Point）、源服务访问点SSAP（Source Service Access Point）和Control字段组成。

SNAP（Sub-network Access Protocol）由机构代码（Org Code）和类型（Type）字段组成。Org Code三个字节都为0。Type字段的含义与Ethernet_II帧中的Type字段相同。IEEE802.3帧根据DSAP和SSAP字段的取值又可分为以下几类：
  1）当DSAP和SSAP都取特定值0xff时，802.3帧就变成了Netware-ETHERNET帧，用来承载NetWare类型的数据。
  2）当DSAP和SSAP都取特定值0xaa时，802.3帧就变成了ETHERNET_SNAP帧。ETHERNET_SNAP帧可以用于传输多种协议。
  3）DSAP和SSAP其他的取值均为纯IEEE802.3帧。

数据帧传输

数据链路层基于MAC地址进行帧的传输。

以太网在二层链路上通过MAC地址来唯一标识网络设备，并且实现局域网上网络设备之间的通信。MAC地址也叫物理地址，大多数网卡厂商把MAC地址烧入了网卡的ROM中。发送端使用接收端的MAC地址作为目的地址。以太帧封装完成后会通过物理层转换成比特流在物理介质上传输。

以太网的MAC地址

MAC地址由两部分组成，分别是供应商代码和序列号。其中前24位代表该供应商代码，由IEEE管理和分配。剩下的24位序列号由厂商自己分配。

如同每一个人都有一个名字一样，每一台网络设备都用物理地址来标识自己，这个地址就是MAC地址。网络设备的MAC地址是全球唯一的。MAC地址长度为48比特，通常用十六进制表示。MAC地址包含两部分：前24比特是组织唯一标识符（OUI，Organizationally Unique Identifier），由IEEE统一分配给设备制造商。例如，华为的网络产品的MAC地址前24比特是0x00e0fc。后24位序列号是厂商分配给每个产品的唯一数值，由各个厂商自行分配（这里所说的产品可以是网卡或者其他需要MAC地址的设备）。

单播（Unicast）

局域网上的帧可以通过三种方式发送。第一种是单播，指从单一的源端发送到单一的目的端。每个主机接口由一个MAC地址唯一标识，MAC地址的OUI中，第一字节第8个比特表示地址类型。对于主机MAC地址，这个比特固定为0，表示目的MAC地址为此MAC地址的帧都是发送到某个唯一的目的端。在冲突域中，所有主机都能收到源主机发送的单播帧，但是其他主机发现目的地址与本地MAC地址不一致后会丢弃收到的帧，只有真正的目的主机才会接收并处理收到的帧。

广播（Broadcast）

第二种发送方式是广播，表示帧从单一的源发送到共享以太网上的所有主机。广播帧的目的MAC地址为十六进制的FF:FF:FF:FF:FF:FF，所有收到该广播帧的主机都要接收并处理这个帧。

广播方式会产生大量流量，导致带宽利用率降低，进而影响整个网络的性能。

当需要网络中的所有主机都能接收到相同的信息并进行处理的情况下，通常会使用广播方式。

组播（Multicast）

第三种发送方式为组播，组播比广播更加高效。组播转发可以理解为选择性的广播，主机侦听特定组播地址，接收并处理目的MAC地址为该组播MAC地址的帧。

组播MAC地址和单播MAC地址是通过第一字节中的第8个比特区分的。组播MAC地址的第8个比特为1，而单播MAC地址的第8个比特为0。

当需要网络上的一组主机（而不是全部主机）接收相同信息，并且其他主机不受影响的情况下通常会使用组播方式。

数据帧的发送和接收

当主机接收到的数据帧所包含的目的MAC地址是自己时，会把以太网封装剥掉后送往上层协议。

帧从主机的物理接口发送出来后，通过传输介质传输到目的端。共享网络中，这个帧可能到达多个主机。主机检查帧头中的目的MAC地址，如果目的MAC地址不是本机MAC地址，也不是本机侦听的组播或广播MAC地址，则主机会丢弃收到的帧。

如果目的MAC地址是本机MAC地址，则接收该帧，检查帧校验序列（FCS）字段，并与本机计算的值对比来确定帧在传输过程中是否保持了完整性。如果帧的FCS值与本机计算的值不同，主机会认为帧已被破坏，并会丢弃该帧。如果该帧通过了FCS校验，则主机会根据帧头部中的Type字段来确定将帧发送给上层哪个协议处理。本例中，Type字段的值为0x0800，表明该帧需要发送到IP协议上处理。在发送给IP协议之前，帧的头部和尾部会被剥掉。

IP编址

上层协议地址

以太网帧中的Type字段值为0x0800，表示该帧的网络层协议为IP协议。

在剥掉帧的头部和尾部之前，网络设备需要根据帧头中Type字段确定下一步将帧发送到哪个上层协议进行处理。本例中的帧头部Type字段表示该帧需要上送到IP协议进行处理。以下将介绍帧的头部和尾部被剥掉后，IP协议将如何处理帧中的数据。

IP报文头部

IP报文头部信息用于指导网络设备对报文进行路由和分片。同一个网段内的数据转发通过链路层即可实现，而跨网段的数据转发需要使用网络设备的路由功能。分片是指数据包超过一定长度时，需要被划分成不同的片段使其能够在网络中传输。

IP报文头部长度为20到60字节，报文头中的信息可以用来指导网络设备如何将报文从源设备发送到目的设备。其中，版本字段表示当前支持的IP协议版本，当前的版本号为4。DS字段早期用来表示业务类型，现在用于支持QoS中的差分服务模型，实现网络流量优化。

源和目的IP地址是分配给主机的逻辑地址，用于在网络层标识报文的发送方和接收方。根据源和目的IP地址可以判断目的端是否与发送端位于同一网段，如果二者不在同一网段，则需要采用路由机制进行跨网段转发。

IP编址

IP地址分为网络部分和主机部分。

IP地址由32个二进制位组成，通常用点分十进制形式表示。

IPv4地址为32比特的二进制数，通常用点分十进制表示。IP地址用来标识网络中的设备，具有IP地址的设备可以在同一网段内或跨网段通信。IP地址包括两部分，第一部分是网络号，表示IP地址所属的网段，第二部分是主机号，用来唯一标识本网段上的某台网络设备。

每个网段上都有两个特殊地址不能分配给主机或网络设备。第一个是该网段的网络地址，该IP地址的主机位为全0，表示一个网段。第二个地址是该网段中的广播地址，目的地址为广播地址的报文会被该网段中的所有网络设备接收。广播地址的主机位为全1。除网络地址和广播地址以外的其他IP地址都可以作为网络设备的IP地址。

二进制、十进制和十六进制

在IP网络中，二进制和十六进制是常用的编码方式。

网络中的数据可以采用二进制、十进制或十六进制来表示，了解这些进制对理解IP网络基础知识很有必要。每种进制使用不同的基值表示每一位的数值。二进制每一位只有0和1两个值，基值为2，二进制数的每一位都可以用2的x次幂来表示，x表示二进制数的位数。十六进制的每一位可以有16个数值，范围为0-F（即0-9和A-F），A对应十进制的10，F对应十进制的15（二进制的1111）。

IP地址以字节为单位分为四段，每字节包含8个比特，可以表示0到255，共256个数值。从二进制到十进制转换表中可以看到每一位二进制数所代表的十进制数。上面的表格举例说明了8位二进制数转换为十进制数和十六进制数的情况。从表格中也可以看到全0和全1所对应的十进制数和十六进制数。

二进制和十进制转换

32位的IP地址分为4个字节，每个字节有256个取值。因此，理论上IPv4可以有4,294,967,296个IP地址，但实际上只有其中一部分地址可以分配给网络设备使用。本例中，IP地址的前三个字节表示网络号，最后一个字节表示该网络上网络设备可用的地址范围。将二进制格式的IP地址转换为十进制格式时，需要把二进制中每一位1所代表的值加在一起，得出IP地址的十进制值。

IP地址分类

IPv4地址被划分为A、B、C、D、E五类，每类地址的网络号包含不同的字节数。A类，B类和C类地址为可分配IP地址，每类地址支持的网络数和主机数不同。比如，A类地址可支持126个网络，每个网络支持224 （16,777,216 )个主机地址，另外每个网段中的网络地址和广播地址不能分配给主机。C类地址支持200多万个网络，每个网络支持256个主机地址，其中254个地址可以分配给主机使用。

D类地址为组播地址。主机收到以D类地址为目的地址的报文后，且该主机是该组播组成员，就会接收并处理该报文。各类IP地址可以通过第一个字节中的比特位进行区分。如A类地址第一字节的最高位固定为0，B类地址第一字节的高两位固定为10，C类地址第一字节的高三位固定为110，D类地址第一字节的高四位固定为1110，E类地址第一字节的高四位固定为1111。

IP地址类型

私有地址范围

10.0.0.0~10.255.255.255

172.16.0.0~172.31.255.255

192.168.0.0~192.168.255.255

特殊地址

127.0.0.0~127.255.255.255

0.0.0.0

255.255.255.255

IPv4中的部分IP地址被保留用作特殊用途。为节省IPv4地址，A、B、C类地址段中都预留了特定范围的地址作为私网地址。现在，世界上所有终端系统和网络设备需要的IP地址总数已经超过了32位IPv4地址所能支持的最大地址数4,294,967,296。为主机分配私网地址节省了公网地址，可以用来缓解IP地址短缺的问题。企业网络中普遍使用私网地址，不同企业网络中的私网地址可以重叠。默认情况下，网络中的主机无法使用私网地址与公网通信；当需要与公网通信时，私网地址必须转换成公网地址。还有其他一些特殊IP地址，如127.0.0.0网段中的地址为环回地址，用于诊断网络是否正常。IPv4中的第一个地址0.0.0.0表示任何网络，这个地址的作用将在路由原理中详细介绍。IPv4中的最后一个地址255.255.255.255是0.0.0.0网络中的广播地址。

网络通信

源主机必须要知道目的主机的IP地址后才能将数据发送到目的地。源主机向其他目的主机发送报文之前，需要检查目的IP地址和源IP地址是否属于同一个网段。如果是，则报文将被下发到底层协议进行以太网封装处理。如果目的地址和源地址属于不同网段，则主机需要获取下一跳路由器的IP地址，然后将报文下发到底层协议处理。

子网掩码（Mask）

子网掩码用于区分网络部分和主机部分。子网掩码与IP地址的表示方法相同。每个IP地址和子网掩码一起可以用来唯一的标识一个网段中的某台网络设备。子网掩码中的1表示网络位，0表示主机位。

默认子网掩码

每类IP地址有一个缺省子网掩码。A类地址的缺省子网掩码为8位，即第一个字节表示网络位，其他三个字节表示主机位。B类地址的缺省子网掩码为16位，因此B类地址支持更多的网络，但是主机数也相应减少。C类地址的缺省子网掩码为24位，支持的网络最多，同时也限制了单个网络中主机的数量。

地址规划

通过子网掩码可以判断主机所属的网段、网段上的广播地址以及网段上支持的主机数。图中这个例子，主机地址为192.168.1.7，子网掩码为24位（C类IP地址的缺省掩码），从中我们可以判断该主机位于192.168.1.0/24网段。将IP地址中的主机位全部置为1，并转换为十进制数，即可得到该网段的广播地址192.168.1.255。网段中支持的主机数为2n，n为主机位的个数。本例中n=8，28=256，减去本网段的网络地址和广播地址，可知该网段支持254个有效主机地址。

有类IP编址的缺陷

在设计网络时使用有类IP地址会造成地址的浪费。

如果企业网络中希望通过规划多个网段来隔离物理网络上的主机，使用缺省子网掩码就会存在一定的局限性。网络中划分多个网段后，每个网段中的实际主机数量可能很有限，导致很多地址未被使用。如图所示的场景下，如果使用缺省子网掩码的编址方案，则地址使用率很低。

变长子网掩码

采用可变长子网掩码可解决上述问题。缺省子网掩码可以进一步划分，成为变长子网掩码（VLSM）。通过改变子网掩码，可以将网络划分为多个子网。本例中的地址为C类地址，缺省子网掩码为24位。现借用一个主机位作为网络位，借用的主机位变成子网位。一个子网位有两个取值0和1，因此可划分两个子网。该比特位设置为0，则子网号为0，该比特位设置为1，则子网号为128。将剩余的主机位都设置为0，即可得到划分后的子网地址；将剩余的主机位都设置为1，即可得到子网的广播地址。每个子网中支持的主机数为27-2（减去子网地址和广播地址），即126个主机地址。

网关（Gateway）

网关用来转发来自不同网段之间的数据包。

报文转发过程中，首先需要确定转发路径以及通往目的网段的接口，然后将报文封装在以太帧中通过指定的物理接口转发出去。如果目的主机与源主机不在同一网段，报文需要先转发到网关，然后通过网关将报文转发到目的网段。

网关是指接收并处理本地网段主机发送的报文并转发到目的网段的设备。为实现此功能，网关必须知道目的网段的IP地址。网关设备上连接本地网段的接口地址即为该网段的网关地址。

IP包分片

网络中转发的IP报文的长度可以不同，但如果报文长度超过了数据链路所支持的最大长度，则报文就需要分割成若干个较小的片段才能够在链路上传输。将报文分割成多个片段的过程叫做分片。

接收端根据分片报文中的标识符（Identification），标志（Flags)，及片偏移（Fragment Offset）字段对分片报文进行重组。标识符用于识别属于同一个数据包的分片，以区别于同一主机或其他主机发送的其它数据包分片，保证分片被正确的重新组合。标志字段用于判断是否已经收到最后一个分片。最后一个分片的标志字段设置为0，其他分片的标志字段设置为1，目的端在收到标志字段为0的分片后，开始重组报文。片偏移字段表示每个分片在原始报文中的位置。第一个分片的片偏移为0，第二个分片的片偏移表示紧跟第一个分片后的第一个比特的位置。比如，如果首片报文包含1259比特，那么第二分片报文的片偏移字段值就应该为1260。

生存时间

报文在网段间转发时，如果网络设备上的路由规划不合理，就可能会出现环路，导致报文在网络中无限循环，无法到达目的端。环路发生后，所有发往这个目的地的报文都会被循环转发，随着这种报文逐渐增多，网络将会发生拥塞。

为避免环路导致的网络拥塞，IP报文头中包含一个生存时间TTL（Time To Live）字段。报文每经过一台三层设备，TTL值减1。初始TTL值由源端设备设置。当报文中的TTL降为0时，报文会被丢弃。同时，丢弃报文的设备会根据报文头中的源IP地址向源端发送ICMP错误消息。

协议号

目的端的网络层在接收并处理报文以后，需要决定下一步对报文该做如何处理。IP报文头中的协议字段标识了将会继续处理报文的协议。与以太帧头中的Type字段类似，协议字段也是一个十六进制数。该字段可以标识网络层协议，如ICMP（Internet Control Message Protocol，因特网控制报文协议），也可以标识上层协议，如TCP（Transmission Control Protocol，传输控制协议，对应值0x06）、UDP（User Datagram Protocol，用户数据包协议，对应值0x11）。

常用端口列举

端口：0

服务：Reserved

说明：通常用于分析操作系统。这一方法能够工作是因为在一些系统中“0”是无效端口，当你试图使用通常的闭合端口连接它时将产生不同的结果。一种典型的扫描，使用 IP地址为0.0.0.0，设置ACK位并在以太网层广播。
端口：1

服务：tcpmux

说明：这显示有人在寻找SGI Irix机器。Irix是实现tcpmux的主要提供者，默认情况下 tcpmux在这种系统中被打开。Irix机器在发布是含有几个默认的无密码的帐户，如： IP、GUEST UUCP、NUUCP、DEMOS 、TUTOR、DIAG、OUTOFBOX等。许多管理员在安装后忘记删除这些帐户。因此HACKER在INTERNET上搜索tcpmux并利用这些帐户。
端口：7

服务：Echo

说明：能看到许多人搜索Fraggle放大器时，发送到X.X.X.0和X.X.X.255的信息。
端口：19

服务：Character Generator

说明：这是一种仅仅发送字符的服务。UDP版本将会在收到UDP包后回应含有垃圾字符的包。TCP连接时会发送含有垃圾字符的数据流直到连接关闭。HACKER利用IP欺骗可以发动DoS攻击。伪造两个chargen服务器之间的UDP包。同样Fraggle DoS攻击向目标地址的这个端口广播一个带有伪造受害者IP的数据包，受害者为了回应这些数据而过载。
端口：20、21

服务：FTP

说明：FTP服务器所开放的端口，20用于数据传输，21用于控制。最常见的攻击者用于寻找打开 anonymous的FTP服务器的方法。这些服务器带有可读写的目录。木马Doly Trojan、 Fore、Invisible FTP、WebEx、WinCrash和Blade Runner所开放的端口。
端口：22

服务：Ssh

说明：PcAnywhere建立的TCP和这一端口的连接可能是为了寻找ssh。这一服务有许多弱点，如果配置成特定的模式，许多使用RSAREF库的版本就会有不少的漏洞存在。
端口：23

服务：Telnet

说明：远程登录，入侵者在搜索远程登录UNIX的服务。大多数情况下扫描这一端口是为了找到机器运行的操作系统。还有使用其他技术，入侵者也会找到密码。木马Tiny Telnet Server就开放这个端口。
端口：25

服务：SMTP

说明：SMTP服务器所开放的端口，用于发送邮件。入侵者寻找SMTP服务器是为了传递他们的SPAM。入侵者的帐户被关闭，他们需要连接到高带宽的E-MAIL服务器上，将简单的信息传递到不同的地址。木马Antigen、Email Password Sender、Haebu Coceda、 Shtrilitz Stealth、WinPC、WinSpy都开放这个端口。
端口：31

服务：MSG Authentication

说明：木马Master Paradise、Hackers Paradise开放此端口。
端口：42

服务：WINS Replication

说明：WINS复制
端口：53

服务：Domain Name Server（DNS）

说明：DNS服务器所开放的端口，入侵者可能是试图进行区域传递（TCP），欺骗DNS （UDP）或隐藏其他的通信。因此防火墙常常过滤或记录此端口。
端口：67

服务：Bootstrap Protocol Server

说明：通过DSL和Cable modem的防火墙常会看见大量发送到广播地址255.255.255.255 的数据。这些机器在向DHCP服务器请求一个地址。HACKER常进入它们，分配一个地址把自己作为局部路由器而发起大量中间人（man-in-middle）攻击。客户端向68端口广播请求配置，服务器向67端口广播回应请求。这种回应使用广播是因为客户端还不知道可以发送的IP地址。
端口：69

服务：Trival File Transfer

说明：许多服务器与bootp一起提供这项服务，便于从系统下载启动代码。但是它们常常由于错误配置而使入侵者能从系统中窃取任何文件。它们也可用于系统写入文件。
端口：79

服务：Finger Server

说明：入侵者用于获得用户信息，查询操作系统，探测已知的缓冲区溢出错误，回应从自己机器到其他机器Finger扫描。
端口：80

服务：HTTP

说明：用于网页浏览。木马Executor开放此端口。
端口：99

服务：Metagram Relay

说明：后门程序ncx99开放此端口。
端口：102

服务：Message transfer agent(MTA)-X.400 over TCP/IP

说明：消息传输代理。
端口：109

服务：Post Office Protocol -Version3

说明：POP3服务器开放此端口，用于接收邮件，客户端访问服务器端的邮件服务。POP3服务有许多公认的弱点。关于用户名和密码交换缓冲区溢出的弱点至少有20个，这意味着入侵者可以在真正登陆前进入系统。成功登陆后还有其他缓冲区溢出错误。
端口：110

服务：SUN公司的RPC服务所有端口

说明：常见RPC服务有rpc.mountd、NFS、rpc.statd、rpc.csmd、rpc.ttybd、amd等
端口：113

服务：Authentication Service

说明：这是一个许多计算机上运行的协议，用于鉴别TCP连接的用户。使用标准的这种服务可以获得许多计算机的信息。但是它可作为许多服务的记录器，尤其是FTP、POP、IMAP、SMTP和IRC等服务。通常如果有许多客户通过防火墙访问这些服务，将会看到许多这个端口的连接请求。记住，如果阻断这个端口客户端会感觉到在防火墙另一边与E-MAIL服务器的缓慢连接。许多防火墙支持TCP连接的阻断过程中发回RST。这将会停止缓慢的连接。
端口：119

服务：Network News Transfer Protocol

说明：NEWS新闻组传输协议，承载USENET通信。这个端口的连接通常是人们在寻找USENET服务器。多数ISP限制，只有他们的客户才能访问他们的新闻组服务器。打开新闻组服务器将允许发/读任何人的帖子，访问被限制的新闻组服务器，匿名发帖或发送SPAM。
端口：135

服务：Location Service

说明：Microsoft在这个端口运行DCE RPC end-point mapper为它的DCOM服务。这与UNIX 111端口的功能很相似。使用DCOM和RPC的服务利用计算机上的end-point mapper注册它们的位置。远端客户连接到计算机时，它们查找end-point mapper找到服务的位置。HACKER扫描计算机的这个端口是为了找到这个计算机上运行Exchange Server吗？什么版本？还有
端口：110

服务：pop3

说明：POP3(Post Office Protocol 3)服务器开放此端口，用于接收邮件，客户端访问服务器端的邮件服务。POP3服务有许多公认的弱点。关于用户名和密码交换缓冲区溢出的弱点至少有20个，这意味着入侵者可以在真正登陆前进入系统。成功登陆后还有其他缓冲区溢出错误。
端口：137、138、139

服务：NETBIOS Name Service

说明：其中137、138是UDP端口，当通过网上邻居传输文件时用这个端口。而139端口：通过这个端口进入的连接试图获得NetBIOS/SMB服务。这个协议被用于windows文件和打印机共享和SAMBA。还有WINS Regisrtation也用它。
端口：143

服务：Interim Mail Access Protocol v2

说明：和POP3的安全问题一样，许多IMAP服务器存在有缓冲区溢出漏洞。记住：一种LINUX蠕虫（admv0rm）会通过这个端口繁殖，因此许多这个端口的扫描来自不知情的已经被感染的用户。当REDHAT在他们的LINUX发布版本中默认允许IMAP后，这些漏洞变的很流行。这一端口还被用于IMAP2，但并不流行。
端口：161

服务：SNMP 说明：SNMP允许远程管理设备。所有配置和运行信息的储存在数据库中，通过SNMP可获得这些信息。许多管理员的错误配置将被暴露在Internet。Cackers将试图使用默认的密码public、private访问系统。他们可能会试验所有可能的组合。SNMP包可能会被错误的指向用户的网络。
端口：389

服务：LDAP、ILS

说明：轻型目录访问协议和NetMeeting Internet Locator Server共用这一端口。
端口：443

服务：Https

说明：网页浏览端口，能提供加密和通过安全端口传输的另一种HTTP。
端口：993

服务：IMAP

说明：SSL（Secure Sockets layer）
端口：1080

服务：SOCKS代理协议服务器

说明：SOCKS代理协议服务器
端口：1433

服务：SQL

说明：Microsoft的SQL服务开放的端口。
端口：1503

服务：NetMeeting T.120

说明：NetMeeting T.120
端口：1521

服务：Oracle 数据库

说明：Oracle 数据库
端口：1720

服务：NetMeeting

说明：NetMeeting H.233 call Setup。
端口：1731

服务：NetMeeting Audio Call Control

说明：NetMeeting音频调用控制。
端口：3306

服务：MySQL 数据库

说明：MySQL 数据库
端口：3389

服务：超级终端

说明：WINDOWS 2000终端开放此端口。
端口：4000

服务：QQ客户端

说明：腾讯QQ客户端开放此端口。
端口：5631

服务：pcAnywere

说明：有时会看到很多这个端口的扫描，这依赖于用户所在的位置。当用户打开pcAnywere时，它会自动扫描局域网C类网以寻找可能的代理（这里的代理是指agent而不是proxy）。入侵者也会寻找开放这种服务的计算机。，所以应该查看这种扫描的源地址。一些搜寻pcAnywere的扫描包常含端口22的UDP数据包。
端口：6970

服务：RealAudio

说明：RealAudio客户将从服务器的6970-7170的UDP端口接收音频数据流。这是由TCP-7070端口外向控制连接设置的。
端口：7323

服务：

说明：Sygate服务器端。
端口：8000

服务：OICQ

说明：腾讯QQ服务器端开放此端口。
端口：8010

服务：Wingate

说明：Wingate代理开放此端口。
端口：8080

服务：代理端口

说明：WWW代理开放此端口

传输层协议

传输层定义了主机应用程序之间端到端的连通性。传输层中最为常见的两个协议分别是传输控制协议TCP（Transmission Control Protocol）和用户数据包协议UDP（User Datagram Protocol）。

TCP

TCP是一种面向连接的传输层协议，可提供可靠的传输服务。

TCP位于TCP/IP模型的传输层，它是一种面向连接的端到端协议。TCP作为传输控制协议，可以为主机提供可靠的数据传输。在本例中，两台主机在通信之前，需要TCP在它们之间建立可靠的传输通道。

TCP端口号

端口号用来区分不同的网络服务。

TCP允许一个主机同时运行多个应用进程。每台主机可以拥有多个应用端口，每对端口号、源和目标IP地址的组合唯一地标识了一个会话。端口分为知名端口和动态端口。有些网络服务会使用固定的端口，这类端口称为知名端口，端口号范围为0-1023。如FTP、HTTP、Telnet、SNMP服务均使用知名端口。动态端口号范围从1024到65535，这些端口号一般不固定分配给某个服务，也就是说许多服务都可以使用这些端口。只要运行的程序向系统提出访问网络的申请，那么系统就可以从这些端口号中分配一个供该程序使用。

TCP头部

TCP通常使用IP作为网络层协议，这时TCP数据段被封装在IP数据包内。

TCP数据段由TCP Header（头部）和TCP Data（数据）组成。TCP最多可以有60个字节的头部，如果没有Options字段，正常的长度是20字节。

TCP Header是由如上图标识的一些字段组成，这里列出几个常用字段。

16位源端口号：源主机的应用程序使用的端口号。

16位目的端口号：目的主机的应用程序使用的端口号。每个TCP头部都包含源和目的端的端口号，这两个值加上IP头部中的源IP地址和目的IP地址可以唯一确定一个TCP连接。

32位序列号：用于标识从发送端发出的不同的TCP数据段的序号。数据段在网络中传输时，它们的顺序可能会发生变化；接收端依据此序列号，便可按照正确的顺序重组数据。

32位确认序列号：用于标识接收端确认收到的数据段。确认序列号为成功收到的数据序列号加1。

4位头部长度：表示头部占32bit字的数目，它能表达的TCP头部最大长度为60字节。

16位窗口大小：表示接收端期望通过单次确认而收到的数据的大小。由于该字段为16位，所以窗口大小的最大值为65535字节，该机制通常用来进行流量控制。

16位校验和：校验整个TCP报文段，包括TCP头部和TCP数据。该值由发送端计算和记录并由接收端进行验证。

TCP建立连接的过程

TCP通过三次握手建立可靠连接。

TCP是一种可靠的，面向连接的全双工传输层协议。

TCP连接的建立是一个三次握手的过程。如图所示：

主机A（通常也称为客户端）发送一个标识了SYN的数据段，表示期望与服务器A建立连接，此数据段的序列号（seq）为a。

服务器A回复标识了SYN+ACK的数据段，此数据段的序列号（seq）为b，确认序列号为主机A的序列号加1（a+1），以此作为对主机A的SYN报文的确认。

主机A发送一个标识了ACK的数据段，此数据段的序列号（seq）为a+1，确认序列号为服务器A的序列号加1（b+1），以此作为对服务器A的SYN报文的确认。

TCP传输过程

TCP的可靠传输还体现在TCP使用了确认技术来确保目的设备收到了从源设备发来的数据，并且是准确无误的。

确认技术的工作原理如下：

目的设备接收到源设备发送的数据段时，会向源端发送确认报文，源设备收到确认报文后，继续发送数据段，如此重复。

如图所示，主机A向服务器A发送TCP数据段，为描述方便假定每个数据段的长度都是500个字节。当服务器A成功收到序列号是M+1499的字节以及之前的所有字节时，会以序列号M+1499+1=M+1500进行确认。另外，由于数据段N+3传输失败，所以服务器A未能收到序列号为M+1500的字节，因此服务器A还会再次以序列号M+1500进行确认。

TCP流量控制

TCP滑动窗口技术通过动态改变窗口大小来实现对端到端设备之间的数据传输进行流量控制。

如图所示，主机A和服务器A之间通过滑动窗口来实现流量控制。为方便理解，此例中只考虑主机A发送数据给服务器A时，服务器A通过滑动窗口进行流量控制。

主机A向服务器发送4个长度为1024字节的数据段，其中主机的窗口大小为4096个字节。服务器A收到第3个数据段后，缓存区满，第4个数据段被丢弃。服务器以ACK 3073响应，窗口大小调整为3072，表明服务器的缓冲区只能处理3072个字节的数据段。于是主机A改变其发送速率，发送窗口大小为3072的数据段。

TCP关闭连接

主机在关闭连接之前，要确认收到来自对方的ACK。

TCP支持全双工模式传输数据，这意味着同一时刻两个方向都可以进行数据的传输。在传输数据之前，TCP通过三次握手建立的实际上是两个方向的连接，因此在传输完毕后，两个方向的连接必须都关闭。

TCP连接的建立是一个三次握手的过程，而TCP连接的终止则要经过四次握手。

如图所示：

主机A想终止连接，于是发送一个标识了FIN，ACK的数据段，序列号为a，确认序列号为b。

服务器A回应一个标识了ACK的数据段，序列号为b，确认序号为a+1，作为对主机A的FIN报文的确认。

服务器A想终止连接，于是向主机A发送一个标识了FIN，ACK的数据段，序列号为b，确认序列号为a+1。

主机A回应一个标识了ACK的数据段，序列号为a+1，确认序号为b+1，作为对服务器A的FIN报文的确认。

以上四次交互便完成了两个方向连接的关闭。

UDP

UDP是一种面向无连接的传输层协议，传输可靠性没有保证。

当应用程序对传输的可靠性要求不高，但是对传输速度和延迟要求较高时，可以用UDP协议来替代TCP协议在传输层控制数据的转发。UDP将数据从源端发送到目的端时，无需事先建立连接。UDP采用了简单、易操作的机制在应用程序间传输数据，没有使用TCP中的确认技术或滑动窗口机制，因此UDP不能保证数据传输的可靠性，也无法避免接收到重复数据的情况。

UDP头部

UDP头部仅占8字节，传输数据时没有确认机制。

UDP报文分为UDP报文头和UDP数据区域两部分。报头由源端口、目的端口、报文长度以及校验和组成。UDP适合于实时数据传输，如语音和视频通信。相比于TCP，UDP的传输效率更高、开销更小，但是无法保障数据传输的可靠性。UDP头部的标识如下：

16位源端口号：源主机的应用程序使用的端口号。

16位目的端口号：目的主机的应用程序使用的端口号。

16位UDP长度：是指UDP头部和UDP数据的字节长度。因为UDP头部长度为8字节，所以该字段的最小值为8。

16位UDP校验和：该字段提供了与TCP校验字段同样的功能；该字段是可选的。

UDP传输过程

使用UDP传输数据时，由应用程序根据需要提供报文到达确认、排序、流量控制等功能。

主机A发送数据包时，这些数据包是以有序的方式发送到网络中的，每个数据包独立地在网络中被发送，所以不同的数据包可能会通过不同的网络路径到达主机B。这样的情况下，先发送的数据包不一定先到达主机B。因为UDP数据包没有序号，主机B将无法通过UDP协议将数据包按照原来的顺序重新组合，所以此时需要应用程序提供报文的到达确认、排序和流量控制等功能。通常情况下，UDP采用实时传输机制和时间戳来传输语音和视频数据。

UDP不提供重传机制，占用资源小，处理效率高。

一些时延敏感的流量，如语音、视频等，通常使用UDP作为传输层协议。

UDP适合传输对时延敏感的流量，如语音和视频。

在使用TCP协议传输数据时，如果一个数据段丢失或者接收端对某个数据段没有确认，发送端会重新发送该数据段。

TCP重新发送数据会带来传输延迟和重复数据，降低了用户的体验。对于时延敏感的应用，少量的数据丢失一般可以被忽略，这时使用UDP传输将能够提升用户的体验。

数据转发过程

TCP/IP协议簇和底层协议配合，保证了数据能够实现端到端的传输。数据传输过程是一个非常复杂的过程，例如数据在转发的过程中会进行一系列的封装和解封装。对于网络工程师来说，只有深入地理解了数据在各种不同设备上的转发过程，才能够对网络进行正确的分析和检测。

数据转发过程概述

数据包在相同网段内或不同网段之间转发所依据的原理基本一致。

数据可以在同一网络内或者不同网络间传输，数据转发过程也分为本地转发和远程转发，但两者的数据转发原理是基本一样的，都是遵循TCP/IP协议簇。

本示例中，主机A需要访问服务器A的Web服务，并且假定两者之间已经建立了TCP连接。接下来会以此示例来讲解数据在不同网络间的传输过程。

TCP封装

当主机建立了到达目的地的TCP连接后，便开始对应用层数据进行封装。

主机A会对待发送的应用数据首先执行加密和压缩等相关操作，之后进行传输层封装。Web应用是基于传输层的TCP协议传输数据的。主机A使用TCP进行报文封装时，必须填充源端口和目的端口字段，初始序列号和确认序列号字段，标识位，窗口字段以及校验和字段。此例中数据段的源端口号为主机A随机选择的1027号端口，目的端口号为服务器A的TCP知名端口80。

IP封装

主机A完成传输层封装后，一般会进行网络层数据封装，在使用IP进行封装时，需要明确IP报文的源和目的地址。如果IP报文的大小大于网络的最大传输单元（MTU），则该报文有可能在传输过程中被分片。

生存时间（TTL）字段用来减少网络环路造成的影响。ARG3系列路由器产生的数据包，默认TTL值为255。路由器转发一个数据包时，该值会被减1，如果路由器发现该值被减为0，就会丢弃该数据包。这样，即使网络中存在环路，数据包也不会在网络上一直被转发。

协议字段标识了传输层所使用的协议。本例中，传输层使用的是TCP协议，所以该字段的填充值为0X06。

查找路由

主机A必须要拥有到达目的地的路由。

每个主机都会独自维护各自的路由表项。主机A在发送数据前需要先检查是否能够到达目的端，这个过程是通过查找路由来完成的。在此示例中，主机A拥有一条到达“任何网络”（在IP编址部分已经简要介绍过）的路由，它发往其他网络的数据都会通过IP地址为10.1.1.1的接口转发到下一跳，即网关10.1.1.254。

ARP

通过ARP缓存表找到下一跳的MAC地址。

如果表项里没有下一跳的MAC地址，主机A会发送ARP请求。

接下来，由于数据包要被封装成数据帧，所以主机A需要获取下一跳的MAC地址，也就是网关的MAC地址。主机首先会查询ARP缓存表。本例中，主机A的ARP缓存表中存在网关MAC地址的表项。

如果没有查找到网关的MAC地址表项，主机A会通过发送ARP请求来获取网关的MAC地址。

以太网封装

主机A在链路层封装数据帧时，会遵循IEEE 802.3或Ethernet_II标准，Ethernet_II帧头中的类型字段填充为0x0800，以表示网络层使用的是IP协议。源MAC地址为主机A的MAC地址，目的MAC地址为网关路由器E0/0接口的MAC地址。

数据帧转发过程

主机工作在半双工状态下，所以会使用CSMA/CD来检测链路是否空闲。

前导码用于使接收者进入同步状态，定界符用于指示帧的开始。

主机A工作在半双工状态下，所以会使用CSMA/CD来检测链路是否空闲。如果链路空闲，主机A会将一个前导码（Preamble）和一个帧首定界符（SFD）附加到帧头然后进行传输。前导码的作用是使接收设备进行同步并做好接收数据帧的准备。前导码是包括了7个字节的二进制“1”、“0”交替的代码，即1010…10共56位。帧首定界符是长度为1个字节的10101011二进制序列，它的作用是使接收端对帧的第一位进行定位。

同一个冲突域里的设备都会接收到主机A发送的数据帧。

只有网关（RTA）会处理该数据帧，并继续转发。

本例中，主机A发送数据帧到共享以太网，此网络中的所有网络设备都会收到该帧。设备收到帧之后，首先会进行FCS校验。如果FCS校验未能通过，则帧被立即丢弃。对于通过了FCS校验的帧，设备会检查帧中的目的MAC地址。如果帧中的目的MAC地址与自己的MAC地址不同，设备将丢弃帧，如果相同，则会继续处理。处理过程中，帧头帧尾会被剥去（也就是解封装），剩下的数据报文会被根据帧头中的类型字段的值来送到网络层中的对应协议模块去处理。

数据包转发过程

网关检查是否具有到达目的网络的路由条目。

如果存在转发路径，则为数据包添加一个新的二层帧头和帧尾，并继续转发。

RTA收到此数据报文后，网络层会对该报文进行处理。RTA首先根据IP头部信息中的校验和字段，检查IP数据报文头部的完整性，然后根据目的IP地址查看路由表，确定是否能够将数据包转发到目的端。RTA还必须对TTL的值进行处理。另外，报文大小不能超过MTU值。如果报文大小超过MTU值，则报文将被分片。

网络层处理完成后，报文将被送到数据链路层重新进行封装，成为一个新的数据帧，该帧的头部会封装新的源MAC地址和目的MAC地址。如果当前网络设备不知道下一跳的MAC地址，将会使用ARP来获得。

数据帧解封装

RTB以服务器A的MAC地址作为目的MAC继续转发。

服务器A接收到该数据帧后，发现目的MAC为自己的MAC，于是会继续处理该数据帧。

该示例中，服务器A处于一个共享以太网中，两台服务器都会收到RTB发送的数据帧。该帧的目的MAC地址与服务器B的接口MAC地址不匹配，所以会被服务器B丢弃。

服务器A成功收到该帧，并通过FCS校验。服务器A将利用帧中的类型字段来识别在网络层处理该数据的协议。该示例中，服务器A会将解封装后的此数据交给网络层的IP协议来进行处理。

数据包解封装

服务器A检查数据包的目的IP地址，发现目的IP与自己的IP地址相同。

服务器A剥掉数据包的IP头部后，会送往上层协议TCP继续进行处理。

服务器A通过IP协议来处理该报文，首先会通过校验和字段来验证报文头的完整性，然后检查IP报文头中的目的IP地址是否与自己当前的IP地址匹配。

如果在源与目的之间的数据传输期间数据发生了报文分片，则报文会被目的端重新组合。标识字段用于标识属于同一数据源的分片报文，偏移量表示该分片在原分组中的相对位置。标志字段目前只有两位有意义，标志字段最低位为1，表示后面还有分片，为0表示这已经是最后一个数据片；中间一位为1表示不能分片，为0表示允许分片。所有的分片报文必须被目的端全部接收到后才会进行重新组合。

协议字段表示此数据包携带的上层数据是哪种协议的数据。需要注意的是，下一个报头并非总是传输层报头。例如，ICMP报文也是使用IP协议封装，协议字段值为0x01。

数据段解封装

服务器A检查TCP头部的目的端口，然后将数据段发送给应用层的HTTP协议进行处理。

当IP报文头被处理完并剥离后，数据段会被发送到传输层进行处理。在此示例中，传输层协议使用的是TCP，且发送端和接收端已经通过三次握手建立了连接。传输层收到该数据段后，TCP协议会查看并处理该数据段头部信息，其中目的端口号为80，用于表示处理该数据的应用层协议为HTTP协议。TCP处理完头部信息后会将此数据段头部进行剥离，然后将剩下的应用数据发送到HTTP协议进行处理。

【Blog Build】Plan of Jekyll Blog - Episode 1: Jekyll-3 on Ubuntu and Nginx

2020-05-04T00:00:00+00:00

This tutorial you will learn how to configure Jekyll-3 on Ubuntu 16.04 and Nginx.

Jekyll On Ubuntu

The release of the Ubuntu is Ubuntu 16.04 LTS (Xenial Xerus).

You can follow this link Jekyll on Ubuntu to configure Jekyll.

Before we install Jekyll, we need to install Ruby and other dependencies:

sudo apt-get install ruby-full build-essential zlib1g-dev

Caution: sudo apt-get install ruby-full command on Ubuntu 16.04 even 18.04 can only install Ruby2.5, it might take some unsuspected problem.

Avoid installing RubyGems packages (called gems) as the root user. (Well, AliCloud only provides root account and I am lazy about adding a new user account. So I think it doesn’t matter to use root account.) Instead, set up a gem installation directory for your user account. The following commands will add environment variables to your ~/.bashrc file to configure the gem installation path:

echo '# Install Ruby Gems to ~/gems' >> ~/.bashrc
echo 'export GEM_HOME="$HOME/gems"' >> ~/.bashrc
echo 'export PATH="$HOME/gems/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Finally, install Jekyll and Bundler:

gem install jekyll bundler

You can make a quick start for surfing the Jekyll blog:

jekyll new my-awesome-site
cd my-awesome-site
bundle exec jekyll serve
# => Now browse to http://localhost:4000

Or, clone the repository from GitHub and build Jekyll blog:

git clone https://github.com/IcingTomato/blog.old.git
cd blog.old
jekyll serve
# => Now browse to http://localhost:4000

Liquid warning

If you follow the step, congratulation, you cannot see any blog in your website.

Just like this:

Well, because Ruby2.5 made its Bundler incompatible with Jekyll-4.0, so we have to uninstall Jekyll-4.0 and install the previous versions.

gem uninstall jekyll
gem install jekyll -v 3.1.3

Jekyll Serve

jekyll serve will publish your site on localhost:4000. But you can change the port:

jekyll serve --port 4001

But you can’t visit it on public network. So you can:

jekyll serve -w --host=0.0.0.0

After doing these jobs, we can’t visit our website ethier.

Nginx Configuration

Because Jekyll uses port 4000, so we will make a Nginx “proxy” from port 4000 to port 80.

First, install Nginx:

sudo apt-get install nginx

Then, use your favourite text editor to edit /etc/nginx/conf.d/jekyll.conf:

root@blog:~# sudo nano /etc/nginx/conf.d/jekyll.conf

server {
    listen 80;
    server_name your.domain;
    location / {
        proxy_pass http://localhost:4000;
    }
}

Finally, Ctrl+O and Ctrl+X to save and exit, then restart nginx.service:

sudo systemctl restart nginx
jekyll serve --detach

【安卓搞机记】Google Pixel XL 折腾记

2018-01-22T00:00:00+00:00

我在18年的时候，攒了好久的一笔钱，买了 Pixel XL，换掉了可怜的 iPhone5s，然后就开始了我的折腾之路。

前言

手机摔个稀碎，没法拍图了

Pixel/Pixel XL V版解锁教程

退出谷歌账号，取消屏幕密码，删除指纹
把设备恢复出厂设置
跳过设置向导所有东西，不要连接wifi
进入开发者选项开启USB调试，并授权电脑访问
电脑使用adb命令

adb shell pm uninstall --user 0 com.android.phone 
adb reboot

比较关键的一步，国内很多人卡在这里，主要是要让手机可以访问谷歌并且消除wifi上的X号，我的方法是先使用adb命令（或者科学上网法）

adb shell settings put global captive_portal_https_url https://www.google.cn/generate_204 

然后开关飞行模式，再开启外网，再连接wifi，就可以消除信号x了

设置锁屏密码为图形，再通过桌面的google程序登录谷歌账号
这时候再回去开发者选项就会看到OEM解锁可以开了
打开OEM解锁重启进入BootLoader

电源+音量+ 或

adb reboot bootloader

使用adb命令

fastboot oem unlock

或

fastboot flashing unlock

然后手机会进入一个界面，音量键选择YES（将会清除所有数据）
清除完了之后手机会跳回到BootLoader界面，可以看到底下已经是UNLOCK状态了
然后重启手机，再进入开发者选项，就会看到OEM解锁那里已经是解锁状态了

如何进入Bootloader界面？

方法一：手机关机，等待3秒钟，按住音量下1秒，不要松开，然后按住电源键，等待手机振动，手机进入bootloader界面。
方法二：手机关机，等待3秒钟，按住音量下1秒，链接电源线，等待手机振动，手机进入bootloader界面。
方法三：手机开机状态下，打开usb调试，在cmd窗口中手动输入

adb reboot bootloader

线刷包刷机教程

在谷歌Pixel镜像下载对应的线刷包
然后把所有的文件放到同一个文件夹内
手机进入Bootloader界面，链接电脑
这时候可以确认驱动是不是安装好了，打开设备管理器
双击刚才那个文件夹下的 flash-all.bat，开始刷机（刷机会清除所有数据哦）
刷机过程中手机会重启多次，请静静等待结束

为什么要解锁 Bootloader？

解锁 Bootloader 是打开玩机之门的钥匙。只有在 Bootloader 解锁的前提下，我们接下来的步骤才得以顺利进行：安装 TWRP、获取 Root 权限……最后，通过一些需要 Root 权限的特殊手段，打开位置历史记录功能，获得近乎完整的 Android 体验。

让我们直奔正题吧：

（注意：解锁 Bootloader 重置设备数据，请注意备份）

首先，我们需要安装必（ni）备（dong）的工具并成功接入互联网。

前往「设置-关于手机-版本号」，猛击版本号 7 次开启「开发者选项」。

在开发者选项中开启「OEM 解锁」。若该选项显示为灰色，请检查你的网络连接是否正（ke）常（xue）USB 调试。

在 Pixel 设备中，开启 OEM 解锁需要连网

通过数据线将手机连接至电脑，以管理员身份运行命令提示符（CMD），输入 adb shell 并回车。

此时，手机端会弹出 USB 调试申请，点击「允许」。

回到命令提示符窗口，键入

adb reboot bootloader

并回车，手机会立即重启至 Bootloader 模式。

在 Bootloader 解锁界面中，使用音量键 +/- 来控制光标，选择「Yes」并按下电源键来进行 Bootloader 解锁。

稍等片刻之后，你的设备会自动重启，开机时屏幕下方出现一把打开的小锁，那 Bootloader 就解锁成功啦。

刷入第三方 Recovery —— TWRP

如果说 Bootloader 是玩机大门上的那把锁，那么 TWRP 就是你打开玩机之门后的领路人。

所以在解锁 Bootloader 之后，紧接着要做的事情就是刷入第三方 Recovery —— TWRP。由于 Pixel 与 Nexus 的系统分区方式不同，刷入 TWRP 的方式也略为复杂一些：

首先，前往 TWRP 官网下载最新版 TWRP 压缩包（.zip）和临时 TWRP 镜像文件（.img）。

将 .img 文件留在电脑上，同时将 .zip 文件拷贝至内置储存。

重启手机至 Fastboot 模式（参考上面的方法或关机后长按「电源」和「音量 -」），在电脑以管理员身份运行命令提示符。

在命令提示符窗口中输入 cd 你的 .img 文件路径来进行定向（比如我的 .img 文件放在 E:\Android 下，那就键入 cd E:\Android 并回车），然后输入

fastboot boot xxx.img //xxx 为具体的文件名

此时手机会重启至临时 TWRP。

在临时 TWRP 中，选择「Install」，找到我们事先放在内置储存中的压缩包文件，点击刷入。

至此，我们就已经用第三方 TWRP 替换了系统自带的 Recovery，接下来的 Root 操作也得以进行：

前往 SuperSU 官网下载最新版 SuperSU 压缩包。

将压缩包拷贝至手机内置储存。

重启手机至 TWRP（关机后长按「电源」和「音量+」），找到 SuperSU 压缩包并刷入。

完成后重启手机，首次启动过程会自动中断并再次自动重启，不用担心。开机后，手机便已获得 Root 权限，SuperSU 权限管理应用也已经安装至系统当中。

做好这些工作之后，我们就可以进一步使用 LocationReportEnabler 等需要 Root 权限的应用来开启位置记录报告功能，最终获得完整的 Android 生态体验了。

如何进行系统更新

非 Root 用户很难对系统文件进行修改，但在进行系统更新时则较为轻松，在保证网络条件畅（ke）通（xue）的前提下，只需前往「设置-关于-系统更新」，便可自动检查、下载并升级至最新版本的 Android 操作系统。

但对 Root 用户而言，手动刷入工厂镜像进行系统更新的方法则更为稳妥。

首先，我们需要前往 Google 的 Nexus/Pixel 工厂镜像网站找到并下载最新版本的 Android 系统镜像，然后解压。

完整工厂镜像文件压缩包包含了这些内容

如果你是拿到手机想要优先进行系统升级的用户，将手机重启至 Fastboot 模式并连接电脑后，直接运行 flash-all.bat 即可全自动升级至最新版本；如果你想保留升级前的系统数据，则需要在运行 flash-all.bat 前对其进行一些处理。

使用文本文档、Notepad++ 等工具打开 flash-all.bat，找到

fastboot -w update image-marlin-xxxxxx.zip

字段，将其改为

fastboot update image-marlin-nof27b.zip //即去掉 -w

然后保存，即可利用修改后的 flash-all.bat 文件在保留数据的前提下进行系统更新。

另外，在运行 flash-all.bat 进行更新的过程中，很有可能会出现报错。报错文本类似于

archive does not contain 'boot.sig'
archive does not contain 'recovery.sig'
archive does not contain 'system.sig'

当出现这样的字段时，千万不要终止操作。耐心等待耐心等待耐心等待！只要最后出现

finished. total time: 128.109s 
Press any key to exit...

即是升级成功，手机也会自动重启进入新系统。

另外，在这个过程中所出现的错误往往和 platform-tools（包含 ADB、fastboot 等）版本过旧有关。所以遇到其他形式的报错也不用惊慌，前往 Google 官方网站下载安装最新版本的 platform-tools 后，再次执行以上操作步骤即可。

Google 从年初开始提供独立的 platform-tools 下载

与非 root 系统自动更新相比，手动刷入完整版工厂镜像尽管要麻烦不少，但也更加灵活。

举个例子，我的 Pixel XL 到手时的系统版本是 Android 7.1.1，但安全更新补丁停留在去年 10 月。如果采用非 root 系统自动更新的方法，那我总计需要更新五次才能更新至最新的 3 月安全更新补丁。

手动 Fastboot 刷入工厂镜像则简单许多，只要我们刷入的是完整版工厂镜像，就可以无视版本跨度，一次性升级至最新版本。

原生安卓WiFi信号去叹号去叉教程5.0-Android P

Captive Portal是安卓5引入的一种检测网络是否正常连接的机制，制作的非常有创意，通过HTTP返回的状态码是否是204来判断是否成功，如果访问得到了200带网页数据，那你就可能处在一个需要登录验证才能上网的环境里，比如说校园网，再比如说一些酒店提供的客户才能免费使用的WiFi（其实是通过DNS劫持实现的），如果连接超时（根本就连接不上）就在WiFi图标和信号图标上加一个标志，安卓5和6是叹号，安卓7改成一个叉了。只不过默认访问的是谷歌自家的验证服务器，然而由于你懂的原因，就算你连接上了网络也连不上这个服务器… 嗯…那其实还是没有连接上网络嘛… 噫….

谷歌设计了一个开关来控制是否启用这个特性，同时也提供了一个变量来控制待验证的服务器地址，国内的修改版ROM通常都改成了高通中国的地址，还有一些ROM设计了代码在重启的时候恢复这个设置，不知道是出于什么目的。

没更新7.0的时候，一直用小狐狸的叹号杀手，很不错的应用，可惜当时他已经很久不更新了，当时安卓N不能用，后来自己做了个小工具，想了想就干脆上架酷安吧，也能帮助大家，这样有了CaptiveMgr工具，这分明就是个没有名字的名字嘛…根本就是foo, bar一样…好像也没什么好叫的了？现在代码还比较乱，要是哪天有空把这堆代码整理出来就开源了算了，毕竟纯粹体力活。

具体的原理不在这里写了，这里主要写如何去掉叹号或者叉标志。

如果有root权限直接用我这个工具算了，比较方便，毕竟用命令也就是检测一下系统然后代替执行命令而已嘛。

(PS: 如果使用SS/SSR可以通过NAT模式让系统直接连接，其内部是通过iptables实现的)

如果没有root权限就得按下面操作了，做好配置以后重启WiFi和数据流量（打开再关闭飞行模式即可）就可以看到效果了。

以下需要ADB调试，配置不赘述

5.0 - 6.x教程

5和6还不支持HTTPS，直接修改即可

检测开关相关：

先处理开关状态，这个变量删除就是默认开启的，删除操作随意执行，反正没影响，删除状态下获取这个变量会返回null。

注意：如果关闭，则无法判断当前网络是否需要登录，无法自动弹出登录页面

adb shell settings delete global captive_portal_server //删除
adb shell settings put global captive_portal_server 0 //禁用
adb shell settings get global captive_portal_server  //查询状态

服务器地址相关：

adb shell settings delete global captive_portal_server  //删除地址就可以恢复默认的谷歌服务器
adb shell settings put global captive_portal_server captive.v2ex.co  //设置一个可用地址（高通/V2EX都推荐）
adb shell settings get global captive_portal_server  //查询当前地址

7.0 - 7.1教程

这两个版本相比5和6没有大的更改，只是默认连接服务器的时候使用HTTPS，但是提供了一个开关用以指定是否使用HTTPS

检测开关相关：同5.0 - 6.x

HTTPS开关相关：

adb shell settings delete global captive_portal_use_https  //删除（直接删除则默认使用HTTPS）
adb shell settings put global captive_portal_use_https 0  //禁用HTTPS（写1启用 写0禁用）
adb shell settings get global captive_portal_use_https  //查询HTTPS开关状态

服务器地址相关：（如果启用了HTTPS需要先确定地址是否支持HTTPS）同5.0 - 6.x

7.1.1教程

这个版本把HTTPS和HTTP两个地址分开保存，并通过7.0加入的HTTPS开关来控制使用哪一个地址。

检测开关相关：同5.0 - 6.x

HTTPS开关相关：同7.0 - 7.1

服务器地址相关：

adb shell settings delete global captive_portal_https_url  //删除（删除默认用HTTPS）
adb shell settings delete global captive_portal_http_url

分别修改两个地址

adb shell settings put global captive_portal_http_url http://captive.v2ex.co/generate_204
adb shell settings put global captive_portal_https_url https://captive.v2ex.co/generate_204

7.1.2教程

此版本服务器地址判断逻辑相比7.1.1没有更改，但是检测的开关却变了。

检测开关：

#删除变量：（删除以后默认启用）
adb shell settings delete global captive_portal_mode
#关闭检测：
adb shell settings put global captive_portal_mode 0
#查看当前状态：
adb shell settings get global captive_portal_mode

服务器地址相关（同7.1.1）：

#删除（删除默认用HTTPS）
adb shell settings delete global captive_portal_https_url
adb shell settings delete global captive_portal_http_url  
#分别修改两个地址
adb shell settings put global captive_portal_http_url http://captive.v2ex.co/generate_204
adb shell settings put global captive_portal_https_url https://captive.v2ex.co/generate_204

8.0.0和8.1.0和9.0(Android P)同上7.1.2，未做修改

隐藏导航栏和状态栏

#全屏沉浸：
adb shell settings put global policy_control immersive.full=*

#沉浸状态栏：
adb shell settings put global policy_control immersive.status=*

#沉浸导航栏：
adb shell settings put global policy_control immersive.navigation=*

#单独控制某一个app不沉浸，比如以下代码设定google实时界面不沉浸，其他程序沉浸：
adb shell settings put global policy_control immersive.full=apps,-com.google.android.googlequicksearchbox

#恢复到正常方式：
adb shell settings put global policy_control null

adb 查看android手机中应用的包名和安装位置

#查看是否连接手机
adb devices

#进入指定的device的shell
adb shell
#或者
adb -s ********* shell

#adb 查看所有安装的包
adb shell pm list packages

#根据某个关键字查找包
pm list packages | grep tencent

#查看包安装位置
pm list packages -f

#同样可以进行筛选
pm list packages -f | grep tencent

#将apk拉到pc中
adb pull /data/app/com.tencent.tbs-1/base.apk ~/Downloads

黑阈

adb -d shell sh /data/data/me.piebridge.brevent/brevent.sh

Google Pixel 电信破解

仅适用于一代，无需双清，无需QPST，摆脱繁琐的刷机

在Android Pie下测试通过，重启后不丢失

开发者模式中开启 OEM 解锁后，重启手机进入 bootloader 模式，在电脑端运行 fastboot oem unlock

注：此过程会清除手机数据，请及时备份。

下载modem.img

刷入modem.img

fastboot flash modem_a modem.img
fastboot flash modem_b modem.img

理论上不支持移动和联通，如更换请重刷官方底包

注意（如果有路由器级别kexue可以忽略）

你需要2018年3月或之前的系统。原因是这样的：有一个叫frp的分区，它的全称是——Factory Reset Protection。开机设置读取frp，得知是否首次开机。清除frp，伪装成首次开机。不幸的是，4月的官方镜像里的开机设置没有这种操作。开机设置才不管frp呢，必须联网。所以在恢复出厂设置前一定要看看你的安全补丁日期是哪个月的！！如果是4月的需要先刷回3月。

2021年2月21日补记

忘记是哪一次刷机的时候Pixel和Pixel XL的包搞混了，在Pixel上刷了XL的包，结果还能用？就是屏幕的最小宽度（可以在设置 -> 系统 -> 开发者选项 -> 绘图 下面更改）变了好像？

【Linux】Fedora 上手配置

【博客搭建】Jekyll 语法高亮配置

Java

Scala

C++

Python

【Linux】Inline assembly for x86 in Linux

GNU assembler syntax in brief

Register naming

Source and destination ordering

Size of operand

Immediate operand

Indirect memory reference

Inline assembly

Memory operand constraint(m)

Matching(Digit) constraints

Examples of common inline assembly usage

“asm” and the register constraint “r”

Use of specific register constraints

Using matching constraints

Use of memory operand constraint

Using clobbered registers

Conclusion

Resources

【Linux】Linux 汇编语言开发指南

简介

Linux 汇编语法格式

Hello World!

Linux 汇编工具

系统调用

命令行参数

小结

参考资料

【搞机小子】Airpi AP3000M 5G CPE 使用体验

【赛博丁真】让你的笔电也加入 5G

【玩转树莓派】VSCode 远程登录树莓派并免密登录

安装 VSCode 及 Remote SSH 插件

生成 SSH 密钥对（如果没有的话）

登录树莓派并上传公钥

编辑 SSH 配置文件（Windows）

【阅板无数】使用 OpenOCD 对 Raspberry Pi CM5 进行调试

测试点位

树莓派配置

OpenOCD 配置

启动 OpenOCD 开始调试

使用 GDB 连接 OpenOCD

参考资料

【阅板无数】（Intel x86 IoT系列）Intel Quark D2000 复活记

前言

规格

结语

复活雷神的锤子

Pin Map

Pin Name

Example

手动编译 IAMCU i586 的工具链

环境

烧录

配置 Zephyr RTOS

环境准备

下载 Zephyr 源码

安装 Python 依赖项

构建应用程序

完成

补记 （2026-01-22 更新）

引用

【Linux 从入门到重修C语言】系统调用的一种奇技淫巧

【玩转树莓派】制作一个口袋服务器 2

连接 Wi-Fi

换源

更新软件包列表并安装 ifupdown 和 dnsmasq

配置 USB 网络

设置 Swap

结语

番外

IP 转发

【玩转树莓派】制作一个口袋服务器

烧录镜像

UART 连接

配置USB网络

补记（2026-01-22 更新）

更新软件包列表并安装 `ifupdown` 和 `dnsmasq`

`git rm` 操作步骤

【Calc】CASIO Graph Light Lycée 法版中文翻译

【WSFC 学习笔记】如何理解 Windows Server 故障转移群集的 Quorum

技术规格⁵