逍遥子

记一次 arm64 非法内存访问调试

Tue, 01 Nov 2022 21:25:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

最近工业软件组的小朋友在移植程序到arm64下的时候碰到了一个比较难调诡异的问题，花了几个小时帮忙调试了一下，将过程记录一下。防止以后踩坑。

问题分析

程序执行到某一个分支的时候内存飞了。用gdb分析dump文件，提示非法内存访问。提示 cannot access memory at address 0xxxxxxxx 这种错误。由于软件代码比较庞大（几十万），没有第一时间去检查编译配置，编译日志等等（后面正好是这个地方出错！！！），只能去定位具体的函数。

实际代码比较复杂，我做了简化: 有两个c文件，a.c 和 b.c，其中b.c有一个函数 foo() ，返回一个指针，a.c 中获取这个指针然后打印。

// a.c
#include <stdio.h>
int main()
{
    char *p = foo();                  // <-- 留意这里
    printf("addr in a: %p\n", p);
}

// b.c
#include <stdio.h>
#include <stdlib.h>
char *foo()
{
    char *p = malloc(1024);
    printf("addr in b: %p\n", p);
    return p;
}

$ gcc -o test a.c b.c && ./test
addr in b: 0x798e04e260
addr in a: 0xffffffff8e04e260       // <-- 高4位的地址全被置1了。导致得到的指针地址非法。

排查

用 gdb 断点跟踪，foo返回的指针是对的，但是一出 foo 函数，赋值给p就出错了(高4位置为1) 为啥？

用反汇编查看，恶魔终于现行了。

foo:
    // cut start
    mov x0, 1024
    bl  malloc
    str x0, [sp, 24]
    ldr x0, [sp, 24]                    //<-- 这里 x0 得到了正确的地址
    ret
    // cut end

main:
    // cut start
    bl  foo                             //<-- 调用 foo，返回值存在 x0 中
    sxtw    x0, w0                      // <-- 为毛这里还有一个符号扩展的 xstw 操作??
    // cut end

我们知道无论是 x86 还是arm，编译器一般将第一个寄存器当做函数的参数和返回值。从上面的汇编分析，出错的根源在于编译器在调用完 foo 之后对 x0 做了 sxtw 操作，将 x0 的低32位寄存器 w0 不变，高 32 位全置1。这闹的。。。

原因很清楚了，google 了一下为什么会多出来这行汇编，根源在于对于 foo() 的隐式申明的函数调用，在 x86 平台下，gcc做了多余的处理，从而使得返回值满足64位的长度。至于在32位下为什么没有问题，因为32位系统下，int型和指针类型都是一样长度的。我做了验证，x86 下的情况也是一样，会多插入一条 cltq 扩展位数的指令。

When C doesn't find a declaration, it assumes this implicit declaration: int f();, which means the function can receive whatever you give it, and returns an integer. If this happens to be close enough (and in case of printf, it is), then things can work. In some cases (e.g. the function actually returns a pointer, and pointers are larger than ints), it may cause real trouble.

Note that this was fixed in newer C standards (C99, C11). In these standards, this is an error. However, gcc doesn't implement these standards by default, so you still get the warning.

从上可知，调用返回值的长度大于 4个字节的函数，如果没有在调用者那里申明，在 64 位系统下就一定位发生异常。比如下面的代码

// a.c 
#include <stdio.h>
int main()
{
    long int p = foo();
    printf("p in a: %ld\n", p);
}

// b.c
#include <stdio.h>
#include <stdlib.h>
long foo()
{
    long p = 0x1000000001;
    printf("p in a: %ld\n", p);
    return p;
}

总结

教训就是对研发团队来讲，一定要做好代码审查，在编译c/c++项目的时候，不要忽略任何警告！最好引入小型的 CI/CD 工具，在编译期间就把这类问题给彻底fix掉。否则会在很多低级错误上花费大量时间。

Xenomai 安装部署

Thu, 09 Jun 2022 18:54:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

简介

Xenomai 主要由三部分组成：

cobalt: 内核空间的实时内核。
dovetail: 类似 ADEOS的实现，管理分发中断。Liunx 5.4 以前的代码这部分工作由 ipipe处理。
libcobalt: 用户空间的实时库。

cobalt 和 libcobalt 随 xenomai 源码提供，dovetail 与具体的硬件架构和Linux 版本相关，以Linux补丁的形式提供。

环境准备

NOTE: 编译的机器和目标机器可以不在一台

ubuntu 22.04
kernel 5.15.55
dovetail 5.15.51-dovetail1
xenomai v3.2.1

