1

CORE_LIBS="$CORE_LIBS -L/usr/lib64/mysql -lmysqlclient -lz -lcrypt -lnsl -lm -L/usr/lib64 -lssl -lcrypto"

修改过是这样的，

1
2

CORE_LIBS="$CORE_LIBS -L/usr/lib64/mysql -Wl,-Bstatic -lmysqlclient \
    -Wl,-Bdynamic -lz -lcrypt -lnsl -lm -L/usr/lib64 -lssl -lcrypto"

　　其中用到的两个选项：-Wl,-Bstatic和-Wl,-Bdynamic。这两个选项是gcc的特殊选项，它会将选项的参数传递给链接器，作为链接器的选项。比如-Wl,-Bstatic告诉链接器使用-Bstatic选项，该选项是告诉链接器，对接下来的-l选项使用静态链接；-Wl,-Bdynamic就是告诉链接器对接下来的-l选项使用动态链接。下面是man gcc对-Wl,option的描述，

       -Wl,option
           Pass option as an option to the linker.  If option contains commas, it is
           split into multiple options at the commas.  You can use this syntax to pass
           an argument to the option.  For example, -Wl,-Map,output.map passes -Map output.map
           to the linker.  When using the GNU linker, you can also get the same effect with
           -Wl,-Map=output.map.

下面是man ld分别对-Bstatic和-Bdynamic的描述，

       -Bdynamic
       -dy
       -call_shared
           Link against dynamic libraries. You may use this option multiple times on the
           command line: it affects library searching for -l options which follow it.

       -Bstatic
       -dn
       -non_shared
       -static
           Do not link against shared libraries. You may use this option multiple times on
           the command line: it affects library searching for -l options which follow it.
           This option also implies --unresolved-symbols=report-all.  This option can be
           used with -shared.  Doing so means that a shared library is being created but
           that all of the library's external references must be resolved by pulling in
           entries from static libraries.

　　值得注意的是对-static的描述：-static和-shared可以同时存在，这样会创建共享库，但该共享库引用的其他库会静态地链接到该共享库中。

　　传说中，存在这么一串神秘的字符，你把它们放到终端，然后回车，不消太久，你的机器就变植物人只能低电平复位重启了。这串神秘的字符看起来是这样的，

1

dutor@home: ~$ :(){ :|:; };:&

　　这是神马玩意儿呢？好的，现在听我的，把你的脑袋面对显示器逆时针旋转四分之一圆周，像不像一个张着血盆大口的长袍老怪？
　　严肃点，你看懂它的真相了吗？换种等价的写法，

1

dutor@home: ~$ foo(){ foo|foo; };foo&

　　其实就是“声明”了一个函数，然后在后台执行这个函数。在函数体内部，以管道的形式调用递归调用自身。第一种写法只是把函数名换成”:”产生的怪胎。
　　就这么简单吗？函数体里面，以管道连接的第二个foo会被执行吗？这需要了解Unix终端下的管道机制，在这之前，先观察一下这些进程的进程树。为了不致于死的那么快，对这个函数稍加修改，

1
2

dutor@home: ~$ :(){ sleep 30;:|:; };:&
[1] 12345

　　接下来使用pstree命令，查看进程12345的子进程树。

1

dutor@home: ~$ watch pstree -c 12345

　　每隔30秒左右，进程树变化一次，依次，

bash---sleep

bash-+-bash---sleep
     `-bash---sleep

bash-+-bash-+-bash---sleep
     |      `-bash---sleep
     `-bash-+-bash---sleep
            `-bash---sleep

