1 版本号#

Top Makefile的开头会有版本描述，VERSION 是主版本号，PATCHLEVEL 是补丁版本号，SUBLEVEL 是次版本号，这三个一 起构成了 uboot 的版本号，比如当前的 uboot 版本号就是2016.03。EXTRAVERSION 是附加 版本信息，NAME 是和名字有关的，一般不使用这两个。

2 MAKEFLAGS#

有两个特殊的变量：SHELL和MAKEFLAGS，这两个变量除非使用unexport声明， 否则的话在整个make的执行过程中，它们的值始终自动的传递给子make。
MAKEFLAGS 追加了一些值，-rR表示禁止使用内置的隐 含规则和变量定义，--include-dir指明搜索路径，$(CURDIR)表示当前目录。

3 设置命令输出详细程度#

①uboot 默认编译使用短命令。

②设置变量V=1来实现完整的命令输出。


③make -s设置成静默输出，将会silent_输出,不打印任何提示信息。如下：

MAKE_VERSION就是make版本号，我这里是4.2.1。因此filter 4.%,$(MAKE_VERSION)得到的过滤结果不为空。

当使用make -s编译的时候，-s会作为 MAKEFLAGS 变量的一部分传递给 Makefile。因此$(firstword x$(MAKEFLAGS))得到xrRs，最后quiet=silent_,否则不使用silent_输出。最后使用 export 导出变量 quiet、Q 和 KBUILD_VERBOSE。

4 设置编译结果输出位置#

在 make 的时候使用O来指定 输出目录，这么做是为了将源文件 和编译产生的文件分开，当然也可以不指定 O 参数，不指定的话源文件和编译产生的文件都在 同一个目录内。

判断O是否来自于命令行，如果来自命令行的话，KBUILD_OUTPUT 就为$(O)，也就是输出目录。

一开始判断KBUILD_OUTPUT 是否为空。 如果指定了输出目录就调用 mkdir 命令创建目录。

5 代码检查#

命令make C=1使能代码检查，检查那些需要重新编译的文 件。make C=2用于检查所有的源码文件。

6 子模块编译#

使用命令make M=dir即可，旧语法make SUBDIRS=dir也是支持的。

如果定 义 了 SUBDIRS或者M,那么KBUILD_EXTMOD就会被赋值。然后进入目标_all 依赖 modules，要先编译出 modules，也就是编译模块。
否则KBUILD_EXTMOD为空，进入all编译。
判断KBUILD_SRC是否为空，如果为空的话就设置变量srctree为当前目录，否则srctree就是KBUILD_SRC。一般不设置 KBUILD_SRC。
设置变量src和 obj，都为当前目录，设置VPATH，导出量 scrtree、objtree 和 VPATH。

7 获取主机架构系统信息#

最终开发服务器主机架构和操作系统信息如下:

8 设置目标架构、工具链和配置文件#

HOSTARCH是x86_64,我们编译make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-就是用于设置目标 ARCH 和 CROSS_COMPILE。

KCONFIG_CONFIG，这里设置配置文件为.config，.config 默认是没有的，需要使用命令make xxx_defconfig 对 uboot 进行配置，配置完成以后就会在 uboot 根目录下生成.config。
设置主机编译器HOSTCC，HOSTCXX等。

9 调用 scripts/Kbuild.include#

在整个Kbuild系统中，scripts/Kbuild.include 提供了大量通用函数以及变量的定义，这些定义将被 Makefile.build 、Makefile.lib 和 top Makefile频繁调用，以实现相应的功能,scripts/Kbuild.include 参与整个内核编译的过程，是编译的核心脚本之一。

Kbuild.include定义了很多变量:

里面定了build变量，后面产生配置文件时会用到：

9.1 build变量#

build := -f $(srctree)/scripts/Makefile.build obj

例如：

1
2

%config: scripts_basic outputmakefile FORCE
    $(Q)$(MAKE) $(build)=scripts/kconfig $@

当我们执行make menuconfig时:

1
2

menuconfig: scripts_basic outputmakefile FORCE
    make -f $(srctree)/scripts/Makefile.build obj=scripts/kconfig menuconfig

9.1.1 调用scripts/Makefile.build#

参见后面12.3.1.1节再详细介绍。

与build变量相类似的，还有以下的编译指令:

$(modbuiltin):

1

modbuiltin := -f $(srctree)/scripts/Makefile.modbuiltin obj

$(dtbinst):

1

dtbinst := -f $(srctree)/scripts/Makefile.dtbinst obj

$(clean):

1

clean := -f $(srctree)/scripts/Makefile.clean obj

$(hdr-inst):

1

hdr-inst := -f $(srctree)/scripts/Makefile.headersinst obj

这四条指令，分别对应 內建模块编译、dtb文件安装、目标清除和头文件安装.

9.2

9.2 filechk变量#

1
2
3
4
5
6
7
8
9
10
11

define filechk
    $(Q)set -e;             \
    mkdir -p $(dir $@);         \
    { $(filechk_$(1)); } > $@.tmp;      \
    if [ -r $@ ] && cmp -s $@ $@.tmp; then  \
        rm -f $@.tmp;           \
    else                    \
        $(kecho) '  UPD     $@';    \
        mv -f $@.tmp $@;        \
    fi
endef

1. mkdir -p $(dir $@)：如果$@目录不存在，就创建目录，$@是编译规则中的目标部分。($@ 在 Makefile 表目标文件)
2. 执行filechk_$(1),然后将执行结果保存到 $@.tmp中
3. 对比$@.tmp和$@是否有更新，有更新就使用 $@.tmp，否则删除 $@.tmp。

9.3 if_changed变量#

下一节有详细解析介绍：

uboot顶层makefile-2编译过程 - fuzidage - 博客园 (cnblogs.com)

uboot-编译过程Make分析 | Hexo (fuzidage.github.io)

9.4 scripts/Makefile.lib文件作用#

9.4.1 定义编译选项#

1
2
3
4
5
6
7

asflags-y  += $(EXTRA_AFLAGS)
ccflags-y  += $(EXTRA_CFLAGS)
cppflags-y += $(EXTRA_CPPFLAGS)
ldflags-y  += $(EXTRA_LDFLAGS)

KBUILD_AFLAGS += $(subdir-asflags-y)
KBUILD_CFLAGS += $(subdir-ccflags-y

9.4.2 去重#

如果某个模块已经被定义在obj-y中，就没必要再编译了。

1
2
3
4

# 去除obj-m中已经定义在obj-y中的部分
obj-m := $(filter-out $(obj-y),$(obj-m))
# 去除lib-y中已经定义在obj-y中的部分
lib-y := $(filter-out $(obj-y), $(sort $(lib-y) $(lib-m)))

9.4.3 modules.order#

1
2
3
4

#将obj-y中的目录 dir 修改为 dir/modules.order赋值给modorder，
#将obj-m中的.o修改为.ko赋值给modorder。 
modorder    := $(patsubst %/,%/modules.order,\
                 $(filter %/, $(obj-y)) $(obj-m:.o=.ko))

内核将编译的外部模块全部记录在 modules.order 文件中，以便 modprobe 命令在加载卸载时查询使用。

1
2
3

kernel/drivers/input/mouse/psmouse.ko
kernel/drivers/input/misc/100ask_adxl345-spi.ko
kernel/drivers/input/evbug.ko

9.4.4 目录的处理#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#挑选出obj-y 和 obj-m 中的纯目录部分，然后添加到subdir-y和subdir-m中。  
__subdir-y  := $(patsubst %/,%,$(filter %/, $(obj-y)))
subdir-y    += $(__subdir-y)

__subdir-m  := $(patsubst %/,%,$(filter %/, $(obj-m)))
subdir-m    += $(__subdir-m)

#需要被递归搜寻的子路径，带有可编译内部和外部模块的子目录。  
subdir-ym   := $(sort $(subdir-y) $(subdir-m))

#obj-y 中纯目录部分则将其改名为dir/build-in.a,obj-y的其他部分则不变。  
obj-y       := $(patsubst %/, %/built-in.a, $(obj-y))

#将obj-m中的纯目录部分剔除掉(因为已经在上面加入到subdir-m中了)。
obj-m       := $(filter-out %/, $(obj-m))

obj-y 和 obj-m 的定义中同时夹杂着目标文件和目标文件夹，文件夹当然是不能直接参与编译的，所以需要将文件夹提取出来。

将 obj-y or obj-m中以"/"结尾的纯目录部分提取出来，并赋值给 subdir-ym.

9.4.5 设备树相关#

1
2
3
4
5
6
7

extra-y             += $(dtb-y)
extra-$(CONFIG_OF_ALL_DTBS) += $(dtb-)

ifneq ($(CHECK_DTBS),)
extra-y += $(patsubst %.dtb,%.dt.yaml, $(dtb-y))
extra-$(CONFIG_OF_ALL_DTBS) += $(patsubst %.dtb,%.dt.yaml, $(dtb-))
endif

将所有的dtb-y赋值给extra-y。

9.4.6 添加路径#

1
2
3
4
5
6
7
8
9
10
11
12

extra-y     := $(addprefix $(obj)/,$(extra-y))
always      := $(addprefix $(obj)/,$(always))
targets     := $(addprefix $(obj)/,$(targets))
modorder    := $(addprefix $(obj)/,$(modorder))
obj-m       := $(addprefix $(obj)/,$(obj-m))
lib-y       := $(addprefix $(obj)/,$(lib-y))
subdir-obj-y    := $(addprefix $(obj)/,$(subdir-obj-y))
real-obj-y  := $(addprefix $(obj)/,$(real-obj-y))
real-obj-m  := $(addprefix $(obj)/,$(real-obj-m))
single-used-m   := $(addprefix $(obj)/,$(single-used-m))
multi-used-m    := $(addprefix $(obj)/,$(multi-used-m))
subdir-ym   := $(addprefix $(obj)/,$(subdir-ym))

文件的处理最后，给所有的变量加上相应的路径，以便编译的时候进行索引。

Makefile.lib 通常都被包含在于 Makefile.build中，这个变量继承了Makefile.build的 obj 变量。而 Makefile.build 的obj变量则是通过调用 $(build) 时进行赋值的。

9.5 scripts/Makefile.build文件作用#

9.5.1 包含 include/config/auto.conf#

包含include/config/auto.conf文件，这个文件的内容是这样的：

1
2
3
4
5
6

CONFIG_RING_BUFFER=y
CONFIG_HAVE_ARCH_SECCOMP_FILTER=y
CONFIG_SND_PROC_FS=y
CONFIG_SCSI_DMA=y
CONFIG_TCP_MD5SIG=y
CONFIG_KERNEL_GZIP=y

9.5.2 包含 scripts/Kbuild.include#

9.5.3 处理编译目标#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#主机程序，在前期的准备过程中可能需要用到，比如make menuconfig时需要准备命令行的图形配置。
ifneq ($(hostprogs-y)$(hostprogs-m)$(hostlibs-y)$(hostlibs-m)$(hostcxxlibs-y)$(hostcxxlibs-m),)
include scripts/Makefile.host
endif

#判断obj，如果obj没有指定则给出警告 
ifndef obj
$(warning kbuild: Makefile.build is included improperly)
endif

#如果有编译库的需求，则给lib-target赋值，并将 $(obj)/lib-ksyms.o 追加到 real-obj-y 中。 
ifneq ($(strip $(lib-y) $(lib-m) $(lib-)),)
lib-target := $(obj)/lib.a
real-obj-y += $(obj)/lib-ksyms.o
endif

#如果需要编译 将要编译进内核(也就是obj-y指定的文件) 的模块，则赋值 builtin-target 
ifneq ($(strip $(real-obj-y) $(need-builtin)),)
builtin-target := $(obj)/built-in.a
endif

#如果定义了 CONFIG_MODULES，则赋值 modorder-target。
ifdef CONFIG_MODULES
modorder-target := $(obj)/modules.order
endif

modorder-target将被赋值为$(obj)/modules.order， module.order这个文件记录了可加载模块在Makefile中出现的顺序，主要是提供给modprobe程序在匹配时使用。

9.5.4 默认编译目标_build#

例子见12.3.1.1.1。

9.5.4.1builtin-target#

1
2

$(builtin-target): $(real-obj-y) FORCE
    $(call if_changed,ar_builtin)

1
2

real-prereqs = $(filter-out $(PHONY), $^)
cmd_ar_builtin = rm -f $@; $(AR) rcSTP$(KBUILD_ARFLAGS) $@ $(real-prereqs)

ar_builtin就是执行cmd_ar_builtin, 就是使用ar指令打包成 $(builtin-target),也就是$(obj)/built-in.a。它的依赖文件被保存在 $(real-obj-y) 中。

$(real-obj-y) 在scritps/Makefile.lib被处理出来的变量, 对应目录下的所有目标文件，不包含文件夹。

9.5.4.2 lib-target#

1
2

$(lib-target): $(lib-y) FORCE
    $(call if_changed,ar)

同理，最终将调用cmd_ar命令:

1
2

real-prereqs = $(filter-out $(PHONY), $^)
cmd_ar = rm -f $@; $(AR) rcsTP$(KBUILD_ARFLAGS) $@ $(real-prereqs)

将本模块中的目标全部打包成$(lib-target),也就是 $(obj)/lib.a

9.5.4.3 extra-y#

$(extra-y) 在Makefile.lib中被确定，主要负责dtb相关的编译:

1
2

extra-y             += $(dtb-y)
extra-$(CONFIG_OF_ALL_DTBS) += $(dtb-)

Makefile.lib 中可以找到对应的实现:

1
2

$(obj)/%.dtb: $(src)/%.dts $(DTC) FORCE
    $(call if_changed_dep,dtc,dtb)

调用了 cmd_dtc:

1
2
3
4
5
6
7
8

cmd_dtc = mkdir -p $(dir ${dtc-tmp}) ; \
    $(HOSTCC) -E $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc-tmp) $< ; \

    $(DTC) -O $(2) -o $@ -b 0 \
        $(addprefix -i,$(dir $<) $(DTC_INCLUDE)) $(DTC_FLAGS) \
        -d $(depfile).dtc.tmp $(dtc-tmp) ; \

    cat $(depfile).pre.tmp $(depfile).dtc.tmp > $(depfile)