安装基本工具软件：

# 安装部署编译依赖包
# apt-get install -y build-essential libncurses-dev flex bison libssl-dev dkms libelf-dev libiberty-dev pahole \
  devscripts debhelper autotools-dev autoconf automake libtool pkg-config libltdl-dev
# mkdir -p ~/xenomai && cd ~/xenomai  # 将 ~/xenomai 作为工作目录, 个人习惯

准备内核源码和补丁

准备内核源码

# wget -c https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.15.55.tar.xz
# tar xf linux-5.15.55.tar.xz

准备补丁：由于dovetail 是一个内核补丁，所以选择 dovetail 的时候需要和对应的内核版本匹配。在这里选择对应的版本，这里选择 patch-5.15.51-dovetail1.patch.bz2

# wget https://xenomai.org/downloads/dovetail/patch-5.15.51-dovetail1.patch.bz2
# bzip -d patch-5.15.51-dovetail1.patch.bz2

准备 xenomai 源码

从这里下载最新稳定版，这里选择 3.2.1 版本。

# wget -c https://source.denx.de/Xenomai/xenomai/-/archive/v3.2.1/xenomai-v3.2.1.tar.bz2
# tar xf xenomai-v3.2.1.tar.bz2

编译安装内核

打内核补丁

根据 xenomai 的架构，需要对linux内核打 dovetail 和 cobalt的补丁。

打 dovetail 补丁:

# cd ~/xenomai/linux-5.15.55/
# patch -p1 < ../patch-5.15.51-dovetail1.patch  # 打 dovetail 补丁

打 cobalt 补丁:

首先生成 cobalt 补丁:

# cd ~/xenomai/xenomai-v3.2.1/scripts/
# ./prepare-kernel.sh --help
usage: prepare-kernel --linux=<linux-tree> [--dovetail=<dovetail-patch>]|[--ipipe=<ipipe-patch>] [--arch=<arch>] [--outpatch=<file> [--filterkvers=y|n] [--filterarch=y|n]] [--forcelink] [--default] [--verbose]
# --linux 指定 linux 源码路径
# --dovetail 制定 dovetail 补丁，因为选择手动打补丁，这里忽略
# --arch 指定硬件架构，这里选择 x86_64
# --outpath 指定输出 cobalt 补丁的路径
# ./prepare-kernel.sh --linux=/root/xenomai/linux-5.15.55 --arch=x86_64 --outpatch=/root/xenomai/cobalt-core-3.2.1-1.patch

应用 cobalt 补丁

# 回到 linux 打补丁
# cd ~/xenomai/linux-5.15.55/
# patch -p1 < ../cobalt-core-3.2.1-1.patch

配置内核选项

# cd ~/xenomai/linux-5.15.55/
# 配置内核选项是很麻烦的，为了方便，在现在运行的 ubuntu 的内核基础上修改可以节省大连工作量，如果为了生产环境，建议手动配置所有内核选项，做出一个精简的内核。
# cp /boot/config-$(uname -r) .config
# make menuconfig

默认会看到这样的警告，需要针对 xenomai 将一些内核选项配置完成之后这些警告才会消失。

[*] Xenomai/cobalt (NEW)  --->
    *** WARNING! Page migration (CONFIG_MIGRATION) may increase ***
    *** latency. ***
    *** WARNING! At least one of APM, CPU frequency scaling, ACPI 'processor' ***
    *** or CPU idle features is enabled. Any of these options may ***
    *** cause troubles with Xenomai. You should disable them. ***

依次进行以下修改:

General setup
  --> Preemption Model (Preemptible Kernel (Low-Latency Desktop))
    --> (X) Preemptible Kernel (Low-Latency Desktop)   --> 配置可抢占式内核

Processor type and features
  --> Processor family
    --> (X) Core 2/newer Xeon                          --> 根据具体的处理器架构选择。
  --> [ ] Multi-core scheduler support                 --> 关闭多核调度优化，后面的 CPU 自动调频依赖此项

Power management and ACPI options
  --> ACPI (Advanced Configuration and Power Interface) Support
    --> < > Processor
  --> CPU Frequency scaling
    --> [ ] CPU Frequency scaling                      --> 关闭 CPU 自动调频
  --> CPU Idle
    --> [ ] CPU idle PM support                        --> 关闭 CPU idle 特性

Memory Management options                              --> 关闭影响实时性的内存选项
  --> [ ] Allow for memory compaction
  --> [ ] Transparent Hugepage Support
  --> [ ] Contiguous Memory Allocator
  --> [ ] Page migration