bash-+-bash-+-bash-+-bash---sleep
     |      |      `-bash---sleep
     |      `-bash-+-bash---sleep
     |             `-bash---sleep
     `-bash-+-bash-+-bash---sleep
            |      `-bash---sleep
            `-bash-+-bash---sleep
                   `-bash---sleep

　　可见，该进程树以二叉树的形式进行扩展。间接说明了，以管道连接的两个命令并不是一次执行的，即两个命令的执行是并发的，时间上是有交叠的。

终端下的管道机制

　　Unix终端下管道的实现使用了进程间通讯的一种，即匿名管道。由于匿名管道是匿名的，所以只能用在有亲缘关系的进程之间。通常是父进程创建匿名管道，然后fork出子进程，这时父子进程共享匿名管道的描述符。然后父进程向管道中写数据，子进程从管道中读数据。
　　具体到bash中的管道：bash首先解析用户的输入，比如foo | bar。然后，bash使用fork创建子进程P1，必要时使用wait族系统调用等待子进程结束。由P1创建匿名管道，然后P1再次fork出P2进程。接着，P1关闭匿名管道的读端，并将写端的文件描述符复制到标准输出（dup系统调用）；P2关闭匿名管道的写端，并将读端的文件描述符复制到标准输入。最后，P1使用exec族系统调用执行foo，覆盖当前进程空间；P2使用执行bar。这样，最终foo的标准输出就被管道连接到了bar的标准输入上了。
　　要注意的是，这里foo和bar谁是父谁是子是取决于实现的，不变的是管道流始终是自左向右的。
下面是一段示例代码，

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

//~ foo.c
int
main()
{
    write(1, "message\n", 8);
    return 0;
}
//~ bar.c
int
main()
{
    char buf[9] = {0};
    read(0, buf, sizeof(buf));
    buf[0] -= 32;
    write(1, buf, 8);
    return 0;
}
//~ main.c
int
main()
{
    pid_t pid;
    if ((pid = fork()) == 0) {
        //~ child will establish a pipe
        int fd[2];
        pipe(fd);
        if (fork() == 0) {
            //~ child of child
            close(fd[1]); //~ only read
            dup2(fd[0], 0); //~ dupliate 'in-endian' of the pipe to 'stdin'
            execv("./bar", NULL); //~ execute 'bar'
        }
        close(fd[0]); //~ only write
        dup2(fd[1] , 1); //~ duplicate 'out-endian' of the pipe to 'stdout'
        execv("./foo", NULL); //~ execute 'foo'
        wait(NULL);
    }
    //~ parent will wait.
    wait(NULL);
    return 0;
}

1
2
3
4
5

dutor@home: ~$ cc foo.c -o foo && cc bar.c -o bar && cc main.c -o main
dutor@home: ~$ ./foo
message
dutor@home: ~$ ./main
Message

总结

　　关于终端下的管道，它的简洁和强大自不必说。需要清楚的是，管道中各进程的启动是没有一定的次序的，执行时间是交叠的。一旦知道这些，下面的命令的结果就不会出乎意料。

1

dutor@home: ~$ cat main.c | sed 's#//.*##' > main.c #warning: main.c may be truncated.

　　这个命令可以并行的执行某个程序，

1
2
3
4

# 如果run.sh产生大量标准输出时，只有最后一个进程的输出会显示到终端
# 其他的都会'堆积'到匿名管道中(如果run.sh不从标准输入读取数据的话)
# 这可能导致进程阻塞
dutor@home: ~$ ./run.sh | ./run.sh | ./run.sh | ./run.sh

#
# /etc/rc.conf - Main Configuration for Arch Linux
#
...
# -----------------------------------------------------------------------
# DAEMONS
# -----------------------------------------------------------------------
#
# Daemons to start at boot-up (in this order)
#   - prefix a daemon with a ! to disable it
#   - prefix a daemon with a @ to start it up in the background
#
DAEMONS=(syslog-ng @network netfs dbus !bluetooth @crond @alsa @wicd @hal @slim)

还有.xinitrc:

1
2
3
4
5
6
7
8
9
10
11

#! /bin/bash
 
xscreensaver &
rl=$(runlevel | grep -o [0-6])
 
case $rl in
	4) exec openbox-session;;
	5) exec gnome-session;;
#4) exec ck-lauch-session openbox-session;;
#5) exec ck-lauch-session gnome-session;;
esac

　　另外，在xinitrc中，执行exec ck-lauch-session openbox-session时，总无法登陆：从slim登陆后又会出现slim登陆界面。

$ dd if=Archlinux.iso of=/dev/sdb bs=4M

　　dd命令完成后，使用fdisk察看，会发现U盘已经存在一个分区和文件系统（当然之前的文件系统和分区就不见了），而且U盘已经被设置为可引导。我对Ubuntu, Debian和Gentoo的镜像做相似的测试，但都没有相同的效果。有兴趣的朋友可以研究一下Arch的iso的结构。
　　使用制作好的可启动U盘，就可以开始安装了。对于基本系统的安装，具体的安装细节不再啰嗦，不熟悉的朋友可以参照上面说的安装手册、Arch Wiki或者其他资料进行。这里仅介绍下我在安装的过程中遇到的问题。
　　首先选择安装源，可以选择光盘（这里即U盘）或者网络，网络安装是一种十分方便的方法，但对网络要求较高。我选择使用U盘作为安装源。
　　接下来设置时钟，选择时区。硬件时钟的设置有UTC和localtime两种，如果你的机器需要双/多重引导，尤其是与Windows共存，应该选择localtime。
　　该选择/建立分区了。由于之前我的机器是Ubuntu和Win 7双系统，对Ubuntu也要说ByeBye了，所以我直接选择之前的各Linux分区，包括：/boot, /, swap, /home, 因为之前/home下有大量数据，且只是“用户数据”，所以不需也不能格式化。而其他都需要重新格式化。在操作分区的时候，一定要慎之又慎，一定要清楚每一个操作会产生什么样的后果。例如，我选择将/dev/sda10，即Ubuntu中的/home，挂载到/home时，会有提示“是否重新建立文件系统”。
　　分区的事情搞定，下面的事情就轻松多了。
　　选择索要安装的软件包，其中base和base-devel是必须的，其他可选，我选择了其中无线网络支持的相关包。软件包的安装几分钟就可完成。
　　建立好分区和文件系统，安装完软件包，系统的框架就已经建立起来了。下面就要对系统的各种参数进行配置。在配置之前，需要选择编辑配置文件时使用的编辑器，对vi熟悉的就选择vi，否则选nano。如果前面的操作没有错误，配置也不会太过复杂，但为了保险起见，最好检查每一个配置文件，对每一个需要配置的选项。其中可能比较重要的是网络和软件mirror的选择。根据具体情况，可以选择static和dhcp两种方式，如果选择静态，通常还要配置相应的gateway和dns。软件的镜像，我选择了网易163的开源镜像，速度很快。
　　对系统进行基本的配置后，一个能够运行的基本系统就建立了，但还不能够引导，还需要安装一个bootloader。我选择使用grub，当前Arch使用的是grub 0.97，而不是grub2。所以配置grub需要察看和编辑menu.lst。如果之前分区和文件系统挂载没有问题，menu.lst也应该不会有问题。只是默认情况下，之前存在与机器上的其他系统（比如Windows）不会被列入grub的引导菜单，需要手动加入。最后将grub记录写入到MBR即可，我这里即将grub安装到/dev/sda.
　　最后，重启。
　　之后，登陆到系统，添加新用户。在更新整个系统之前，首先要做的就是配置网络。当时我就卡在了网络配置上了，系统中没有eth0接口，因为没有我的网卡的驱动。最终，我不得不，使用其他机器下载对应的网卡驱动，然后编译、加载和重启，才联上了网络。
　　更新系统。Arch使用不同于Ubuntu/Debian的“包管理”机制，除了最常用的pacman，还有ABS, Yaourt等，使用方法见诸世界各地。

　　做为个人使用，没有X，没有桌面的系统是不食人间烟火的系统。下面要做的就是，安装Xorg, 显卡驱动（安装X时，开源驱动会被安装，没有特殊需求的话，可不用手动安装）。安装桌面环境，重量级如GNOME、KDE之流，轻量级如xfce、lxde等等。我没有直接现成的安装桌面环境，而是分别安装窗口管理器(openbox)，登陆管理器(slim)，文件管理器(Thunar)，系统面板(tint2)等等。有了基本的桌面，还需要安装和配置系统的字体(ttf-ms-fonts, bitstream等等)，中文输入法(ibus-sunpinyin), 无线网络管理利器(wicd)。

　　再最后，就是安装最常用的应用程序了，虚拟终端(urxvt)，浏览器(chromium)，编辑器(vim/gvim/gedit)，媒体播放器(mplayer, smplayer, audacious)，pdf阅读器(evince, xpdf)，图片查看/编辑器(eog, feh, Gimp)，邮件客户端(mutt, Thunderbird)，即时通讯工具(Pidgin)，不啦不啦。

　　“折腾”似乎无休无止，但折腾的过程中你得到了什么，失去了什么，只有自己能够体会，折腾的度要由自己把握，在好玩儿、实用和学习之间找到自己的平衡点。

1
2
3
4
5
6
7
8
9
10

vpath % /home/dutor/
vpath rc /home/dutor/.lftp/
vpath vsftpd.conf /etc/
vpath openbox /home/dutor/.config/
vpath tint2 /home/dutor/.config/
 
BACKUP: .vimrc .vim .bashrc .Xresources .xbindkeysrc .gitconfig .bin .screenrc \
.wordump.txt vsftpd.conf openbox .tmux.conf .conkyrc tint2
	dcp $?
	touch BACKUP

　　其中，vpath是make的命令，用于指定文件的搜索目录。BACKUP是一个空文件，每当完成备份时，使用touch命令更新其时间戳。dcp是一个脚本，将其参数指明的文件拷贝到Dotfiles目录，$?是make的自动变量，代表依赖关系中比目标更新的依赖。dcp是这样的，

1
2
3
4
5
6

[ $# -eq 0 ] && echo "Usage: dcp <file> ..." && exit 1
for i
do
    echo -n " copying $i..."
    cp $i $DCPPATH -rp && echo 'done'
done

其中$DCPPATH保存了配置文件的保存目录，即Dotfiles.

　　另外，我还将我的配置文件放在了github.com上，使用git clone https://github.com/xdutor/Dotfiles.git可以得到。

$ iconv -f coding1 -t coding2 file1 -o file2

　　若file1省略，则使用标准输入；若-o选项省略，则使用标准输出。
　　例如，我想把所有GBK编码的.cue文件转化为utf8编码：

$ find . -name "*.cue" -exec iconv -f gbk -t utf8 {} -o {} \;

　　关于编码，还有一个比较实用的工具luit：

$ luit -encoding coding COMMAND

　　luit将COMMAND命令的输出按照coding编码解释，然后转化为本地系统的编码并输出。
　　例如，各个BBS的telnet输出通常是GBK编码的，直接使用telnet连接可能会出现乱码。使用luit即可，

$ luit -encoding gbk telnet bbs.dlut.edu.cn

1

shopt -s expand_aliases

设置这个选项，可以在bashrc中，也可以在需要使用alias的脚本中。

　　再就是，如果在脚本中的同一行内，先定义alias，接着马上使用该alias是会产生错误的。原因就是bash在解释执行脚本过程中，每次读取至少一行命令，alias展开就是在读取时进行的，读取之后（alias展开也完成了）才开始执行命令（当然，还会有参数扩展等其他操作）。由于进行alias展开时该行的alias命令尚未执行，所以其中的alias就不会被展开。举个例子吧，

1
2

shopt -s expand_aliases
alias ll='ls -lh'; alias e='exit'; ll; e

执行该脚本，会发现ls 和exit命令均未被执行，错误提示ll和e命令未找到。所以，脚本中，alias命令最好单独成行。
　　同样的问题也出现在组合命令中，比如while, for循环等结构，

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

shopt -s expand_aliases
for i in `seq 1 10`
do
    alias ll='ls -lh'
    ll # command ll not found.
done
 
for i in `seq 1 10`
do
    alias ll='ls -lh'
    ll # now ok
done

　　类似地，在shell函数中alias也会出现同样的问题。事实上，shell中的函数只不过是一种特殊的、有名字和参数的、使用{}的组合命令，所以单行函数中’}'之前是必须要有分号的，就像普通的{}组合命令一样。之所以非单行函数不需要分号，是因为换行可以代替分号。
　　最后，bash中alias不可以使用位置参数（据说csh）是可以的，也就是说，不可以使用alias mkcd=’mkdir $1 && cd $1′这样的命令（这种命令允许你在alias中按照自己的意愿安排参数的位置，例如对于alias ll=’ls $1 -lh’，ll file被展开为ls file -lh，而不是简单的展开为ls -lh file）。如果在bash中确实需要这样做，就应该使用函数来完成，比如，function mkcd() { ‘mkdir $1 && cd $1; }.

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

~$ echo --help
--help
~$ man echo
ECHO(1)                          User Commands                         ECHO(1)
NAME
       echo - display a line of text
SYNOPSIS
       echo [OPTION]... [STRING]...
DESCRIPTION
       Echo the STRING(s) to standard output.
 
  -n             do not output the trailing newline
  -e             enable interpretation of backslash escapes
  -E             disable interpretation of backslash escapes (default)
      --help     display this help and exit
      --version  output version information and exit
......
 
NOTE: your shell may have its own version of echo, which usually supersedes
the version described here.  Please refer to your shell's documentation
for details about the options it supports.
......

还真有–help选项。“眼尖”的同学可能注意到了，man echo输出中的NOTE说明，shell（比如bash）可能有自己的echo版本，而且可能优先于man echo的echo。
　　什么是shell自己版本的echo呢？原来，shell中可以使用的命令有“内建命令”（built-in）和外部命令之分。内建命令有shell本身实现，即和shell进程同属于一个地址空间执行，比如echo可能是shell中的一个函数实现的。内置命令通常是无法或者不适以外部命令的形式实现的命令，比如cd, source, alias, bind, history, set等等。外部命令是一些独立的可执行文件，由shell以fork/exec的形式执行。
　　使用type命令可以获取命令的类型。由type type可以知道type命令本身也是内建命令。

　　知道这些，通过–help选项输出echo的帮助信息就不是什么难事了，

1
2
3
4

~$ which echo
/bin/echo
~$ /bin/echo --help
......

　　BTW，man echo查看的是外部echo的信息，那怎么查看内建echo的帮助信息呢？

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

~$ help echo
echo: echo [-neE] [arg ...]
    Output the ARGs.  If -n is specified, the trailing newline is
    suppressed.  If the -e option is given, interpretation of the
    following backslash-escaped characters is turned on:
        \a      alert (bell)
        \b      backspace
        \c      suppress trailing newline
        \E      escape character
        \f      form feed
        \n      new line
        \r      carriage return
        \t      horizontal tab
        \v      vertical tab
        \\      backslash
        \0nnn   the character whose ASCII code is NNN (octal).  NNN can be
                0 to 3 octal digits
 
    You can explicitly turn off the interpretation of the above characters
    with the -E option.

我们发现，内建的echo是没有–help选项的。事实上，它只有三个选项，-neE。

for i in $(ls *.mp3); do COMMANDS; done

这个单行命令的目的对当前目录下的所有mp3文件执行由COMMANDS表示的命令。但这个命令通常达不到预期的效果，至少早我的Music目录下不会成功。我的mp3歌曲中很大一部分是从Google Music上面下载的，绝大部分英文歌曲的文件名中都包含空格，即是说，命令替换（command substitution）$(ls *.mp3)的结果可能是这样的：My Love.mp3 Shape of My Heart.mp3。这种情况下，for循环的每次迭代中，变量i的值就不是预期的My Love.mp3和Shape of My Heart.mp3，而分别会是My, Love.mp3, Shape, of, My, Heart.mp3。这样，你就会得到一大堆的No such file or directory的错误信息。为什么会这样呢？这是因为Bash在允许的情况下，会对变量的扩展结果进行分词（word splitting），规则就是根据shell变量IFS的第一个字符（默认为空格）对变量的扩展结果进行分词。
将for循环改成这种形式可以解决分词的问题：

1
2
3
4
5
6

for i in *.mp3
do
    COMMANDS
done
# 单行形式就是for i in *.mp3; do COMMANDS; done
# ;只是起到命令和关键字间的分割符的作用，完全可以用换行符来代替

　　而这样防止分词是不可行的：

1
2
3
4

for i in "$(ls *.mp3)"
do
    COMMANDS
done

　　原因是这样一来ls的所有输出都会被当成一个文件名赋给变量i，这肯定不是你想要的。但这种防止分词的方法在许多情况下是值得采用的，而且有意识地对变量加上双引号是值得鼓励的。比如在这类命令中：

1

cp $foo $bar

如果不对foo和bar加引号，当其中包含空格时，会产生意想不到且令人不快的效果。

for i in $*; do COMMANDS; done

　　$*是对所有位置参数（从$1开始）的引用，各个参数以IFS分隔，若IFS为空，则所有参数就会粘到一起。在这个for中，如果位置参数中包含空格，同样会产生分词的问题，将$*加引号更不是解决之道。正确的方法是使用$@代替$*，并使用双引号。$@和$*的不同之处在于即使IFS为空，$@中的参数们也不会粘到一起。而且，对$@加引号的效果相当于给个位置参数分别加引号。所以，这样写就能得到预期效果：

1
2
3
4

for i in "$@"
do
    COMMANDS
done

　　由于对位置参数进行逐一操作是如此的常用，以至于这样写是等效的：

1
2
3
4

for i
do
    COMMANDS
done

‘-’开头的文件名

　　这是一个经常被提到的问题，对Linux熟悉的人想必都知道。为命令提供以’-'开头的参数（argument），会让该命令误以为是为其提供的选项（option），而通常这样的选项是不存在的（存在的话，问题就更隐晦了）。通常有两种解决方法，连续使用两个’-'，告诉该命令（还是shell？）后面都是参数，没选项了。另外一种方法就是为文件名（如果该参数是文件的话）加上路径。

1
2
3

cp -foo bar # Wrong
cp -- -foo bar # OK
cp ./-foo bar # OK

　　另外，使用GDB调试程序时，可能需要向被调试程序传递参数。

1

gdb a.out arg1 arg2

这样是不行的，因为arg1, arg2会被当作传递给GDB的参数。GDB并不理会–，而是有自己的方法来被告知结束参数扫描，即使用–args或-args选项，

1

gdb --args a.out arg1 arg2

　　针对gdb，向被调试程序传递参数更好的方法是通过进入gdb后run或start命令来进行。

‘['是一个命令

　　当[与if相遇，而且由于它们是如此频繁地相遇，以至于'['经常被误认为是条件表达式if的一部分。事实上，if的标准结构是这样的：

1
2
3
4
5
6
7
8

if COMMANDS
then              # 必要的
    SOME COMMANDS
elif COMMANDS     # 可选，且可有多个
    OTHER COMMANDS
else              # 可选，但只能有一个
    ELSE COMMANDS
fi                # 必要的

　　注意，这里并没有'['。if和elif只是根据其后的命令（组）的退出状态（exit status）来判断是否进入相应的区块。因此，在语句if [ CONDITONAL EXPRESSION ]; then COMMANDS; fi中，’[]‘并不是为了组织CONDITIONAL EXPRESSION，而是为了测试其有效性。’['是shell的一个内建命令（builtin command），等价与test命令，只是'['的最后一个参数必须是']‘罢了。
　　正因为’['是一个命令，所以它与参数、参数之间必须是相互分开的。比如[$foo=bar], [ $foo=bar ], [ $foo =bar ]都是不正确的，[ $foo = bar ]才是正确的，因为这里$foo, =, bar, ]均是’['的参数。

'['与'[['的区别

　　首先，'['是一个命令，'[['是一个shell关键字：

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

$ type [
[ is a shell builtin
$ type [[
[[ is a shell keyword
$ [ # 参数错误
/bin/bash: line 0: [: missing `]'
$ echo $?
2
$ [ ]
$ echo $? # 参数为空（除了']'），估值为1
1
$ [[ # 回车
>foo ]] # PS2
$ echo $? # foo为非空string，估值为0
0