$(2) 为 dtb，-O dtb 表示输出文件格式为 dtb 。 -o $@, $@ 为目标文件，表示输出目标文件，输入文件则是对应的 $<。

9.5.4.4 obj-m#

由于它是一系列的 .o 文件，所以它的编译是通过模式规则的匹配完成的。

1
2
3

$(obj)/%.o: $(src)/%.c $(recordmcount_source) $(objtool_dep) FORCE
    $(call cmd,force_checksrc)
    $(call if_changed_rule,cc_o_c)

执行rule_cc_o_c:

1
2
3
4
5
6
7
8
9

define rule_cc_o_c
    $(call cmd,checksrc)
    $(call cmd_and_fixdep,cc_o_c)
    $(call cmd,gen_ksymdeps)
    $(call cmd,checkdoc)
    $(call cmd,objtool)
    $(call cmd,modversions_c)
    $(call cmd,record_mcount)
endef

cmd 函数其实就是执行 cmd_$1,那么也就是上述命令中分别执行 cmd_checksrc,cmd_gen_ksymdeps等等。

其中最重要的指令就是 ： $(call cmd_and_fixdep,cc_o_c)，它对目标文件执行了 fixdep，生成依赖文件，然后执行了 cmd_cc_o_c, 这个命令就是真正的编译指令:

1

cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<

9.5.4.5 modorder-target#