NOTE: linux各个发行版默认选择大部分驱动和功能，这里最好也将这些选项去掉只保留适合目标机器的精简内核，否则编译时间和编译完成的体积会非常大。以下是建议关闭的选项:

[ ] Linux guest support                  --> 作为虚拟机guest运行才需要此项
[ ] Suspend to RAM and standby           --> xno: 关闭休眠到内存选项, S3 state
[ ] Hibernation (aka 'suspend to disk')  --> xno: 关闭休眠到磁盘选项
< > Microsoft Hyper-V client drivers     --> 去掉 hyperv 虚拟机驱动支持
File systems                             --> 禁用不需要的文件系统
Device Drivers                           --> 禁用不需要的设备驱动

编译内核

# make -j$(nproc) bindeb-pkg  # 选择直接编译打包为 deb 包.

编译完成后会生成一系列 .deb 包：

# lsd -1 linux-*.deb
linux-headers-5.15.55_5.15.55-1_amd64.deb
linux-image-5.15.55-dbg_5.15.55-1_amd64.deb
linux-image-5.15.55_5.15.55-1_amd64.deb
linux-libc-dev_5.15.55-1_amd64.deb

安装新内核

进入目标机器，执行

# dpkg -i linux-image-5.15.55_5.15.55-1_amd64.deb

编译安装 xenomai

# cd ~/xenomai/xenomai-v3.2.1/
# debuild -us -uc  # 使用debuild工具编译成 .deb 包
# dpkg -i xenomai-runtime_2.99.0_amd64.deb \
  libxenomai1_2.99.0_amd64.deb \
  libxenomai-dev_2.99.0_amd64.deb

测试使用

首先使用自带的 xeno-test 工具检查基本环境，简单的延迟测试等，看是否有问题。 检查 no support 选项

# xeno-test  # 使用 xeno-test 工具做基本的环境测试
......
arith OK
cpu_affinity skipped (no kernel support)
gdb OK
......

手动编写一个实时demo调用xenomai 接口测试一下情况

// gcc -o hello hello.c $(xeno-config --posix --alchemy --cflags) $(xeno-config --posix --alchemy --ldflags)
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <xenomai/alchemy/task.h>

RT_TASK demo_task;

void demo(void *arg)
{
  RT_TASK_INFO curtaskinfo;

  // 获取当前任务信息并打印
  rt_task_inquire(&demo_task, &curtaskinfo);
  // NOTE: 实际实时应用开发中，linux系统调用不放在实时任务中，防止系统切换
  printf("Task name : %s \n", curtaskinfo.name);
}

int main(int argc, char* argv[])
{
  char *str = "demo";

  printf("start task\n");

  rt_task_create(&demo_task, str, 0, 50, 0);
  rt_task_start(&demo_task, &demo, 0);

  sleep(1);
}

如果实时内核没有运行的话，xeno-test 和测试程序分别会报以下错误:

# xeno-test
Started child 1807: /bin/bash /usr/lib/xenomai/testsuite/xeno-test-run-wrapper /usr/bin/xeno-test
++ echo 0
/usr/bin/xeno-test: line 91: /proc/xenomai/latency: No such file or directory

# ./hello
   0"000.000| BUG in low_init(): [main] Cobalt core not enabled in kernel

Go 使用 sqlite3 数据库

Mon, 08 Nov 2021 17:54:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

目前常用的 Go 的sqlite 的驱动有以下几个:

https://github.com/mattn/go-sqlite3 基于 cgo实现，支持database/sql接口。
https://github.com/feyeleanor/gosqlite3 基于cgo，不支持database/sql接口。
https://github.com/phf/go-sqlite3 基于cgo，不支持database/sql接口。

因为 mattn 的实现支持 go 的sql接口，所以选择使用这个。

package main

import (
    "database/sql"
    "fmt"

    // 即使导入了 sql, 这里也要显示导入 go-sqlite3,
    // 否则报错 open db err: sql: unknown driver "sqlite3" (forgotten import?)
    _ "github.com/mattn/go-sqlite3"
)

const sql_file string = "/tmp/maan.sqlite3"
const create string = `
    CREATE TABLE trade (
        id INTEGER NOT NULL,
        date DATETIME NOT NULL,
        code VARCHAR NOT NULL,
        name VARCHAR,
        op INTEGER,
        number INTEGER,
        price FLOAT,
        PRIMARY KEY (id)
    );
    INSERT INTO trade (date, code, name, op, number, price)
    VALUES ('2022-06-01', '1234', '平安', 1, 100, 90.0);
    INSERT INTO trade (date, code, name, op, number, price)
    VALUES ('2022-06-02', '1234', '平安', 0, 100, 92.0);
    INSERT INTO trade (date, code, name, op, number, price)
    VALUES ('2022-06-03', '2234', '石油', 0, 4, 6.0);
    INSERT INTO trade (date, code, name, op, number, price)
    VALUES ('2022-06-05', '3234', '媒体', 1, 5, 7.0);
    `