　　其次，'[ ]‘和’[[ ]]’内均可以使用条件表达式（conditional expression）。常见的条件表达式包括：字符串比较’=', ‘>’, ‘<', '!='之类，文件测试'-f', '-d', '-z'之类, 以及逻辑关系'-a', '-o'之类，算数比较'-eq', '-le', '-gt'之类，还包括字符串本身（串为空时估值为1）。另外，在'[[ ]]'中，还可以使用'=='和'=~'进行字符串的模式匹配，右侧为模式串，左侧为待匹配串。'=='与'=~'的区别在于，前者为普通匹配，后者为扩展的正则匹配，比如*在两种匹配模式中的含义是不同的：

1
2
3
4
5
6
7
8
9
10

$ s=foo
$ [[ $s == *o ]]
$ echo $?
0 # 匹配成功
$ [[ $s =~ *o ]]
$ echo $?
2 # 匹配失败
$ [[ $s =~ .*o ]]
$ echo $?
0 # 匹配成功

　　’[ ]‘内不可以使用&&, ||，而’[[ ]]’可以。即’[ a && b ]‘不行，’[[ a && b ]]’行，但’[ ] && [ ]‘的形式是可行的
　　还有就是，Bash会对’[ ]‘内的变量进行分词，却不对’[[ ]]’进行分词：

1
2
3
4
5
6