modorder-target值为 $(obj)/modules.order，也就是大多数目录下都存在这么一个 modules.orders `文件，来提供一个该目录下编译模块的列表。

1
2

$(modorder-target): $(subdir-ym) FORCE
    $(Q)(cat /dev/null; $(modorder-cmds)) > $@

1
2
3
4

modorder-cmds =                     \
    $(foreach m, $(modorder),           \
        $(if $(filter %/modules.order, $m), \
            cat $m;, echo kernel/$m;))

该操作的目的就是将需要编译的.ko的模块以kernel/$(dir)/*.ko为名记录到 obj-m 指定的目录下。

9.5.4.6 subdir-ym#

1
2

$(subdir-ym):
    $(Q)$(MAKE) $(build)=$@ need-builtin=$(if $(findstring $@,$(subdir-obj-y)),1)

这就是Kbuild递归遍历子目录编译的策略，对于每个需要递归进入编译的目录，都调用：

1

$(Q)$(MAKE) $(build)=$@ need-builtin=$(if $(findstring $@,$(subdir-obj-y)),1)

10 设置交叉编译器#

11 核心变量导出#

在顶层 Makefile 会导出很多变量：

1
2
3
4
5
6
7
8
9

export VERSION PATCHLEVEL SUBLEVEL UBOOTRELEASE UBOOTVERSION
export ARCH CPU BOARD VENDOR SOC CPUDIR BOARDDIR
export CONFIG_SHELL HOSTCC HOSTCFLAGS HOSTLDFLAGS CROSS_COMPILE AS LD CC
export CPP AR NM LDR STRIP OBJCOPY OBJDUMP
export MAKE AWK PERL PYTHON
export HOSTCXX HOSTCXXFLAGS DTC CHECK CHECKFLAGS

export KBUILD_CPPFLAGS NOSTDINC_FLAGS UBOOTINCLUDE OBJCOPYFLAGS LDFLAGS
export KBUILD_CFLAGS KBUILD_AFLAGS

打印出export的这些变量：

①这些变量来自config.mk，里面定义了ARCH,CPU,BOARD,VENDOR,SOC，BOARDDIR等变量。变 量 ARCH ， 值 为 $(CONFIG_SYS_ARCH:"%"=%) ， 也 就 是 提 取 CONFIG_SYS_ARCH 里面双引号“”之间的内容。比如 CONFIG_SYS_ARCH=“arm”的话， ARCH=arm。经过展开确定了CPUDIR=arch/arm/cpu/armv7。
②这里有一个sinclude指令，sinclude 和 include 的功能类似，在 Makefile 中都是读取指定文件内容，这里读取 文件$(srctree)/arch/$(ARCH)/config.mk 的内容。sinclude 读取的文件如果不存在的话不会报错。
③依次包含arch,cpu,soc，vendor,board相关的config.mk

.config如下：

12 make xxx_defconfig 配置过程#

输入命令进行配置：

1

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- mx6ull_14x14_ddr512_emmc_defconfig

12.1 产生版本日期信息#

先产生version_h和timestamp_h。version_h记录uboot版本和编译器版本。timestamp_h记录uboot的日期时间戳信息。打开这两个头文件：

12.2 配置变量#

MAKECMDGOALS 是 make 的一个环境变量，这个变量会保存你所指 定的终极目标列表，比如执行make mx6ull_alientek_emmc_defconfig，那么 MAKECMDGOALS 就为 mx6ull_alientek_emmc_defconfig。filter函数将 MAKECMDGOALS 中符合no-dot-config-targets的部分过滤出来，可以看到为空，所以dot-config还是等于1.

KBUILD_EXTMOD前面提到没有编译子模块，KBUILD_EXTMOD为空，进入，在判断

1

ifneq ($(filter config %config,$(MAKECMDGOALS),)

当make mx6ull_alientek_emmc_defconfig, 明显过滤出来不为空，因此config-targets=1.

words $(MAKECMDGOALS)等于1，最后得到：

1
2
3

config-targets = 1
mixed-targets = 0
dot-config = 1

12.3 执行3个依赖#

KBUILD_DEFCONFIG等于mx6ull_14x14_ddr512_emmc_defconfig， KBUILD_KCONFIG等于空，导出。
匹配到%config， 执行scripts_basic、outputmakefile 和 FORCE 3个依赖.

12.3.1 scripts_basic#

scripts/Kbuild.include定义了build变量。$Q$(MAKE) $(build)=scripts/basic展开build变量后得：

1

make -f ./scripts/Makefile.build obj=scripts/basic

12.3.1.1 scripts/Makefile.build#

scripts_basic 会调用文件./scripts/Makefile.build,打开这个文件：

这里$(obj)=scripts/basic, patsubst 是替换函数在scripts/basic中查找符合tpl/%的部分，然后将tpl/取消掉，但是 scripts/basic没有tpl/，所以 src= scripts/basic。两个ifeq ($(obj),$(src))都满足条件，最终prefix等于.。

kbuild-dir 展开后为：

1

$(if $(filter /%, scripts/basic), scripts/basic, ./scripts/basic)

因为没有以/为开头的单词，所以$(filter /%, scripts/basic)的结果为空，kbuilddir=./scripts/basic。
kbuild-file 展开后为：

1

$(if $(wildcard ./scripts/basic/Kbuild), ./scripts/basic/Kbuild, ./scripts/basic/Makefile)

scrpts/basic 目录中没有Kbuild这个文件，所以 kbuild-file= ./scripts/basic/Makefile.
scripts/Makefile.build文件包含/scripts/basic/Makefile

12.3.1.1.1 找到默认目标_build#

再继续分析scripts/Makefile.build：

__build 是默认目标，因为命令@make -f ./scripts/Makefile.build obj=scripts/basic没有指定目标，所以会使用到默认目标：__build。

顶层 Makefile 中，KBUILD_BUILTIN 为 1， KBUILD_MODULES 为 0，因此展开后目标__build 为：

1
2

__build:$(builtin-target) $(lib-target) $(extra-y)) $(subdir-ym) $(always)
@:

直接打印出这5个目标：所以最终只有一个依赖scripts/basic/fixdep要执行，产生fixdep.

执行打印如下：

至此第一个依赖scripts_basic就结束了。
总结：scripts_basic就是利用scripts/Makefile.build去找到_build目标，然后去scripts/basic目录编译出fixdep.

12.3.2 outputmakefile#

由于KBUILD_SRC为空，不执行。否则会为源码路径创建source这个符号链接，执行mkmakefile。

12.3.3 FORCE#

Makefile最底下定了FORCE目标，可以看到什么都不执行。

FORCE的作用：

可以看到它也是一个目标，没有依赖文件且没有命令部分，由于它没有命令生成FORCE，所以每次都会被更新。

所以它的作用就是：FORCE作为依赖时，就导致依赖列表中每次都有FORCE依赖被更新，导致目标每次被重新编译生成。

12.4 产生.config#

回到%config 处：
$(Q)$(MAKE) $(build)=scripts/kconfig $@展开后

1

make -f ./scripts/Makefile.build obj=scripts/kconfig mx6ull_14x14_ddr512_emmc_defconfig

再次进入scripts/Makefile.build， 用echo得到一些变量值:

1
2
3

kbuild-dir = ./scripts/kconfig
kbuild-file = ./scripts/kconfig/Makefile
include ./scripts/kconfig/Makefile

打开./scripts/kconfig/Makefile：

%_defconfig: $(obj)/conf匹配到我们的mx6ull_14x14_ddr512_emmc_defconfig，先编译依赖scripts/kconfig/conf,编译生成scripts/kconfig/conf如下：

最终利用conf工具从configs目录找到mx6ull_14x14_ddr512_emmc_defconfig，将配置写成.config文件。
总结defconfig配置过程：

12.5 制作defconfig#

如果没有对应的defconfig可以找一个与自己板级信息类似的defconfig生成一个.config，再通过menuconfig来完成自己board的配置，并最后通过savedefconfig保存为自己board的defconfig：

1
2
3
4

make CROSS_COMPILE=aarch64-linux-gnu- evb-rk3399_defconfig
make menuconfig
make savedefconfig
cp defconfig configs/my_defconfig

1.1 help或者？#

1.1.1 help+具体命令#

? bootz 或 help bootz

1.2 信息查询#

1.2.1 bdinfo#

1.2.2 printenv#

前确保 uboot 中的环境变量 bootargs 内容如下:
console=ttymxc0,115200 root=/dev/mmcblk1p2 rootwait rw

1
2
3
4
5

cp arch/arm/boot/zImage /home/zuozhongkai/linux/tftpboot/ -f
cp arch/arm/boot/dts/imx6ull-14x14-evk.dtb /home/zuozhongkai/linux/tftpboot/ -f
tftp 80800000 zImage 
tftp 83000000 imx6ull-14x14-evk.dtb
bootz 80800000 - 83000000

1.2.3 version#

1.3 环境变量#

1.3.1 setenv设定环境变量#

设置bootdelay时间为5s.

1
2

setenv bootdelay 5
saveenv

1
2

setenv author zuozhongkai
saveenv

新建环境变量也是用setenv。

1.3.2 saveenv保存环境变量#

1.3.3 setenv删除环境变量#

1
2

setenv author
saveenv

设置变量为空表示删除掉该环境变量，重启该环境变量就不会存在了。

1.3.4 环境变量原理#

include/env_default.h定义了很多环境变量，如bootargs,bootdelay,bootcmd等：

由 于 没 有 定 义DEFAULT_ENV_INSTANCE_EMBEDDED和CONFIG_SYS_REDUNDAND_ENVIRONMENT，因此 uchar default_environment[]数组保存环境变量。

1.3.4.1 bootcmd展开#

如CONFIG_BOOTCOMMAND等一系列宏都是定义在include/configs/mx6ull_alientek_emmc.h:

uboot 使用了类似 shell 脚本语言的方式来编写的,首先run findfdt， findfdt 是用来查找开发板对应的设备树文件(.dtb)，IMX6ULL EVK 的设备树文件为imx6ull-14x14-evk.dtb，findfdt内容如下：

1
2
3
4
5
6
7
8
9

"findfdt="\
"if test $fdt_file = undefined; then " \
"if test $board_name = EVK && test $board_rev = 9X9; then " \
"setenv fdt_file imx6ull-9x9-evk.dtb; fi; " \
"if test $board_name = EVK && test $board_rev = 14X14; then " \
"setenv fdt_file imx6ull-14x14-evk.dtb; fi; " \
"if test $fdt_file = undefined; then " \
"echo WARNING: Could not determine dtb to use; fi; " \
"fi;\0" \

那么run findfdt就等同于执行setenv fdt_file imx6ull-14x14-evk.dtb。设置fdt_file环境变量等于imx6ull-14x14-evk.dtb。
mmc dev ${mmcdev}用于切换 mmc 设备，mmcdev 为 1，因此这行代码就是：mmc dev 1，也就是切换到 EMMC 上。
先执行 mmc dev ${mmcdev}切换到 EMMC 上，然后使用命令 mmc rescan 扫描看有没有 SD 卡或者 EMMC 存在，如果没有的话就直接跳到else，执行 run netboot，netboot也是一个自定义的环境变量，这个变量是从网络启动 Linux 的。
扫描到EMMC后，run loadbootscript：
loadbootscript=fatload mmc ${mmcdev}:${mmcpart} ${loadaddr} ${script};
其中 mmcdev=1，mmcpart=1，loadaddr=0x80800000，script= boot.scr，因此展开以后就是：
loadbootscript=fatload mmc 1:1 0x80800000 boot.scr;
loadbootscript 就是从 mmc1 的分区 1 中读取文件 boot.src 到 DRAM 的 0X80800000 处。但是 mmc1 的分区 1 中没有 boot.src 这个文件，可以使用命令ls mmc 1:1查看一下 mmc1 分区1 中的所有文件，看看有没有 boot.src 这个文件。再展开bootscript：

1
2

bootscript=echo Running bootscript from mmc ...;
source

由于boot.src 文件不存在，所以 bootscript 也就不会运行。就运行环境变量 loadimage:
loadimage=fatload mmc ${mmcdev}:${mmcpart} ${loadaddr} ${image}
loadimage展开：
loadimage=fatload mmc 1:1 0x80800000 zImage
fatload就是从 mmc1 的分区中读取 zImage 到内存的 0X80800000 处，而 mmc1的分区 1 中存在 zImage。
loadimage执行完，执行mmcboot环境变量，run mmcboot：

①打印Booting from mmc …
②运行环境变量 mmcargs，mmcargs 用来设置 bootargs，后面分析 bootargs 的时候在学习。
③判断boot_fdt是否为yes或者try，根据uboot输出的环境变量信息可知boot_fdt=try。因此执行loadfdt。
④执行loadfdt环境变量,如下：
loadfdt=fatload mmc ${mmcdev}:${mmcpart} ${fdt_addr} ${fdt_file}
展开以后就是:
loadfdt=fatload mmc 1:1 0x83000000 imx6ull-14x14-evk.dtb
因此 loadfdt 的作用就是从 mmc1 的分区 1 中读取 imx6ull-14x14-evk.dtb 文件并放到 0x83000000处。
⑤loadfdt加载dtb成功后，调用命令 bootz 启动 linux：
bootz ${loadaddr} - ${fdt_addr};
展开：
bootz 0x80800000 - 0x83000000 (注意‘-’前后要有空格)

总结一下bootcmd展开：

1
2
3
4

mmc dev 1 //切换到 EMMC
fatload mmc 1:1 0x80800000 zImage //读取 zImage 到 0x80800000 处
fatload mmc 1:1 0x83000000 imx6ull-14x14-evk.dtb //读取设备树到 0x83000000 处
bootz 0x80800000 - 0x83000000 //启动 Linux

我们可以将bootcmd环境变量进行简化：

1
2
3
4
5

#define CONFIG_BOOTCOMMAND \
 "mmc dev 1;" \
 "fatload mmc 1:1 0x80800000 zImage;" \
 "fatload mmc 1:1 0x83000000 imx6ull-alientek-emmc.dtb;" \
 "bootz 0x80800000 - 0x83000000;"

或者：
setenv bootcmd 'mmc dev 1; fatload mmc 1:1 80800000 zImage; fatload mmc 1:1 83000000 imx6ullalientek-emmc.dtb; bootz 80800000 - 83000000;'

1.3.4.2 bootargs展开#

bootargs 保存着 uboot 传递给 Linux 内核的参数。从emmc启动时，bootargs 环境变量是由 mmcargs 设置的：
mmcargs=setenv bootargs console=${console},${baudrate} root=${mmcroot}
其中：
console=ttymxc0，baudrate=115200，mmcroot=/dev/mmcblk1p2 rootwait rw
mmcargs展开以后就是:
mmcargs=setenv bootargs console= ttymxc0, 115200 root= /dev/mmcblk1p2 rootwait rw

可以看出环境变量 mmcargs 就是设置 bootargs 的值为console= ttymxc0, 115200 root= /dev/mmcblk1p2 rootwait rw。
①console=ttymxc0,115200 综合起来就是设置 ttymxc0（也就是串口 1）作为 Linux 的终端，并且串口波特率设置为 115200。
②root=/dev/mmcblk1p2 用于指明根文件系统存放在mmcblk1 设备的分区 2 中。在 I.MX6U-ALPHA 开发板中/dev/mmcblk1 表示 EMMC，而/dev/mmcblk1p2 表示EMMC 的分区 2。
③root 后面有rootwait rw，rootwait 表示等待 mmc 设备初始化完成以后再挂载，否则的话mmc 设备还没初始化完成就挂载根文件系统会出错的。rw 表示根文件系统是可以读写的，不加rw 的话可能无法在根文件系统中进行写操作，只能进行读操作。

1.3.4.3 bootdlelay#

uboot命令行倒计时

1.4 内存操作#

1.4.1 md#

md[.b, .w, .l] address [# of objects]

注意：uboot 命令中的数字都是十六进制的

1. 命令中的[.b .w .l]对应 byte、word 和 long，也就是分别以 1 个字节、2 个字节、4 个字节来显示内存值.
2. address 就是要查看的内存起始地址.
3. [# of objects]表示要查看的数据长度:

这个数据长度单位不是字节，而是跟你所选择的显示格式有关。比如你设置要查看的内存长度为20(十六进制为 0x14)，如果显示格式为.b 的话那就表示 20 个字节；如果显示格式为.w 的话就表示 20 个 word，也就是 20*2=40 个字节；如果显示格式为.l 的话就表示 20 个 long，也就是20*4=80 个字节

1
2
3

md.b 80000000 10 //读16字节
md.w 80000000 10 //读32字节
md.l 80000000 10 //读64字节

1.4.2 nm命令#

写内存，写成功后地址不会自增。

1

nm [.b, .w, .l] address

0500e031 表示地址 0x80000000 现在的数据，？后面就可以输入要修改后的数据 0x12345678，输入完成以后按下回车，然后再输入‘q’即可退出。
退出后输入md.l查看。

1.4.3 mm命令#

写内存，写成功后地址会自增。
比如以.l 格式修改从地址 0x80000000 开始的连续 3 个内存块(3*4=12个字节)的数据为 0X05050505.

输入md命令查看一下：

1.4.4 mw命令#

写一段连续的内存。

1

mw [.b, .w, .l] address value [count]

比如使用.l 格式将以 0X80000000 为起始地址的 0x10 个内存块(0x10 * 4=64 字节)填充为 0X0A0A0A0A

1

mw.l 80000000 0A0A0A0A 10

1.4.5 cp命令#

数据拷贝命令，用于将 DRAM 中的数据从一段内存拷贝到另一段内存中，或者把 Nor Flash 中的数据拷贝到 DRAM 中。

cp [.b, .w, .l] source target count

我们使用.l 格式将 0x80000000 处的地址拷贝到 0X80000100 处，长度为 0x10 个内存块(0x10 * 4=64 个字节).

cp.l 80000000 80000100 10

1.4.6 cmp命令#

比较两段内存的数据是否相等。

cmp [.b, .w, .l] addr1 addr2 count

比较 0x80000000 和 0X80000100 这两个地址数据是否相等，比较长度为 0x10 个内存块(16 * 4=64 个字节)

cmp.l 80000000 80000100 10

我们再随便挑两段内存比较一下，比如地址0x80002000 和 0x800003000，长度为 0X10.

可以看出，0x80002000 处的数据和 0x80003000 处的数据就不一样.

1.5 网络操作命令#

预先设置号网络相关环境变量：

setenv ipaddr 192.168.1.50
setenv ethaddr b8:ae:1d:01:00:00
setenv gatewayip 192.168.1.1
setenv netmask 255.255.255.0
setenv serverip 192.168.1.253
saveenv

1.5.1 ping命令#

ping 192.168.1.100

1.5.2 dhcp命令（自动ip获取）#

dhcp 用于从路由器获取 IP 地址，前提得开发板连接到路由器上的，如果开发板是和电脑
直连的，那么 dhcp 命令就会失效。直接输入 dhcp 命令即可通过路由器获取到 IP 地址。

DHCP 不单单是获取 IP 地址，其还会通过 TFTP 来启动 linux 内核，输入? dhcp即
可查看 dhcp 命令详细的信息：

1.5.3 nfs命令#

nfs(Network File System)网络文件系统,通过网络将编译好的 linux 镜像和设备树文件下载
到 DRAM 中，然后就可以直接运行。
虚拟机Ubuntu先搭建好nfs服务，详见：nfs服务搭建 linux搭建nfs服务 | Hexo (fuzidage.github.io)

1

nfs [loadAddress] [[hostIPaddr:]bootfilename]

loadAddress 是要保存的 DRAM 地址，[[hostIPaddr:]bootfilename]是要下载的文件地址,
我们将正点原子官方编译出来的 Linux 镜像文件 zImage 下载到开发板 DRAM 的 0x80800000这个地址处。

1

nfs 80800000 192.168.1.253:/home/zuozhongkai/linux/nfs/zImage

下载过程如图下：

下载完成以后查看 0x80800000 地址处的数据，使用命令 md.b 来查看前 0x100 个字节的数据。

我们再用UE打开编译出的zImage，对比一下说明 nfs 命令下载到的zImage 是正确的。

1.5.4 tftp命令#

tftp 命令的作用和 nfs 命令一样，都是用于通过网络下载东西到 DRAM 中。tftp服务搭建参考：tftp服务搭建 linux搭建tftp和ftp服务 | Hexo (fuzidage.github.io)

tftpboot [loadAddress] [[hostIPaddr:]bootfilename]

loadAddress 是文 件在 DRAM 中的 存放 地址 ，
[[hostIPaddr:]bootfilename]是要从 Ubuntu 中下载的文件。但是和 nfs 命令的区别在于，tftp 命令不需要输入文件在 Ubuntu 中的完整路径，只需要输入文件名即可。比如我们现在将 tftpboot 文件夹里面的 zImage 文件下载到开发板 DRAM 的 0X80800000 地址处。

1

tftp 80800000 zImage

1.6 emmc和sd卡指令#

mmc相关命令：

1.6.1 mmc info#

当前选中的 MMC 设备是EMMC，版本为 5.0，容量为 7.1GiB(EMMC为 8GB)，速度为 52000000Hz=52MHz，8 位宽的总线。还有一个与 mmc info 命令相同功能的命令：mmcinfo，“mmc”和“info”之间没有空格。

1.6.2 mmc rescan#

mmc rescan 命令用于扫描当前开发板上所有的 MMC 设备，包括 EMMC 和 SD 卡。

1.6.3 mmc list#

查看当前开发板一共有几个 MMC 设备.

可以看出当前开发板有两个 MMC 设备：FSL_SDHC:0 和 FSL_SDHC:1 (eMMC)，这是因为我现在用的是 EMMC 版本的核心板，加上 SD 卡一共有两个 MMC 设备，FSL_SDHC:0 是 SD卡，FSL_SDHC:1(eMMC)是 EMMC。默认会将 EMMC 设置为当前 MMC 设备，这就是为什么输入mmc info查询到的是 EMMC 设备信息，而不是 SD 卡。要想查看 SD 卡信息，就要使用命令mmc dev来将 SD 卡设置为当前的 MMC 设备。

1.6.4 mmc dev#

选择切换当前emmc设备。

mmc dev [dev] [part]

[dev]用来设置要切换的 MMC 设备号，[part]是分区号。如果不写分区号的话默认为分区 0。

1

mmc dev 0 //切换到 SD 卡，0 为 SD 卡，1 为 eMMC

切换到sd这个mmc后，输入mmc info命令既可以查看sd信息：

可以看到当前 SD 卡为 3.0 版本的，容量为 14.8GiB(16GB 的 SD 卡)，4 位宽的总线。

1.6.5 mmc part#

查看mmc分区

1
2

mmc dev 1 //切换到 EMMC
mmc part //查看 EMMC 分区

切到核心板的emmc后，mmc part显示分区信息，此时 EMMC 有两个分区，第一个分区起始扇区为 20480，长度为 262144 个扇区；第二个分区起始扇区为 282624，长度为 14594048 个扇区。
如果 EMMC 里面烧写了 Linux 系统的话，EMMC 是有 3 个分区的，第 0 个分区存放 uboot，第 1 个分区存放Linux 镜像文件和设备树，第 2 个分区存放根文件系统。但是在上图中只有两个分区，那是因为第 0 个分区没有格式化，所以识别不出来，实际上第 0 个分区是存在的。一个新的 SD卡默认只有一个分区，那就是分区 0，所以前面讲解的 uboot 烧写到 SD 卡，其实就是将 u-boot.bin烧写到了 SD 卡的分区 0 里面.

1

mmc dev 1 2 //将 EMMC 的分区 2 设置为当前 MMC 设备

1.6.6 mmc read#

1

mmc read addr blk# cnt

读mmc设备中的数据。addr 是数据读取到 DRAM 中的地址，blk 是要读取的块起始地址(十六进制)，一个块是 512字节，这里的块和扇区是一个意思，在 MMC 设备中我们通常说扇区，cnt 是要读取的块数量(十六进制)。比如从 EMMC 的第 1536(0x600)个块开始，读取 16(0x10)个块的数据到 DRAM 的0X80800000 地址处

1
2

mmc dev 1 0 //切换到 MMC 分区 0
mmc read 80800000 600 10 //读取数据

这里我们还看不出来读取是否正确，通过 md.b 命令查看 0x80800000 处的数据就行了，查看 16*512=8192(0x2000)个字节的数据。

可以看到baudrate=115200.board_name=EVK.board_rev=14X14等字样，
这个就是 uboot 中的环境变量。EMMC 核心板 uboot 环境变量的存储起始地址就是1536*512=786432。

1.6.7 mmc write#

1

mmc write addr blk# cnt

从DRAM写数据到mmc设备。
比如通过 nfs 或者 tftp 命令将新的 u-boot.bin 下载到开发板的 DRAM 中，然后再使用命令mmc write将其写入到 MMC设备中。

1
2
3

mmc dev 0 //切换到 SD 卡
version //查看uboot版本号
tftp 80800000 u-boot.imx

可以看出，u-boot.imx 大小为 379904 字节，379904/512=742，所以我们要向 SD 卡中写入742 个块，如果有小数的话就要加 1 个块。使用命令mmc write从 SD 卡分区 0 第 2 个块(扇区)开始烧写，一共烧写 742(0x2E6)个块

1
2

mmc dev 0 0
mmc write 80800000 2 2E6

烧写成功，重启开发板(从 SD 卡启动)，重启以后再输入 version 来查看版本号：

这样就给mmc0也就是sd卡烧录了uboot, 同理要烧录emmc也是同理，切到mmc1即可：

1
2
3
4

mmc dev 1 0 //切换到 EMMC 分区 0
tftp 80800000 u-boot.imx //下载 u-boot.imx 到 DRAM
mmc write 80800000 2 32E //烧写 u-boot.imx 到 EMMC 中
mmc partconf 1 1 0 0 //分区配置，EMMC 需要这一步！

注意：千万不要写 SD 卡或者 EMMC 的前两个块(扇区)，里面保存着分区表！

1.6.7 mmc erase#

1

mmc erase blk# cnt

擦除 MMC 设备的指定块, blk 为要擦除的起始块，cnt 是要擦除的数量。

1.7 文件操作命令（fat文件系统）#

1.7.1 fatinfo#

fatinfo <interface> [<dev[:part]>]

于查询指定 MMC 设备分区的文件系统信息，interface 表示接口，比如 mmc，dev 是查询的设备号，part 是要查询的分区。比如我们要查询 EMMC 分区 1 的文件系统信息：

1

fatinfo mmc 1:1

上图显示mmc1也就是emmc设备的分区1的文件系统为fat32格式。

1.7.1 fatls#

fatls <interface> [<dev[:part]>] [directory]

查询设备分区的目录和文件信息。interface 是要查询的接口，比如 mmc，dev 是要查询的设备号，part 是要查询的分区，directory是要查询的目录。

1

fatls mmc 1:1   //查询 mmc1设备（EMMC 设备）中分区 1 中的所有的目录和文件

1.7.3 fstype#

fstype <interface> <dev>:<part>

查看 MMC 设备某个分区的文件系统格式.正点原子 EMMC 核心板上的 EMMC 默认有 3 个分区, 分区 0 格式未知，因为分区 0 存放的 uboot，并且分区 0 没有格式化，所以文件系统格式未知。分区 1 的格式为 fat，分区 1 用于存放 linux 镜像和设备树。分区 2 的格式为 ext4，用于存放 Linux 的根文件系统(rootfs)。

1
2
3

fstype mmc 1:0
fstype mmc 1:1
fstype mmc 1:2

1.7.4 fatload#

fatload <interface> [<dev[:part]> [<addr> [<filename> [bytes [pos]]]]]

将指定的文件读取到 DRAM.
interface 为接口，比如 mmc，dev 是设备号，part 是分区，addr 是保存在 DRAM 中的起始地址，filename 是要读取的文件名字。bytes 表示读取多少字节的数据，如果 bytes 为 0 或者省略的话表示读取整个文件。pos 是要读的文件相对于文件首地址的偏移，如果为 0 或者省略的话表示从文件首地址开始读取.

fatload mmc 1:1 80800000 zImage  //将 EMMC 分区 1 中的 zImage 文件读取到 DRAM 中的0X80800000 地址处

225ms 内读取了 6785272 个字节的数据，速度为 28.8MiB/s，速度是非常快的，因为这是从 EMMC 里面读取的，而 EMMC 是 8 位的，速度肯定会很快的。

1.7.5 fatwrite#

将 DRAM 中的数据写入到 MMC 设备。
uboot 默认没有使能 fatwrite 命令，需要修改板子配置头文件，比如 mx6ullevk.h、 mx6ull_alientek_emmc.h 等,需要开启宏：

1

#define CONFIG_FAT_WRITE /* 使能 fatwrite 命令 */

fatwrite <interface> <dev[:part]> <addr> <filename> <bytes>

interface 为接口，比如 mmc，dev 是设备号，part 是分区，addr 是要写入的数据在 DRAM中的起始地址，filename 是写入的数据文件名字，bytes 表示要写入多少字节的数据。

比如我们通过nfs or tftp命令下载镜像到DRAM后，通过fatwrite去烧写image：

zImage 大小为6785272(0X6788f8)个字节(注意，由于开发板系统在不断的更新中，因此zImage 大小不是固定的，一切以实际大小为准)，接下来使用命令fatwrite将其写入到 EMMC 的分区 1 中，文件名字为 zImage：

fatwrite mmc 1:1 80800000 zImage 6788f8

完成以后使用fatls命令查看一下 EMMC 分区 1 里面的文件：

1.8 文件操作命令（ext文件系统）#

ext文件系统是linux常用的文件系统，一般rootfs就是典型的ext2文件系统。
ext2load、ext2ls、ext4load、ext4ls 和 ext4write。这些命令的含义和使用与 fatload、fatls 和 fatwrite一样，只是 ext2 和 ext4 都是针对 ext 文件系统的。

1

ext4ls mmc 1:2	//emmc设备分区2就是ext4文件系统，存放了rootfs

1.9 nandflash操作命令#

输入? nand即可查看NAND 相关命令：

1.9.1 nand info#

打印 NAND Flash 信息:

1.9.2 nand device#

用于切换 NAND Flash，如果你的板子支持多片 NAND 的话就可以使用此命令来设置当前所使用的 NAND。

1.9.3 nand erase#

nand erase 命令用于擦除 NAND Flash，NAND Flash 的特性(位翻转，只能由1变成0,而不能由0变成1)决定了在向 NAND Flash 写数据之前一定要先对要写入的区域进行擦除.

1
2
3

nand erase[.spread] [clean] off size //从指定地址开始(off)开始，擦除指定大小(size)的区域。
nand erase.part [clean] partition //擦除指定的分区
nand erase.chip [clean] //全篇擦除

1.9.3 nand write#

nand write addr off size

addr 是要写入的数据首地址，off 是 NAND 中的目的地址，size 是要写入的数据大小。

编译出来 NAND版本的 kernel 和 dtb 文件，在烧写之前要先对 NAND 进行分区，也就是规划好 uboot、linux kernel、设备树和根文件系统的存储区域，I.MX6U-ALPHA 开发板出厂系统 NAND 分区如下：

1
2
3
4
5
6

0x000000000000-0x0000003FFFFF : "boot"
0x000000400000-0x00000041FFFF : "env"
0x000000420000-0x00000051FFFF : "logo"
0x000000520000-0x00000061FFFF : "dtb"
0x000000620000-0x000000E1FFFF : "kernel"
0x000000E20000-0x000020000000 : "rootfs"

一共有六个分区，第一个分区存放 uboot，地址范围为 0x0~0x3FFFFF(共 4MB)；第二个分区存放 env（环境变量），地址范围为 0x400000~0x420000(共 128KB)；第三个分区存放 logo(启动图标)，地址范围为 0x420000~0x51FFFF(共 1MB)；第四个分区存放 dtb(设备树)，地址范围为0x520000~0x61FFFF(共 1MB)；第五个分区存放 kernel(也就是 linux kernel)，地址范围为0x620000~0xE1FFFF(共 8MB)；剩下的所有存储空间全部作为最后一个分区，存放 rootfs(根文件系统)。

1
2
3

tftp 0x87800000 zImage //下载 zImage 到 DRAM 中
nand erase 0x620000 0x800000 //从地址 0x620000 开始擦除 8MB 的空间
nand write 0x87800000 0x620000 0x800000 //将接收到的 zImage 写到 NAND 中

这里我们擦除了 8MB 的空间，因为一般 zImage 就是 6,7MB 左右，8MB 肯定够了，如果不够的话就再多擦除一点就行了。同理烧录dtb:

1
2
3

tftp 0x87800000 imx6ull-14x14-emmc-7-1024x600-c.dtb //下载 dtb 到 DRAM 中
nand erase 0x520000 0x100000 //从地址 0x520000 开始擦除 1MB 的空间
nand write 0x87800000 0x520000 0x100000 //将接收到的 dtb 写到 NAND 中

1.9.4 nand read#

nand read addr off size

从 NAND 中的指定地址读取指定大小的数据到 DRAM.
addr 是目的地址，off 是要读取的 NAND 中的数据源地址，size 是要读取的数据大小。

1

nand read 0x83000000 0x520000 0x19000  //读取设备树(dtb)文件到 0x83000000 地址处

1.10 设备树相关#

1.10.1 fdt addr#

设置设备树起始地址：

1
2

nand read 0x83000000 0x520000 0x19000 //比如把nand中dtb分区数据读到dram
fdt addr 83000000	//设置好设备树起始地址

1.10.2 fdt header#

查看设备树头部信息：

fdt header

1.10.3 fdt print#

解析出dts内容：

1.11 启动相关#

1.11.1 bootz (启动zImage)#

bootz [addr [initrd[:size]] [fdt]]

addr 是 Linux 镜像文件在 DRAM 中的位置，initrd 是 initrd 文件在DRAM 中的地址，如果不使用 initrd 的话使用‘-’代替即可，fdt 就是设备树文件在 DRAM 中的地址.

1
2
3

tftp 80800000 zImage
tftp 83000000 imx6ull-14x14-emmc-7-1024x600-c.dtb
bootz 80800000 - 83000000

换一张启动方式：从mmc1也就是emmc启动：

1
2
3

fatload mmc 1:1 80800000 zImage
fatload mmc 1:1 83000000 imx6ull-14x14-emmc-7-1024x600-c.dtb
bootz 80800000 - 83000000

1.11.1 bootm (启动uImage)#

bootm [addr [initrd[:size]] [fdt]]

bootm 命令和 bootz 类似，它是启动 uImage 镜像。uImage是U-boot专用的映像文件，它是在zImage之前加上一个长度为0x40的“头”，说明这个映像文件的类型、加载位置、生成时间、大小等信息。
bootm如果不需要启动设备树：

bootm addr

1.11.3 boot#

boot 会读取环境变量 bootcmd 来启动 Linux 系统：
比如设置bootcmd如下，从网络启动linux：

1
2
3

setenv bootcmd 'tftp 80800000 zImage; tftp 83000000 imx6ull-14x14-emmc-7-1024x600-c.dtb; bootz 80800000 - 83000000'
saveenv
boot

同理，如果想从emmc启动linux,设置bootcmd如下：

1
2
3

setenv bootcmd 'fatload mmc 1:1 80800000 zImage; fatload mmc 1:1 83000000 imx6ull-14x14-emmc-7-1024x600-c.dtb; bootz 80800000 - 83000000'
savenev
boot

1.11.4 go命令#

go addr

跳到指定的地址处执行, addr表示DRAM地址

1
2

tftp 87800000 printf.bin	//一个裸机程序，打印输入的按键，将两个整数相加
go 87800000

1.11.5 run#

run 命令用于运行环境变量中定义的命令，比如可以通过run bootcmd来运行 bootcmd 中的启动命令:

1
2
3
4
5

setenv mybootemmc 'fatload mmc 1:1 80800000 zImage; fatload mmc 1:1 83000000 imx6ull-14x14-emmc-7-1024x600-c.dtb;bootz 80800000 - 83000000'
setenv mybootnand 'nand read 80800000 4000000 800000;nand read 83000000 6000000 100000;bootz 80800000 - 83000000'
setenv mybootnet 'tftp 80800000 zImage; tftp 83000000imx6ull-14x14-emmc-7-1024x600-c.dtb;
bootz 80800000 - 83000000'
saveenv

设置了3个环境变量，可以run mybootemmc或者run mybootnand或者run mybootnet来分别从emmc启动，从nand启动，从网络启动。

1.12 内存测试mtest#

mtest [start [end [pattern [iterations]]]]

start 是要测试的 DRAM 开始地址，end 是结束地址，比如我们测试 0X80000000~0X80001000这段内存，输入mtest 80000000 80001000

可以看出，测试范围为 0X80000000~0X80001000，已经测试了 486 次，如果要结束测试就按下键盘上的“Ctrl+C”键。

1 dynamic_debug介绍#

这里强烈推荐驱动开发者用这种方式输出log。linux kernel space中有pr_debug及dev_dbg来使用dynamic debug。可以看到当用户define DEBUG后，pr_debug和dev_dbg就等于printk的KERN_DEBUG级别输出了；否则什么也不打印。

1.1 开启dynamic debug#

要使用dynamic_debug需要在kernel的defconfig中开启。

1
2

CONFIG_DEBUG_FS=y
CONFIG_DYNAMIC_DEBUG=y

用menuconfig去配置的话如下图：

1.2 dynamic debug使用#

编译好image后，需要挂载debugfs（不挂载的话将不会创建debugfs,那么/sys/kernel/debug/下是空的）。

修改etc/fstab文件，追加下面这段字符:

1

nodev      /sys/kernel/debug debugfs   defaults    0   0

可以用cat /sys/kernel/debug/dynamic_debug/control | grep xxx.c来查看自己想要查看的log所在文件有没有包含进去。

这里可以看到该文件所有用dev_dbg()打印出的讯息。

那如果不开启CONFIG_DYNAMIC_DEBUG，将不会产生/sys/kernel/debug/dynamic_debug目录, 是不能进行动态打印的。

1.2.1 开启dynamic debug#

1
2

echo "module cvi_mipi_rx +p" > /sys/kernel/debug/dynamic_debug/control
echo "file cvi_vip_cif.c +p" >/sys/kernel/debug/dynamic_debug/control

这两种方式都是开dynamic debug，第一种是对模块开启，第二种只对文件开启。

下面举一个栗子：

开启之后，可以看到dev_dbg()打印的log都会输出。

反之，关闭dynamic debug：

1
2

echo "module cvi_mipi_rx -p" > /sys/kernel/debug/dynamic_debug/control
echo "file cvi_vip_cif.c -p" >/sys/kernel/debug/dynamic_debug/control

除了上面的两种方式还有一种可以只开启某个function:

1

echo "func _init_resource +p" > /sys/kernel/debug/dynamic_debug/control

2 dev_err/dev_info/dev_warn#

在Linux驱动代码中，有大量的调试信息，那么推荐使用dev_err/dev_info/dev_warn这一系列函数族。这一系列函数族定义在include/linux/device.h。

其实这些函数族本质上和下面printk.h中的定义也是完全一致的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#define pr_emerg(fmt, ...) \
        printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
#define pr_alert(fmt, ...) \
        printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_crit(fmt, ...) \
        printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_err(fmt, ...) \
        printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
#define pr_warning(fmt, ...) \
        printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
#define pr_warn pr_warning
#define pr_notice(fmt, ...) \
        printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
#define pr_info(fmt, ...) \
        printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)

下图是示例，可以看到err级别以下的log没有打印，那么设置printk的控制台级别可以把对应的log输出到console。

如何设置printk console level可以看上一篇Linux日志管理-printk和dmesg。

3 可变参数宏#

##__VA_ARGS__表示可变参数宏，可以用来传递多个参数，如：

1
2
3
4
5
6
7
8
9
10
11

#define my_dbg(fmt, ...) \
do {                        \
        printf("[%s] [%d] " fmt, __func__, __LINE__, ##__VA_ARGS__);\
} while(0)
#define my_dbg(fmt...) \
do { \
　　printf("[%s] [%d] ", __func__, __LINE__); \
　　printf(fmt); \
} while(0)

char *name = "robin"; int age = 18; my_dbg("this is a test. name:%s, age:%d\n", name, age);

结果如下：

那和下面这种写法呢本质上是完全一样的。

4 模块打印等级控制#

4.1 按照打印等级控制#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#ifndef _XXX_DEBUG_H_
#define _XXX_DEBUG_H_

#include <linux/debugfs.h>

extern u32 xxx_log_lv;

#define DBG_ERR        1   /* error conditions                     */
#define DBG_WARN       2   /* warning conditions                   */
#define DBG_NOTICE     3   /* normal but significant condition     */
#define DBG_INFO       4   /* informational                        */
#define DBG_DEBUG      5   /* debug-level messages                 */

#if defined(CONFIG_LOG)
#define TRACE_XXX(level, fmt, ...) \
    do { \
        if (level <= xxx_log_lv) { \
            if (level == DBG_ERR) \
                pr_err("%s:%d(): " fmt, __func__, __LINE__, ##__VA_ARGS__); \
            else if (level == DBG_WARN) \
                pr_warn("%s:%d(): " fmt, __func__, __LINE__, ##__VA_ARGS__); \
            else if (level == DBG_NOTICE) \
                pr_notice("%s:%d(): " fmt, __func__, __LINE__, ##__VA_ARGS__); \
            else if (level == DBG_INFO) \
                pr_info("%s:%d(): " fmt, __func__, __LINE__, ##__VA_ARGS__); \
            else if (level == DBG_DEBUG) \
                printk(KERN_DEBUG "%s:%d(): " fmt, __func__, __LINE__, ##__VA_ARGS__); \
        } \
    } while (0)
#else
#define TRACE_XXX(level, fmt, ...)
#endif

#endif /* _xxx_DEBUG_H_ */

当级别高于DBG,即可输出高于DBG的所有级别打印。

4.2 精确控制打印等级#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

extern u32 vi_log_lv;
enum vi_msg_pri {
    VI_ERR        = 0x1,
    VI_WARN        = 0x2,
    VI_NOTICE    = 0x4,
    VI_INFO        = 0x8,
    VI_DBG        = 0x10,
};
#define vi_pr(level, fmt, arg...) \
    do { \
        if (vi_log_lv & level) { \
            if (level == VI_ERR) \
                pr_err("%s:%d(): " fmt, __func__, __LINE__, ## arg); \
            else if (level == VI_WARN) \
                pr_warn("%s:%d(): " fmt, __func__, __LINE__, ## arg); \
            else if (level == VI_NOTICE) \
                pr_notice("%s:%d(): " fmt, __func__, __LINE__, ## arg); \
            else if (level == VI_INFO) \
                pr_info("%s:%d(): " fmt, __func__, __LINE__, ## arg); \
            else if (level == VI_DBG) \
                pr_debug("%s:%d(): " fmt, __func__, __LINE__, ## arg); \
        } \
    } while (0)

可以随意开启任意级别打印，比如只开启DBG，只开启WARN。

5 用户态模块打印等级控制#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

XXX_S32 *log_levels;
XXX_CHAR const *log_name[8] = {
    (XXX_CHAR *)"EMG", (XXX_CHAR *)"ALT", (XXX_CHAR *)"CRI", (XXX_CHAR *)"ERR",
    (XXX_CHAR *)"WRN", (XXX_CHAR *)"NOT", (XXX_CHAR *)"INF", (XXX_CHAR *)"DBG"
};

XXX_S32 XXX_LOG_SetLevelConf(LOG_LEVEL_CONF_S *pstConf)
{
    log_levels[pstConf->enModId] = pstConf->s32Level;
    return XXX_SUCCESS;
}

XXX_S32 XXX_LOG_GetLevelConf(LOG_LEVEL_CONF_S *pstConf)
{
    pstConf->s32Level = log_levels[pstConf->enModId];
    return XXX_SUCCESS;
}

#ifndef __XXX_DEBUG_H__
#define __XXX_DEBUG_H__

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <syslog.h>
#include <string.h>
#include <XXX_common.h>

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */

/*
 * Debug Config
 */
#define CONFIG_XXX_GDB_NO 1
#define CONFIG_XXX_GDB "n"
#define CONFIG_XXX_LOG_TRACE_SUPPORT 1
#define CONFIG_XXX_LOG_TRACE_ALL 1
#define CONFIG_XXX_LOG_TRACE_LEVEL 4


#define XXX_DBG_EMERG      0   /* system is unusable                   */
#define XXX_DBG_ALERT      1   /* action must be taken immediately     */
#define XXX_DBG_CRIT       2   /* critical conditions                  */
#define XXX_DBG_ERR        3   /* error conditions                     */
#define XXX_DBG_WARN       4   /* warning conditions                   */
#define XXX_DBG_NOTICE     5   /* normal but significant condition     */
#define XXX_DBG_INFO       6   /* informational                        */
#define XXX_DBG_DEBUG      7   /* debug-level messages                 */

typedef struct _LOG_LEVEL_CONF_S {
    MOD_ID_E  enModId;
    XXX_S32   s32Level;
    char   cModName[16];
} LOG_LEVEL_CONF_S;

#define XXX_PRINT printf

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"

extern XXX_S32 * log_levels;
extern XXX_CHAR const *log_name[8];

#pragma GCC diagnostic pop

#define _GENERATE_STRING(STRING) (#STRING),
static const char *const MOD_STRING[] = FOREACH_MOD(_GENERATE_STRING);
#define XXX_GET_MOD_NAME(id) (id < XXX_ID_BUTT)? MOD_STRING[id] : "UNDEF"

/* #ifdef XXX_DEBUG */
#ifdef CONFIG_XXX_LOG_TRACE_SUPPORT

    #define XXX_ASSERT(expr)                               \
    do {                                                   \
        if (!(expr)) {                                 \
            printf("\nASSERT at:\n"                \
                   "  >Function : %s\n"            \
                   "  >Line No. : %d\n"            \
                   "  >Condition: %s\n",           \
                   __func__, __LINE__, #expr);     \
            _exit(-1);                             \
        } \
    } while (0)

#ifndef FPGA_PORTING

    #define XXX_TRACE(level, enModId, fmt, ...)            \
    do {                                                   \
        XXX_S32 LogLevel = (log_levels == NULL) ? CONFIG_XXX_LOG_TRACE_LEVEL : log_levels[enModId];      \
        if (level <= LogLevel)           \
            syslog(LOG_LOCAL5|level, "[%s-%s] " fmt, XXX_GET_MOD_NAME(enModId), log_name[level],    \
                ##__VA_ARGS__);           \
    } while (0)
#else
    #define XXX_TRACE(level, enModId, fmt, ...) \
        printf(fmt, ##__VA_ARGS__)
#endif
#else
    #define XXX_ASSERT(expr)
    #define XXX_TRACE(level, enModId, fmt...)
#endif

#define XXX_TRACE_ID(level, id, fmt, ...)                                           \
        XXX_TRACE(level, id, "%s:%d:%s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)

#define XXX_TRACE_LOG(level, fmt, ...)  \
        XXX_TRACE(level, XXX_ID_LOG, "%s:%d:%s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)

#define XXX_TRACE_SYS(level, fmt, ...)                                           \
        XXX_TRACE(level, XXX_ID_SYS, "%s:%d:%s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* __cplusplus */

#endif  /* __XXX_COMM_SYS_H__ */

1 printk#

printk函数主要做两件事情：第一件就是将信息记录到log中，而第二件事就是调用控制台驱动来将信息输出。printk的相关函数定义在linux/printk.h。

1.1 日志级别#

printk需要设置日志级别，用来控制printk打印的这条信息是否在终端上显示的，当printk设置的日志级别高于控制台级别时，printk要打印的信息才会在控制台打印出来。

内核日志一共有8种级别:

1
2
3
4
5
6
7
8

#define        KERN_EMERG        "<0>"        /* system is unusable                        */
#define        KERN_ALERT        "<1>"        /* action must be taken immediately        */
#define        KERN_CRIT        "<2>"        /* critical conditions                        */
#define        KERN_ERR        "<3>"        /* error conditions                        */
#define        KERN_WARNING        "<4>"        /* warning conditions                        */
#define        KERN_NOTICE        "<5>"        /* normal but significant condition        */
#define        KERN_INFO        "<6>"        /* informational                        */
#define        KERN_DEBUG        "<7>"        /* debug-level messages                        */

1.2 控制台级别#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#define MINIMUM_CONSOLE_LOGLEVEL 1 /*可以使用的最小日志级别*/
#define DEFAULT_CONSOLE_LOGLEVEL 7 /*默认的控制台级别*/
#define DEFAULT_MESSAGE_LOGLEVEL 4 /* 默认的日志级别 */

int console_printk[4] = {
    DEFAULT_CONSOLE_LOGLEVEL,/*控制台日志级别：优先级高于该值的消息将被打印至控制台*/
    DEFAULT_MESSAGE_LOGLEVEL,/*缺省的消息日志级别：将用该优先级来打印没有优先级的消息*/
    MINIMUM_CONSOLE_LOGLEVEL,/*最低的控制台日志级别：控制台日志级别可被设置的最小值（最高优先级）*/
    DEFAULT_CONSOLE_LOGLEVEL,/*缺省的控制台日志级别：控制台日志级别的缺省值*/
};

#define console_loglevel (console_printk[0])
#define default_message_loglevel (console_printk[1])
#define minimum_console_loglevel (console_printk[2])
#define default_console_loglevel (console_printk[3])

使用命令 cat /proc/sys/kernel/printk 来查看这四个值:

结果显示了 current, default, minimum 和 boot-time-default 日志级别。

其中的 4 4 1 7，分别对应与：console_loglevel、default_message_loglevel、minimum_console_loglevel、default_console_loglevel

default_message_loglevel：

缺省时的消息日志级别，因此当printk未指定优先级时，将以该默认级别输出，也就是DEFAULT_MESSAGE_LOGLEVEL =4， 对应KERN_WARNING。

也就是说printk("hello world\n");就表示printk(KERN_WARNING "hello world\n");

那如果我们将控制台级别设成<4，如：

echo 3 > /proc/sys/kernel/printk

那么printk("hello world\n");就无法输出到控制台。

1.3 修改控制台级别#

1
2
3

echo "n" > /proc/sys/kernel/printk
#Eg:
echo 8 > /proc/sys/kernel/printk

另一种方式，使用 dmesg：

1

dmesg -n 8

此时所有的printk日志级别都会被输出到控制台，如下图所示:

1
2
3
4
5
6
7
8

printk ( KERN_EMERG "Hello, EMERG.\n" ) ;
printk ( KERN_ALERT "Hello, ALERT.\n" ) ;
printk ( KERN_CRIT "Hello, CRIT.\n" ) ;
printk ( KERN_ERR "Hello, ERR.\n" ) ;
printk ( KERN_WARNING "Hello, WARNING.\n" ) ;
printk ( KERN_NOTICE "Hello, NOTICE.\n" ) ;
printk ( KERN_INFO "Hello, INFO.\n" ) ;
printk ( KERN_DEBUG "Hello, DEBUG.\n" ) ;

再来一种方法，修改bootargs：

Uboot中修改console=ttyS0,115200改为loglevel=7 console=ttyS0,115200,表示设置内核的console_loglevel 值=7，开机cat /proc/sys/kernel/printk，可以看到控制台级别被设置成了7:

1.4 printk带时间戳讯息#

make menuconfig开启如下:

1.5 printk底层实现#

源码位于kernel\printk\printk.c。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

printk
    // linux 4.9: kernel/printk/internal.h
    // linux 5.4: kernel/printk/printk_safe.c
    vprintk_func 
        vprintk_default(fmt, args);
            vprintk_emit
                vprintk_store // 把要打印的信息保存在log_buf中
                    log_output
                preempt_disable();
                if (console_trylock_spinning())
                    console_unlock();
                preempt_enable();
console_unlock
    for (;;) {
        msg = log_from_idx(console_idx);
        if (suppress_message_printing(msg->level)) {
            /* 如果消息的级别数值大于console_loglevel, 则不打印此信息 */
        }
        printk_safe_enter_irqsave(flags);
        call_console_drivers(ext_text, ext_len, text, len);
        printk_safe_exit_irqrestore(flags);
    }

1.5.1 命令行参数console#

1
2
3

/* IMX6ULL */
[root@100ask:~]# cat /proc/cmdline
console=ttymxc0,115200 root=/dev/mmcblk1p2 rootwait rw

命令行信息可以来自设备树或者环境变量:

1
2
3
4
5

/ {
    chosen {
                bootargs = "console=ttymxc1,115200";
        };
};

修改环境变量：

1
2
3
4
5
6
7

/* 进入IMX6ULL的UBOOT */
=> print mmcargs
mmcargs=setenv bootargs console=${console},${baudrate} root=${mmcroot}
=> print console
console=ttymxc0
=> print baudrate
baudrate=115200

1.5.2 console驱动注册过程#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

struct console {
    char    name[16];  // name为"ttyXXX"，在cmdline中用"console=ttyXXX0"来匹配
    // 输出函数
    void    (*write)(struct console *, const char *, unsigned);
    
    int        (*read)(struct console *, char *, unsigned);
    // APP访问/dev/console时通过这个函数来确定是哪个(index)设备
    // 举例:
    // a. cmdline中"console=ttymxc1"
    // b. 则注册对应的console驱动时：console->index = 1
    // c. APP访问/dev/console时调用"console->device"来返回这个index
    struct  tty_driver *(*device)(struct console *co, int *index);
    void    (*unblank)(void);
    // 设置函数, 可设为NULL
    int        (*setup)(struct console *, char *);
    // 匹配函数, 可设为NULL
    int        (*match)(struct console *, char *name, int idx, char *options); 
    short    flags;
    // 哪个设备用作console: 
    // a. 可以设置为-1, 表示由cmdline确定
    // b. 也可以直接指定
    short    index;
    // 常用: CON_PRINTBUFFER
    int        cflag;
    void    *data;
    struct     console *next;
};

1.5.2.1 处理命令行参数#

1
2

__setup("console=", console_setup);
console=ttymxc0,115200  console=ttyVIRT0

处理u-boot通过dts传给内核的cmdline参数，比如bootparam参数。

对于这两个”console=xxx”就会调用console_setup函数两次，构造得到2个数组项:

1
2
3
4
5
6
7
8
9
10

struct console_cmdline {
    char    name[16];            /* Name of the driver        */
    int    index;                /* Minor dev. to use        */
    char    *options;            /* Options for the driver   */
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
    char    *brl_options;            /* Options for braille driver */
#endif
};
 
static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];

在cmdline中，最后的”console=xxx”就是”selected_console”(被选中的console，对应/dev/console)：

1.5.2.2 register_console#

1
2
3

uart_add_one_port
    uart_configure_port
        register_console(port->cons);

Linux下Uart子系统驱动 - fuzidage - 博客园 (cnblogs.com)

1.5.2.3 /dev/console#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

tty_open
    tty = tty_open_by_driver(device, inode, filp);
        driver = tty_lookup_driver(device, filp, &index);
            case MKDEV(TTYAUX_MAJOR, 1): {
                struct tty_driver *console_driver = console_device(index);
 
/* 从console_drivers链表头开始寻找
 * 如果console->device成功，就返回它对应的tty_driver
 * 这就是/dev/console对应的tty_driver
 */ 
struct tty_driver *console_device(int *index)
{
    struct console *c;
    struct tty_driver *driver = NULL;
 
    console_lock();
    for_each_console(c) {
        if (!c->device)
            continue;
        driver = c->device(c, index);
        if (driver)
            break;
    }
    console_unlock();
    return driver;
}

Linux下Uart子系统驱动 - fuzidage - 博客园 (cnblogs.com)

1.6 内核信息的早期打印#

当我们注册了uart_driver、并调用uart_add_one_port后，它里面才注册console，在这之后才能使用printk。

如果想更早地使用printk函数，比如在安装UART驱动之前就使用printk，这时就需要自己去注册console。

更早地、单独地注册console，有两种方法：

early_printk：自己实现write函数，不涉及设备树，简单明了

earlycon：通过设备树传入硬件信息，跟内核中驱动程序匹配
earlycon是新的、推荐的方法，在内核已经有驱动的前提下，通过设备树或cmdline指定寄存器地址即可。

1.6.1 early_printk#

arch\arm\kernel\early_printk.c，必须实现这几点：

• 配置内核，选择：CONFIG_EARLY_PRINTK
• 内核中实现：printch函数
• cmdline中添加：earlyprintk

1.6.2 earlycon#

2 prink.h介绍#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#define pr_emerg(fmt, ...) \
        printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
#define pr_alert(fmt, ...) \
        printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_crit(fmt, ...) \
        printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_err(fmt, ...) \
        printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
#define pr_warning(fmt, ...) \
        printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
#define pr_warn pr_warning
#define pr_notice(fmt, ...) \
        printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
#define pr_info(fmt, ...) \
        printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
/* If you are writing a driver, please use dev_dbg instead */
#if defined(CONFIG_DYNAMIC_DEBUG)
#include <linux/dynamic_debug.h>

/* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
#define pr_debug(fmt, ...) \
        dynamic_pr_debug(fmt, ##__VA_ARGS__)
#elif defined(DEBUG)
#define pr_debug(fmt, ...) \
        printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#else
#define pr_debug(fmt, ...) \
        no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#endif

pr_emerg到pr_info都是一些基本的kernel打印函数，用来设置内核日志打印级别，可以看到它和下面这种打印本质上并无差异。

而pr_debug则有3种输出方式，当开启dynamic_debug后，则走dynamic_pr_debug流程（dynamic_debug见下一节）。当用户开启了DEBUG宏，则走printk流程，否则什么都不打印。

3 dmesg命令#

3.1 /proc/kmsg#

/proc/kmsg 是一个特殊的文件，它提供了内核消息缓冲区的访问，这个缓冲区包含了内核产生的所有消息，包括各种调试和错误信息，如内核的启动打印

dmesg命令就是cat /proc/kmsg。

3.2 修改内核日志缓冲区大小#

3.3 dmesg#

dmesg命令是从kernel ring buffer中读取内核日志信息。因此可以用dmesg命令查看。

1
2
3
4
5
6
7
8
9
10

-C:  直接清除ring buffer
-c： 当完成打印显示后清除环缓冲内的内容。
-s： 缓冲区大小
　	定义一个大小为"缓冲区大小"的缓冲区用于查询内核环缓冲区。默认大小为 8196，如果你设置了一个大于默认值的环缓冲区，那你就可以用这个选项定义一个相当的缓冲区来查看完整的环缓冲区内容。

-n：级别

dmesg -k：打印内核信息
dmesg -u：打印用户空间信息

其实用dmesg -n也是可以设置控制台打印级别:

有时候在调试kernel驱动时内核panic了or死锁了，那么无法敲命令，如何查看日志呢？重启后日志就没了，那么可以敲如下命令：

1

cat /proc/kmsg > /mnt/data/ker.log & 2>&1

用后台进程将日志导入到文件。

1. dmesg -f：根据系统打印信息:

可用系统有

kern - kernel messages（内核信息）
user - random user-level messages（随机用户信息）
mail - mail system（邮件系统信息）
daemon - system daemons（系统守护进程信息）
auth - security/authorization messages（认证授权安全信息）
syslog - messages generated internally by syslogd（系统日志信息）
lpr - line printer subsystem（打印机信息）
news - network news subsystem（网络系统信息）

2. dmesg -l：根据level来打印信息:

可用的level信息有

   emerg - system is unusable（系统无法使用）
      alert - action must be taken immediately
       crit - critical conditions（临界条件）
        err - error conditions（错误条件）
       warn - warning conditions（警告条件）
     notice - normal but significant condition
       info - informational
      debug - debug-level messages（debug）

1 syslogd简介#

syslogd不仅仅是记录kernel log的服务，还能记录user space中的日志。

syslogd是Linux下的一个记录日志文件服务。新版本叫做rsyslogd。

syslogd有一系列的子服务，例如mail、auth、cron、kern等等，这些子服务提供日志记录的功能,。当程序要记录log时,可以直接调用这些子服务将日志记录到设定的地方。

syslogd是一个守护进程，配置这整个守护进程以及其子服务的地方就是/etc/syslog.conf这个文件。可以从https://www.rsyslog.com/doc/master/获取官方文档。

1.1 日志格式#

如果配置好并运行了 syslogd 或 klogd，一般所有 log的信息也会追加到 /var/log/messages。并且kernel log信息被记录在/val/log/kern.log。

可以看到基本日志格式包含以下四列:

1. 事件产生的时间(Jan 1 08:00:09)
2. 发生事件的服务器的主机名 (cvitek)
3. 产生事件的服务名或程序名 (kernel or local5)
4. 事件的具体信息(…cif a0c2000.cif:..)

当开启rsyslogd后，不能透过/proc/kmsg来查看kernel log。

1.2 /etc/syslog.conf服务配置#

1. /etc/rsyslog.conf 是rsyslog服务的总配置文件
2. /etc/rsyslog.d 该目录是单独配置的rsyslog配置文件

1.2.1 总配置/etc/syslog.conf#

rsyslog记录哪些日志，到底记录了什么样的日志，是通过这个/etc/rsyslog.conf配置文件来决定的，先分析一下rsyslogd的总配置文件：

默认规则会定义在/etc/rsyslog.d/50-default.conf中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#################
#### MODULES ####
#################
module(load="imuxsock") # provides support for local system logging   ；加载提供对本地系统日志的支持
module(load="imklog")   # provides kernel logging support；加载读取内核消息模块
#module(load="immark")  # provides --MARK-- message capability
# provides UDP syslog reception  （接收使用UDP 协议转发过来的日志，这里#注释掉了表示不启用）
#module(load="imudp")
#input(type="imudp" port="514")  （允许514端口接收）
# provides TCP syslog reception （接收使用UDP 协议转发过来的日志）
#module(load="imtcp")
#input(type="imtcp" port="514")（允许514端口接收）
# Enable non-kernel facility klog messages
$KLogPermitNonKernelFacility on
###########################
#### GLOBAL DIRECTIVES ####
###########################
#
# Use traditional timestamp format.
# To enable high precision timestamps, comment out the following line.
#
$ActionFileDefaultTemplate RSYSLOG_TraditionalFileFormat
# Filter duplicated messages
$RepeatedMsgReduction on
#
# Set the default permissions for all log files.
#
$FileOwner syslog
$FileGroup adm
$FileCreateMode 0640
$DirCreateMode 0755
$Umask 0022
$PrivDropToUser syslog
$PrivDropToGroup syslog
#
# Where to place spool and state files
#
$WorkDirectory /var/spool/rsyslog
(记录所有日志类型的info级别以及大于info级别的信息到/var/log/messages,但是mail邮件信息,authpriv验证方面的信息和cron时间任务相关的信息除外)
#*.info;mail.none;authpriv.none;cron.none    /var/log/messages
# Include all config files in /etc/rsyslog.d/ 
#
$IncludeConfig /etc/rsyslog.d/*.conf  （表示加载该目录中的所有配置）

1.2.2 rsyslog规则（/etc/rsyslog.d/*.conf）#

rsyslog规则配置文件一般由以下3部分组成，每一行表示一个项目，格式为：facility.level action，分别表示日志类型，日志等级，日志输出路径。一般系统默认的规则定义在/etc/rsyslog.d/50-default.conf：

一般所有日志类型都会被追加在/val/log/messages。如：

1

*.info;mail.none;authpriv.none;cron.none    /var/log/messages  

1.2.2.1 facility-日志类型#

• kern: 内核信息
• user: 用户进程相关信息
• mail: 电子邮件相关信息
• Local0- local7: 为本地使用预留的服务
• daemon: 后台进程相关信息
• syslog: 系统日志信息

1.2.2.2 level-按严重程度由低到高排序#

• none: 没有重要级
• debug: 调试信息
• info: 打印的信息
• notice: 具有重要信息的普通条件
• warning: 警告信息
• err: 错误信息
• crit: 阻止某些工具或子系统功能实现的错误条件
• alert: 需要立即被修改的条件
• emerg: 该系统不可用

1.2.2.3 action-表示log保存的位置#

那下面我也抄过来一份比较全面的规则定义示例供大家参考:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 记录mail日志等级为error及以上日志
mail.err                                                        /var/log/mail_err.log
# 记录mail所有等级为warn级别的日志（仅记录warn级别）
mail.=warn                                                        /var/log/mail_err.log
# 记录kern所有日志
kern.*                                                                /var/log/kern.log
# 将mail的所有信息，除了info以外，其他的都写入/var/adm/mail
mail.*;mail.!=info   /var/adm/mail
# 将日志等级为crit或更高的内核消息定向到远程主机finlandia
# 如果主机崩溃，磁盘出现不可修复的错误，可能无法读取存储的消息。如果有日志在远程主机上，可以尝试找出崩溃的原因。
kern.crit                                                     @finlandia
# 记录所有类型的warning等级及以上日志
*.warning                                                        /var/log/syslog_warn.log
# 记录mail的warning日志和kern的error日志,其他所有的info日志
*.info;mail.warning;kern.error                /var/log/messages
# 记录kernel的info到warning日志
kern.info;kern.!err   /var/adm/kernel-info
# 将mail和news的info级别日志写入/var/adminfo
mail,news.=info    /var/adm/info
# 将所有系统中所有类型的info日志和notice日志存入/var/log/massages,mail的所有日志除外。
*.=info;*.=notice;\
mail.none /var/log/messages
# 紧急消息（emerg级别）将使用wall显示给当前所有登录的用户，这里用等号表示只对emerg日志级别有效
*.=emerg                   *
# 该规则将所有alert以及更高级别的消息定向到操作员的终端，即登录的用户“root”和“joey”的终端。
*.alert      root,joey

1.3 程序如何配置syslog子服务(自定义rsyslog规则)#

问题：进程如何发送消息给rsyslog守护进程，rsyslog守护进程是如何对各种日志区分开来的？

像/usr/sbin/sshd、/usr/bin/login、/usr/bin/su这些进程，它们是调用一个叫syslog的系统调用, syslog系统调用是一个用于向rsyslog守护进程发送消息的的系统函数。
/usr/sbin/sshd,/usr/bin/login、/usr/bin/su这些进程专门执行登录验证时，它们在调用syslog系统函数会一般会传入LOG_AUTH这个常量。

而/usr/bin/crond和/usr/bin/at这些在调用syslog系统调用会传入LOG_CRON这个常量（具体请看**syslog()**函数），日志归类规则如下：

所以如果用LOG_AUTH的syslog()函数调用，那么会归类到了/val/log/secure。

如果用LOG_CRON的syslog()调用则归类到了/val/log/cron。而kernel等其他log被记录在了/val/log/messages中。

那么我们可以自定义规则如下:

1
2
3
4
5
6

syslogfacility-text：表示facility日志类型
syslogseverity-text：表示level日志级别

这里对aisdk.conf用local7日志类型产生的大于warn日志级别的log都将记录到/val/log/aisdk，
对kern.conf用kern类型产生的所有级别日志都记录到/val/log/kern，
Local5类型的日志记录到/val/log/middleware, 并且当日志级别等于或高于4（warn）时也会追加到console.

注意busybox要开启使能syslog.conf解析：/etc/syslog.conf解析，CONFIG_FEATURE_SYSLOGD_CFG=y

2 syslog()函数#

用户空间也可以用syslog()函数来记录自己的进程的日志，所以用户进程可以自定义日志规则。
调用openlog是可选择的。如果不调用openlog，则在第一次调用syslog时，会自动调用openlog。
syslog的相关函数和宏定义一般在toolchain中都会有定义:

1
2
3
4

#include <syslog.h>
void openlog (char*ident,int option ,int facility);
void syslog(int priority,char*format,……)
void closelog();

2.1 openlog函数#

第1个参数为ident，该参数常用来表示信息的来源。ident信息会被固定地添加在每行日志的前面：
第2个参数 option控制标志:

第3个参数为facility：

2.2 syslog函数#

第一个参数priority表示日志级别：

下面是具体的例子：

这里printf("%m")等价于printf("%s",strerror(errno));它表示把errno用string形式打印出来。

由于我这里facility为user时，是记录在/val/log/syslog中的:

因此打印log如下:

2.3 重定向log#

我们也可以把log定向到自己想要的地方。

2.3.1 方法1-修改rsyslog.conf#

将facility=user时的所有level级别的log重定向到/val/log/user.log, 重启rsyslog服务:

此时log将被写入到新配置的位置/val/log/user.log, 当然/val/log/syslog也会保留一份.（因为也符合/val/log/syslog这条规则）

2.3.2 方法2-修改code中的facility#

那这里的facility被设置成了local0, 那也会记录在/val/log/syslog:

2.4 设置log等级#

1. 这里新增一个app.conf，然后自定义log路径:

当然还可以类似于这样子写， syslogfacility-text和syslogseverity-text是rsyslog自带的系统变量。

2. 重启rsyslog服务

   

这里切成4个文件，每个文件记录1024k。

3. 运行程序,查看log如下:

   

4. 那现在修改log等级为warn, 表示只有大于等于该等级的log才会记录。

   

5. 再次重启rsyslog服务，运行程序，可以看到”log debug”不再打印：

   

2.5 重定向log到console#

再次重启rsyslog服务，运行程序，那么可以看到err级别的log打印在了console上，但是低于err级别还是会记录在/val/log/app。

3 dup函数介绍#

用来将标准输出重定向到文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

static int dup_fd;
static int dup_fd_bak = 1000;

static int dup_fd(void)  {
    dup_fd = open( "./printf_dup_log.txt ", O_CREAT | O_RDWR | O_TRUNC);
    dup2(STDOUT_FILENO, dup_fd_bak);/*backup stdout*/
    dup2(dup_fd, STDOUT_FILENO);
    return 0;
}
static int rst_fd(void)  {
    dup2(dup_fd_bak, fileno(stdout));/*recover stdout*/
    close(dup_fd);
    return 0;
}

1 获取 tslib 源码#

https://github.com/libts/tslib
git clone https://github.com/libts/tslib.git

2 修改 tslib 源码所属用户#

sudo chown book:book tslib-1.21 -R
这一步一定要做！否则在稍后的编译中会遇到各种问题。

3 ubuntu 工具安装#

1
2
3

sudo apt-get install autoconf
sudo apt-get install automake
sudo apt-get install libtool

4 编译 tslib#

1
2
3
4
5

cd tslib-1.21/ //进入 tslib 源码目录
./autogen.sh
./configure --host=arm-linux-gnueabihf --prefix=/home/zuozhongkai/linux/IMX6ULL/tool/tslib
make //编译
make install //安装

“--host”参数指定编译器，“--prefix”参数指定编译完成以后的 tslib 文件安装到哪里.
完成以后 tslib 目录下的内容如下：

把所有文件拷贝到开发板的根文件系统中：
sudo cp * -rf /home/zuozhongkai/linux/nfs/rootfs

5 配置 tslib#

打开/etc/ts.conf 文件，找到下面这一行：
module_raw input
打开/etc/profile 文件，在里面加入如下内容：

1
2
3
4
5
6

export TSLIB_TSDEVICE=/dev/input/event1
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/etc/ts.conf
export TSLIB_PLUGINDIR=/lib/ts
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0

TSLIB_TSDEVICE 表示触摸设备文件，这里设置为/dev/input/event1，这个要根据具体情况设置，如果你的触摸设备文件为 event2 那么就应该设置为/dev/input/event2，以此类推。
TSLIB_CALIBFILE 表示校准文件，如果进行屏幕校准的话校准结果就保存在这个文件中，这里设置校准文件为/etc/pointercal，此文件可以不存在，校准的时候会自动生成。
TSLIB_CONFFILE 表示触摸配置文件，文件为/etc/ts.conf，此文件在移植 tslib 的时候会生成。
TSLIB_PLUGINDIR 表示 tslib 插件目录位置，目录为/lib/ts。
TSLIB_CONSOLEDEVICE 表示控制台设置，这里不设置，因此为 none。
TSLIB_FBDEVICE 表示 FB 设备，也就是屏幕，根据实际情况配置，我的屏幕文件为/dev/fb0，因此这里设置为/dev/fb0。

6 tslib 测试#

一般电容屏可以不用校准，如果是电阻屏就要先进行校准。
输入ts_calibrate
校准完成以后如果不满意，或者不小心对电容屏做了校准，那么直接删除掉/etc/pointercal文件即可。

6.1 ts_test_mt#

此命令会打开一个触摸测试界面：

Drag：拖拽按钮，默认就是此功能，大家可以看到屏幕中间有一个十字光标，我们可以通过触摸屏幕来拖拽此光标。一个触摸点一个十字光标，对于 5 点电容触摸屏，如果 5 个手指都放到屏幕上，那么就有 5 个光标，一个手指一个。
Draw：绘制按钮，按下此按钮我们就可以在屏幕上进行简单的绘制，可以通过此功能检测多点触摸工作是否正常。
Quit：退出按钮，退出 ts_test_mt 测试软件。
点击“Draw”按钮，使用绘制功能，5 个手指一起划过屏幕，如果多点电容屏工作正常的话就会在屏幕上留下 5 条线：

可以看到有5条横线。

1 前言-参考资料#

正点原子：http://www.openedv.com/docs/boards/arm-linux/zdyz-i.mx6ull.html

2 linux 命令#

1.1 磁盘相关#

1.1.1 fdisk#

1.1.1.1 查看分区#

fdisk -l显示磁盘分区使用情况

1.1.1.2 删除分区#

fdisk /dev/sdb1 用来对sdb1进行分区.

输入m表示获取帮助，默认有分区sdb1, 然后输入d删除分区1，p打印出分区表，i表示打印出详细分区信息，n表示新增分区信息，w表示保存，q表示退出。

来看dev/sd*信息，发现已经没有了sdb1.

1.1.1.3 创建分区#

再来看如何建立分区1：
先建立一个1GB的分区，1GB= 1024 * 1024 * 1024=1073741824 B = 2097152个sector，一个sector有512 byte,再加上2048 个sector，那么等于2099200个sector。

再来何建立分区2：

这里First sector使用默认值2101248，Last sector使用4198400（1G是2097152， 2101248 + 2097152 = 4198400），分区2也是1GB
再来何建立分区3：

First sector和Last sector使用默认，那么最终分区3有26.8GiB。

最后输入w保存退出，来看下分区:

1.1.2 磁盘格式化命令-mkfs#

mkfs命令用来对磁盘分区格式化，将格式化好的sd卡放入windows系统查看，可以看到3个盘:

1.1.2.1 mount#

1.1.3 du#

1.1.4 df#

1.2 文件字符操作命令#

1.2.1 xargs#

find -name *.sh |xargs grep -rn "build_all"

1.2.1 find#

按时间搜索：
-atime 访问时间 (单位是天，分钟单位则是-amin，以下类似）
-mtime 修改时间 （内容被修改）
-ctime 变化时间 （元数据或权限变化）

最近7天被访问过的所有文件：
find . -atime 7 -type f -print
最近7天被修改的文件：
find . -maxdepth 2 -mtime 7 -type f

通配符#

一版find命令还会伴随通配符使用：

1
2
3
4

*：匹配任意多个字符
?：匹配任意一个字符
[...]：匹配中括号内出现的任意一个字符
[!...]：不匹配中括号内出现的任意一个字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$ find . -name *.txt
$ find -name *.[ch]
$ find -name *fsi*.?  #查找包含fsi字符，同时又有.c或者.h等单个字符后缀的文件
./i2c/busses/i2c-fsi.c
./spi/spi-fsi.c
./input/joystick/fsia6b.c
./fsi/fsi-sbefifo.c
./fsi/fsi-master-ast-cf.c
./fsi/fsi-master-aspeed.c
./fsi/fsi-master.h
./fsi/fsi-occ.c
./fsi/fsi-master-hub.c
./fsi/fsi-master-gpio.c
./fsi/fsi-core.c
./fsi/fsi-scom.c
./fsi/cf-fsi-fw.h

伴随执行任务#

1
2

# 找到后执行删除
find . -name "*.txt" -exec rm {} \;

1.2.2 grep#

find /path/to/directory -type f -name "*.txt" | grep "keyword"

-w 全词匹配。
-v 反向搜索
-i 不区分大小写

1
2
3
4
5
6
7

$匹配以字符串结尾的行
^ 匹配以字符串开头的行

找出空行 grep "^$" test.txt -n
找出unix开头的行grep "^unix" geekfile.txt
找出.结尾的行 grep "\.$" test.txt -n -o
找出os.结尾的行，grep "os.$" geekfile.txt

[abc]中括号

匹配abc字符中的任意一个:

匹配a-z:

下面一个脚本用grep -v排除掉不需要的行，也就是删除包含指定字符的行从一个文件。

1
2
3
4
5
6
7
8
9
10
11

#!/bin/bash
# 定义要删除的特定字符
pattern="特定字符"
# 定义要处理的文件名
filename="文件名"
# 使用grep命令找到含有特定字符的行，并将结果输出到一个临时文件中
grep -v "$pattern" "$filename" > temp.txt
# 将临时文件的内容复制回原始文件
cat temp.txt > "$filename"
# 删除临时文件
rm temp.txt

uniq 删除重复行#

tr字符串替换#