func doExec(db *sql.DB, sql string, args ...interface{}) {
    stmt, err := db.Prepare(sql)
    if err != nil {
        fmt.Println("database error", err)
        panic(err)
    }
    defer stmt.Close()
    stmt.Exec(args...)

}
func main() {
    // open db
    db, err := sql.Open("sqlite3", sql_file)
    if err != nil {
        fmt.Println("open db err:", err)
        return
    }
    // lazy close db
    defer db.Close()

    // create db
    if _, err := db.Exec(create); err != nil {
        fmt.Println("create table err:", err)
        return
    }

    // insert row
    sql := `INSERT INTO trade (date, code, name, op, number, price) 
 VALUES ('2022-06-09', '1234', '平安', 1, 120, 52.0)`
    doExec(db, sql)

    // delete row
    sql = "DELETE FROM trade WHERE id=?"
    doExec(db, sql, 1)

    // update row
    sql = "UPDATE trade SET NAME=? WHERE id=2"
    doExec(db, sql, "更新")

    // query sql
    rows, err := db.Query("SELECT id, name, date, number, price FROM trade WHERE code=?", "1234")
    if err != nil {
        fmt.Println("query db err:", err)
        return
    }
    defer rows.Close()
    for rows.Next() {
        var uid int
        var name string
        var date string
        var number string
        var price float32
        rows.Scan(&uid, &name, &date, &number, &price)
        fmt.Printf("id: %d, name=%s, date: %s, number: %s, price: %f\n", uid, name, date, number, price)
    }
}

Go 项目的静态编译方式

Thu, 07 Oct 2021 17:54:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

默认 go 语言是静态编译的, 比如:

$ cat hello.go && go build hello.go && file hello && ldd hello
package main
import "fmt"
func main () {
    fmt.Println("hello")
}

hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
        not a dynamic executable

但是对于使用了 CGO 机制直接用 C 代码的项目，默认情况下是动态链接的, 这在比如容器环境下调试非常不方便，所以最好采用静态链接的方式。在实践中，通常又分为两种方式：

自己的项目工程中使用了 CGO

例如以下情况:

$ cat hello1.go && go build hello1.go && file hello1 && ldd hello1
package main

//#include <stdio.h>
import "C"

func main() {
    C.puts(C.CString("Hello, Cgo\n"))
}
hello1: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=0cb254b1d81832db6f1685361a7e6c228a1bdae3, not stripped
        linux-vdso.so.1 =>  (0x00007ffe8f065000)
        libpthread.so.0 => /lib64/libpthread.so.0 (0x00007fb96dd1e000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fb96d950000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fb96df3a000)

在容器环境下调试代码的时候，外部编译好的程序由于依赖的关系，在容器中会运行失败

$ cat hello1.go
package main

// #include <stdio.h>
// void hello() {printf("hello1\n");}
import "C"

func main() {
    C.hello()
}
$ go build -o /tmp/hello1 hello1.go && docker run -ti --rm -v /tmp:/data busybox /data/hello1
exec /data/hello1: no such file or directory

这个时候需要采用静态编译的方式来构建程序

$ go build -o /tmp/hello1 -ldflags '-extldflags "-static"' -a hello1.go && file hello1
hello1: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=be8ef4888e8e1d29787b32e0a6ad8064e60a931a, not stripped

$ docker run -ti --rm -v /tmp:/data busybox /data/hello1
hello1

其中：

-ldflags 表示传递给 Go 链接器的参数
-extldflags "-static" 告诉 Go 的链接器采用静态编译该程序

导入的标准库中使用了 CGO

目前标准库中有两个模块使用了 CGO：

os/user 有原生go实现和C实现。c实现的好处在于能在 LDAP等获取用户信息，一般用不到。
net 同样有两个实现，大部分情况下 go 的实现已经够用了。

因此，只要将上面两个模块使用 go 原生实现就可以达到静态编译的效果，这里有两种方式实现：

第一种，使用 -tags osusergo,netgo 明确使用 go 的实现

$ go build main.go && file main
main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), not stripped

$ go build -tags osusergo,netgo main.go && file main
main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