$ s="a b"
$ [ $s = "a b" ]
bash: [: too many arguments
$ [[ $s = "a b" ]]
$ echo $?
0

cd dir; rm files

　　这条命令的目的是进入目录dir，然后删除一些文件。如果由于某种原因cd失败了，rm还会接着执行，可能就坏事儿了。本人曾经将/etc/passwd mv到另一个地方，然后就悲剧了……
为防止这类失误，在执行一些危险性动作之前，务必要检查先前的命令是否成功执行了。这里，将’;'换作&&即可。

$foo=bar

　　如果变量foo保存的值为FOO，那么实际上这里真正执行的是FOO=bar。shell中赋值不需要使用’$'，只有当”取”值时才需要使用’$'。同样的道理read $foo;通常也是不正确的。
关于赋值，需要知道’='两侧不允许有空格，例如foo= bar会被shell当作一次命令的执行，命令名是foo=通常是不存在的，bar作为其参数。

cat file | sed ‘s/foo/bar/g’ > file

　　这条命令的目的是将文件file中所有的foo替换为bar, 但实际上该命令并没有按照预想有cat将file内容打印到sed的标准输入，执行替换后将结果再次保存到file。事实上，sed并没有处理任何数据，在管道建立时file就被截为空文件了。
解决方法就是利用中间/临时文件，

1
2

cat file | sed 's/foo/bar/g' >tmp
mv tmp file

　　更方便的是使用sed的-i选项

1

sed -i 's/foo/bar/g' file

　　事实上，sed -i也利用了临时文件，只是对用户透明罢了。
　　不要在管道不同命令中读写同一文件。

echo <<EOF

1
2
3
4

$echo <<EOF
Hello,
    World
EOF

　　立即文档(here document)提供了一种将大块的字符串连接到命令的标准输入的方法。当不幸的是echo 并不从标准输入读取数据。在这里，可以使用cat代替echo.

for i in {1..$n}; do COMMANDS; done

　　这里，本意是将i从1到$n迭代$n次。但这行命令无法工作，因为大括号扩展(braces expansion)先于参数扩展（parameter expansion）进行。然而，对{1..$n}进行大括号扩展时，由于1是数字而$不是数字而无法扩展，无法扩展的式子会被保留，稍后$n才会被扩展。

1
2
3
4
5

$ echo {01..10}
01 02 03 04 05 06 07 08 09 10
$ n=10
$ echo {01..$n}
{01..10}

　　解决方法是使用for的另外一种形式,

1
2
3
4

for ((i=0; i <= n; ++i))
do
    COMMANDS
done

echo “~”

　　这里涉及到~扩展（Tilde expansion），~会被扩展为当前用户的用户目录，”值”相当于$HOME，~user被扩展为user的用户目录。但当~在引号中时，将不被扩展，因此echo “~”仅仅输出’~'，此时应使用$HOME代替。

　　先就这样吧，shell这东西语法太过琐碎和诡异，写写简单的实用脚本还行，比较大的程序还是使用Python这类脚本比较方便。但使用Shell脚本的最大好处就是可以更有效地利用其它功能强大的命令，比如grep,sed,awk,find。通过管道，可以将这些工具有机的组合起来，shell脚本为这种组合操作提供了逻辑和流程控制。do one thing, do it better.

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
123
124

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h> //~ O_RDWR, S_IRWXU etc.
#include <pthread.h>
#include <time.h>
#include <limits.h>
#include <signal.h>
 
void daemonize();
 
//~ thread functions
void *listen_ms(void *);
void *listen_kb(void *);
 
//~ time stamp, keeping the time
//~ when the last KB or Mouse event happened.
volatile time_t stamp;
 
//~ mutex keeping stamp consistent.
pthread_mutex_t stamp_mutex;
 
int
main()
{
    daemonize();
    //~ initialize the mutex, stamp
    pthread_mutex_init(&stamp_mutex, NULL);
    //time(&stamp);
    stamp = time(NULL);
 
    //~ create two threads monitoring the Mouse and Keyboard.
    pthread_t ms_tid, kb_tid;
    if(pthread_create(&ms_tid, NULL, listen_ms, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
    if(pthread_create(&kb_tid, NULL, listen_kb, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
 
    unsigned int interval = 60 * 30;
    while(1)
    {
        sleep(1);
        pthread_mutex_lock(&stamp_mutex);
        if( time(NULL) - stamp > interval )
        {
            /*printf("shutdown\n");*/
            /*fflush(stdin);*/
            system("init 0");
        }
        pthread_mutex_unlock(&stamp_mutex);
    }
    //~ join the threads, though it'll never be excuted.
    pthread_join(ms_tid, NULL);
    pthread_join(kb_tid, NULL);
 
    return 0;
}
 
void *
listen_ms(void * arg)
{
    int fd = open("/dev/input/mice", O_RDONLY);
    if(fd < 0)
    {
        perror("open mice");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Moused Moved.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void *
listen_kb(void * arg)
{
    int fd = open("/dev/input/event3", O_RDONLY);
    if(fd < 0)
    {
        perror("open event3");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Key Hit.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0);
    close(1);
    close(2);
    int fd = open("/dev/null", O_RDWR);
    //int fd = open("log.txt", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

　　需要说明的是，共享变量stamp需要互斥地访问。另外，对鼠标事件的监听是借助于对设备文件/dev/input/mice的读取（阻塞方式），键盘的监听借助于对/dev/input/event3的阻塞读取，但我猜想在不同机器上可能会是其它诸如event0,event5之类的文件。
　　不足之处在于，无法对全屏模式进行判断，即是说，如果你全屏看一部较长的电影，可能会被关机……
　　如果你有好的方法来实现本文的功能，还请不吝赐教！

守护进程的特性

　　守护进程有种种特性，使之成为守护进程。
　　运行周期较长。守护进程通常在系统启动时由/etc/rc*.d中的启动脚本或者用户在终端手动启动，在系统结束时停止或由用户手动停止。不像普通进程那样在用户退出终端后就被停止，守护进程会一直运行（下面会看到守护进程在启动后会脱离执行它的终端）。
　　脱离其运行环境。守护进程没有控制终端。进程在创建时（fork）会继承父进程的PCB（进程控制块），因此会同时拥有父进程的许多资源和关系，比如打开的文件描述符、socket、环境变量、控制终端、进程组、登录会话等。而守护进程需要关闭这些资源、脱离这些关系。

创建守护进程

　　鉴于守护进程的这些特性，一个普通进程若想成为守护进程，就需要做一些特殊的操作。

脱离控制终端

　　多数用户进程都是从终端运行的，它由与终端关联的shell（用户登录时由login执行的，比如bash程序）经过fork/exec启动。用户程序启动后shell会等待该进程（wait或waitpid等）结束，如果该进程为后台运行，shell会立即返回命令提示符等待用户的其它操作，否则shell会在用户进程结束时才打印命令提示符。
　　所以，为了能使守护进程运行后shell立即返回，通常在程序的入口采用下面的代码来完成：

1
2

if( fork() > 0)
    exit(0);

　　程序fork产生新进程，父进程立即返回（shell等待的就是父进程），shell进程的wait也会成功返回，而子进程则会继续执行。注意，此时子进程的父进程已经过继成为init进程（进程号为1）的子进程了。

另立门户

　　执行的上面的操作后，用户进程（子进程）并未真正脱离控制终端。因为子进程继承了父进程的关系，属于父进程所在的进程组，和父进程同属于一个作业，还隶属于控制终端所关联的登录会话（login session）。关于进程组、作业、登录会话等概念，请参考《高级Unix环境编程》(Advanced Programming of Unix Environment)，及Google。
　　若想脱离这些复杂的关系，操作却十分简单，只须在子进程一开始，调用函数setsid()即可。setsid做了以下工作：脱离了原来的进程组和登录会话，创建新的进程组和会话，并担当其进程组的Group Leader和会话的Session Leader.
　　这时候，该进程已经真正脱离了其控制终端，即是说，该进程在其原控制终端退出登录后仍可以在系统中运行。

关闭继承打开的文件描述符

　　控制终端，准确说是shell默认打开了三个文件，0代表标准输入，1代表标准输出，2代表标准错误输出。由该shell执行的进程也会继承打开这三个文件，所以它的所有子进程默认的输入和输出也都关联到此终端。因为守护进程也可能有其他用户进程通过exec系列函数执行，守护进程同样会继承这些文件描述符。因此在守护进程中需要关闭继承而来的所有描述符，APUE中stevens的代码：

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

int close_all_fd(void)
{
        struct rlimit lim;
        unsigned int i;
 
        if (getrlimit(RLIMIT_NOFILE, &lim) < 0)
                return -1;
        if (lim.rlim_cur == RLIM_INFINITY)
                lim.rlim_cur = 1024;
        for (i = 0; i < lim.rlim_cur; i ++) {
#ifdef MYPERF
                if (i == 1)
                        continue;
#endif
                if (close(i) < 0 && errno != EBADF)
                        return -1;
        }
        return 0;
}

改变当前工作目录

　　每个进程都有自己的当前工作目录，进程创建时默认继承父进程的工作目录。守护进程需要将当前工作目录改变，否则其所在目录所挂载的文件系统将无法卸载（可能是你不想要的），通常将其改变之根目录，方法是chdir(“/”);

重设文件创建掩码

　　为了能够自主控制文件创建权限位，常将文件创建掩码重设为0000，即umask(0);

忽略SIGCHLD信号

　　由于守护进程运行周期长，为了避免因为等待子进程而产生僵尸进程，通常需要忽略SIGCHLD信号：signal(SIGCHLD, SIG_IGN);

总结

　　方便起见，通常把创建守护进程的一系列操作包装为一个函数，在需要的地方调用即可：

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

void daemonize();
int
main()
{
    daemonize();
    //~ other operations here.
    return 0;
}
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0); //~ im so lazy a guy.
    close(1);
    close(2);
    //~ you can use I/O functions, but to/from the black hole...
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

Linux权限模式介绍

　　用ls -l命令列出文件的详细信息，关于ls -l参见这里。

1
2
3
4
5
6

$ ll # alias ll='ls -lh'
total 20K
-rwxr-xr-x 1 dutor dutor 7.1K 2010-08-08 12:45 a.out
-rw-r--r-- 1 dutor dutor  540 2010-08-08 12:29 main.c
-rw-r--r-- 1 dutor dutor  472 2010-07-17 23:18 main.cpp
-rw-r--r-- 1 dutor dutor   53 2010-04-26 12:24 Makefile

ls -l输出内容包括七个域，其中第一个域包括10个字符。第一个字符指明了文件类型，可能是以下字符：

• -: 普通文件；
• d: directory，目录文件；
• l: link，符号链接；
• s: socket文件；
• b: block，块设备；
• c: charactor，字符设备；
• p: FIFO pipe，管道文件。

　　接下来的9个字符指明了文件的访问权限：每三位指明一类用户的权限，分别是文件属主（user）、同组用户（group）、其它用户（other），权限分为读（r）、写（w）、执行（x），相应位若为-，表示此类用户不具有相应权限。
　　另外，x对应的位置（执行位）还可能是其它字符。比如，user或group的执行位若为s，表示该文件的set-user-id或者set-group-id（这两种id下文会着重介绍）和执行权限x被同时置位；若为S，则表示set-user-id或set-group-id被置位，而执行权限x不被置位。other的执行为如果为t，表示该文件的粘滞位（sticky bit）和x均被置位；若为T，则表示只有粘滞位被置位。粘滞位如果被置位，而且该文件为可执行文件，则当文件被执行时，其文本段（.text段，即代码段）会被加载到swap中，程序结束时仍然保留在swap，当下次执行该文件时，将直接从swap中加载，由于swap在磁盘中为连续的block，因此加载速度会提高。另外，如果目录文件的粘滞位被置位，也具有特殊含义，此处从略 。
　　
　　需要特别说明的是目录的权限。Linux/Unix中，目录是一种“特殊”的文件，这个文件包括该目录下所有文件（包括子目录）的文件名和索引节点，i-node号。读一个目录是指列出该目录下所有的文件和子目录，如ls。写一个目录是指增加、删除或者重命名该目录下的文件或目录，如rm,mv等，值得一提的是，你可能无法读写和执行一个文件，但却可能删除这个文件，只要你对其所在目录具有写权限。一个目录的执行权限是指，该目录可以是一个（搜索）路径的一部分，即你必须对你要访问的文件的路径中的任何一个目录都具有执行权限，形象地你可以把目录的执行权限当作是过境的绿卡。

chmod命令介绍

　　下面介绍如何使用chmod命令来设定和修改文件的权限位。
　　首先，chmod命令本身的执行也有限制，普通用户只能修改自己的文件的权限位，超级用户可以使用chmod修改任意用户任意文件的权限。使用chmod的方法为chmod [option] mode file. 常用的选项就是-R，用来对整个目录及其子目录中的文件进行模式（权限）修改。mode可以由两种方式指定，一种是由字母表达式表示的相对修改方式，一种是以4位8进制表示的绝对方式。
　　第一种方式：chmod [ugoa][+-=][rwxst] file. u指代user，g指代group，o指代other，a指代all。+-=分别执行指代增加、减少、设定相应权限（由后面的参数指定）。rwxst分别指代读、写、执行、set-user-id/set-group-id、sticky-bit粘滞位。整体上理解，就是对哪类用户（ugoa，为a时可省略）执行哪些权限（rwxst）的什么修改（+-=）。示例：

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

$ chmod u-x a.out 
$ ll a.out
-rw-r-xr-x 1 dutor dutor 7.1K 2010-08-08 13:33 a.out
$ chmod +t a.out 
$ ll a.out
-rw-r-xr-t 1 dutor dutor 7.1K 2010-08-08 13:33 a.out
$ chmod g=rs a.out 
$ ll a.out
-rw-r-Sr-t 1 dutor dutor 7.1K 2010-08-08 13:33 a.out
$ chmod a+x a.out 
$ ll a.out
-rwxr-sr-t 1 dutor dutor 7.1K 2010-08-08 13:33 a.out

　　第二种方式：chmod xxxx file. 其中x为一个八进制的数字，即0~7，由三个代表权限权值的数字相加或者按位或形成。各权限位的权值分别为：r:4, w:2, x:1; set-user-id:4, set-group-id:2, t:1. 其中，set-user-id, set-group-id和t组成第一个8进制数，其它三个八进制数分别代表user、group和other的权限，由rwx组成。另外，你可以指定少于4个的8进制数字，这样，前面未指定的数字就为0。示例：

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

$ ll a.out 
-rwxr-xr-x 1 dutor dutor 7.1K 2010-08-08 13:54 a.out
$ chmod 0755 a.out 
$ ll a.out 
-rwxr-xr-x 1 dutor dutor 7.1K 2010-08-08 13:54 a.out
$ chmod 0777 a.out 
$ ll a.out 
-rwxrwxrwx 1 dutor dutor 7.1K 2010-08-08 13:54 a.out
$ chmod 1700 a.out 
$ ll a.out 
-rwx-----T 1 dutor dutor 7.1K 2010-08-08 13:54 a.out
$ chmod 6760 a.out 
$ ll a.out 
-rwsrwS--- 1 dutor dutor 7.1K 2010-08-08 13:54 a.out

user-id和group-id

　　一个用户，有两个id：user-id和group-id。user-id对于一个用户唯一的，但一个用户可以隶属于多个不同的group，但默认的组只有一个，这里的默认是指这个用户创建的文件默认隶属的组。这里说的group-id即为默认组id。
　　相对于下面要介绍的effective-user-id和effective-group-id，上面的user-id和group-id确切地说是real-user-id和real-group-id。这两个id被保存在/etc/passwd文件中，创建用户时被写入，每当用户登录时由登录程序来读取该文件，并设定相应用户的id，OS以用户的用户id和组来判断你是否具有相应的权限来执行特定的操作。
　　effective-user-id和effective-group-id，是针对可执行文件来说的，通常一个被执行的程序（进程）的effective-user-id和effective-group-id与real-user-id和real-group-id是相同的，都等于执行该程序的用户的user-id和group-id，不管该程序文件本身属于哪个用户。但当该程序文件的set-user-id或者set-group-id被置位时，该程序进程的effective-user-id或effective-group-id就是该程序文件属主的user-id或group-id，而不是该进程的real-user-id或real-group-id。
　　那么，effective-user-id和effective-group-id有什么作用呢？
　　在一个进程试图去访问一种资源时，比如读、写某个文件，OS（内核）会判断此进程对该文件是否具有相应的权限，判断的依据就是上面介绍的文件的权限访问位。那么，OS是拿进程的real*id，即执行该程序的用户的id来判断呢，还是拿进程的可执行文件的属主的id来判断呢？答案是，拿进程的effective-user-id和effective-group-id来判断，而effective-user-id和effective-group-id与set-user-id和set-group-id有关。这样，问题就明了了。
　　举例来说，/etc/passwd文件保存了系统中用户的基本信息（早期的Unix中，甚至直接将用户密码保存在该文件中），它的属主是root用户，普通用户对该文件只有读权限。但系统又需要允许用户修改自己的信息，这样就提供了相应的命令，例如passwd命令。这个命令的可执行文件的属主为root用户，为了普通用户也能够通过passwd命令修改密码，这个命令的set-user-id就被置位了。而普通用户的身份认证就转移到了passwd程序内部了，例如不允许普通用户修改其它用户的密码。上面所说的你可以自己验证：

1
2

$ ll `which passwd`
-rwsr-xr-x 1 root root 37K 2010-01-27 01:09 /usr/bin/passwd # set-user-id被置位

　　注意，由于现在用户密码已经不再直接保存在/etc/passwd中了，因此passwd命令可能不再修改该文件，而该文件肯定也是不允许root之外的用户（准确说是不具有超级权限的用户）修改的。事实上，真正保存密码的文件是/etc/shadow，而这个文件的权限位为0640。

普通的自动补全

　　Tab键就是这样一个快捷键，利用它你可以不必输入命令/参数/文件/目录的的完整名称，它可以进行自动不全。比如：

1
2
3
4
5
6
7
8
9

dutor@dutor-desktop:~$ #alias l="ls -CFh"
dutor@dutor-desktop:~$ l
Desktop/    Downloads/  Pictures/   Videos/ 
Documents/  Music/      Templates/  Wdir/
dutor@dutor-desktop:~$ #cd des<Tab> 
dutor@dutor-desktop:~$ cd Desktop/
/home/dutor/Desktop
dutor@dutor-desktop:~ #cd d<Tab><Tab>
Desktop/   Documents/ Downloads/

　　当可选项唯一时，按下TAB键就会立即被不全。而如果有多个候选项时，按下TAB两次，所有候选项都会被列出。如上例，D开头的有三个目录，Desktop, Documents和Downloads，若想进入Destop目录，只需键入De即可。若想进入另外两个目录中的某一个，至少需要输入该目录开头的三个字符。
　　经常使用Vim的朋友（亲们？）可能会发现，Vim的命令模式（Last Line Mode）中使用帮助文档或者打开另外一个文件时，也有Tab自动不全的功能。不仅如此，当有多个候选项存在时，按下Tab或者Ctrl+n会逐次遍历这些候选项，直到找到你想要的选项。那么，Bash里面可以实现类似的功能吗？
　　当然，因为默认情况下，Vim的命令行和Bash的命令行使用的是“同一个”行编辑组件：Readline。细心的朋友可能发现，在Vim的命令行中，Ctrl+a、Ctrl+e等命令也是可以使用的。

配置inputrc

　　我们这里需要的是一种叫做菜单式补全（menu-complete）的功能。通常，默认情况下，这个选项是没有被配置的。为了配置这项功能，并为之进行快捷键绑定，我们需要修改inputrc配置文件，这个文件中保存了Readline的一些键绑定和其它诸如编辑模式的配置选项。像许多其它配置文件一样，inputrc有系统级的配置选项/etc/inputrc和用户级的点文件~/.inputrc。建议建立自己的点文件，而不是直接编辑系统级文件，当然如果整个系统只是你一个人在用的话，你也可以在/etc/inputrc上面直接编辑。但使用点文件的另一个好处告诉你，它是属于你自己的，即使在另外一个不同的发行版上，点文件通常也是可以直接使用的。这可以减轻你在不同系统上的不适。
　　好了，打开或者建立你的.inputrc，写下，下面两行：

1
2

"\C-j": menu-complete
"\C-k": menu-complete-backward

　　保存，然后重启Bash或者执行下面命令，使inputrc的配置立即生效：

1

bind -f ~/.inputrc

　　此时，通过Ctrl+j就可以把“下一个”候选项加入命令行，或者通过Ctrl+k把“上一个”候选项加入命令行。加入这项功能的另外一个好处就是，如果你要处理中文的文件或目录时，不比切换输入法（我的rxvt甚至无法使用中文输入法），选择即可。

了解更多Readline

　　在inputrc中还可以定义很多其它的特性，若想详细了解这些特性即配置方法，请参考这份关于GNU Readline Library的说明文档。

　　大体上库的存在，有两方面的原因，一是代码的复用，二是声明和实现的分离。将功能相近的使用模块封装成库，使代码的复用、管理和分发变得简单了许多，例如著名的开源图形库ncurses，你可以自行编译，更可以直接使用已经编译好的现成的库文件。另外，由于库是二进制文件，某种意义上讲，将功能的实现部分隐藏了起来，这就为商业代码的保护提供了一种方式。
　　库文件按照链接方式和时机，可以分为动态库和静态库，下面分别介绍它们在Linux环境中的创建和使用方法。

静态链接库

　　静态库是指在程序的链接阶段，其中被用到的代码会被直接链接到可执行文件中的库。静态链接的可执行程序包含了其所需的全部库函数：所有库函数都连接到程序中。 这类程序是完整的，其运行不需要外部库的支持。 静态链接程序的优点之一是其安装之前不需要做环境准备工作 。
　　Linux中，静态库的扩展名通常为.a，它仅仅是一些目标文件（.o）的归档（archive）或者说打包，另外，为了链接时能够快速地定位其中的符号（函数、变量名等），静态库还会包含一个对其中符号的索引。
　　创建静态库的过程十分简单，除编译所必须的工具之外，要用到的命令只有两个ar和ranlib。ar可以将各个目标文件进行归档，ranlib对ar生成的归档文件（即静态库文件）进行索引。假设现在有这样几个源文件：plus.c, sub.c及相应的头文件，另外还有一个用来调用库文件中函数的主文件main.c，它们的内容分别是：
plus.c,

1
2
3
4
5
6

#include "plus.h"
int
plus(int a, int b)
{
    return a + b;
}

sub.c,

1
2
3
4
5
6

#include "sub.h"
int
sub(int a, int b)
{
    return a - b;
}

main.c,

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    int a = plus(1, 2);
    printf("%d\n", a);
    return 0;
}

　　下面将plus.c和sub.c编译，制作成静态库libmath.a，依次执行：

1
2
3

$ cc -c plus.c sub.c
$ ar rc libmath.a plus.o sub.o
$ ranlib libmath.a

　　现在我们的libmath.a静态库已经制作完成，其中使用了ar命令的两个选项，c表示若库文件不存在则创建之，r表示库文件中若已经存在某个目标文件，且较旧，则执行替换。使用这个静态库更加简单：

1
2
3

$ cc main.c -L. -lmath -o main
$ ./main
3

动态链接库

　　动态库和静态库相似，也是各个目标文件的集合。但相比静态链接的程序，动态链接可执行程序要小得多：这类程序运行时需要外部共享 函数库的支持，因此好像并不完整。除了程序体小之外，动态链接允许程序包指定必须的库，而不必将库装入程序包内。动态链接技术还允许多个运行中的程序共享一个库，这样就不会出现同一代码的多份拷贝共占内存的情况了。由于这些原因，当前多数程序采用动态链接技术。
　　在Linux中的扩展名通常为.so。但在链接时，并不会被链接到可执行文件中，而是在执行时（需要时）由操作系统的动态加载模块动态地加载到内存，并链接到可执行文件地址空间的相应位置。
　　动态链接库的创建也分为编译和”归档”两个阶段，但不同的是在这两个阶段需要使用一些不同的命令选项。首先，需要将源文件编译成一种成为位置无关码（PIC: Position Independent Code）的目标文件，这种代码可以被加入到内存的任何位置却不需要加载器对其进行重定位，关于这种格式可以参考《链接器与加载器》和《程序员的自我修养–链接装载与库》中较为详尽的描述。接下来需要将这些位置无关码“归档”为.so文件。整个过程只需一个工具即可，即gcc。还是上面的源文件，执行以下命令：

1
2

$ cc -c -fpic plus.c sub.c
$ cc -shared -o libmath.so *.o

　　这样，包含plus.o和sub.o的动态库文件libmath.so就创建完成了。其中cc（gcc的符号链接）命令的-fpic或-fPIC选项使之创建位置无关的目标文件，使用-shared选项可以创建最终的动态库文件。
　　使用动态库文件有两种方法，一种是让操作系统的动态加载模块（如ld-linux.so.2）在执行时加载动态库。另一种是在代码中使用dl库动态加载库文件。
　　先介绍下第一种方法。使用这种方法需要在编译可执行文件时指明库名及其路径（对于自己的编写的动态库而言）：

1

$ cc main.c -L. -lmath -o main

　　这时可执行文件main就被创建了，上面的命令并没有将libmath.so中相应的目标代码链接到main中（你可以对比一下这里的main和静态链接的main的大小），只是在库中查找和确认main.c中用到的符号而已。但通常这个main现在还无法正常执行，这涉及到系统查找动态库的路径问题，系统通常只在某些指定的目录（标准路径）下查找所需的库文件，若在标准路径中无法找到所需的库，则会到环境变量LD_LIBRARY_PATH（如果存在的话）指定的目录下查找，若仍无法找到就会报错。因为libmath.so在main的当前目录中，而当前目录通常并不在标准路径之列。为了使libmath.so能够被找到和加载，你可以把它放到标准路径中，但更好的方法是将其所在目录加入到LD_LIBRARY_PATH变量中。执行下面的命令：

1
2
3
4

$ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. # 添加当前目录
$ export LD_LIBRARY_PATH # 将环境变量导出，使其在子shell中可用
$ ./main
3

　　
　　下面介绍使用dl库加载动态库，dl库中函数很少很简练，看main.c代码:

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    void * lib_handle = dlopen("./libmath.so", RTLD_LAZY);
    if(lib_handle)
    {
        int (*plus_ptr)(int, int) = dlsym(lib_handle, "plus");
        if(plus_ptr)
        {
            int a = plus_ptr(1, 2);
            printf("%d\n", a);
        }
        dlclose(lib_handle);
    }
    return 0;
}

　　main.c中，首先使用dlopen打开需要的动态库，其中参数RTLD_LAZY指明仅当需要调用该库时才进行加载。dlopen返回一个句柄，dlsym使用该句柄和符号来取得相应函数的地址，这里使用int (*)(int, int)函数指针来接收plus函数的地址。接下来使用得到的函数指针调用相应的函数，最后通过dlclose函数来关闭句柄。编译这个程序需要使用dl动态链接库，因此需要使用gcc的-ldl选项：

1
2
3

$ cc main.c -ldl -o main
$ ./main
3

.so与.a文件的对比

　　最后附上libmath.a和libmath.so文件的内容，使用objdump的-d选项查看的：
libmath.a,

In archive libmath.a:

plus.o:     file format elf32-i386
Disassembly of section .text:
00000000 <plus>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	8b 45 0c             	mov    0xc(%ebp),%eax
   6:	8b 55 08             	mov    0x8(%ebp),%edx
   9:	8d 04 02             	lea    (%edx,%eax,1),%eax
   c:	5d                   	pop    %ebp
   d:	c3                   	ret    

sub.o:     file format elf32-i386
Disassembly of section .text:
00000000 <sub>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	8b 45 0c             	mov    0xc(%ebp),%eax
   6:	8b 55 08             	mov    0x8(%ebp),%edx
   9:	89 d1                	mov    %edx,%ecx
   b:	29 c1                	sub    %eax,%ecx
   d:	89 c8                	mov    %ecx,%eax
   f:	5d                   	pop    %ebp
  10:	c3                   	ret

libmath.so:

libmath.so:     file format elf32-i386
Disassembly of section .init:
00000324 <_init>:
 324:	55                   	push   %ebp
 325:	89 e5                	mov    %esp,%ebp
 327:	53                   	push   %ebx
 328:	83 ec 04             	sub    $0x4,%esp
......
0000044c <plus>:
 44c:	55                   	push   %ebp
 44d:	89 e5                	mov    %esp,%ebp
 44f:	8b 45 0c             	mov    0xc(%ebp),%eax
 452:	8b 55 08             	mov    0x8(%ebp),%edx
 455:	8d 04 02             	lea    (%edx,%eax,1),%eax
 458:	5d                   	pop    %ebp
 459:	c3                   	ret
 45a:	90                   	nop
 45b:	90                   	nop

0000045c <sub>:
 45c:	55                   	push   %ebp
 45d:	89 e5                	mov    %esp,%ebp
 45f:	8b 45 0c             	mov    0xc(%ebp),%eax
 462:	8b 55 08             	mov    0x8(%ebp),%edx
 465:	89 d1                	mov    %edx,%ecx
 467:	29 c1                	sub    %eax,%ecx
 469:	89 c8                	mov    %ecx,%eax
 46b:	5d                   	pop    %ebp
 46c:	c3                   	ret
 46d:	90                   	nop
 46e:	90                   	nop
 46f:	90                   	nop
......

Disassembly of section .fini:

000004a8 <_fini>:
 4a8:	55                   	push   %ebp
 4a9:	89 e5                	mov    %esp,%ebp
 4ab:	53                   	push   %ebx
 4ac:	83 ec 04             	sub    $0x4,%esp
 4af:	e8 00 00 00 00       	call   4b4 <_fini+0xc>
 4b4:	5b                   	pop    %ebx
 4b5:	81 c3 40 1b 00 00    	add    $0x1b40,%ebx
 4bb:	e8 d0 fe ff ff       	call   390 <__do_global_dtors_aux>
 4c0:	59                   	pop    %ecx
 4c1:	5b                   	pop    %ebx
 4c2:	c9                   	leave
 4c3:	c3                   	ret

　　可见，相对.a，.so有很多额外的代码段，其中比较重要的是<_init>段和<_fini>段。它们分别进行一些前期和后期处理工作，例如<_init>通常在dlopen返回之前执行一些.so库中的一些初始化工作（C++中就可能是全局构造或者静态对象的构造函数）。

1

find fold [option]

　　下面按照不同的选项介绍find命令。

find -name

　　-name是最常用的选项，它指定了需要查找的文件名的模式，模式中可以使用通配符和简单的正则表达式。下面的命令查找Wdir目录下的.cpp文件：

1
2
3
4
5
6
7
8
9
10
11

dutor@dutor-desktop:~$ find Wdir -name "*.cpp"
Wdir/Cpp/Pthread/main.cpp
Wdir/Cpp/STL/sort_list.cpp
Wdir/Cpp/STL/Heap.cpp
Wdir/Cpp/STL/operator.cpp
Wdir/Cpp/STL/bind2nd/main.cpp
Wdir/Cpp/STL/Kth-Max.cpp
Wdir/Cpp/STL/priority_queue.cpp
Wdir/Cpp/ACM/Huffman/main.cpp
Wdir/Cpp/ACM/Bellman-Ford/main.cpp
......

　　需要注意的是，如果搜索目录以相对路径形式指定，则搜索结果也以相对路径形式给出；否则，搜索结果以绝对路径形式给出。

find -user

　　-user选项指定需要搜索的文件的属主/用户。相似地，-group指定需要搜索的用户组。

find -type

　　-type选项指定文件的类型，该选项可以使用的参数如下：

find ! -option

　　!可以对特定选项进行反义，下面命令搜索不属于dutor用户的.cpp文件：

1

find . -name "*.cpp" ! -user dutor

　　注意!与-之间的空格。

find -size

　　使用-size选项可以根据文件的大小进行查找。下面命令查找大小为10M(近似)的文件：

1

find . -size 10M

　　-size选项的参数的单位可以是

　　另外，-size参数前还可以使用+和-，分别表示大于和小于指定大小的文件。例如下面命令查找大于10M的文件：

1

find . -size +10M

find -a

　　find命令的各选项可以利用-a, -o, -n进行逻辑组合。-a表示AND，-o表示OR，-n表示NOT。另外还可以使用转义的括号\(\)对逻辑表达式进行分组。例如下面命令查找大于或等于10M的普通文件：

1

find . \( -size +10M -o -size 10M \) -a -type f

find -exec

　　-exec是一个非常有用的选项，它允许对find的查找结果文件执行某个命令。例如，想把当前目录下所有的扩展名为.JPG的图片扩展名改为.jpg，可以执行如下命令：

1

find . -name "*.JPG" -exec rename 's/JPG/jpg/g' {} \;

　　其中{}表示find查找结果文件中的一个的文件名，转义的分号\;作为exec选项的结束，另外\;之前需要一个空格。

软链接

　　软链接使用ln命令的-s选项创建：

1

ln -s source target #创建source文件的软链接target

　　软链接类似于Windows中的快捷方式，内部保存的是源文件的路径，路径可以是相对路径，也可以是绝对路径：

1
2
3
4
5
6

dutor@dutor-desktop:~$ ln -s gvim.tgz gvim
dutor@dutor-desktop:~$ ln -s /home/dutor/gvim.tgz gvim2
dutor@dutor-desktop:~$ ll gvim* # alias ll='ls -l'
lrwxrwxrwx 1 dutor dutor    8 2010-07-01 20:32 gvim -> gvim.tgz
lrwxrwxrwx 1 dutor dutor   20 2010-07-01 20:33 gvim2 -> /home/dutor/gvim.tgz
-rw-r--r-- 1 dutor dutor 8.5M 2010-06-29 23:06 gvim.tgz

　　软链接应用十分广泛。
　　在文件系统中多处共享同一个较大文件时，使用软链接就可以避免创建多个副本。
　　维护动态库文件的版本时，使用软链接，在升级库文件后，只需修改软链接的源文件，而使用该库的程序则不需要修改。

硬链接

　　不带有任何选项的ln命令即可创建硬链接：

1

ln source target #创建source文件的硬链接target

　　硬链接创建后，链接文件与源文件没有主次之分，文件系统中它们都和同一个inode相关联，即具有相同的inode号：

1
2
3
4

dutor@dutor-desktop:~$ ln gvim.tgz gvim
dutor@dutor-desktop:~$ ll -i gvim*
1048032 -rw-r--r-- 2 dutor dutor 8.5M 2010-06-29 23:06 gvim # 第3个域代表该文件的链接数
1048032 -rw-r--r-- 2 dutor dutor 8.5M 2010-06-29 23:06 gvim.tgz

　　因此，系统不允许用户为目录创建硬件链接，否则，目录树就不再是有向无环的了。只许州官放火，不许百姓点灯，系统却可以为目录“创建”硬链接（系统知道自己在做什么，却不知用户会做什么），那就是.和..分别指向当前目录和上级目录。因此每个目录的链接数至少是2.

　　另外，由于硬链接的实现依赖于特定的文件系统，因此不可以跨文件系统。而软链接是基于路径的，所以只要是挂载在系统目录树中的文件或目录，都可以创建软链接。

ls

　　不带参数的ls列举当前目录下有哪些文件和目录，ls Folder列举Folder目录中的文件和子目录，ls File显示File文件的信息（默认为文件名）。

1
2
3
4
5
6
7
8
9

dutor@dutor-desktop:~$ cd Wdir/
/home/dutor/Wdir
dutor@dutor-desktop:~/Wdir$ ls
APUE  ASM  Cpp  LaTeX  PHP  Python  QT  Shell
dutor@dutor-desktop:~/Wdir$ ls Cpp/
ACM     main    main.cpp  Makefile    Pthread  symtab         tags    test.s
Curses  main.c  main.s    Playaround  STL      SystemProgram  test.c  TutManual
dutor@dutor-desktop:~/Wdir$ ls Cpp/Makefile
Cpp/Makefile

ls -a

　　-a选项同ls，但会列举当前目录或者指定目录下的所有文件，包括dot文件（.开头的文件）和.目录和..目录。

1
2

dutor@dutor-desktop:~/Wdir$ ls -a
.  ..  APUE  ASM  Cpp  .I2C.c.swp  LaTeX  PHP  Python  QT  Shell

ls -A

　　-A选项同ls，但会列举当前目录或者指定目录下的所有文件，包括dot文件（.开头的文件），但不包括.目录和..目录。

1
2

dutor@dutor-desktop:~/Wdir$ ls -A
APUE  ASM  Cpp  .I2C.c.swp  LaTeX  PHP  Python  QT  Shell

ls -l

　　-l选项的ls命令将列举当前目录或指定目录中文件或者子目录的详析信息。

1
2
3
4
5
6
7
8
9
10

dutor@dutor-desktop:~/Wdir/Cpp/STL$ ls -l
total 32
drwxr-xr-x 2 dutor dutor 4096 2010-04-19 19:25 bind2nd
-rw-r--r-- 1 dutor dutor 1296 2010-03-27 18:39 Heap.cpp
-rw-r--r-- 1 dutor dutor  980 2010-03-27 18:03 Kth-Max.cpp
-rw-r--r-- 1 dutor dutor 1168 2010-04-29 20:24 main.cpp
-rw-r--r-- 1 dutor dutor  709 2010-04-20 17:58 operator.cpp
-rw-r--r-- 1 dutor dutor  654 2010-03-27 17:40 priority_queue.cpp
-rw-r--r-- 1 dutor dutor  461 2010-04-10 22:41 sort_list.cpp
-rw-r--r-- 1 dutor dutor  655 2010-04-29 21:18 test.cpp

ls -l列举的信息包含7个以Tab的域：

• 第一个域：第一个字符指明了文件类型
  • -: 普通文件；
  • d: 目录文件；
  • l: 符号链接；
  • s: socket文件；
  • b: 块设备；
  • c: 字符设备；
  • p: 管道文件。

  后面的9个字符指明了文件的访问权限：每三位指明一类用户的权限，分别是文件属主、同组用户、其它用户，权限分为读（r）、写（w）、执行（x）。

• 第二个域：链接数。普通文件至少为1，目录至少为2（.和..）；
• 第三域：文件属主；
• 第四域：用户组；
• 第五域：文件大小，其中目录大小通常为块大小的整数倍；
• 第六域：文件的最近修改日期和时间，修改文件意味着对其内文件或子目录的增添和修改；
• 第七域：文件名

ls -t

　　按文件的修改时间列举文件，最近修改的在前。

1
2
3
4

dutor@dutor-desktop:~/Wdir$ ls
APUE  ASM  Cpp  LaTeX  PHP  Python  QT  Shell
dutor@dutor-desktop:~/Wdir$ ls -t
Cpp  QT  Shell  PHP  ASM  LaTeX  APUE  Python

ls -r

　　以相反顺序列举文件。

1
2
3
4
5
6

dutor@dutor-desktop:~/Wdir$ ls
APUE  ASM  Cpp  LaTeX  PHP  Python  QT  Shell
dutor@dutor-desktop:~/Wdir$ ls -t
Cpp  QT  Shell  PHP  ASM  LaTeX  APUE  Python
dutor@dutor-desktop:~/Wdir$ ls -tr
Python  APUE  LaTeX  ASM  PHP  Shell  QT  Cpp

ls -1

　　单独行列举文件。

ls -F

　　可视化显示文件类型。

1
2

$ ls -F
Desktop/  Documents/  Ubuntu-App@  firstfile  Music/  Public/  Templates/

• / ： 目录
• nothing ： 普通文件.
• @ ：符号链接文件
• * ：可执行文件

ls -latr

　　即是说，各个选项可以结合使用，除了互相排斥的选项，例如-a和-A。

使用alias

使用alias会更加方便，我定义的alias有：

1
2
3

alias ll='ls -lh'
alias la='ls -A'
alias l='ls -CF'

1

mkdir -p Project/a/src

而不是

1
2
3
4
5

mkdir Project
cd Project
mkdir a
cd a
mkdir src

　　当然，如果你有mkcd，就可以直接

1

mkcd Project/a/src

　　此外，如果我们想创建多层次、多维度的目录树，mkcd也显得比较苍白了。例如我们想要建立目录Project，其中含有4个文件夹a, b, c, d，且这4个文件都含有一个src文件夹。或许，我们可以逐个创建，但我更倾向于使用单个命令来搞定，而mkdir 的-p选项和shell的参数扩展允许我这么做，例如下面的一个命令就可以完成任务。

1

mkdir -p Project/{a,b,c,d}/src

　　嗯，mkdir -p到此over~

1
2
3
4
5
6
7
8
9
10
11

# mkcd: mkdir, then cd
mkcd()
{
    if [ $# = "1" ]
    then
        mkdir -p "$1"
        cd "$1"
    else
        echo "Usage: mkcd folder"
    fi
}

　　很简单，相信你一看就知道它能做什么了。
　　你需要做的就是把这个函数丢进你的.bashrc，然后

1

source ~/.bashrc # 重新加载，使.bashrc立即生效

　　sed是Linux环境下的一个文本流、行编辑器，十分强大，这里贴一些常用的单行脚本，脚本最初来源于此，基本未做改动。另外一个强大的文本处理工具就是awk，对于这两个工具，个人觉得，根据个人选择其一就够用了，我自己就喜欢sed多一点。Bones在这里用awk对下面的各个sed命令行做了相应的替代。
　　推荐一本关于sed和awk的书《sed & awk》，作者Dale Dougberty, Arnold Robbins。中文版在网上已经买不到了，china-pub倒是有，不过是原版的一般人承受不起那个价位。幸好这本书的作者提供免费的电子版，在网上应该可以搜的到。

sed单行命令快速参考

文本间隔

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

# 在每一行后面增加一空行
 sed G
 
 # 将原来的所有空行删除并在每一行后面增加一空行。
 # 这样在输出的文本中每一行后面将有且只有一空行。
 sed '/^$/d;G'
 
 # 在每一行后面增加两行空行
 sed 'G;G'
 
 # 将第一个脚本所产生的所有空行删除（即删除所有偶数行）
 sed 'n;d'
 
 # 在匹配式样“regex”的行之前插入一空行
 sed '/regex/{x;p;x;}'
 
 # 在匹配式样“regex”的行之后插入一空行
 sed '/regex/G'
 
 # 在匹配式样“regex”的行之前和之后各插入一空行
 sed '/regex/{x;p;x;G;}'

编号

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

# 为文件中的每一行进行编号（简单的左对齐方式）。这里使用了“制表符”
 # （tab，见本文末尾关于'\t'的用法的描述）而不是空格来对齐边缘。
 sed = filename | sed 'N;s/\n/\t/'
 
 # 对文件中的所有行编号（行号在左，文字右端对齐）。
 sed = filename | sed 'N; s/^/     /; s/ *\(.\{6,\}\)\n/\1  /'
 
 # 对文件中的所有行编号，但只显示非空白行的行号。
 sed '/./=' filename | sed '/./N; s/\n/ /'
 
 # 计算行数 （模拟 "wc -l"）
 sed -n '$='

文本转换和替代(这是我最常用到的功能了)

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

# Unix环境：转换DOS的新行符（CR/LF）为Unix格式。
 sed 's/.$//'                     # 假设所有行以CR/LF结束
 sed 's/^M$//'                    # 在bash/tcsh中，将按Ctrl-M改为按Ctrl-V
 sed 's/\x0D$//'                  # ssed、gsed 3.02.80，及更高版本
 
 # Unix环境：转换Unix的新行符（LF）为DOS格式。
 sed "s/$/`echo -e \\\r`/"        # 在ksh下所使用的命令
 sed 's/$'"/`echo \\\r`/"         # 在bash下所使用的命令
 sed "s/$/`echo \\\r`/"           # 在zsh下所使用的命令
 sed 's/$/\r/'                    # gsed 3.02.80 及更高版本
 
 # DOS环境：转换Unix新行符（LF）为DOS格式。
 sed "s/$//"                      # 方法 1
 sed -n p                         # 方法 2
 
 # DOS环境：转换DOS新行符（CR/LF）为Unix格式。
 # 下面的脚本只对UnxUtils sed 4.0.7 及更高版本有效。要识别UnxUtils版本的
 #  sed可以通过其特有的“--text”选项。你可以使用帮助选项（“--help”）看
 # 其中有无一个“--text”项以此来判断所使用的是否是UnxUtils版本。其它DOS
 # 版本的的sed则无法进行这一转换。但可以用“tr”来实现这一转换。
 sed "s/\r//" infile >outfile     # UnxUtils sed v4.0.7 或更高版本
 tr -d \r <infile >outfile        # GNU tr 1.22 或更高版本
 
 # 将每一行前导的“空白字符”（空格，制表符）删除
 # 使之左对齐
 sed 's/^[ \t]*//'                # 见本文末尾关于'\t'用法的描述
 
 # 将每一行拖尾的“空白字符”（空格，制表符）删除
 sed 's/[ \t]*$//'                # 见本文末尾关于'\t'用法的描述
 
 # 将每一行中的前导和拖尾的空白字符删除
 sed 's/^[ \t]*//;s/[ \t]*$//'
 
 # 在每一行开头处插入5个空格（使全文向右移动5个字符的位置）
 sed 's/^/     /'
 
 # 以79个字符为宽度，将所有文本右对齐
 sed -e :a -e 's/^.\{1,78\}$/ &/;ta'  # 78个字符外加最后的一个空格
 
 # 以79个字符为宽度，使所有文本居中。在方法1中，为了让文本居中每一行的前
 # 头和后头都填充了空格。 在方法2中，在居中文本的过程中只在文本的前面填充
 # 空格，并且最终这些空格将有一半会被删除。此外每一行的后头并未填充空格。
 sed  -e :a -e 's/^.\{1,77\}$/ & /;ta'                     # 方法1
 sed  -e :a -e 's/^.\{1,77\}$/ &/;ta' -e 's/\( *\)\1/\1/'  # 方法2
 
 # 在每一行中查找字串“foo”，并将找到的“foo”替换为“bar”
 sed 's/foo/bar/'                 # 只替换每一行中的第一个“foo”字串
 sed 's/foo/bar/4'                # 只替换每一行中的第四个“foo”字串
 sed 's/foo/bar/g'                # 将每一行中的所有“foo”都换成“bar”
 sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' # 替换倒数第二个“foo”
 sed 's/\(.*\)foo/\1bar/'            # 替换最后一个“foo”
 
 # 只在行中出现字串“baz”的情况下将“foo”替换成“bar”
 sed '/baz/s/foo/bar/g'
 
 # 将“foo”替换成“bar”，并且只在行中未出现字串“baz”的情况下替换
 sed '/baz/!s/foo/bar/g'
 
 # 不管是“scarlet”“ruby”还是“puce”，一律换成“red”
 sed 's/scarlet/red/g;s/ruby/red/g;s/puce/red/g'  #对多数的sed都有效
 gsed 's/scarlet\|ruby\|puce/red/g'               # 只对GNU sed有效
 
 # 倒置所有行，第一行成为最后一行，依次类推（模拟“tac”）。
 # 由于某些原因，使用下面命令时HHsed v1.5会将文件中的空行删除
 sed '1!G;h;$!d'               # 方法1
 sed -n '1!G;h;$p'             # 方法2
 
 # 将行中的字符逆序排列，第一个字成为最后一字，……（模拟“rev”）
 sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
 
 # 将每两行连接成一行（类似“paste”）
 sed '$!N;s/\n/ /'
 
 # 如果当前行以反斜杠“\”结束，则将下一行并到当前行末尾
 # 并去掉原来行尾的反斜杠
 sed -e :a -e '/\\$/N; s/\\\n//; ta'
 
 # 如果当前行以等号开头，将当前行并到上一行末尾
 # 并以单个空格代替原来行头的“=”
 sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'
 
 # 为数字字串增加逗号分隔符号，将“1234567”改为“1,234,567”
 gsed ':a;s/\B[0-9]\{3\}\>/,&/;ta'                     # GNU sed
 sed -e :a -e 's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta'  # 其他sed
 
 # 为带有小数点和负号的数值增加逗号分隔符（GNU sed）
 gsed -r ':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'
 
 # 在每5行后增加一空白行 （在第5，10，15，20，等行后增加一空白行）
 gsed '0~5G'                      # 只对GNU sed有效
 sed 'n;n;n;n;G;'

选择性地显示特定行

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

# 显示文件中的前10行 （模拟“head”的行为）
 sed 10q
 
 # 显示文件中的第一行 （模拟“head -1”命令）
 sed q
 
 # 显示文件中的最后10行 （模拟“tail”）
 sed -e :a -e '$q;N;11,$D;ba'
 
 # 显示文件中的最后2行（模拟“tail -2”命令）
 sed '$!N;$!D'
 
 # 显示文件中的最后一行（模拟“tail -1”）
 sed '$!d'                        # 方法1
 sed -n '$p'                      # 方法2
 
 # 显示文件中的倒数第二行
 sed -e '$!{h;d;}' -e x              # 当文件中只有一行时，输入空行
 sed -e '1{$q;}' -e '$!{h;d;}' -e x  # 当文件中只有一行时，显示该行
 sed -e '1{$d;}' -e '$!{h;d;}' -e x  # 当文件中只有一行时，不输出
 
 # 只显示匹配正则表达式的行（模拟“grep”）
 sed -n '/regexp/p'               # 方法1
 sed '/regexp/!d'                 # 方法2
 
 # 只显示“不”匹配正则表达式的行（模拟“grep -v”）
 sed -n '/regexp/!p'              # 方法1，与前面的命令相对应
 sed '/regexp/d'                  # 方法2，类似的语法
 
 # 查找“regexp”并将匹配行的上一行显示出来，但并不显示匹配行
 sed -n '/regexp/{g;1!p;};h'
 
 # 查找“regexp”并将匹配行的下一行显示出来，但并不显示匹配行
 sed -n '/regexp/{n;p;}'
 
 # 显示包含“regexp”的行及其前后行，并在第一行之前加上“regexp”所
 # 在行的行号 （类似“grep -A1 -B1”）
 sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h
 
 # 显示包含“AAA”、“BBB”或“CCC”的行（任意次序）
 sed '/AAA/!d; /BBB/!d; /CCC/!d'  # 字串的次序不影响结果
 
 # 显示包含“AAA”、“BBB”和“CCC”的行（固定次序）
 sed '/AAA.*BBB.*CCC/!d'
 
 # 显示包含“AAA”“BBB”或“CCC”的行 （模拟“egrep”）
 sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d    # 多数sed
 gsed '/AAA\|BBB\|CCC/!d'                        # 对GNU sed有效
 
 # 显示包含“AAA”的段落 （段落间以空行分隔）
 # HHsed v1.5 必须在“x;”后加入“G;”，接下来的3个脚本都是这样
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'
 
 # 显示包含“AAA”“BBB”和“CCC”三个字串的段落 （任意次序）
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;/BBB/!d;/CCC/!d'
 
 # 显示包含“AAA”、“BBB”、“CCC”三者中任一字串的段落 （任意次序）
 sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
 gsed '/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d'         # 只对GNU sed有效
 
 # 显示包含65个或以上字符的行
 sed -n '/^.\{65\}/p'
 
 # 显示包含65个以下字符的行
 sed -n '/^.\{65\}/!p'            # 方法1，与上面的脚本相对应
 sed '/^.\{65\}/d'                # 方法2，更简便一点的方法
 
 # 显示部分文本——从包含正则表达式的行开始到最后一行结束
 sed -n '/regexp/,$p'
 
 # 显示部分文本——指定行号范围（从第8至第12行，含8和12行）
 sed -n '8,12p'                   # 方法1
 sed '8,12!d'                     # 方法2
 
 # 显示第52行
 sed -n '52p'                     # 方法1
 sed '52!d'                       # 方法2
 sed '52q;d'                      # 方法3, 处理大文件时更有效率
 
 # 从第3行开始，每7行显示一次    
 gsed -n '3~7p'                   # 只对GNU sed有效
 sed -n '3,${p;n;n;n;n;n;n;}'     # 其他sed
 
 # 显示两个正则表达式之间的文本（包含）
 sed -n '/Iowa/,/Montana/p'       # 区分大小写方式

选择性地删除特定行

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

# 显示通篇文档，除了两个正则表达式之间的内容
 sed '/Iowa/,/Montana/d'
 
 # 删除文件中相邻的重复行（模拟“uniq”）
 # 只保留重复行中的第一行，其他行删除
 sed '$!N; /^\(.*\)\n\1$/!P; D'
 
 # 删除文件中的重复行，不管有无相邻。注意hold space所能支持的缓存
 # 大小，或者使用GNU sed。
 sed -n 'G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P'
 
 # 删除除重复行外的所有行（模拟“uniq -d”）
 sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'
 
 # 删除文件中开头的10行
 sed '1,10d'
 
 # 删除文件中的最后一行
 sed '$d'
 
 # 删除文件中的最后两行
 sed 'N;$!P;$!D;$d'
 
 # 删除文件中的最后10行
 sed -e :a -e '$d;N;2,10ba' -e 'P;D'   # 方法1
 sed -n -e :a -e '1,10!{P;N;D;};N;ba'  # 方法2
 
 # 删除8的倍数行
 gsed '0~8d'                           # 只对GNU sed有效
 sed 'n;n;n;n;n;n;n;d;'                # 其他sed
 
 # 删除匹配式样的行
 sed '/pattern/d'                      # 删除含pattern的行。当然pattern
                                       # 可以换成任何有效的正则表达式
 
 # 删除文件中的所有空行（与“grep '.' ”效果相同）
 sed '/^$/d'                           # 方法1
 sed '/./!d'                           # 方法2
 
 # 只保留多个相邻空行的第一行。并且删除文件顶部和尾部的空行。
 # （模拟“cat -s”）
 sed '/./,/^$/!d'        #方法1，删除文件顶部的空行，允许尾部保留一空行
 sed '/^$/N;/\n$/D'      #方法2，允许顶部保留一空行，尾部不留空行
 
 # 只保留多个相邻空行的前两行。
 sed '/^$/N;/\n$/N;//D'
 
 # 删除文件顶部的所有空行
 sed '/./,$!d'
 
 # 删除文件尾部的所有空行
 sed -e :a -e '/^\n*$/{$d;N;ba' -e '}'  # 对所有sed有效
 sed -e :a -e '/^\n*$/N;/\n$/ba'        # 同上，但只对 gsed 3.02.*有效
 
 # 删除每个段落的最后一行
 sed -n '/^$/{p;h;};/./{x;/./p;}'

其他特殊应用

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

# 移除手册页（man page）中的nroff标记。在Unix System V或bash shell下使
 # 用'echo'命令时可能需要加上 -e 选项。
 sed "s/.`echo \\\b`//g"    # 外层的双括号是必须的（Unix环境）
 sed 's/.^H//g'             # 在bash或tcsh中, 按 Ctrl-V 再按 Ctrl-H
 sed 's/.\x08//g'           # sed 1.5，GNU sed，ssed所使用的十六进制的表示方法
 
 # 提取新闻组或 e-mail 的邮件头
 sed '/^$/q'                # 删除第一行空行后的所有内容
 
 # 提取新闻组或 e-mail 的正文部分
 sed '1,/^$/d'              # 删除第一行空行之前的所有内容
 
 # 从邮件头提取“Subject”（标题栏字段），并移除开头的“Subject:”字样
 sed '/^Subject: */!d; s///;q'
 
 # 从邮件头获得回复地址
 sed '/^Reply-To:/q; /^From:/h; /./d;g;q'
 
 # 获取邮件地址。在上一个脚本所产生的那一行邮件头的基础上进一步的将非电邮
 # 地址的部分剃除。（见上一脚本）
 sed 's/ *(.*)//; s/>.*//; s/.*[:<] *//'
 
 # 在每一行开头加上一个尖括号和空格（引用信息）
 sed 's/^/> /'
 
 # 将每一行开头处的尖括号和空格删除（解除引用）
 sed 's/^> //'
 
 # 移除大部分的HTML标签（包括跨行标签）
 sed -e :a -e 's/<[^>]*>//g;/</N;//ba'
 
 # 将分成多卷的uuencode文件解码。移除文件头信息，只保留uuencode编码部分。
 # 文件必须以特定顺序传给sed。下面第一种版本的脚本可以直接在命令行下输入；
 # 第二种版本则可以放入一个带执行权限的shell脚本中。（由Rahul Dhesi的一
 # 个脚本修改而来。）
 sed '/^end/,/^begin/d' file1 file2 ... fileX | uudecode   # vers. 1
 sed '/^end/,/^begin/d' "$@" | uudecode                    # vers. 2
 
 # 将文件中的段落以字母顺序排序。段落间以（一行或多行）空行分隔。GNU sed使用
 # 字元“\v”来表示垂直制表符，这里用它来作为换行符的占位符——当然你也可以
 # 用其他未在文件中使用的字符来代替它。
 sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed '1s/={NL}=//;s/={NL}=/\n/g'
 gsed '/./{H;d};x;y/\n/\v/' file | sort | sed '1s/\v//;y/\v/\n/'
 
 # 分别压缩每个.TXT文件，压缩后删除原来的文件并将压缩后的.ZIP文件
 # 命名为与原来相同的名字（只是扩展名不同）。（DOS环境：“dir /b”
 # 显示不带路径的文件名）。
 echo @echo off >zipup.bat
 dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1 \1.TXT/" >>zipup.bat

Shell预设环境变量

参数扩展与模式匹配

dd简介

　　dd是一个比较古老的命令，早在Unix诞生之时就来到人间，成为每一个Hacker的必备工具。它是干什么的？对此，man大叔有话说。dd是一个拷贝文件的命令，同时它会根据特定选项对文件进行转换和格式化。主要的选项有：

• ibs=BYTES，一次从输入文件中拷贝的字节数（BLOCKS）
• if=FILE ，指定输入文件，缺省为stdin
• obs=BYTES， 一次从输出文件中拷贝的字节数
• of=FILE，指定输出文件，不会截断文件，缺省为stdout
• bs=BYTES，同时指定ibs=BYTES, obs=BYTES
• cbs=BYTES ，每次转换的字节数
• conv=KEYWORDS[,KEYWORDS]，根据KEYWORDS指定的规则（多个规则以逗号,分隔）对文件进行转换
• count=BLOCKS，指定从输入文件中要拷贝的BLOCKS数
• seek=BLOCKS，从输出文件开头处跳过指定的BLOCKS数
• skip=BLOCKS ，从输出文件开头处跳过指定的BLOCKS数

　　指定BYTES时默认为BYTES个字节，如512为512字节。数字后面可以加单位修饰，如512b同512, 512w等于512*2, 512K等于512*1024, 512M等于512*1024*1024。
　　可供选择的KEYWORDS有：

• ascii ，将EBCDIC编码转换为ASCII编码
• ebcdic，将ASCII编码转换为EBCDIC编码
• block，将\n结束变长记录转换到cbs指定的长度，不足部分以空格填充
• unblock，将每个cbs尾部填充的空格剔除
• lcase，将字母转换为小写
• ucase，将字母转换为大写
• swab，交换每对相邻的字符的位置，例如’echo abcd|dd conv=swab’输出badc
• noerror，忽略读文件产生的错误
• sync，将每一个输入块用0填充至ibs指定的大小

dd用例

文件/设备备份

dd if=/dev/hda of=/path/to/image

将整个磁盘hda镜像到image文件。

dd if=/dev/hda | gzip >/path/to/image.gz

备份/dev/hda全盘数据，并利用gzip工具进行压缩，保存到指定路径

gzip -dc /path/to/image.gz | dd of=/dev/hda

将压缩的备份文件恢复到指定盘

dd if=/dev/fd0 of=disk.img count=1 bs=1440k

将软驱数据备份到当前目录的disk.img文件

dd if=/dev/hda of=/path/to/mbr count=1 bs=512

备份磁盘开始的512Byte大小的MBR信息到指定文件

dd if=/path/to/mbr of=/dev/hda

将备份的MBR信息写到磁盘开始部分

dd if=/dev/mem of=/root/mem.bin bs=1024

将内存里的数据拷贝到root目录下的mem.bin文件

dd if=/dev/cdrom of=cd.iso

拷贝光盘数据，保存为cd.iso文件

改变交换分区的大小

dd if=/dev/zero of=/swapfile bs=4096 count=512K

创建一个足够大的文件（此处为2G）

mkswap /swapfile

格式化这个文件为swap文件

swapon /swapfile

启用这个swap文件

/swapfile swap swap defaults 0 0

在每次开机的时候自动加载swap文件, 需要在 /etc/fstab 文件中增加一行

测试硬盘的速度

dd if=/dev/zero of=largefile bs=1M count=1K

产生一个大小为1G的文件

dd if=largefile of=/dev/null bs=1M count=1K

复制该文件到空设备/dev/null
通过这两个命令可测试出磁盘的读写速度

快速生成一定大小的文件

dd if=/dev/zero of=largefile bs=1M count=1K

产生大小为1G的文件，由0填充

dd if=/dev/urandom of=largefile bs=1M count=1K

产生大小为1G的文件，由随机数填充

Unix/Linux的一些特殊设备文件

一切皆文件。

• /dev/mem，直接存取物理内存
• /dev/null，空设备。任何写入都将被直接丢弃，任何读取都将得到EOF。
• /dev/zero，零字节源，只能读取到无限多的零字节。
• /dev/full，满设备。任何写入都将失败，并把errno设为ENOSPC以表示没有剩余空间。
• /dev/random，随机数发生器。完全由用户的输入来产生随机数。 如果用户停止所有动作，则停止产生新的随机数。
• /dev/urandom，更快，但是不够安全的随机数发生器。尽可能由用户的输入来产生随机数，如果用户停止所有动作，则把已经产生的随机数做为种子来产生新的随机数。

cd wdir # 切换至当前目录下的wdir目录，使用相对路径
cd /home/chris # 使用绝对路径

特殊目录

　　为了能够较快的切换目录，Linux下定义了一些特殊的名称或者变量，他们代表着特殊的目录。

1
2
3
4
5
6
7
8

cd .. # 至上级目录，即父目录，根目录/的父目录为其本身
cd . # 至当前目录，即未改变目录，.在某些情况下很是有用
cd ~ # 至当前登录用户的用户目录，如/home/ivan
cd # 同上
cd $HOME # 同上
cd ~Chris # 至Chris同学的用户目录，即/home/Chris
cd - # 至最近离开的目录，很常用
cd !$ # !$为上一个命令中的最后一个参数

使用别名alias

　　alias命令可以定义别名，Shell会将以后执行的命令中alias的第一个参数替换为第二个参数然后执行：

1
2

alias short="longlong -a long"
short # 等同于longlong -a long

　　利用alias，可以使我们更快的输入一些常用的但比较长的命令，这当然也适用于cd命令。为了不用每次有执行alias定义别名，我们应该把这些别名放入shell的配置文件中，比如.bashrc和.bash_profile，当shell(这里假定是bash)启动时会自动执行其中的命令。下面列出我常用的一些别名，仅供参考：

1
2
3
4
5
6
7
8
9

alias ll='ls -lh'
alias la='ls -A'
alias l='ls -CF'
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias -- -='cd -' # --指示命令选项已经结束，下面全都是参数，否则=会被当作选项
alias bl='bc -l' # calculator with compute library.
bind 'set completion-ignore-case on' # 使shell的Tab自动补全忽略字母的大小写

使用$CDPATH

　　$CDPATH是bash的标准环境变量，它保存着cd命令默认搜索的一些目录，类似于$PATH变量。它是一组由分号:分隔的目录的路径组成的。
　　举例来说，我的工作目录为/home/Wdir，其下有很多不同类的目录，比如Cpp、Site、ACM、APUE、LaTeX等等。每次我都需要执行cd Wdir/ACM进入ACM目录，甚是麻烦。如果我把/home/Wdir加入到$CDPATH变量中，我就可以通过cd ACM直接进入ACM目录了。我的$CDPATH=’/:./:~/Wdir:/var:/media’，同样地，我们需要把这个设置写入到.bashrc中，把该环境变量导出(export):

export CDPATH='/:./:~/Wdir:/var:/media'

Update!!!(2010-05-30)

　　介绍一个新命令，保准你从未听说过，但它实现的操作你应该一直都在使用，这个命令就是mkcd。其实它不是一个命令，而是一个shell函数：

1
2
3
4
5
6
7
8
9
10
11

# mkcd: mkdir, then cd
mkcd()
{
    if [ $# = "1" ]
    then
        mkdir -p "$1"
        cd "$1"
    else
        echo "Usage: mkcd folder"
    fi
}

　　很简单，相信你一看就知道它能做什么了。
　　你需要做的就是把这个函数丢进你的.bashrc，然后

1

source ~/.bashrc # 重新加载，使.bashrc立即生效

注意

　　任何东西都不可滥用。过度的使用alias可能会造成名字的混乱，向$CDPATH添加过多的目录有时也会让你吃尽苦头。

　　操作系统采用虚拟内存的方式管理存储器有很多好处：
　　第一，虚拟内存管理可以控制物理内存的访问权限。物理内存本身是不限制访问的，任何地址都可以读写，而操作系统要求不同的页面具有不同的访问权限，这是利用CPU模式和MMU的内存保护机制实现的。例如，代码段被只读保护起来，防止被错误的指令意外改写，内核地址空间也被保护起来，防止在用户模式下执行错误的指令意外改写内核数据。这样，执行错误指令或恶意代码的破坏能力受到了限制，顶多使当前进程因段错误终止，而不会影响整个系统的稳定性。

　　第二，虚拟内存管理最主要的作用是让每个进程有独立的地址空间。所谓独立的地址空间是指，不同进程中的同一个VA被MMU映射到不同的PA，并且在某一个进程中访问任何地址都不可能访问到另外一个进程的数据，这样使得任何一个进程由于执行错误指令或恶意代码导致的非法内存访问都不会意外改写其它进程的数据，不会影响其它进程的运行，从而保证整个系统的稳定性。另一方面，每个进程都认为自己独占整个虚拟地址空间，这样链接器和加载器的实现会比较容易，不必考虑各进程的地址范围是否冲突。

　　第三，方便了共享库的实现。采用共享库的目的在于节省内存(物理内存)，一些公用模块在内存中可以只保存一份，让各进程共享，而不是各自加载一份，当然，只读的代码段可以共享，可写的数据段就必须各自保留一份了。采用虚拟内存机制后，可以将物理内存中所加载的共享库分别映射到进程各自的地址空间，由于加载地址可能不同，所以共享库必须实现为地址无关码(PIC)。

　　第三，VA到PA的映射会给分配和释放内存带来方便，物理地址不连续的几块内存可以映射成虚拟地址连续的一块内存。比如要用malloc分配一块很大的内存空间，虽然有足够多的空闲物理内存，却没有足够大的连续空闲内存，这时就可以分配多个不连续的物理页面而映射到连续的虚拟地址范围。

　　第四，“增加”了程序可以使用的内存空间。一个系统如果同时运行着很多进程，为各进程分配的内存之和可能会大于实际可用的物理内存，虚拟内存管理使得这种情况下各进程仍然能够正常运行。因为各进程分配的只不过是虚拟内存的页面，这些页面的数据可以映射到物理页面，也可以临时保存到磁盘上而不占用物理页面。当所访问的页面不在内存中时再将其加载进来，无空闲页面的时候还可能需要采取一定的置换算法将某个页面换出。这种机制的可行性得益于伟大的“局部性原理”。