第二种方式，使用 "CGO_ENABLED=0" 表示禁用 CGO

$ go build main.go && file main
main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), not stripped

$ CGO_ENABLED=0 go build main.go && file main
main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

注意：这种方式和上面提到的自己的项目中使用了 CGO 冲突。

Glib 的事件机制

Wed, 15 Sep 2021 17:54:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

GLIB 的事件机制比较复杂，设计好多概念和模块，网络上相关的介绍也比较乱，最好的理解方式就是自己动手敲一遍相关代码，然后做一个总结。

GLib 事件机制介绍

GLib 的事件框架主要有以下组件:

GMainLoop : 管理所有可用事件源, 添加初始事件源后，会不断检查来自每个事件源的新事件并分派相关函数处理.
GMainContext : 每个时间源创建之后都需要关联到一个 GMainContext 中。
GSource : 具体的事件源对象.

GLib 的事件分发机制流程：

创建一个 GMainContext
创建一个 GSource, 指定该 source 的相关元素，如准备事件,检查事件，分发执行函数等。将需要监控的事件源,回调函数等（如果有，如文件描述符）添加到source中，并将这个source关联到 GMainContext上。
创建一个 GMainLoop，并将 GMainContext 关联到这个loop上。
运行 loop。

此后 GMainLoop 将会按照我们设定的条件周而复始的开始处理事件，如对于文件读写，当有文件可读/可写时候，调用相关的回调函数读写等。

Demo

下面的 demo 展示从事件创建 -> 添加到context -> 关联到loop,运行的基本流程

#include <glib.h>
#include <stdio.h>
#include <string.h>

typedef struct DemoSource {
    GSource source;
    char *data;
} DemoSource;

/**
 * 如果 GSourceFuncs::prepare() 返回 TRUE, 则 GSourceFuncs::dispatch 立即执行
 * 如果 GSourceFuncs::prepare() 返回 FALSE:
 *   --> 等待 p_timeout 时间之后:
 *     --> 如果 GSourceFuncs::check() 返回 TRUE, 则 GSourceFuncs::dispatch 立即执行
 *     --> 如果 GSourceFuncs::check() 返回 FALSE, 继续进入 GSourceFuncs::prepare()
 */
static gboolean source_prepare(GSource *source, gint *p_timeout)
{
    static int i = 0;
    if (i++ % 4 == 0) {
        printf("%s:%d\n", __FUNCTION__, __LINE__);
        return TRUE;
    }

    printf("%s:%d\n", __FUNCTION__, __LINE__);
    *p_timeout = 1000;
    return FALSE;
    return FALSE;
}

static gboolean source_check(GSource *source)
{
    printf("%s:%d\n", __FUNCTION__, __LINE__);
    return TRUE;
}

static gboolean source_dispatch(GSource *source, GSourceFunc callback,
                                       gpointer user_data)
{
    printf("%s:%d\n", __FUNCTION__, __LINE__);
    return TRUE;
}

static GSourceFuncs source_funcs = {
    .prepare = source_prepare,
    .check = source_check,
    .dispatch = source_dispatch,
};

int main(int argc, char *argv[])
{
    char *data = "demo source";
    GMainContext *main_context;

    GSource *source = g_source_new(&source_funcs, sizeof(DemoSource));
    DemoSource *demo_source = (DemoSource *)source;
    demo_source->data = data;

    main_context = g_main_context_new();
    g_source_attach(source, main_context);
    g_source_unref(source);

    GMainLoop *loop = g_main_loop_new(main_context, FALSE);
    g_main_loop_run(loop);
    g_main_loop_unref(loop);

    return 0;
}

对于文件事件源，类似的处理，只不过多了文件是否可读写的相关操作。

#include <glib.h>
#include <stdio.h>
#include <string.h>

typedef struct DemoSource {
    GSource source;
    GIOChannel *channel;
    GPollFD fd;
} DemoSource;

/**
 * 对文件类型的source，GSourceFuncs::prepare() 返回 -1,
 * 然后在 GSourceFuncs::check() 中检查是否读写事件已经就绪.
 * 如果 check 检查到就绪，dispatch 调用callback执行。
 */
static gboolean source_prepare(GSource *source, gint *p_timeout)
{
    printf("%s:%d\n", __FUNCTION__, __LINE__);

    *p_timeout = -1;
    return FALSE;
}

static gboolean source_check(GSource *source)
{
    DemoSource *demo_source = (DemoSource *)source;

    if (demo_source->fd.revents != demo_source->fd.events) {
        return FALSE;
    }

    return TRUE;
}

static gboolean source_dispatch(GSource *source, GSourceFunc callback,
                                gpointer user_data)
{
    if (callback) {
        callback(source);
    }

    return TRUE;
}

static GSourceFuncs source_funcs = {
    .prepare = source_prepare,
    .check = source_check,
    .dispatch = source_dispatch,
};

gboolean watch(gpointer user_data)
{
    char *buf = NULL;
    gsize len = 0;
    DemoSource *source = (DemoSource *)user_data;

    g_io_channel_read_line(source->channel, &buf, &len, NULL, NULL);
    if (len > 0) {
        printf("%s", buf);
    }

    g_free(buf);
    return TRUE;
}

int main(int argc, char *argv[])
{
    GMainContext *main_context;

    GSource *source = g_source_new(&source_funcs, sizeof(DemoSource));
    DemoSource *demo_source = (DemoSource *)source;

    demo_source->channel = g_io_channel_new_file("/tmp/test.txt", "r", NULL);
    demo_source->fd.fd = g_io_channel_unix_get_fd(demo_source->channel);
    demo_source->fd.events = G_IO_IN;
    g_source_add_poll(source, &demo_source->fd);
    g_source_set_callback(source, watch, NULL, NULL);

    main_context = g_main_context_new();
    g_source_attach(source, main_context);
    g_source_unref(source);

    GMainLoop *loop = g_main_loop_new(main_context, FALSE);
    g_main_loop_run(loop);
    g_main_loop_unref(loop);

    return 0;
}

一般使用中直接使用 g_io_create_watch/g_io_add_watch 就可以简化相关代码

K3S 快速安装体验

Mon, 21 Jun 2021 16:35:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

k3s是经CNCF一致性认证的Kubernetes发行版，专为物联网及边缘计算设计。架构包含server节点，agent节点。在生产环境中部署，需要部署多server节点保证高可用。这里只是为了快速体验 k3s, 采用单节点 server 和多agent节点的方式。架构如下:

部署前工作

系统更新
网络配置：包括主机名配置，时区配置，软件源等
关闭防火墙，selinux
关闭交换分区

部署server节点

# 1. 先安装配置docker
[root@k3s1 ~]# yum install -y docker-ce
[root@k3s1 ~]# systemctl enable --now docker
# 2. 下载安装 k3s
[root@k3s1 ~]# wget https://rancher-mirror.rancher.cn/k3s/k3s-install.sh
# 2.1 默认 k3s 不适用docker，采用 containerd，这里特别指明采用 docker
# 2.2 使用 INSTALL_K3S_MIRROR=cn 环境变量制定使用国内源加速下载
# 2.3 k3s 自带 lb 插件，这里我们禁用这个插件，后面采用 metallb 的方案
[root@k3s1 ~]# INSTALL_K3S_MIRROR=cn bash k3s-install.sh --docker --disable=traefik
# 3. 查看 k3s 的 token, 后面部署 agent 用到
[root@k3s1 ~]# cat /var/lib/rancher/k3s/server/node-token
K1013f26620ae0297e33b4369b3e634d41a93994787d3f9ca6f3c24dbad8d898ba3::server:eb416ac93cf97f38599d9207ac3d74d6

部署 agent 节点

# 1. 安装配置 docker
[root@k3s2 ~]# yum install -y docker-ce
[root@k3s2 ~]# systemctl enable --now docker
# 2. 下载安装 k3s
[root@k3s2 ~]# wget https://rancher-mirror.rancher.cn/k3s/k3s-install.sh
# 2.1 默认 k3s 不适用docker，采用 containerd，这里特别指明采用 docker
# 2.2 使用 INSTALL_K3S_MIRROR=cn 环境变量制定使用国内源加速下载, SERVER_IP 是server服务器的IP地址，token通过上一步获取
[root@k3s2 ~]# INSTALL_K3S_MIRROR=cn K3S_URL=https://[SERVER_IP]:6443 K3S_TOKEN=[TOKEN] bash k3s-install.sh --docker

测试

部署完成后，在server节点验证集群情况

[root@k3s1 work]# kubectl get nodes
NAME   STATUS     ROLES                  AGE     VERSION
k3s1   Ready      control-plane,master   3m50s   v1.23.6+k3s1
k3s2   NotReady   <none>                 9s      v1.23.6+k3s1

[root@k3s1 work]# kubectl get pods -n kube-system
NAME                                      READY   STATUS              RESTARTS   AGE
helm-install-traefik-zd94v                0/1     ContainerCreating   0          3m50s
helm-install-traefik-crd-9qvk7            0/1     ContainerCreating   0          3m50s
coredns-d76bd69b-kmnwq                    1/1     Running             0          3m50s
local-path-provisioner-6c79684f77-wckqm   1/1     Running             0          3m50s
metrics-server-7cd5fcb6b7-m8ltf           1/1     Running             0          3m50s

部署一个nginx服务验证

[root@k3s1 work]# cat nginx.yaml && echo "==============================" && cat srv.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
==============================
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

[root@k3s1 work]# kubectl apply -f nginx.yaml
[root@k3s1 work]# kubectl apply -f svc.yaml
[root@k3s1 ~]# kubectl get svc
NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
kubernetes      ClusterIP   10.43.0.1      <none>        443/TCP        16h
nginx-service   NodePort    10.43.50.167   <none>        80:31574/TCP   3m18s

[root@k3s1 ~]# curl localhost:31574
<!DOCTYPE html>
......
</html>

部署负载均衡

k8s的LoadBalancer类型的Service依赖于外部的云提供的Load Balancer，metallb提供了在私有云或者裸机环境下的负载均衡方案。这里我们也采用 metallb 的方案。

安装 metallb

[root@k3s1 metallb]# kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.10.2/manifests/namespace.yaml
[root@k3s1 metallb]# kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.10.2/manifests/metallb.yaml
[root@k3s1 metallb]# kubectl get pods -n metallb-system
NAME                         READY   STATUS    RESTARTS   AGE
controller-f54fbc6f9-ppm96   1/1     Running   0          47s
speaker-g7g8l                1/1     Running   0          48s
speaker-h57p6                1/1     Running   0          48s

配置 metallb

[root@k3s1 metallb]# cat metallb-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2
      addresses:
      # 可配置为下列形式或者192.168.1.0/24形式，根据预留的网段具体决定
      # 可配置多个，根据实际情况配置
      - 192.168.137.111-192.168.137.121
[root@k3s1 metallb]# kubectl apply -f metallb-configmap.yaml
configmap/config created

测试

部署一个 lb 的service

[root@k3s1 metallb]# cat lb.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer
[root@k3s1 metallb]# kubectl apply -f metallb-configmap.yaml
configmap/config created

# 这里我手动修改了 pod 里面nginx的内容为他的内网ip地址以便测试
[root@k3s1 metallb]# curl http://192.168.137.111
10.42.1.3
[root@k3s1 metallb]# curl http://192.168.137.111
10.42.0.22

其他

k3s 不支持 docker 的 systemd 的 cgroupdriver, 如果有自定义docker配置，务必不要配置此项

QT Designer 使用未显示在工具箱中控件

Fri, 21 May 2021 16:35:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

在 QT 项目开发的时候，使用 QT Designer 进行 UI 设计的时候，有时候想用的控件不在 Designer 工具箱里面，比如 QWebEngineView 之类的控件就没有，会感到很别扭。在 QT 官方文档上查询了一下，可以通过 promote widget 的方式解决这个问题。

首先，拖动一个 widget 到放置控件的地方，右键这个 widget，选择提升为

最后在弹出的 promote 窗口上输入该控件的描述，包括控件类名和头文件，然后点击提升就可以了。

重启声卡服务

Fri, 21 May 2021 09:00:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

随着时间的变迁，我的老古董 Mac Air 又遇到新的问题，联系播放几小时电影之后，或者频繁地进行快进等操作的时候，画面突然会暂停，以为是显卡什么的坏了，进行一番排查之后，才发现罪魁祸首原来是名为 coreaudiod 的服务出现了 bug.

找到问题之后解决就很简单了. 重启该服务即可。PS: 在 Mac 上重启很多系统服务只需要杀死该服务即可，如 Finder 等。

$ sudo killall -9 coreaudiod

使用 Jekyll 和 Github 搭建个人博客

Tue, 30 Jun 2020 00:00:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

晕晕乎乎了两年，准备把停更的 blog 更新一下。但是时过境迁，很多技术方法都已经成为古董了，之前的blog是在 vps 上用 wordpress 搭建的，我在电脑上写好 emacs-org 格式的文章后，用脚本转换为 html 然后用 wordpress 的 API 发表的。现在不想太折腾了，简单研究了一番，发现用 Jekyll 和 github 的组合最方便省心。

大体思路为，文章还是在本地用 emacs-org 的格式来写(毕竟我用了10来年已经比较熟悉了)，然后用 pandoc 转换为基本的 markdown，最后写一个小脚本简单处理一下图片， jekyll tag 等问题。

安装 Jekyll

Jekyll 基于 ruby，所以首先要安装 ruby，这里选择使用 rbenv 来安装管理 ruby。

以下操作在我的 mac 上进行:

$ brew install rbenv ruby-build
$ echo 'eval "$(rbenv init -)"' >> ~/.bash_profile  
$ rbenv install -l              # 列出所有可安装的版本
$ rbenv install 2.7.1           # 安装最新稳定版本
$ rbenv global 2.7.1            # 设置全局 ruby 版本
# 将 gem 安装的文件列入可执行文件路径中
$ echo 'export PATH="$HOME/.gem/ruby/2.7.0/bin:$PATH"' >> ~/.bash_profile 

安装 Jekyll:

$ gem install --user-install bundler jekyll
$ jekyll -v   # 检查是否安装成功
jekyll 4.1.1

在 Github 上选择模板

这里选择 leopardpan 的 blog 模板: 在他的 blog github 上 fork 到自己仓库，注意仓库名要改为 username.github.io 这种名字。 username 是你的 github 用户名。

克隆仓库

$ git clone [email protected]:mathslinux/mathslinux.github.io.git # 克隆仓库

在本地启动 blog 查看效果, 启动后在 http://127.0.0.1:4000/ 就可以查看调试了。

$ jekyll serve

也可以在 http://username.github.io/ 查看。其中 username 是你的 github 用户名。之后发表新的 blog 之后直接 git push 后就是更新了。

修修改改

jekyll 模板中的主要需要修改的文件:

_config.yml: blog 的全局配置, 包括 blog 名字等等，按照自己的实际情况修改。
_includes/footer.html: 修改里面的版权等信息。
about.md: 关于自己的介绍。
images: 该目录包含自己的头像，背景，支付宝，微信等的二维码图像等，按需修改。

发表文章

发表文章很简单，只需要以 markdown 的格式写好文章，放到 _posts 目录下即可。需要注意的是文件名要以 Date-Title.md 这种格式，如 2017-10-06-Free_Up_Space.md

文件内容和 markdown 格式没有区别。但是在文件头，需要添加一些元数据。

---
layout: post
tag: Emacs
date: [2017-01-22 日 16:30]
title: 在 Emacs 内部运行 Shell
---

layout: post 这行不用变。
tag: 文章的标签。
date: 日期。
title: 文章的标题。

Issues

由于国内网络的原因，安装的时候卡在下载ruby过程

可以用科学上网的方式先把包下载到 rbenv 的缓存中, 再执行 rbenv install 操作

$ mkdir -p ~/.rbenv/cache/ && mv ruby-2.7.1.tar.bz2 ~/.rbenv/cache
$ rbenv install 2.7.1

如果执行 jekyll serve 出现依赖包的问题

比如出现如下错误

/bundler/spec_set.rb:86:in `block in materialize': Could not find public_suffix-4.0.5 in any of the sources (Bundler::GemNotFound)

进入 blog 主目录，删除 Gem用 bundle 自动安装依赖

$ bundle install

搭建 windows 的 go vscode 开发环境

Tue, 07 May 2019 17:54:00 +0000

#+SETUPFILE: ~/Dropbox/Doc/Org_Templates/level-1.org

最近由于一些原因，只能用 windows 电脑，记录一下用windows开发go语言相关项目开发环境搭建情况。

安装配置 go

安装 go

从 https://golang.google.cn/dl/ 下载windows的安装包，双击安装。结束后打开 PowerShell，输入以下指令验证

PS C:\Users\HP> go env | Select-String "gopath|goroot"
set GOPATH=C:\Users\HP\go
set GOROOT=D:\Program Files\Go  

NOTE: GOPATH 和 GOROOT 环境变量已经配置了，如果不想用默认的使用以下指令自己配置

PS C:\Users\HP> go env -w GOPATH=[YOUR-PATH]

配置

开启 go module

$ go env -w GO111MODULE=on

由于你懂得原因，go官方仓库国内无法访问，使用代理

$ go env -w GOPROXY=https://goproxy.cn,direct

安装配置 vscode

到 https://code.visualstudio.com/ 下载安装vscode

安装配置vscode的go插件

打开 vs

输入 Ctrl+Shift+X 然后搜索 go，安装第一个结果 Rich Go language support for Visual Studio Code
输入 Ctrl+Shift+P 然后搜索 go: install/update tools –> 选择全部 –> 确定, 等待 Go 工具完成更新

参考

更多的 go proxy的配置请参考 https://github.com/goproxy/goproxy.cn/blob/master/README.zh-CN.md