1.编译
前段时间非常的郁闷…因为在运行生成校准程序ts_calibrate时总是出现一个错误：ts_open:Inappropriate ioctol for device
后来无数折腾后经过nanfansky指点才知道是自己板子的触摸屏驱动不支持ioctl操作，狂汗…
 
重新编译tslib
 
cd tslib-1.3
 
export CC=/usr/local/arm/2.95.3/bin/arm-linux-gcc   //指定交叉编译器
 
./autogen.sh   //生成config文件
 
export PATH=/usr/local/arm/2.95.3/bin:$PATH
 
echo "ac_cv_func_malloc_0_nonnull=yes" >arm-linux.cache
     
./configure --host=arm-linux --cache-file=arm-linux.cache --enable-inputapi=no
 
vi src/ts_read_raw.c //修改内容如下
 
make
 
 
****************************************************
在make之前，为了支持触摸屏,打开src/ts_read_raw.c文件，查看触摸屏驱动程序数据结构，看与ts_read_raw.c结构中的哪个一样，就将代码中的 char *defaulttseventtype="UCB1x00"; 修改为 自己板子上对应的驱动结构。
因为我的驱动对应的是h3600_ts_event结构
typedef struct {
 unsigned short pressure;
 unsigned short x;
 unsigned short y;
 unsigned short pad;
} TS_RET;
所以修改为：
   char *defaulttseventtype="H3600";
 
************************************
如果不修改源代码，也可以在后面的测试中重新指定环境变量
export TSLIB_TSEVENTTYPE=H3600 //通过这个对tslib中的设备结构体定义
*****************************************************
 
如果你触摸屏驱动程序支持ioctl操作，上面的configure操作中的--enable-inputapi=no］你可以删除。
然后就可以make了
 
*************************************************
 
 
2.测试：
2.1 我在/root/share下新建了一个tslib目录,只copy了一些需要的文件
 
mkdir /root/share/tslib
 
mkdir /root/share/tslib/tests
 
mkdir /root/share/tslib/plugins
 
mkdir /root/share/tslib/lib
 
mkdir /root/share/tslib/etc
 
 
cp /root/2410s/tslib-1.3/tests/.libs/ts_* /root/share/tslib/tests/           //几个所需的测试文件，比如生成的校准文件，测试文件等等
  
cp /root/2410s/tslib-1.3/src/.libs/libts-0.0.so.0* /root/share/tslib/lib/    //几个所需的库文件
 
cp /root/2410s/tslib-1.3/src/.libs/libts.so /root/share/tslib/lib/          //几个所需的库文件          
 
cp /root/2410s/tslib-1.3/plugins/*.so /root/share/tslib/plugins/            //触摸屏插件模块库
 
cp /root/2410s/tslib-1.3/etc/ts.conf /root/share/tslib/etc/                 //配置文件    
 
 
2.2 连接板子
执行minicom
 
mount –t nfs –o nolock 192.168.0.155:/root/share /mnt/nfs使板子mount上PC，共享路径/root/share
 
2.3 做链接
ln -s /dev/fb/0 /dev/fb0
 
//帧缓冲设备板子上为/dev/fb/0,但程序默认为/dev/fb0,所以做了一个链接/dev/fb0到/dev/fb/0
 
ln -sf /dev/touchscreen/0raw /dev/ts
 
//qtopia要打开/dev/ts,你没有这个文件, 所以 dev下边应该有触摸平的节点,
相当于, qtopia启动要找 /dev/ts, 但是你只有/dev/touchscreen/0raw,
所以你把ts链接到你的触摸屏的文件就可以了!
我得触摸屏设备节点文件为/dev/touchscreen/0raw
 所以,建立链接 /dev/ts 到/dev/touchscreen/0raw
（这里要自己针对自己板子具体的文件进行设置，要不然也会报错）
 
 
2.4 指定环境变量
export QWS_MOUSE_PROTO=TPanel:/dev/touchscreen/0raw
 
export T_ROOT=/mnt/nfs/tslib
 
export LD_LIBRARY_PATH=$T_ROOT/lib //指定tslib库文件路径
 
export TSLIB_CONSOLEDEVICE=none //tslib运行需要的控制台，这里就是LCD屏幕 ,设定控制台设备为none，否则默认为/dev/tty,
 
export TSLIB_FBDEVICE=/dev/fb0    //指定帧缓冲设备
 
export TSLIB_TSDEVICE=/dev/touchscreen/0raw         //

n>指定触摸屏设备节点文件
 
export TSLIB_CALIBFILE=$T_ROOT/etc/pointercal     //指定触摸屏校准文件pintercal的存放位置
 
 
********************************************************************
注：qte的/src/kernel/qwsmouse_qws.cpp里面校准文件默认打开是在/etc下面为/etc/pointercal，
可是我得板子的根文件系统为只读，所以我放在/mnt/nfs/tslib/etc下面了，
所以在交叉编译qte的时候需要修改qwsmouse_qws.cpp
**************************************************
 
 
export TSLIB_CONFFILE=$T_ROOT/etc/ts.conf   //指定TSLIB配置文件的位置
 
export TSLIB_PLUGINDIR=$T_ROOT/plugins    //指定触摸屏插件所在路径
 
2.5 校准
运行校准程序校准屏幕（5点校准）
cd $T_ROOT/tests
 
./ts_calibrate   //板子上陆续出现5个光标，点击完毕后会生成校准文件pintercal存放在$T_ROOT/etc/下面
 
********************************************
 
ts_calibrate是一个应用程序，在屏幕上画几个按钮，将用户点击后从ts驱动获得的数据和
屏上的坐标位置通过一套算法来获得校准数据写到一个校准文件里。
******************************************
 
 
3. 可能遇到的错误分析：
在测试的时候，运行./ts_calibrate又出现了令人十分之郁闷的错误：
ts_config: Success
追查后应该是在打开ts_config中出现了错误（居然报Success，无欲至极）
在网上发现多是这个错误（这是1.4版本的错）：
Couldnt load module input
No raw modules loaded
tsconfig: Success
我没有上面那两行的错误，不过应该是一样的错误原因
 
 
那么错误就定位在 ts_config 里。并且可以进一步确定是在加载插件模块时出的错
查询了ts_load_module.c这个文件发现网上和自己的不太一样（网上公布的源码是1.4或者是0.1.1的吧）我的是1.3的
我下载了tslib-0.1.1的后重新实验 就发现错误的是这样子的(第一个错误是由ts.conf所决定的)
Couldnt load module pthres
No raw modules loaded
tsconfig: Success
 
 
阅读了tslib 的原代码，知道了cstdlib 库里的一个函数： getenv
是用来得到指定系统环境变量的值。是为了测试 tslib 是否得到正确的环境变量。
其环境变量默认的值在readme中有注明。
 
 
加载插件模块时出出错分析：
ts_calibrate会打开ts_config
ts_config函数里首先会读取 tslib 配置文件（ts.conf，由 TSLIB_CONFFILE环境变量指定,在tslib/etc下面），
然后根据这个文件逐个加载插件库
 
1.3版本的ts.conf内容为
module mousebuts
moudle variance xlimit=50 ylimit=50 pthreshold=3
moudle dejitter xdelta=1 ydelta=1 pthreshold=3
moudle linear
 
 
ts_config又会调用ts_load_module加载库。从这个函数里，程序先是得到配置文件中指定加载的模块名，
然后根据模块名构造了一个 so 文件文件名，然后调用了系统函数 dlopen 加载库！
 
Linux 下的加载dlopen 类似于 Windows 下动态链接库的函数：dlopen
错误就应该出在构造的库文件名是错误的---其指定的文件不存在
---从而导致 dlopen无法加载。所以才提示找不到文件或目录！
 
那么这样就是应该把需要的mousebuts.so variance.so dejitter.so linear.so应该复制到/tslib/plugins中
（上面修正后作了这一步，就可以拉，就不会出现错误拉）
 
 
 
**************************************
 
这里来谈一谈tslib-1.4,和1.3有一点点不一样，主要是配置文件的差别
一般来说，tsllib-1.4种一个完整的ts.conf配置文件如下所示：
module_raw input
module pthres
module variance delta=30
module dejitter delta=100
module linear
 
 
出现这个错误
Couldnt load module input
No raw modules loaded
tsconfig: Success
 
第一行告诉tslib从linux的输入设备读取数据，需要用到input这个模块，也就是plugin目录下的input.so文件，
所以你的TSLIB_PLUGINDIR一定要配置正确，让tslib能够找到模块文件。
其他参数分别控制触摸点的连续下压、变化宽度、轨迹变化和线性校准。
也是要把其对应的需要的几个库文件复制到/tslib/plugins中
 
第二行导致"No raw modules loaded."的原因有两个：
注意：一是你的ts.conf中没有指定module_raw，自带的ts.conf的所有module_raw都被注释掉了，
# Uncomment if you wish to use the linux input layer event interface
# module_raw input
 
# Uncomment if you''re using a Sharp Zaurus SL-5500/SL-5000d
# module_raw collie
 
# Uncomment if you''re using a Sharp Zaurus SL-C700/C750/C760/C860
# module_raw corgi
 
# Uncomment if you''re using a device with a UCB1200/1300/1400 TS interface
# module_raw ucb1x00
 
# Uncomment if you''re using an HP iPaq h3600 or similar
#module_raw h3600
 
# Uncomment if you''re using a Hitachi Webpad
# module_raw mk712
 
# Uncomment if you''re using an IBM Arctic II
# module_raw arctic2
 
你应该打开至少一个module_raw选项，有人就选择了input，去掉了它的注释
得到module_raw input
 
另一个原因就是你没有正确配置TSLIB_PLUGINDIR，tslib从你指定的目录中没有找到plugin需要的模块文件，
请检查你的路径和文件。
文章出处：http://www.diybl.com/course/6_system/linux/Linuxjs/20071129/89010_2.html

一、建立arm交叉编译工具链

       在安装QT/E之前，应确保arm-linux交叉编译工具链已经建立，如果还没有可以参考以下步骤建立。

     1、下载交叉编译工具cross-2.95.3.tar.bz2(或其他版本如:cross-3.4.4.tar.bz2),这是已经制作好的arm交叉编译工具链，只需解压及建交环境变量即可使用。

     2、把文件cross-2.95.3.tar.bz2拷贝到一个文件夹，这里我用：/usr/local/arm这个目录。 注意后面建立环境变量时要与之对应。

      3、解压 tar   -xjvf    cross-2.95.3.tar.bz2

      4、建立环境变量 export    PATH=/usr/local/arm/2.95.3/bin:$PATH

或者也可以写进文件 ~/.bashrc中，这样就不用每次开机都export啦。

             vi     ~/.bashrc

             在后面加上 export    PATH=/usr/local/arm/2.95.3/bin:$PATH

     到此arm-linux交叉编译工具链就已经建好了。

二、编译QT

        1、QT/E自由版可到官网ftp下载。网址是：ftp://ftp.trolltech.com/qt/source/ 。 可自己选择一个版本下载，个人认为QT/E 3.x系列比较好用，不过QT/E 2.x系列在网上的资料比较多。但建议不用qt/e 3.3.x 的版本，因为在本人开发的过程当中试用过qt/e 3.3.4和qt/e3.3.8，发现它们在ARM开发板上占CPU的资源特高，一直占cpu 98%左右，现在我还没找到原因，不知道有没有哪位朋友也遇到这个问题。推荐用qt/e 3.1.0版本，我正在用，没遇到什么问题。

(注：问题已经得到解决，原来是键盘接口没做好，等有空与大家分享一下移植键盘接口的过程)

         2、在这里，本人假设用的是 qt-embedded-free-3.1.0.tar.bz2

         3、把文件qt-embedded-free-3.1.0.tar.bz2 拷贝到一个文件夹，这里我用：/usr/local/arm这个目录。 注意后面建立环境变量时要与之对应。

         4、解压 tar   -xjvf   qt-embedded-free-3.1.0.tar.bz2  

             把解压后的文件夹qt-embedded-free-3.1.0改为qte。（可以不改，这里是为了方便，注意后面建立环境变量时要与之对应）   

                        mv     qt-embedded-free-3.1.0     qte

         5、建立环境变量

                       vi     ~/.bashrc

               在后面加上

                       export QTDIR=/usr/local/arm/qte
                       export QTEDIR=$QTDIR
                       export PATH=$QTDIR/bin:$PATH
                       export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

              （请重新登陆，以使得环境变量生效）

          6、配置QT

            进入QT/E目录:     cd    $QTDIR

              输入:   ./configure  -embedded  arm   -thread  -no-cups -qvfb -depths 4,8,16,32

            上述选项： -embedded  arm 指目标平台为arm； -thread 表示支持qt线程，本人开发当中用到； -qvfb 表示支持虚拟缓冲帧工具qvfb；-depths 4,8,16,32 表示支持4，8，16，32 位的显示颜色深度。还有很多选项就不一一列举，请查看 ./configure  -help。

         此外还有一个选项我没用的是 -qconfig  local，你可以把一些开关变量写到一个文件qconfig-local.h 中，并把它放到$QTDIR/src/tools下。可参考这个目录下的qconfig-small.h、qconfig-medium.h 、qconfig-large.h等文件，直接使用它们也行，如：  -qconfig  small 。通过这些开关变量，可以把一些开发当中用不着的构件去掉，减少qt库的大小。这里要对QT比较熟练，初学者可先不理。

            （本人在家里编译到这里曾出现编译 $QTDIR/include/qvaluestack.h 这个文件的时候出错，后来把qt3.3.8对应的文件拷贝过来覆盖便通过了，估计是与gcc的版本不兼容的问题，我在公司里没出现过这种问题）

         7、编译

            make sub-src      // 指定按精简方式编译开发包，也就是说有些Qt 类未被编
译。

          8、测试

                  至此编译工作完成，最后测试一下是否能正常使用。我们可以用QT自带的例子来测试，如:

                  cd  $QTDIR/examples/aclock      //或你自己新建一个QT工程也行

                  make clean                              //把原来的清掉

                   rm    *.pro      Makefile                       //删掉，重新建立工程文件

                   qmake   -project

                    qmake   -spec  $QTDIR/mkspecs/qws/linux-arm-g++   -o  Makefile           

                -spec指定目标板的配置文件，这里我做的是linux arm平台，注意在这里，$QTDIR/mkspecs/qws/linux-arm-g++ 它不是编译器，是一个配置文件，而编译时用的编译器是我们 在第一步建立的arm交叉编译工具链里面的编译器。 

                   make                      

             如果没出错就表示你的QT/E环境已经成功建立。如果提示说cannot   find   -lqte， 那么你试一下修改Makefile文件，找到-lqte ,把它改为-lqte-mt再make一次一般就行了。这是因为如果用到QT线程或其它一些原因，它生成的库不再是libqte.so.3.1.0，而是 libqte-mt.so.3.1.0，所以它便找不到了。

三、移植到开发板（以下都是在目标机环境下）

        1、新建一个目录，如：/qt/lib。进入此目录 cd   /qt/lib

        2、通过 ftp  把上面生成的qt库文件libqte-mt.so.3.1.0下载到开发板/qt/lib/目录下。（注意：不要用wget 下载，会破坏库文件，从而出现  ld.so: dynamic-link.h: 62: elf_get_dynamic_info: Assertion `! "bad dynamic tag"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' failed!.这种错误）

        3、创建qt库连接：

                ln   -s   libqte-mt.so.3.1.0     libqte-mt.so

                ln   -s   libqte-mt.so.3.1.0     libqte-mt.so.3

                ln   -s   libqte-mt.so.3.1.0     libqte-mt.so.3.1

        4、建立环境变量

                       vi     ~/.bashrc

               在后面加上

                       export QTDIR=/qt
                       export QTEDIR=$QTDIR
                       export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

           4、到此目标板的环境已经建好。现在可以把上面的例子aclock下载到目标板上试一下能不能跑起来！

             在开发板控制台下输入:  ./aclock  -qws 

             如果能跑起来但是键盘用不了，那是正常的情况，因为键盘、鼠标等设备的接口还没加进QT/E的原因，而这个不是一两句话能说清的，所以留到以后再另外补充！

　　4.文件系统移植

　　文件系统是基于被划分的存储设备上的逻辑上单位上的一种定义文件的命名、存储、组织及取出的方法。如果一个Linux没有根文件系统，它是不能被正确的启动的。因此，我们需要为Linux创建根文件系统，我们将其创建在K9S1208 NAND FLASH上。

　　Linux的根文件系统可能包括如下目录（或更多的目录）：

　　（1）/bin (binary)：包含着所有的标准命令和应用程序；

　　（2）/dev (device)：包含外设的文件接口，在Linux下，文件和设备采用同种地方法访问的，系统上的每个设备都在/dev里有一个对应的设备文件；

　　（3）/etc (etcetera)：这个目录包含着系统设置文件和其他的系统文件，例如/etc/fstab(file system table)记录了启动时要mount 的filesystem；

　　（4）/home：存放用户主目录；

　　（5）/lib(library)：存放系统最基本的库文件；

　　（6）/mnt：用户临时挂载文件系统的地方；

　　（7）/proc：linux提供的一个虚拟系统，系统启动时在内存中产生，用户可以直接通过访问这些文件来获得系统信息；

　　（8）/root：超级用户主目录；

　　（9）/sbin：这个目录存放着系统管理程序，如fsck、mount等；

　　（10）/tmp(temporary)：存放不同的程序执行时产生的临时文件；

　　（11）/usr(user)：存放用户应用程序和文件。

　　采用BusyBox是缩小根文件系统的好办法，因为其中提供了系统的许多基本指令但是其体积很小。众所周知，瑞士军刀以其小巧轻便、功能众多而闻名世界，成为各国军人的必备工具，并广泛应用于民间，而BusyBox也被称为嵌入式Linux领域的"瑞士军刀"。

　　此地址可以下载BusyBox：http://www.busybox.net，当前最新版本为1.1.3。编译好busybox后，将其放入/bin目录，若要使用其中的命令，只需要建立link，如：

ln -s ./busybox ls
ln -s ./busybox mkdir

　　4.1 cramfs

　　在根文件系统中，为保护系统的基本设置不被更改，可以采用cramfs格式，它是一种只读的闪存文件系统。制作cramfs文件系统的方法为：建立一个目录，将需要放到文件系统的文件copy到这个目录，运行"mkcramfs 目录名 image名"就可以生成一个cramfs文件系统的image文件。例如如果目录名为rootfs，则正确的命令为：

mkcramfs rootfs rootfs.ramfs

　　我们使用下面的命令可以mount生成的rootfs.ramfs文件，并查看其中的内容：

mount -o loop -t cramfs rootfs.ramfs /mount/point

　　此地址可以下载mkcramfs工具：http://sourceforge.net/projects/cramfs/。

　　4.2 jfss2

　　对于cramfs闪存文件系统，如果没有ramfs的支持则只能读，而采用jfss2（The Journalling Flash File System version 2）文件系统则可以直接在闪存中读、写数据。jfss2 是一个日志结构(log-structured)的文件系统，包含数据和原数据(meta-data)的节点在闪存上顺序地存储。jfss2记录了每个擦写块的擦写次数，当闪存上各个擦写块的擦写次数的差距超过某个预定的阀值，开始进行磨损平衡的调整。调整的策略是，在垃圾回收时将擦写次数小的擦写块上的数据迁移到擦写次数大的擦写块上以达到磨损平衡的目的。

　　与mkcramfs类似，同样有一个mkfs.jffs2工具可以将一个目录制作为jffs2文件系统。假设把/bin目录制作为jffs2文件系统，需要运行的命令为：

mkfs.jffs2 -d /bin -o jffs2.img

　　4.3 yaffs

　　yaffs 是一种专门为嵌入式系统中常用的闪存设备设计的一种可读写的文件系统，它比jffs2 文件系统具有更快的启动速度，对闪存使用寿命有更好的保护机制。为使Linux支持yaffs文件系统，我们需要将其对应的驱动加入到内核中fs/yaffs/，并修改内核配置文件。使用我们使用mkyaffs工具可以将NAND FLASH中的分区格式化为yaffs格式（如/bin/mkyaffs /dev/mtdblock/0命令可以将第1个MTD块设备分区格式化为yaffs），而使用mkyaffsimage（类似于mkcramfs、mkfs.jffs2）则可以将某目录生成为yaffs文件系统镜像。

　　嵌入式Linux还可以使用NFS（网络文件系统）通过以太网挂接根文件系统，这是一种经常用来作为调试使用的文件系统启动方式。通过网络挂接的根文件系统，可以在主机上生成ARM 交叉编译版本的目标文件或二进制可执行文件，然后就可以直接装载或执行它，而不用频繁地写入flash。

　　采用不同的文件系统启动时，要注意通过第二章介绍的BootLoader修改启动参数，如广州友善之臂的demo提供如下三种启动方式：

　　（1）从cramfs挂接根文件系统：root=/dev/bon/2()；
　　
　　（2）从移植的yaffs挂接根文件系统：root=/dev/mtdblock/0；

　　（3）从以太网挂接根文件系统：root=/dev/nfs。

　　5.小结

　　本章介绍了嵌入式Linux的背景、移植项目、init进程修改和文件系统移植，通过这些步骤，我们可以在嵌入式系统上启动一个基本的Linux。

HOST主机         :  Red Hat 9 完全安装
交叉编译器       :  freescale提供的arm-926ejs-linux 版本 gcc-4.1.1-glibc-2.4-nptl-sf-1
需要用到的软件包 :  tmake-1.13.tar.gz   qt-x11-2.3.2.tar.gz    qt-embedded-2.3.10-free.tar.gz

一. 安装与建立Qt 桌面运行环境

第一步，解压安装包并设置环境变量
        tar –xzvf tmake-1.13.tar.gz
        tar –xzvf qt-x11-2.3.2.tar.gz
        tar –xzvf  qt-embedded-2.3.10-free.tar.gz
        mv  qt-2.3.10 qt-2.3.10-host
        export TMAKEDIR=$PWD/tmake-1.13
        export QT2DIR=$PWD/qt-2.3.2
        export QTEDIR=$PWD/qt-2.3.10-host

 环境变量的设置是非常重要的，它关系到能否正确的安装及编译这些安装包.
 
 注意: 在以下安装中,make命令执行前先执行一下make clean命令.

第二步，编译Qt/Embedded

1. Build Qt2.3.2
      cd $QT2DIR
      export TMAKEPATH=$TMAKEDIR/lib/linux-g++
      export QTDIR=$QT2DIR
      export PATH=$QTDIR/bin:$PATH
      export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
      make clean
      ./configure -no-xft
      make
      mkdir $QTEDIR/bin
      cp bin/uic $QTEDIR/bin/

 2. Build Qvfb
      export TMAKEPATH=$TMAKEDIR/lib/linux-g++
      export QTDIR=$QT2DIR
      export PATH=$QTDIR/bin:$PATH
      export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
      cd $QTEDIR/tools/qvfb
      make  clean
      tmake -o Makefile qvfb.pro
      make
      mv qvfb $QTEDIR/bin/

       这一步build qvfb 并建立了从Qt/Embedded 2.3.10 到Qt 2.3.2 的静态库的链接。其中qvfb 工具用来生成Virtual framebuffer，这是一个非常有用的工具，它可以模拟在开发板上的显示情况，如果在Virtual framebuffer 中运行没有问题的话，可以直接通过交叉编译在开发板上运行。

 3. Build Qt/Embedded
      cd $QTEDIR
      export TMAKEPATH=$TMAKEDIR/lib/qws/linux-x86-g++
      export QTDIR=$QTEDIR
      export PATH=$QTDIR/bin:$PATH
      export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
      make clean
      ./configure -no-xft -qvfb -depths 4,8,16,32       此时我选择的5
      make
 
第三步，查看运行结果
     如果上面各步都能够成功的编译通过，下面就可以通过运行Qt/Embedded 自带的demo 来查看运行结果。

  在Virtual framebuffer 上运行：
      export QTDIR=$QTEDIR
      export PATH=$QTEDIR/bin:$PATH
      export LD_LIBRARY_PATH=$QTEDIR/lib:$QT2DIR/lib:$LD_LIBRARY_PATH
      cd $QTEDIR/examples/launcher
      qvfb -width 640 -height 480 &
      sleep 10
      ./launcher -qws

二  Qt/E 的交叉编译

 1. Build Qt/Embedded
      tar –xzvf qt-embedded-2.3.10-free.tar.gz
      mv  qt-2.3.10  qt-2.3.10-target
      export PATH=/opt/freescale/usr/local/gcc-4.1.1-glibc-2.4-nptl-sf-1/arm-926ejs-linux/bin:$PATH
      export TMAKEDIR=$PWD/tmake-1.13
      export QT2DIR=$PWD/qt-2.3.2
      export QTEDIR=$PWD/qt-2.3.10-target
      cd $QTEDIR
      export TMAKEPATH=$TMAKEDIR/lib/qws/linux-arm-g++
      export QTDIR=$QTEDIR
      export PATH=$QTDIR/bin:$PATH
      export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
 
  修改tmake配置文件及qt-embedded配置

   vi $TMAKEDIR/lib/qws/linux-arm-g++/tmake.conf
    将  
     TMAKE_CC          = arm-linux-gcc
     TMAKE_CXX         = arm-linux-g++
     TMAKE_LINK        = arm-linux-gcc
     TMAKE_LINK_SHLIB  = arm-linux-gcc
     TMAKE_AR          = arm-linux-ar cqs
    改为
     TMAKE_CC          = arm-926ejs-linux-gcc
     TMAKE_CXX         = arm-926ejs-linux-g++
     TMAKE_LINK        = arm-926ejs-linux-g++
     TMAKE_LINK_SHLIB  = arm-926ejs-linux-g++
     TMAKE_AR          = arm-926ejs-linux-ar cqs

   vi $QTEDIR/configs/linux-arm-g++-shared
    将
     SYSCONF_CXX         = arm-linux-g++
     SYSCONF_CC          = arm-linux-gcc
     SYSCONF_LINK        = arm-linux-gcc
     SYSCONF_LINK_SHLIB  = arm-linux-gcc
     SYSCONF_AR          = arm-linux-ar cqs
    改为
     SYSCONF_CXX         = arm-926ejs-linux-g++
     SYSCONF_CC          = arm-926ejs-linux-gcc
     SYSCONF_LINK        = arm-926ejs-linux-g++
     SYSCONF_LINK_SHLIB  = arm-926ejs-linux-g++
     SYSCONF_AR          = arm-926ejs-linux-ar cqs
  
   vi $QTEDIR/configs/linux-arm-g++-shared-debug
   vi $QTEDIR/configs/linux-arm-g++-static
   vi $QTEDIR/configs/linux-arm-g++-static-debug
   这三个文件修改的地方同$QTEDIR/configs/linux-arm-g++-shared相同

  make clean
  ./configure -xplatform linux-arm-g++ -no-xft -no-qvfb -depths 4,8,16,32
  make

/**********************************************************************************************************************/
  出现错误：
    error: ‘QWSInputMethod’ has not been declared
 
  修改方法：
    cd $QTDIR/src/kernel
    vim qwindowsystem_qws.h

    在前面增加以下两行

    class QWSInputMethod;
    class QWSGestureMethod;

/**********************************************************************************************************************/
 
  出现错误：
    qvaluestack.h:57: 错误：不能从 ‘QValueListIterator<QString>’ 转换到 ‘const char*’，为实参 ‘1’(属于 ‘int remove(const char*)’)

  修改方法：
    vim $QTDIR/include/qvaluestack.h

    将remove( this->fromLast() );改为this->remove( this->fromLast() );

/**********************************************************************************************************************/

 这两个错误是由于编译器的版本太高导致的
  
 交叉编译成功！！                  哈哈

三 在ARM上运行

 1. 编译在arm上运行程序时需要的环境变量
 
  export TMAKEDIR=/work/tmake-1.13
  export TMAKEPATH=$TMAKEDIR/lib/qws/linux-arm-g++
  export PATH=/opt/freescale/usr/local/gcc-4.1.1-glibc-2.4-nptl-sf-1/arm-926ejs-linux/bin:$PATH
  export QTEDIR=/work/qt-2.3.10-target
  export QTDIR=$QTEDIR

一、开发Qtopia的所需的工具
整个GUI系统的构建需要对Qt/Embedded、Qtopia依次分别编链，然后有机地整合在一起。Qt/Embedded为Qtopia提供
了底层支持，GUI系统的图形库窗口组建都由Qt/Embedded实现。
在构建GUI时用于Qt开发的典型工具如下：
tmake：跨平台的Makefile生成器。
moc：用于Qt C++扩展的metra-object编译器。
uic：uic是for x86的文件，从XML文件生成代码的用户界面编译器。即uic用来把.ui文件转换成.h和.cpp文件。
designer：用于设计窗口组建的应用程序。
Qtopia的开发工具包SDK（Software Development Kit）是Qtopia开发环境的核心部分，编译后得到创建应用程序所
需的软件包如下：
qvfb(virtual frame buffer)：X窗口用来运行和测试Qtopia应用程序的系统程序 。
qpe(Qtopia executable)：是Trolltech公司所推出的针对PDA软件的整体解决方案，包含了从底层的GUI系统、
Window Manager、Soft Keyboard到上层的PIM、浏览器、多媒体等方面，用来处理所有的用户程序界面。

二、交叉编译qtopia的过程
1、编译qtopia的准备工作
1.1、所需的软件压缩包：
cross-2.95.3.tar.bz2,
e2fsprogs-1.39.tar.gz.tar.gz，
jpegsrc.v6b.tar.gz，
libpng-1.2.18.tar.bz2，
zlib-1.2.3.tar.bz2,
qtopia-free-src-2.2.0.tar.gz
1.2、建立所需目录
/---usr ---/local/arm
/---root---/yizhi
.  .     .  /armlib
.  .     .  /arminclude
.  .     .  /qtopia-free-2.2.0
.  .     .  /libpng-1.2.18
.  .     .  /zlib-1.2.3
.  .     .  /e2fsprogs-1.39
.  .     .  /jpeg-6b
.  .     .  /qt-2.3.10
.  .     .  /host/qtopia-free-2.2.0
1.3、各个目录的功能作用：
arm：存放PC机上交叉编译的工具
yizhi：下载的软件包全部存放到这里
armlib：编译软件得到qtopia所需要的库文件全部放在这里
arminclude：编译软件得到qtopia所需要的头文件全部放在这里
qtopia-free-2.2.0：qtopia的源代码
jpeg-6b：一个jpeg图形编码解码程序库
libpng-1.2.18：一个png图形编码解码程序库
zlib-1.2.3：一个压缩解压程序库
e2fsprogs-1.39：可以提供uuid支持
qt-2.3.10：qt-embeddedd的文件夹路径
host/qtopia-free-2.2.0：qtopia的源代码
2、编译QTOPIA所依赖的库文件
2.1、安装交叉编译工具
将cross-2.95.3.tar.bz2放到/usr/local/arm文件夹下解压，
# tar –zxvf cross-2.95.3.tar.bz2
这个命令会在你的/usr/local/arm/2.95.3目录下安装 arm-linux-gcc 交叉编译程序，然后在PATH变量中添加一项
：
export PATH=/usr/local/arm/2.95.3/bin:$PATH
测试
# arm-linux-gcc -v
2.2、得到本机运行的uic工具
qtopia-2.2.0版本里面集成了qt\tmake\qtopia。
编译Qt/X11的唯一目的就是为编译QTE提供uic（用户接口编译器）以及基于X Windows系统的FrameBuffer设备模拟
器qvfb。
解压qtopia-free-src-2.2.0.tar.gz,将qtopia-free-2.2.0复制到 /root/yizhi/host
# cd /root/host/qtopia-free-2.2.0
要生成Makefile
# ./configure
# make
解压qtopia-free-src-2.2.0.tar.gz 将其复制至 /root/yizhi/  
# cp /root/yizhi/host/qtopia-free-2.2.0/qt2/bin/uic /root/yizhi/qtopia-free-2.2.0/qt2/bin/
2.3、编译e2fsprogs-1.39
要得到qtopia 所需的二個文件，uuid.h 及 libuuid.so。
# cd /root/yizhi/e2fsprogs-1.39
设置环境变量
# export PATH=/usr/local/arm/2.95.3/bin:$PATH
# export CC= /usr/local/arm/2.95.3/bin/arm-linux-gcc
# ./configure --enable-elf-shlibs --host=arm-linux
 --with-cc=/usr/local/arm/2.95.3/bin/arm-linux-gcc
 --with-linker=/usr/local/arm/2.95.3/bin/arm-linux-ld
 --prefix=/usr/local/arm/2.95.3/arm-linux
# make
将e2fsprogs-1.39/lib/目录下uuid的文件夹复制到yizhi/arminclude下
# cp -r /lib/uuid /root/yizhi/arminclude
# cp lib/libuuid.so* /root/yizhi/armlib /
2.4、交叉编译jpeg库
解压jpegsrc.v6b.tar.gz到/root/yizhi
# cd jpeg-6b
设置环境变量
# export QTDIR=/root/yizhi/qtopia-free-2.2.0/
# export QTEDIR=/root/yizhi/qtopia-free-2.2.0/qtopia/
# export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
# export PATH=/usr/local/arm/2.95.3/bin:$PATH
# export CC= /usr/local/arm/2.95.3/bin/arm-linux-gcc
# ./configure --enable-shared
修改生成的Makefile文件
prefix = /root/yizhi/qt-2.3.10
CC= /usr/local/arm/2.95.3/bin/arm-linux-gcc
AR= /usr/local/arm/2.95.3/bin/arm-linux-ar rc
AR2= /usr/local/arm/2.95.3/bin/arm-linux-ranlib
保存
# cp jconfig.doc jconfig.h
在你的qt-embedded中建立man/man1文件夹,否则安装jpeg库时会出错
# mkdir -p qt-2.3.10/man/man1
最后
# make
# make install –lib
报错,但是在/root/2410s/qt-2.3.10-arm/lib目录下生成了文件夹fonts和libjpeg.so*
# cp jpeglib.h /root/yizhi/arminclude
# cp lib/libjpeg.so* /yizhi/yizhi/armlib
就可以给qt-embedded添加好for arm的libjpeg库放到交叉编译的Lib一份
# cp lib/libuuid.so* /usr/local/arm/2.95.3/arm-linux/lib
2.5、编译libpng库
将libpng-1.2.18.tar.bz2解压到/root/yizhi目录下
# cd /root/yizhi/libpng-1.2.18
# cp  scripts/makefile.linux  ./Makefile
注意，这里的makefile不是用./configure生成，而是直接从scripts/里拷一个
# vi Makefile
修改:
[begin]
 ...
AR_RC=/usr/local/arm/2.95.3/bin/arm-linux-ar rc
CC=/usr/local/arm/2.95.3/bin/arm-linux-gcc
RANLIB=/usr/local/arm/2.95.3/bin/arm-linux-ranlib
prefix=/usr/local/arm/2.95.3/arm-linux
 ...
[end]
保存
# make
# cp libpng12.so*  /root/yizhi/armlib
# cp *.h /root/yizhi/arminclude
2.6、编译zlib
# cd /root/yizhi/zlib-1.2.3
设置环境变量
# export PATH=/usr/local/arm/2.95.3/bin:$PATH
# export LD_LIBRARY_PATH= /usr/local/arm/2.95.3/arm-linux/lib:$LD_LIBRARY_PATH
# export CC= /usr/local/arm/2.95.3/bin/arm-linux-gcc
# ./configure –shared
# vi Makefile
修改:
[begin]
CC=/usr/local/arm/2.95.3/bin/arm-linux-gcc
 ...
LDSHARED=/usr/local/arm/2.95.3/bin/arm-linux-gcc -shared-Wl,-soname,libz.so.1
CPP=/usr/local/arm/2.95.3/bin/arm-linux-gcc -E  
 ...
AR=/usr/local/arm/2.95.3/bin/arm-linux-ar rc
RANLIB=/usr/local/arm/2.95.3/bin/arm-linux-ranlib
 ...
prefix =/usr/local/arm/2.95.3/arm-linux
 ...
[end]
保存
# make
将编译生成的动态库及相关的头文件分别复制到armlib和arminclude目录下
# cp libz.so* /root/yizhi/armlib
# cp *.h /root/yizhi/arminclude
3、交叉编译qtopia
3.1、编译修改工作
①、vi /root/yizhi/qtopia-free-2.2.0/qtopia/mkspecs/qws
/linux-arm-g++/qmake.conf
将此行
QMAKE_LIBS_QT = -lqte
修改为
QMAKE_LIBS_QT = -lqte -lpng -lz -luuid -ljpeg
②、 如果想让Qtopia支持鼠标，需要修改$QPEDIR/src/qt/qconfig-qpe.h文件
注释如下部分
/*
#ifndef QT_NO_QWS_CURSOR
#define QT_NO_QWS_CURSOR
#endif
#ifndef QT_NO_QWS_MOUSE_AUTO
#define QT_NO_QWS_MOUSE_AUTO
#endif
#ifndef QT_NO_QWS_MOUSE_PC
#define QT_NO_QWS

_MOUSE_PC
#endif
*/
③、# cp /root/yuzhi/qtopia-free-2.2.0/qtopia/src/qt/Qconfig-qpe.h
/root/yizhi/qtopia-free-2.2.0/qt2/src/tools
# cd $QPEDIR/src/libraries/qtopia
# cp custom-linux-ipaq-g++.cpp custom-linux-arm-g++.cpp
# cp custom-linux-ipaq-g++.h custom-linux-arm-g++.h
④、将/usr/local/arm/2.95.3/lib/gcc-lib/arm-linux/2.95.3/../../
../../arm-linux/sys-include/linux/videodev.h文件中的#include<linux/
version.h>一行屏蔽
3.2、设置环境变量，编译及安装
①设置编译qtopia的环境变量
# export QTDIR=/root/yizhi/qtopia-free-2.2.0/qt2
# export QPEDIR=/root/yizhi/qtopia-free-2.2.0/qtopia
# export LD_LIBRARY_PATH=$QTDIR/lib:$QPEDIR/lib:$LD_LIBRARY_PATH
# export TMAKEDIR=/root/yizhi/qtopia-free-2.2.0/tmake
# export TMAKEPATH=$TMAKEDIR/lib/qws/linux-arm-g++
# export PATH=/usr/local/arm/2.95.3/bin:$PATH
②创建交叉编译后的qtopia文件夹
# mkdir /root/yizhi/qtopia
③生成Makefile文件（注释2）
# ./configure -qte "-embedded -xplatform linux-arm-g++ -qconfig qpe -no-qvfb -depths 8,16,24,32  
-no-xft -system-jpeg  -system-libpng -system-zlib -gif -thread –release - 
I/root/yizhi/arminclude -L/root/yizhi/armlib -lpng -lz –luuid -ljpeg" -qpe  '-xplatform linux-
arm-g++ -edition pda –displaysize 640x480 -I/root/yizhi/arminclude  -L/root/yizhi/armlib -
prefix=/root/yizhi/qtopia'
④编译qtopia
# make
⑤安装qtopia的交叉编译环境
# make install
编译完成以后/root/yizhi后出现一个qtopia的目录，在/root/yizhi/qtopia/lib/目录下面看到libqte.so、
libqte.so.2 libqte.so.2.3、libqte.so.2.3.12 这四个文件. 这是编译qte的库文件.
将所有需要支持的库文件都放到新生成的qtopia/lib中
# cp /root/yizhi/armlib/*.so* /root/yizhi/qtopia/lib 
4、将qtopia挂在到目标板上
4.1、建立宿主机和开发板的通讯
以/root/share 为共享文件夹，目标板可通过nfs来访问这个共享文件夹。
将qtopia复制到共享文件夹/root/share/
# cp -r /root/yizhi/qtopia  /root/share/
设置共享文件夹：
①、修改/etc/export指定/root/share文件夹为共享可访问的
最后一行加上    /root/share 192.168.0.* (rw)
②、没有关闭防火墙
4.2、启动nfs服务
# service nfs restart  （或nfs /etc/rc.d/init.d/nfs  start）
设置本机的ip 地址为192.168.0.105
# ifconfig eth0 192.168.0.105 up
4.3、测试qtopia是否正常运行
配置串口的波特率为115200，启动目标板。
# minicom
# ifconfig -t nfs eth0 192.168.0.16 up
检测目标板和PC机是否建立了连接
#ping 192.168.0.105
如果建立了连接，将文件复制到目标板上
# mount 192.168.0.105:/root/share /mnt/ext2
# cd /mnt/ext2/qtopia
设置环境变量
# export QTDIR=$PWD
# export QPEDIR=$PWD
# export LD_LIBRARY_PATH=$PWD/lib
我的根文件系统为只读文件系统cramfs，下句是指定一个可读写的文件，作为环境变量HOME
# export HOME=/etc/tmp
帧缓冲设备板子上为/dev/fb/0,但程序默认为/dev/fb0,所以做了一个链，接/dev/fb0到/dev/fb/0
# ln -s /dev/fb/0 /dev/fb0   
指定键盘和鼠标为输入设备
# export QWS_KEYBOARD_PROTO="USB:/dev/input/event1"
# export QWS_MOUSE_PROTO="USB:/dev/input/mouse0"
在qtopia下可能没有pointercal文件可以自创一个其内容是1 0 1 0 1 1  65536
# cp pointercal /etc             
# cp pointercal /etc/tmp
运行PDA
# cd bin
# ./qpe
出现 Tap anywhere on the screen to continue  
用鼠标点击一下桌面，就进入配置显示使用的语言和所在地区的时区，点击finish键，这样就可以在显示终端上看
到qtopia桌面环境了

(有的时候执行环境的权限真的是很重要的)

gdb-6.6使用了autoconf/automake，因此通过设置configure脚本的--target，--host,--prefix参数就可以方便的移植到别的平台。

--target 指定编译后的文件针对的是什么目标板，一般设置为交叉编译器的前缀，比如--target=arm-linux, --target=mips-linux，--target=armv5-linux-uclibc, --target的缺省值为i386-linux, 也就是PC机。

--host 指定编译后的文件的运行环境，取值可以是i386-linux或者交叉编译器的前缀，缺省为i386-linux，

--prefix 指定要安装的目录。

1、到http://www.gnu.org/software/gdb下载gdb-6.6.tar.gz到/tmp解压到/opt下
   #cd /opt
   #tar xzvf /tmp/gdb-6.6.tar.gz

2、建立配置文件、编译
   gdb允许把编译配置和编译结果放到任意的目录，因此可以在gdb目录之外建立一个专门放编译文件的目录。
   #cd /opt
   #mkdir -p arm-gdb/build
   #cd arm-gdb/build

   #/opt/gdb-6.6/configure --host=i386-linux --target=armv5-linux-uclibc --prefix=/opt/arm-gdb
   #make
   #make install
其中：host指定了运行环境为i386机器，target指定了需要调试的目标机环境（我使用的ARM toolchain是armv5-linux-uclibc-gcc，因此这样指定，如果是用arm-linux-gcc，则 --target=arm-linux），prefix指定了编译后的结果存放的位置，也就是安装目录。
   如果在编译arm-linux-low.c这个文件时提示找不到“sys/reg.h”, 则修改arm-linux-low.c，注释掉#include "sys/reg.h"。

    可以在/opt/arm-gdb/bin下找到可执行的armv5-linux-uclibc-gdb, armv5-linux-uclibc-gdbtui, armv5-linux-uclibc-run。

3、gdbserver的移植
   gdbserver要用到gdb源码目录下的一些头文件，因此无法在gdb源码目录之外建立编译文件。
 
   #cd /opt/gdb-6.6/gdb/gdbserver
   #vi build.arm        
   内容如下：
      ./configure --target=armv5-linux-uclibc --host=armv5-linux-uclibc --prefix=/opt/arm-gdb/gdbserver
      make
      make install
   #chmod +x build.arm
   #./build.arm

   注意：此处target参数和host参数都要设置为armv5-linux-uclibc，因为gdbserver是放在目标板上运行的。
   编译后，可以在/opt/arm-gdb/gdbserver/bin下找到armv5-linux-uclibc-gdbserver，下载该文件到目标板并重命名为gdbserver，
   同时要下载gdbserver需要的库文件libthread_db-x.x.x.so，再建立两个符号链接libthread_db.so和libthread_db.so.1。
  
  
4、使用gdbserver
   在目标板上运行gdbserver
   #./gdbserver 192.168.0.2:2345 hello
 
   其中192.168.0.2为目标板的IP，可以写localhost，也可以不写。2345为gdbserver打开的端口，可以自己设置。
   #./gdbserver :2345 hello
 
   在宿主机上运行
   #armv5-linux-uclibc-gdb hello
   (gdb)target remote 192.168.0.2:2345
   (gdb)b main
   (gdb)continue

   使用X-Windows下的DDD
   #ddd --debugger armv5-linux-uclibc-gdb

   在DDD的GDB终端控制窗口中健入:
   (gdb) target 192.168.0.2:2345

6、问题
   移植的gdbserver可以和Host上的mips-linux-gdb连接上，但是run的时候gdbserver出现
   Killing inferior错误
   解决方法：因为执行完target命令后，目标板程序已经在运行，所有应该用continue命令而不是run命令。

7、附1：GDB的基本指令：

   load：装入一个程序
   symbol-file：装入符号库文件，可以是用-g参数编译的可执行文件。
   f(ile)：指定一个可执行文件进行调试，gdb将读取些文件的调试讯息，如f a.exe
   l(ist)：列程序出源文件
   r(un) ：装载完要调试的可执行文件后，可以用run命令运行可执行文件
   b(reak)：设置断点（break point），如b 25，则在源程序的第25行设置一个断点，当程序执行到第25行时，就会产生中断；也可以使用b funcname，funcname为函数的名称，

当程序调用些函数时，则产生中断
   c(ontinue)：c命令可以另中断的程序继续执行，直到下一个中断点或程序结束
   p(rint)：输入某个变量的值，如程序定义了一个int aa的就是，p aa就会输出aa的当前值
   n(ext)：程序执行到断点时中断执行，可以用n指令进行单步执行
   s(tep)：程序执行到断点时中断执行，可以用s指令进行单步执行进某一函数
   q(uit)：退出GDB

8、附2：调试驱动程序和共享库

  (1)调试LKM(Loadable Kernel Module)
  .在目标板上插入模块并输出map信息，查看.text入口地址：
   #insmod -m hello.ko > map
   #grep .text map 
             比如为0xc68c0060
  .在gdb中转入LKM的调试信息：
   (gdb) add-symbol-file hello.ko 0xc68c0060  /*注意必须是LKM .text的入口地址）
  .正常调试

  (2)调试共享库
    .样例程序： 
    test.c:
    #include <stdio.h>
    int test(int a, int b)
    {
    int s = a b;
    printf("%d\n", s);
    return s;
    }

    main.c:
    #include <stdio.h>
    extern int test(int a, int b);
    int main(int argc, char* argv[])
    {
    int s = test(10, 20);
    return s;
    }

    Makefile:
    all: so main
    so:
    armv5-linux-uclibc-gcc -g test.c -shared -o libtest.so
    main:
    armv5-linux-uclibc-gcc -g main.c -L./ -ltest -o test.exe
    clean:
    rm -f *.exe *.so
   
    .编译并设置环境变量
 #make

        在目标板上：
 #export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./
 #gdbserver localhost:2345 ./test.exe

    .运行gdb客户端
 #armv5-linux-uclibc-gdb
 (gdb)symbol-file test.exe
 (gdb)target remote 192.168.0.2:2345
 (gdb)b main
 (gdb)c

    .查看libtest.so的代码在内存中的位置。
     (从gdbserver的输出或者用ps可以得到test.exe的进程ID，这里假设PID是11547)
     在目标板上：
      #cat /proc/11547/maps
 输出：

.........
 0076a000-0076c000 rwxp 0076a000 00:00 0
 00bbe000-00bbf000 r-xp 00bbe000 00:00 0
 00fcc000-00fcd000 r-xp 00000000 03:01 1238761 /root/test/gdbservertest/libtest.so
 00fcd000-00fce000 rwxp 00000000 03:01 1238761 /root/test/gdbservertest/libtest.so
 08048000-08049000 r-xp 00000000 03:01 1238765 /root/test/gdbservertest/test.exe
 08049000-0804a000 rw-p 00000000 03:01 1238765 /root/test/gdbservertest/test.exe
 ........
 
 由此可以知道：libtest.so的代码在00fcc000-00fcd000之间。

    .查看libtest.so的.text段在内存中的偏移位置：
        armv5-linux-uclibc-objdump -h libtest.so |grep .text
 输出：
   .text 00000130 00000450 00000450 00000450 2**4
        即偏移位置为0x00000450

    .回到板子上的gdb窗口，加载libtest.so的符号表。
 (gdb)add-symbol-file libtest.so 0x00fcc450
  (这里0x00fcc450 = 0x00fcc000 0x00000450)

    .在共享库的函数中设置断点
 (gdb)b test

    .继续调试共享库

S3C2410 + linux 2.4.x

Qtopia Core 4。2.2 是QT/embedded的最新版本，

下面是Qtopia Core 4移植过程：

        1. 下载交叉编译链ftp://ftp.handhelds.org/projects/toolchain/arm-linux-gcc-3.4.1.tar.bz2。不要用cross-2.95.3，Qtopia Core 4指明要3.2以上的版本。网上的教程大多就拿cross-2.95.3编译QT/embedded 2的...解压缩到/usr/local/arm目录下

tar xjvf linux-gcc-3.4.1.tar.bz2 -C /

设置交叉编译的环境变量：

export set PATH=/usr/local/arm/3.4.1/bin:$PATH

        2. 下载Qtopia Core 4的源代码qtopia-core-opensource-src-4.2.2.tar.gz，解压

tar zxvf qtopia-core-opensource-src-4.2.2.tar.gz

cd qtopia-core-opensource-src-4.2.2

./configure -embedded arm -xplatform qws/linux-arm-g++ -depths 4,8,12,16 -no-qt3support

注：详细了解参数./configure --help , 其中带*号选项为安装默认值，基中有-KBD等选项，方便嵌入式开发。

gmake VM上约一个半小时

gmake install (需root 权限)

设置Qt的环境变量：

export PATH=/usr/local/Trolltech/QtopiaCore-4.2.2-arm/bin:$PATH

注：环境变量通过/etc/profile可系统启动自动设置。

3.  编译Hello World，代码参考Qt的文档，保存未 hello.ccp 。

    qmake -project

    qmake

    make

得到相应ELF文件。

    4.  移植到目标平台：

A,建立运行库及环境设置。

注：程序运行相关库文件可利用LDD命令得到：ldd ./***** （X86平台可用lsof命令，朋友说的，TKS）

B,COPY 应用程序 TO ARM板。

经过几天的努力，这几天很累，熬夜和查找资料。总之，虽然是自学的嵌入式，可是效果还可以，费了很大劲。

爱你，又想说恨你。可是要想以后有一份不错的工作来养家糊口，只能坚持不懈的努力。正如我一个中兴的朋友说的好：人都会有目标，可是要坚持不懈的努力那就很难。

这几天一直在忙着QTOPIA4.2.1在2410上面的移植，平台的差异，编译器的问题，可是我最后万万没有想到，还是得到一个论坛大哥的帮助，还得以解决。问题出在make的前提是一定要是原来的源代码，不管你是make clean过，还是怎么讲都不行。至少我在red hat linux 9上面是这样的。

 教程是这样的：

一．硬件平台

1．主机： PC机，512M内存以上。

2．目标机： UP-NetARM2410-S实验平台。

二．移植软件资源

1．Red Hat Linux 9.0（主机操作系统）

2．gcc-3.4.1.tar.gz（主机编译器）

3．arm-linux-gcc-3.4.1.tar.bz2（交叉编译器）

4．tslib-1.3.tar.bz2（管理目标平台的触摸屏）

5．qtopia-opensource-src-4.2.1.tar.gz(包含Qt，Qtopia core)

2． GUI(QT)的移植过程

编译前的约定：

1）我的工作目录为：/mnt/nfs。

2）qtopia-opensource-src-4.2.1.tar.gz 软件包放在/mnt/nfs/qtopia4目录下。

一．编译主机编译器 gcc-3.4.1.tar.gz

步骤如下：

# tar –zxvf gcc-3.4.1.tar.gz

# ./configure    (默认安装目录为：/usr/local)

# make

# make install

安装完成后，可执行文件放在/usr/local/bin目录下，库文件放在/usr/local/lib目录下。

二．安装交叉编译器 arm-linux-gcc-3.4.1.tar.bz2

步骤如下：

# tar jxvf arm-linux-gcc-3.4.1.tar.bz2

解压后的文件为 usr目录,其已包括可执行文件，直接将usr拷贝到根目录下。然后

# vi /etc/profile

在里边添加：

export PATH=$PATH:/usr/local/arm/3.4.1/bin

保存退出，执行：

# source /etc/profile

三．编译tslib-1.3.tar.bz2

详细步骤如下：

# tar jxvf tslib-1.3.tar.bz2

解压后的目录为tslib-1.3。

# cd tslib-1.3

# export CC=arm-linux-gcc

# export CXX= arm-linux-g++

# ./autogen.sh

# ./configure --prefix=/mnt/nfs/tslib1.3-install --host=arm-linux

（ 配置目标平台为ARM-linux,在主机上的安装目录为/mnt/nfs/tslib1.3-install ）

# make

# make install
Qtopia4移植过程(二)2007-06-27 22:24四．编译 qtopia-opensource-src-4.2.1.tar.gz

编译前约定：

安装目录为：/mnt/nfs/qtopia4/qtopiatslibinstall

目标目录为：/mnt/nfs/qtopia4/qtopiatslibtarget

下面解压软件包：

# tar zxvf qtopia-opensource-src-4.2.1.tar.gz

然后重命名解压后的包：

# mv qtopia-opensource-4.2.1 qtopiatslibinstall

# cd qtopiatslibinstall

在此目录下，文件夹为qtopiacore的目录即是Qt，QtopiaCore所在目录，里边包含了开发所需的Designer,qmake,uic,moc等工具，也包含了面向嵌入式平台的Qt库。

编译前，首先建立定位到安装目录和目标目录的环境变量：

# export QTOPIAINST=/mnt/nfs/qtopia4/qtopiatslibinstall

# export QTOPIATARG=/mnt/nfs/qtopia4/qtopiatslibtarget

为了让编译适应于目标平台和去除编译中将出现的错误，我们需要对源码进行修改和裁减。因此，编译的详细过程如下：

1． 修改源码包

1）

# cd src/libraries/qtopiabase/

# cp custom-linux-cassiopeia-g++.h custom-linux-arm-g++.h

# cp custom-linux-cassiopeia-g++.cpp custom-linux-arm-g++.cpp

2）修改3.4.1版的arm编译器的文件

# cd /usr/local/arm/3.4.1/

# vi arm-linux/include/linux/videodev2.h

在其中添加如下内容：

#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B','A','8','1')

/*  8  BGBG.. GRGR.. */

保存退出。

# vi arm/3.4.1/arm-linux/sys_include/linux/videodev2.h

在其中添加如下内容：

#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B','A','8','1')

/*  8  BGBG.. GRGR.. */

保存退出。

3) 修改时区信息

# vi src/libraries/qtopia/qtimezone.cpp

将114行的 /usr/share/zoneinfo/ 改为/mnt/nfs/qtopia4/qtopiatslibtarget/zoneinfo/ ,保存退出。

# vi src/settings/systemtime/settime.cpp

将318行的 /usr/share/zoneinfo/ 改为/mnt/nfs/qtopia4/qtopiatslibtarget/zoneinfo/ ,保存退出。

4) 裁减Qtopia core的库

# vi qtopiacore/qconfig-qpe.h

首先注释掉关于鼠标光标的宏定义，让程序运行时，触摸屏中央有光标出现：

// Qtopia Core

/*

#ifndef QT_NO_QWS_CURSOR

#  define QT_NO_QWS_CURSOR

#endif

*/

/*

#ifndef QT_NO_QWS_MOUSE

#  define QT_NO_QWS_MOUSE

#endif

#ifndef QT_NO_QWS_MOUSE_AUTO

#  define QT_NO_QWS_MOUSE_AUTO

#endif

*/

其它宏定义根据需要进行注释。

保存后将qconfig-qpe.h拷贝到global目录。

# cp qtopiacore/qconfig-qpe.h qtopiacore/qt/src/corelib/

global/qconfig-qpe.h

5）注释掉其他文件里的QT_NO_QWS_CURSOR的定义

# vi qtopiacore/qt/src/corelib/global/qfeatures.h

注释掉如下内容：

/*

#if !defined(QT_NO_QWS_CURSOR) && (defined(QT_NO_CURSOR))

#define QT_NO_QWS_CURSOR

#endif

*/

保存退出。

# vi qtopiacore/qt/src/corelib/global/qglobal.h

注释掉以下内容：

//#    define QT_NO_QWS_CURSOR
Qtopia4移植过程(三)2007-06-27 22:252．配置源码包

首先，确定目录为： /mnt/nfs/qtopia4/qtopiatslibinstall

然后进行配置，执行如下命令 ：

# ./configure -silent -release

-image /mnt/nfs/qtopia4/qtopiatslibtarget

-prefix /mnt/nfs/qtopia4/qtopiatslibtarget

-xplatform linux-arm-g++ -arch arm -no-qvfb

-displaysize 640x480 -no-modem

-extra-qtopiacore-config "-release -xplatform qws/linux-arm-g++ -embedded arm -opengl -qconfig qpe -qt-sql-sqlite

-depths 4,8,16,32 -qt-kbd-usb -no-kbd-tty -no-mouse-linuxtp

-qt-mouse-tslib -I/mnt/nfs/tslib1.3-install/include -L/mnt/nfs/tslib1.3-install/lib" 2>../qtopiaconfgureERR.txt

主要配置选项解说如下：

-xplatform linux-arm-g++ -arch arm

目标平台为arm-linux,体系结构为arm。

-no-qvfb

目标平台已支持framebuffer,因而不使用虚拟帧缓冲。

-extra-qtopiacore-config

为Qtopia core 配置选项。

-xplatform qws/linux-arm-g++ -embedded arm

目标平台编译配置文件使用qtopiacore/qt/mkspecs/qws/linux-arm-g++目录下的配置文件，嵌入式平台为arm。

-qconfig qpe

使用配置文件qconfig-qpe.h，若使用qconfig-large.h配置文件，则使用-qconfig large选项。

-qt-sql-sqlite

数据库支持Sqlite。

-qt-kbd-usb

键盘支持usb协议。

-no-mouse-linuxtp -qt-mouse-tslib

-I/mnt/nfs/tslib1.3-install/include -L/mnt/nfs/tslib1.3-install/lib

触摸屏协议不支持linuxtp，支持tslib，并在后面添加上刚才编译的tslib的头文件和库。

2>../qtopiaconfgureERR.txt

最后将配置过程中的错误输出到qtopiaconfgureERR.txt文件中。

3．编译源码包

执行如下命令：

# make 2>../qtopiamakeERR.txt

4．安装编译后源码包

# make install

编译安装完成后，在/mnt/nfs/qtopia4/qtopiatslibtarget目录下产生各个目标文件。

5．建立时区信息

# cd $QTOPIATARG

# mkdir zoneinfo

# cp -a /usr/share/zoneinfo/* $QTOPIATARG/zoneinfo/

五．编译后的处理

完成上面的步骤后，所有软件包已编译完成。下面建立环境变量，进行后期处理，建立开发环境。

1）将designer,qmake 等工具拷贝到$QTOPIATARG/bin/目录下。

# cp $QTOPIAINST/qtopiacore/host/bin/* $QTOPIATARG/bin/

2）建立环境变量：

# vi /etc/profile

添加如下内容：

QTOPIA="/mnt/nfs/qtopia4/qtopiatslibtarget"

LD_LIBRARY_PATH="/usr/lib:/usr/local/lib:/usr/X11R6/lib"

LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$QTOPIA/lib"

PATH="$PATH:$QTOPIA/bin"

QMAKESPEC=/mnt/nfs/qtopia4/qtopiatslibinstall/qtopiacore/qt/mkspecs/qws/linux-arm-g++

export QTOPIA PATH LD_LIBRARY_PATH QMAKESPEC

保存退出。

#source /etc/profile

3）修改ts.conf

# cd /mnt/nfs/tslib1.3-install/etc

# vi ts.conf

原文件内容如下：

#module mousebuts

module variance xlimit=50 ylimit=50 pthreshold=3

module dejitter xdelta=1 ydelta=1 pthreshold=3

module linear

将第一行的“#”去掉，让触摸屏起作用。

到此为止，开发环境建立完毕。
 3 移植成果演示

在这里，我们以Qtopia自带的例子程序为例，来演示应用程序运行步骤。首先在/mnt/nfs/qtopia4/目录下用VI编辑器建立qtopiatslib.sh文件：

export TSLIB_TSEVENTTYPE=event0

export TSLIB_TSDEVICE=/dev/input/event0

export TSLIB_CONFFILE=/mnt/nfs/tslib1.3-install/etc/ts.conf

export TSLIB_CONSOLEDEVICE=none

export TSLIB_CALIBFILE=/mnt/yaffs/tmp/pointercal

export TSLIB_PLUGINDIR=/mnt/nfs/tslib1.3-install/share/ts/plugins

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/mnt/nfs

/tslib1.3-install/lib

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/mnt/nfs

/qtopia4/qtopiatslibtarget/lib

export QWS_SIZE=640x480

export QWS_MOUSE_PROTO="Tslib:/dev/input/event0"

export POINTERCAL_FILE=/mnt/yaffs/tmp/pointercal

insmod /mnt/yaffs/touchscreen/ts-uptech.o

cd /mnt/nfs/tslib1.3-install/bin

./ts_calibrate

cd /mnt/nfs/qtopia4/qtopiatslibtarget/bin

if [ -f "$TSLIB_CALIBFILE" ]; then

./qpe -qws

else

/mnt/nfs/tslib1.3-install/bin/ts_calibrate

./qpe -qws

fi

保存退出，修改用户使用权限：

# chmod 777 qtopiatslib.sh

然后启动目标平台，打开minicom终端,进入目标平台的系统。在主机上启动NFS服务，将主机的/mnt/nfs目录挂载到目标机的/mnt/nfs目录。

在终端里执行：

# ifconfig eth0 192.168.0.1

# mount -t nfs (主机IP地址):/mnt/nfs /mnt/nfs

# cd /mnt/yaffs

# mkdir tmp

# cd /mnt/nfs/qtopia4

# ./qtopiatslib.sh

执行qtopiatslib.sh文件，首先校准触摸屏,依次点击屏幕上出现的五个点，完成后，会在/mnt/yaffs/tmp目录下生成pointercal校准文件。接下来就会启动qpe应用程序，进入Qtopia Phone的界面。

在实验的过程中可能会出现下面的错误：

“在make的时候，遇到了一个错误。/usr/bin/ld .....debug-shared/moc.o提示could't read symbols :File in wrong format”

只要重新用新的源代码来做才能通过。

有时候嵌入式的问题真的很难说。总之，出现问题不要紧，能学到东西。努力吧，嵌入式的新人们。

cvIntegral 计算积分图像。

函数 cvSmooth 可使用上面任何一种方法平滑图像。每一种方法都有自己的特点以及局限。

没有缩放的图像平滑仅支持单通道图像，并且支持8位、16位、32位和32位浮点格式。

简单模糊和高斯模糊支持 1- 或 3-通道, 8-比特 和 32-比特 浮点图像。这两种方法可以（in-place）方式处理图像。

中值和双向滤波工作于 1- 或 3-通道， 8-位图像，但是不能以 in-place 方式处理图像.

cvSplit 函数分解图像到单个色彩通道上，然后单独处理。

函数 cvFilter2D 对图像进行线性滤波，支持 In-place 操作。当开孔部分位于图像外面时，函数从最近邻的图像内部象素差值得到边界外面的象素值。

cvIntegral 计算一次或高次积分图像：

sum(X,Y)=sumx<X,y<Yimage(x,y)sqsum(X,Y)=sumx<X,y<Yimage(x,y)2tilted_sum(X,Y)=sumy<Y,abs(x-X)<yimage(x,y)

利用积分图像，可以方便得到某个区域象素点的和、均值、标准方差或在 0（1） 的选择角度。例如：

sumx1<=x<x2,y1<=y<y2image(x,y)=sum(x2,y2)-sum(x1,y2)-sum(x2,y1)+sum(x1,x1)

因此可以在变化的窗口内做快速平滑或窗口相关。

cvCvtColor 将输入图像从一个色彩空间转换为另外一个色彩空间。函数忽略

IplImage

头中定义的

colorModel

和

channelSeq

域，所以输入图像的色彩空间应该正确指定 (包括通道的顺序，对RGB空间而言，BGR 意味着 24-位格式，其排列为 B0 G0 R0 B1 G1 R1 ... 层叠，而 RGB 意味着 24-位格式，其排列为 R0 G0 B0 R1 G1 B1 ... 层叠). 函数做如下变换：

• RGB 空间内部的变换，如增加/删除 alpha 通道，反相通道顺序，16位  RGB彩色变换(Rx5:Gx6:Rx5),以及灰度图像的变换，使用：

  RGB[A]->Gray: Y=0.212671*R + 0.715160*G + 0.072169*B + 0*AGray->RGB[A]: R=Y G=Y B=Y A=0

  所有可能的图像色彩空间的相互变换公式列举如下：

• RGB<=>XYZ (CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB):

  |X| |0.412411 0.357585 0.180454| |R||Y| = |0.212649 0.715169 0.072182|*|G||Z| |0.019332 0.119195 0.950390| |B||R| | 3.240479 -1.53715 -0.498535| |X||G| = |-0.969256 1.875991 0.041556|*|Y||B| | 0.055648 -0.204043 1.057311| |Z|

• RGB<=>YCrCb (CV_BGR2YCrCb, CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB)

  Y=0.299*R + 0.587*G + 0.114*BCr=(R-Y)*0.713 + 128Cb=(B-Y)*0.564 + 128R=Y + 1.403*(Cr - 128)G=Y - 0.344*(Cr - 128) - 0.714*(Cb - 128)B=Y + 1.773*(Cb - 128)

• RGB=>HSV (CV_BGR2HSV,CV_RGB2HSV)

  V=max(R,G,B)S=(V-min(R,G,B))*255/V if V!=0, 0 otherwise (G - B)*60/S, if V=RH= 180+(B - R)*60/S, if V=G 240+(R - G)*60/S, if V=Bif H<0 then H=H+360

  使用上面从 0° 到 360° 变化的公式计算色调（hue）值，确保它们被 2 除后能试用于8位。

• RGB=>Lab (CV_BGR2Lab, CV_RGB2Lab)

  |X| |0.433910 0.376220 0.189860| |R/255||Y| = |0.212649 0.715169 0.072182|*|G/255||Z| |0.017756 0.109478 0.872915| |B/255|L = 116*Y1/3 for Y>0.008856L = 903.3*Y for Y<=0.008856a = 500*(f(X)-f(Y))b = 200*(f(Y)-f(Z))where f(t)=t1/3 for t>0.008856 f(t)=7.787*t+16/116 for t<=0.008856上面的公式可以参考 http://www.cica.indiana.edu/cica/faq/color_spaces/color.spaces.html

• Bayer=>RGB (CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR,

  CV_BayerBG2RGB, CV_BayerRG2BGR, CV_BayerGB2RGB, CV_BayerGR2BGR,

  CV_BayerRG2RGB, CV_BayerBG2BGR, CV_BayerGR2RGB, CV_BayerGB2BGR)

  Bayer 模式被广泛应用于 CCD 和 CMOS 摄像头. 它允许从一个单独平面中得到彩色图像，该平面中的 R/G/B 象素点被安排如下：

  R	G	R	G	R
  G	B	G	B	G
  R	G	R	G	R
  G	B	G	B	G
  R	G	R	G	R
  G	B	G	B	G

  The output RGB components of a pixel are interpolated from 1, 2 or 4 neighbors of the pixel having the same color. There are several modifications of the above pattern that can be achieved by shifting the pattern one pixel left and/or one pixel up. The two letters C1 and C2 in the conversion constants CV_BayerC1C22{BGR|RGB} indicate the particular pattern type - these are components from the second row, second and third columns, respectively. For example, the above pattern has very popular "BG" type.

cvThreshold 对单通道数组应用固定阈值操作。典型的是对灰度图像进行阈值操作得到二值图像。(cvCmpS 也可以达到此目的) 或者是去掉噪声，例如过滤很小或很大象素值的图像点。有好几种对图像取阈值的方法，本函数支持的方法由

threshold_type 确定

:

threshold_type=CV_THRESH_BINARY:dst(x,y) = max_value, if src(x,y)>threshold 0, otherwisethreshold_type=CV_THRESH_BINARY_INV:dst(x,y) = 0, if src(x,y)>threshold max_value, otherwisethreshold_type=CV_THRESH_TRUNC:dst(x,y) = threshold, if src(x,y)>threshold src(x,y), otherwisethreshold_type=CV_THRESH_TOZERO:dst(x,y) = src(x,y), if (x,y)>threshold 0, otherwisethreshold_type=CV_THRESH_TOZERO_INV:dst(x,y) = 0, if src(x,y)>threshold src(x,y), otherwise

下面是图形化的阈值描述：

cvAdaptiveThreshold 将灰度图像变换到二值图像，采用下面公式：

threshold_type=

CV_THRESH_BINARY

:dst(x,y) = max_value, if src(x,y)>T(x,y) 0, otherwisethreshold_type=

CV_THRESH_BINARY_INV

:dst(x,y) = 0, if src(x,y)>T(x,y) max_value, otherwise

其中 TI 是为每一个象素点单独计算的阈值

对方法 CV_ADAPTIVE_THRESH_MEAN_C，它是 block_size × block_size 块中的象素点，被参数 param1 所减，得到的均值，

对方法 CV_ADAPTIVE_THRESH_GAUSSIAN_C 它是 block_size × block_size 块中的象素点，被参数 param1 所减，得到的加权和(gaussian)。

 NFS PCS/FAQ

1.0: About NFS

2.0: Debugging NFS
  2.1: share and exportfs
  2.2: showmount
  2.3: nfsstat
  2.4: rpcinfo
  2.5: etherfind and snoop
  2.6 Running a snoop of NFS requests:
  2.7 Lockd debug hints

3.0: Common How Tos
  3.1: Exporting Filesystems Under SunOS
  3.2: Exporting Filesystems Under Solaris
  3.3: Mounting Filesystems Under SunOS
  3.4: Mounting Filesystems Under Solaris
  3.5: Setting Up Secure NFS

4.0: Some Frequently Asked Questions
  4.1: Miscellaneous NFS Questions
  4.2: Problems Mounting Filesystems on a Client
  4.3: Common NFS Client Errors Including NFS Server Not Responding
  4.4: Problems Umounting Filesystems on a Client
  4.5: Interoperability Problems With Non-Sun Systems
  4.6: Common NFS Server Errors
  4.7: Common nfsd Error Message on NFS Servers
  4.8: Common rpc.mountd Error Messages on NFS Servers
  4.9: Common rpc.lockd & rpc.statd Error Messages
  4.10: NFS Related Shutdown Errors
  4.11: NFS Performance Tuning

5.0: Patches
  5.1: Core NFS Patches for SunOS
  5.2: Patches Related to NFS for SunOS
  5.3: Core NFS Patches for Solaris
  5.4: Patches Related to NFS for Solaris

 1.0: About NFS

This Tip Sheet documents a wide variety of information concerning NFS,
as implemented in the SunOS and Solaris operating systems. It is
intended as both an introduction to NFS and as a guide to the most
common problems. There are many more complete references to NFS, a few
of which are noted in section 7.4 and 7.5.

The following terms are important to an understanding of NFS:

The NFS SERVER is the machine that makes file systems available to
the network. It does so by either EXPORTING (SunOS term) or SHARING
(Solaris term) them.

The NFS CLIENT is the machine that accesses file systems that have
been made available. It does so by MOUNTING them.

A number of different daemons are involved with NFS:

RPC.MOUNTD only runs on NFS servers. It answers initial requests from
clients for file systems.

NFSD runs on NFS servers. They are the daemons that deal
with the majority of the client NFS requests.

On SunOS 4.1.X, BIODS (block I/O daemons) help clients with
their NFS requests.  These do not exist on Solaris 2.X.

LOCKD and STATD are a set of daemons that keep track of locks on NFS
files. There will typically be a set of daemons running on a client
and server.

NFS partitions can be mounted in one of two ways, hard or soft.

HARD MOUNTS are permanent mounts designed to look just like any
normal, local file system. If a partition that is hard mounted becomes
unavailable, client programs will keep trying to access it forever.
This will cause local processes to lock when a hard mounted disk goes
away. Hard mounts are the default type of mount.

SOFT MOUNTS will fail after a few retries if a remote partition
becomes unavailable. This is a problem if you are writing to the
partition, because you can never be sure that a write will actually
get processed  on the other hand, your local processes will not lock
up if that partition does go away. In general, soft mounts should only
be used if you are solely reading from a disk and even then it should
be understood that the mount is an unreliable one. If you soft mount a
partition that will be written to, you are nearly guaranteeing that
you will have problems.

There are a number of files related to NFS:

/etc/exports (SunOS) or /etc/dfs/dfstab (Solaris) lists which files to
export on a Server. These file are maintained by hand.

/etc/xtab (SunOS) or /etc/dfs/sharetab (Solaris) lists the filesystems
that actually are currently exported. They are maintained by exportfs
and share, respectively.

/etc/rmtab on a server lists filesystems that are remotely mounted by
clients. This file is maintained by rpc.mountd.

/etc/fstab (SunOS) or /etc/vfstab (Solaris) lists which files to mount
on a client. These files are maintained by hand.

/etc/mtab (SunOS) or /etc/mnttab (Solaris) on a client lists
filesystems which are currently mounted onto that client. The mount
and umount commands modify this file.

2.0 Debugging NFS

 General NFS Debugging Note

When NFS is not working or working intermittently, it can be very
difficult to track down what exactly is causing the problem. The
following tools are the best ones available to figure out what exactly
NFS is doing.

 2.1: share and exportfs

share (on Solaris) and exportfs (on SunOS) are good tools to use to
see exactly how a NFS server is exporting its filesystems. Simply log
on to the NFS server and run the command that is appropriate for the
OS.

  SunOS:
  # exportfs
  /usr -root=koeller
  /mnt
  /tmp

The above shows that /mnt and /tmp are exported normally. Since we see
neither rw or ro as options, this means that the default is being
used, which is rw to the world. In addition /usr gives root
permissions to the machine koeller.

  Solaris:
  # share
  -               /var   rw=engineering   ""
  -               /usr/sbin   rw=lab-manta.corp.sun.com   ""
  -               /usr/local   rw   ""

The above shows that /usr/local is exported normally, /var is exported
only to engineering (which happens to be a netgroup) and /usr/sbin is
exported only to lab-manta.corp.sun.com (which is a machine).

Note: netgroups are only supported if you are running NIS or NIS+.
Consult documentation on those products for how to set up netgroups on
your machines

 2.2: showmount

showmount, used with the -e option, can also show how a NFS server is
exporting its file systems. Its benefit is that it works over the
network, so you can see exactly what your NFS client is being offered.
However, showmount does not show all of the mount options and thus
you must sometimes use share or exportfs, as described in
section 2.1. When you do a test with showmount, do it from
the NFS client that is having problems:

  # showmount -e psi
  export list for psi:
  /var       engineering
  /usr/sbin  lab-manta.corp.sun.com
  /usr/local (everyone)

  # showmount -e crimson
  export list for crimson:
  /usr (everyone)
  /mnt (everyone)
  /tmp (everyone)

Note that showmount only displays: the partition and who can mount
it. We will not see any other options displayed. In the example above,
there are no restrictions on who can mount crimson's partitions and
so showmount lists (everyone).

  2.3: nfsstat

The nfsstat command gives diagnostics on what type of messages are
being sent via NFS. It can be run with either the -c option, to show
the stats of an NFS client, or the -s option, to show the stats of an
NFS server. When we run 'nfsstat -c' we see the following:

  # nfsstat -c

  Client rpc:
  calls      badcalls   retrans    badxids    timeouts   waits      newcreds
  45176      1          45         3          45         0          0
  badverfs   timers     toobig     nomem      cantsend   bufulocks
  0          80         0          0          0          0

  Client nfs:
  calls      badcalls   clgets     cltoomany
  44866      1          44866      0

  Version 2: (44866 calls)
  null       getattr    setattr    root       lookup     readlink   read
  0 0%%       7453 16%%   692 1%%     0 0%%       15225 33%%  55 0%%      13880
30%%
  wrcache    write      create     remove     rename     link       symlink
  0 0%%       5162 11%%   623 1%%     914 2%%     6 0%%       306 0%%     0 0%%
  mkdir      rmdir      readdir    statfs
  15 0%%      0 0%%       467 1%%     68 0%%

The rpc stats at the top are probably the most useful. High 'retrans'
and 'timeout' values can indicate performance or network issues. The
client nfs section can show you what types of NFS calls are taking up
the most time. This can be useful if you're trying to figure out what
is hogging your NFS. For the most part, the nfsstat command is most
useful when you are doing network and performance tuning. Section 7.4
and 7.5 list books that give some information on this  they are useful
to
make more sense of the nfsstat statistics.

 2.4: rpcinfo

You can test that you have a good, solid NFS connection to your NFS
server via the rpcinfo command. As explained in the man page, this
program provides information on various rpc daemons, such as nfsd,
rpc.mountd, rpc.statd and rpc.lockd. Its biggest use is to determine
that one of these daemons is responding on the NFS server. The
following examples all show the indicated daemons correctly
responding. If instead you get complaints about a service 'not
responding,' there might be a problem.

To see that nfsd is responding:

  # rpcinfo -T udp crimson nfs
  program 100003 version 2 ready and waiting

[crimson is the name of the remote machine that I am testing]

To see that mountd is responding:

  # rpcinfo -T udp crimson mountd
  program 100005 version 1 ready and waiting
  program 100005 version 2 ready and waiting

To see that lockd is responding:

  # rpcinfo -T udp crimson nlockmgr
  program 100021 version 1 ready and waiting
  rpcinfo: RPC: Procedure unavailable
  program 100021 version 2 is not available
  program 100021 version 3 ready and waiting

  # rpcinfo -T udp crimson llockmgr
  program 100020 version 2 ready and waiting

(the procedure unavailable error for the nlockmgr seems to be normal
for most systems)

If you run rpcinfo and determine that certain rpc services are not
responding, check those daemons on the master.

If none of the above works, you can verify that RPC services are
working at all on the server by running:

  # rpcinfo remote-machine-name

If this gives errors too, there is probably an issue with portmap
(SunOS) or rpcbind (Solaris).

[Note: the above rpcinfo commands will vary slightly under Solaris 2.5
or higher, as those OSes will offer NFS version 3, running over TCP,
rather than UDP.]

 2.5: etherfind and snoop

If all else fails and NFS still doesn't seem to be working right, the
last resort in debugging is to use a network sniffer program, such as
etherfind (SunOS) or snoop (Solaris). This can give you some
indication of whether remote machines are responding at all. Below is
an example of a totally normal NFS interaction, shown by snoop on
Solaris:

  # snoop psi and rainbow-16
  Using device /dev/le (promiscuous mode)
           psi -> rainbow-16   NFS C GETATTR FH=4141
    rainbow-16 -> psi          NFS R GETATTR OK
           psi -> rainbow-16   NFS C READDIR FH=4141 Cookie=2600
    rainbow-16 -> psi          NFS R READDIR OK 1 entries (No more)

These were the results when an 'ls' was run on 'psi' in a directory
that was mounted from 'rainbow-16'. The lines labelled 'C' are NFS
requests, while the lines labelled 'R' are NFS replies. Through snoop
you can easily see: NFS not being responding to (you would get lots of
'C' lines without 'R' replies to them) and also certain errors
(timeouts and retransmits particularly). The man page on snoop gives
some indication of how to make more in-depth use of the tool. In
general, it should only be used for very complex issues, where NFS is
behaving very oddly and even then you must be very good with NFS
to perceive unexpected behavior.  See the next section for
more tips on snoop.

 2.6  Running a snoop of NFS requests:

This is best done from a third, uninvolved machine.  If the
machine that you are trying to debug is on "systemA", then trace
the packets going to and from "systemA" as follows:

snoop -o /var/snoop.out systemA

Alternatively, snoop between systemA and clientB:

snoop -o /var/snoop.out systemA clientB

snoop will run in the window (do not put into background), with a counter
of the packets in the corner of the screen.  It will dump all the
packets into a raw snoop file.  When the "network event" occurs,
wait a couple of seconds and then kill the snoop job.  If the network
event includes error messages in /var/adm/messages, please send
us the /var/adm/messages and the raw snoop file (/var/snoop.out).

You can read the snoop file with snoop -i /var/snoop.out more.  There
are a variety of options in the snoop man page to increase verbosity,
and/or to look at specific packets.

Please note that if disk space becomes an issue, you must
take steps similar to those listed above.  A very large snoop file
can be created in two or three minutes, so snooping is best reserved
for easily reproduced events.

 2.7  Lockd debug hints

Please see section 4.9: Common rpc.lockd & rpc.statd Error Messages
for information regarding specific lockd and statd problems.

Generally you can pick out problem clients by snooping and/or
putting lockd into debug mode.  Sections 2.5 and 2.6 cover snoop.

How to put the Solaris 2.3 and 2.4 lockd into debug mode:
Edit the line in the /etc/init.d/nfs.client script that starts
up lockd to start it with -d3 and redirect stdout to a
filesystem with ALOT of disk space.

   /usr/lib/nfs/lockd -d3 > /var/lockd.debug.out

Note that lockd always creates an empty file in the pwd, called
logfile when it is running in debug mode.  Disregard this file.

If disk space becomes an issue from doing the lockd debug mode,
you will have to stop lockd and restart it.

If you turn the above command from a shell, make sure it is
a bourne or korn shell (sh or ksh).

How to put the Solaris 2.5 lockd into debug mode:

You will have to do this from a shell, preferably
a command tool window.  You must capture the debug output
that scrolls by into a script file:

  script /var/lockd.out
  /usr/lib/nfs/lockd -d3

After you are done debugging, CTRL/C the lockd job since it does
not fork and exec to the background.  Then exit or CTRL/D the
script job.  The debug output will be in /var/lockd.out.

Please note that Solaris 2.5 will also log more detailed debug output into
the /var/adm/messages file.  We will need that also.

How to run a truss of lockd (you rarely need to do this):

Just modify the start of lockd to be a truss of the lockd process.
You will need even more disk space to do this!

For Solaris 2.3 and 2.4:
truss  -o /var/truss.out -vall -f /usr/lib/nfs/lockd
-d3>/var/lockd.debug.out

For Solaris 2.5:
  script /var/lockd.out
  truss -o /var/truss.out -vall -f /usr/lib/nfs/lockd -d3

CTRL/C the script job (and exit from the script shell if on 2.5) after you
have reproduced the problem.

If disk space becomes an issue from doing the truss, use a cron job
to:
1.  stop running truss
2.  move "current" truss file to "old" truss file
3.  get PID of lockd
4.  truss -o /var/truss.out.current -vall -f -p PID (PID from step 3).

3.0 Common How-Tos

 3.1: Exporting Filesystems Under SunOS

In order to export a fs under SunOS, you must first edit the file
/etc/exports on your NFS server, adding a line for the new filesystem.
For example, the following /etc/exports file is for a server that
makes available the filesystems /usr, /var/spool/mail and /home:

  # cat /etc/exports
  /usr
  /var/spool/mail
  /home

You can add normal mount options to these lines, such as ro, rw and
root. These options are fully described in the exports man page. The
following example shows our /etc/exports file, but this time with the
filesystems all being exported read only:

  # cat /etc/exports
  /usr  -ro
  /var/spool/mail       -ro
  /home -ro

If your machine is already exporting filesystems and you are adding a
new one, simply run the exportfs command to make this new
filesystem available:

  # exportfs -a

If you have never exported filesystems from this machine before, you
should reboot it after editing the /etc/exports file. This will cause
rpc.mountd and nfsd to get started and will also automatically export
out the filesystems.

 3.2: Exporting Filesystems Under Solaris

You must edit the file /etc/dfs/dfstab in order to make files
automatically export on a Solaris system. The standard syntax of lines
in that file is:

  share -F nfs partition

For example, the following /etc/dfs/dfstab file is for a server that
makes available the filesystems /usr, /var/spool/mail and /home:

  share -F nfs /usr
  share -F nfs /var/spool/mail
  share -F nfs /home

You can add normal mount options to these lines, such as ro, rw and
root. this is done by proceeding the options with a -o flag. These
options are fully described in the share man page. The following
example shows our /etc/dfs/dfstab file, but this time with the
filesystems all being exported read only:

  share -F nfs -o ro /usr
  share -F nfs -o ro /var/spool/mail
  share -F nfs -o ro /home

If your machine is already exporting filesystems and you are adding a
new one, simply run the shareall command to make this new
filesystem available:

  # shareall

If you have never exported filesystems from this machine before, you
must run the nfs.server script:

  # /etc/init.d/nfs.server start

(The NFS Server will come up fine on the next boot, now that an
/etc/dfs/dfstab file exists)

 3.3: Mounting Filesystems Under SunOS

You can always mount file systems with the mount command, with the
following syntax:

  mount remotemachine:/remotepartition /localpartition

For example:

  mount bigserver:/usr/local /usr/local

You might also give the mount command any of the general mount options.
For example, to mount /usr/local read only, you would use the command:

  mount -o ro bigserver:/usr/local /usr/local

If you wish a filesystem to get mounted every time the machine is
booted, you must edit the /etc/fstab file. The syntax is:

  remotemach:/remotepart        /localpart      nfs     [options]       0 0

The options field is optional and can be left out if none are needed.
To make /usr/local mount automatically, you would add the following to
your /etc/fstab:

  bigserver:/usr/local  /usr/local      nfs     0 0

To make it mount read only, you could use:

  bigserver:/usr/local  /usr/local      nfs     ro      0 0

 3.4: Mounting Filesystems Under Solaris

Section 3.3, above, shows how to correctly use the mount command, to
interactively mount files. It works exactly the same under Solaris.

If you wish a filesystem to get mounted every time the machine is
booted, you must edit the /etc/vfstab file. The syntax is:

  remotemach:/remotepart - localpart nfs - yes [options]

For example, to mount the /usr/local partition, you would enter:

  bigserver:/usr/local - /usr/local nfs - yes -

To mount it read-only, you would enter:

  bigserver:/usr/local - /usr/local nfs - yes ro

Consult the vfstab man page if you're interested in knowing what the
fields that contain "-"s and "yes" are for. For the most part,
they're
only relevant for non-NFS mounts.

 3.5: Setting Up Secure NFS

NFS has built-in private-key encryption routines that can
provide added security. To use this functionality, a
partition must be both exported with the "secure" option and mounted
with the "secure" option. In addition, either NIS or NIS+ must be
available. Secure NFS will not work without one of these naming
services.

To add the -secure option to the /secret/top partition on a SunOS
machine, the following exports entry would be needed on the server:

  /secret/top   -secure

In addition, the following fstab entry would be needed on the client:

  server:/secret/top    /secret/top     nfs     rw,secure       0 0

(Solaris machines would have to have the -secure option similarly
added.)

If you are running NIS+, you will not need to do anything further to
access the partition, since NIS+ users and NIS+ hosts will already have
credentials created for them.

If you are running NIS, you must create credentials for all users and
hosts that might want to access the secure partition.

Root can add credentials for users with the following command:

  # newkey -u username

Users can create their own credentials with the following command:

  $ chkey

The passwd supplied to these programs should be the same as the user's
passwd.

Root can add credentials for hosts with the following command:

  # newkey -h machinename

The passwd supplied to newkey in this case should be the same as the
machine's root passwd.

It is important to note that rpc.yppasswd must be running on your NIS
server for these commands to work. In addition, push out
publickey maps afterwards to make sure that the most up-to-date
credential information is available.

Once this is all done, secure NFS should work on your NIS network,
with two caveats: First, keyserv must be running on your client
machines. If this is not the case, adjust your rc files, so that it
automatically starts up. Second, if a user does not supply a passwd
when logging in (due to a .rhosts or /etc/hosts.equiv for example) or
if his secure key is different than his passwd, then he will need to
execute the command 'keylogin' before he can access the secure NFS
partition.

4.0 Frequently Asked Questions

 4.1: Miscellaneous NFS Questions

Q: What version of NFS does Sun implement?

A: All of the currently supported revisions of SunOS and Solaris
support NFS version 2, over UDP. In addition, Solaris 2.5 will support
NFS version 3, over TCP. Although NFS version 3 is the default
for Solaris 2.5 and up, the NFS will fall back to version 2 if other
machines do not have version 3 capability.

Q: What do these NFS Error Codes mean (e.g. NFS write error 49)?

A: On SunOS, you can find a list of error codes in the intro(2) man
page:

  # man 2 intro

On Solaris, you can consult the /usr/include/sys/errno.h file. SRDB
#10946, available through SunSolve also lists some of the NFS error
codes.

Q: Why isn't my netgroup entry working?

A1: There are lots of factors related to netgroup. First, you must be
using either NIS or NIS+, to propagate the netgroup. Second, netgroup
will only work as ro or rw arguments and even then only when the ro
or rw is not being used to override another ro or rw option. Netgroups
can not be used as an argument to the root option.

A2: NFS requires that the "reverse lookup" capability work such that
the hostname returned by looking up the IP address (gethostbyaddr)
matches EXACTLY the text specified in the netgroup entry.
Otherwise the NFS mount will fail with "access denied"

For example, if the NFS server has the following NIS netgroup entry:

goodhosts   (clienta,,) (clientb,,) (blahblah,,)

clienta is at 192.1.1.1 and the Server uses DNS for hostname lookups.

The NFS request to do the mount arrives from IP address 192.1.1.1
The NFS server looks up the IP address of 192.1.1.1 to get the hostname
associated with that IP address.

The gethostbyaddr MUST return "clienta".  If it does not, the NFS
request will fail with "access denied".  telnet from the NFS client
to the NFS server and run "who am i".  The hostname in parentheses
is the name that should be in the netgroup:

hackley    pts/13       Jan 24 09:21    (mercedes)

The most common cause of this failure is failure of a DNS administrator
to properly manage the "reverse lookup maps" e.g. 192.1.1.IN-ADDR.ARPA.

Q:  What can you tell me about CacheFS?

A:  CacheFS is the "cache file system".  It allows a Solaris 2.X NFS
client
to cache a remote file system to improve performance.  For example,
CacheFS allows you to be on "clienta" and cache your home directory,
which
is mounted via NFS from an NFS server.

Because most often CacheFS is used in conjunction with the automounter,
we have some basic information on CacheFS in our automounter tips sheet
(Product Support Document).  You can read more about CacheFS in the
"NFS Administration Guide" and in the "mount_cachefs" man page.

Q:  Is there a showfh for Solaris to show the NFS File Handle?

A:  Yes here it is:

#!/bin/sh
#
# fhfind: takes the expanded filehandle string from an
# NFS write error or stale filehandle message and maps
# it to a pathname on the server.
#
# The device id in the filehandle is used to locate the
# filesystem mountpoint.  This is then used as the starting
# point for a find for the file with the inode number
# extracted from the filehandle.
#
# If the filesystem is big - the find can take a long time.
# Since there's no way to terminate the find upon finding
# the file, you might need to kill fhfind after it prints
# the path.
#

if [ $# -ne 8 ]  then
        echo
        echo "Usage: fhfind <filehandle> e.g."
        echo
        echo "  fhfind 1540002 2 a0000 4df07 48df4455 a0000 2 25d1121d"
        exit 1
fi

# Filesystem ID

FSID1=$1
FSID2=$2

# FID for the file

FFID1=$3
FFID2=`echo $4   tr [a-z] [A-Z]` # uppercase for bc
FFID3=$5

# FID for the export point (not used)

EFID1=$6
EFID2=$7
EFID3=$8

# Use the device id to find the /etc/mnttab
# entry and thus the mountpoint for the filesystem.

E=`grep $FSID1 /etc/mnttab`
if [ "$E" = "" ]   then
        echo
        echo "Cannot find filesystem for devid $FSID1"
        exit 0
fi

set - $E
MNTPNT=$2

INUM=`echo "ibase=16 $FFID2"   bc` # hex to decimal for find

echo
echo "Now searching $MNTPNT for inode number $INUM"
echo

find $MNTPNT -mount -inum $INUM -print 2>/dev/null

 4.2: Problems Mounting Filesystems on a Client

Q: Why do I get "permission denied" or "access denied" when I
try to
mount a remote filesystem?

A1: Your remote NFS server is not exporting or sharing its file systems.
You can verify this by running the showmount command as follows:

  # showmount -e servername

That will provide you with a list of all the file systems that are
being sent out. If a file system is not being exported, you should
consult section 3.1 or 3.2, as applicable.

A2: Your remote NFS server is exporting file systems, but only to a
limited number of client machines, which does not include you. To
verify this, again use the command showmount:

  # showmount -e psi
  /var       engineering
  /usr/sbin  lab-manta.corp.sun.com
  /usr/local (everyone)

In this example, /usr/local is being exported to everyone, /var is
being exported to the engineering group, and /usr/sbin is only being
exported to the machine lab-manta.corp.sun.com. So, I might get the
denial message if I tried to mount /var from a machine not in the
engineering netgroup or if I tried to mount /usr/sbin from anything
but lab-manta.corp.sun.com.

A3: Your machine is given explicit permission to mount the partition,
but the server does not list your correct machine name. In the example
above, psi is exporting to "lab-manta.corp.sun.com", but the machine
might actually identify itself as "lab-manta" without the suffix. Or,
alternatively, a machine might be exporting to "machine-le0" while the
mount request actually comes from "machine-le1". You can test this by
first running "showmount -e" and then physically logging in to the
server, from the client that cannot mount, and then typing "who". This
will show you if the two names do not match. For example, I am on
lab-manta, trying to mount /usr/sbin from psi:

  lab-manta# mount psi:/usr/sbin /test
  mount: access denied for psi:/usr/sbin

I use showmount -e to verify that I am being exported to:

  lab-manta# showmount -e psi
  export list for psi:
  /usr/sbin  lab-manta.corp.sun.com

I then login to psi, from lab-manta, and execute who:

  lab-manta%% rsh psi
  ...
  psi# who
  root       pts/6        Sep  8 14:02    (lab-manta)

As can be seen, the names "lab-manta" and
"lab-manta.corp.sun.com" do
not match. The entry shown by who, lab-manta, is what should appear in
my export file. When I change it and re-export, I can verify it with
showmount and then see that mounts do work:

  lab-manta[23] showmount -e psi
  export list for psi:
  /usr/sbin  lab-manta
  lab-manta[24] mount psi:/usr/sbin /test
  lab-manta[25]

A4: Your client is a member of a netgroup, but it seems that the netgroup
does not work.  See Section 4.1 for notes on debugging netgroups.

Q: Why do I get the following error when I try and mount a remote file
system:

  nfs mount: remote-machine:: RPC: Program not registered
  nfs mount: retrying: /local-partition

A: rpc.mountd is not running on the server. You probably just exported
the first filesystem from a machine that has never done NFS serving
before. Reboot the NFS server, if it is SunOS 4.X,.  The
NFS server is running Solaris 2.X, run the following:

/etc/init.d/nfs.server start

Note: Consult section 3.1 or 3.2 for information on how to create
the exports file on a SunOS 4.X system or on how to create the dfstab
file on a Solaris 2.X system.

Q: Why doesn't the mountd respond?  After I try the mount I get NFS SERVER
NOT RESPONDING.  When I try to talk to the mountd, rpcinfo gives an rpc
timed out error.  How can I debug or fix a hung mountd on the NFS server.

A: First, try killing the mountd process on the server and restarting it.
This gets around many hung mountd issues.

Second, make sure the NFS server is "patched up".  There is a mountd
patch
for Solaris 2.3 and we've seen cases where the \patch 101973 patch helps
on 2.4.

Further troubleshooting tips to debug the hung mountd on Solaris 2.X:
1.  get the PID of the running mountd
2.  truss -f -vall -p PID
3.  start a snoop at the same time you start the truss
4.  if you have access to it, run "gcore" or "pstack"
(unsupported utilities
    made available by SunService) to get the stack trace of the mountd PID.
    Update:  pstack is supported at 2.5, /usr/proc/bin/pstack .  It is
             on of the new "proc" tools.

Q:  Why do I get the message "Device Busy" in response to my mount
command?

A:  You get this message because some process is using the underlying mount
    point.  For example, if you had a shell whose pwd was /mnt and you
    tried to mount something into /mnt, e.g. mount server:/export/test /mnt
    you would see this error.
    To work around this, find the process using the directory and either kill
    it or move its pwd someplace else.  The "fuser" command is
extremely handy
    to do this:
    mercedes[hackley]:cd /mnt
    mercedes[hackley]:fuser -u /mnt
    /mnt:     4368c(hackley)     368c(hackley)

    In this case you see process # 368 and 4368 are using the /mnt mount point.
    PID 368  is the shell and PID 4368 was the fuser command.

    You can forcibly kill any process (must be root) from a mount point
    using fuser -k /mnt.

    Please note that fuser is not infallible and cannot identify kernel
    threads using a mount point (as sometimes happens with the automounter).

 4.3: Common NFS Client Errors Including NFS Server Not Responding

If a file system has been successfully mounted, you can encounter the
following errors when accessing it.

Q: Why do I get the following error message:

  Stale NFS file handle

A1: This means that a file or directory that your client has open has
been removed or replaced on the server. It happens most often when a
dramatic change is made to the file system on the server, for example
if it was moved to a new disk or totally erased and restored. The
client should be rebooted to clear Stale NFS file handles.

A2: If you prefer not to reboot the machine, you can create a new
mount point on the client for the mount point with the Stale NFS file
handle.

Q: Why do I get the following error message:

  NFS Server <server> not responding
  NFS Server ok

  Note, this error will occur when using HARD mounts.
  This troubleshooting section applies to HARD or SOFT mounts.

A1: If this problem is happening intermittently, while some NFS
traffic is occurring, though slowly, you have run into the performance
limitations of either your current network setup or your current NFS
server. This issue is beyond the scope of what SunService can support.
Consult sections 7.4 & 7.5 for some excellent references that can help you
tune NFS performance. Section 9.0 can point you to where you can get
additional support on this issue from Sun.

A2: If the problem lasts for an extended period of time, during which
no NFS traffic at all is going through, it is possible that your NFS
server is no longer available.

You can verify that the server is still responding by running the commands:

  # ping server
and
  # ping -s server 8000 10
(this will send 10 8k ICMP Echo request packets to the server)

If your machine is not available by ping, you will want to check the
server machine's health, your network connections and your routing.

If the ping works, check to see that the NFS server's nfsd and
mountd are responding with the "rpcinfo" command:

   # rpcinfo -u server nfs

program 100003 version 2 ready and waiting

   # rpcinfo -u server mountd

program 100005 version 1 ready and waiting
program 100005 version 2 ready and waiting

If there is no response, go to the NFS server and find out why
the nfsd and/or /mountd are not working over the network.  From
the server, run the same commands.  If they work OK from the
server, the network is the culprit.  If they do NOT work,
check to see if they are running.  If not, restart them and
repeat this process.  If either nfsd or mountd IS running but
does not respond, then kill it and restart it and retest.

A3: Some older bugs might have caused this symptom. Make sure that you
have the most up-to-date Core NFS patches on the NFS server.
These are listed in Section 5.0 below. In addition, if you are running
quad ethernet cards on Solaris, install the special quad
ethernet patches listed in Section 5.4.

A4:  Try cutting down the NFS read and write size with the NFS mount
options:  rsize=1024,wsize=1024.  This will eliminate problems with
packet fragmentation across WANS, routers, hubs, and switches in a
multivendor environment, until the root cause can be pin-pointed.
THIS IS THE MOST COMMON RESOLUTION TO THIS PROBLEM.

A5: If the NFS server is  Solaris 2.3 and 2.4, 'nfsreadmap' occasionally
caused the "NFS server not responding" message on Sun and non-Sun
NFS clients.  You can resolve this by adding the following entry to
your /etc/system file on the NFS server:

set nfs:nfsreadmap=0

And rebooting the machine.  The nfsreadmap function was removed in 2.5
because it really didn't work.

A6: If you are using FDDI on Solaris, you must enable fragmentation
with the command:
ndd -set /dev/ip ip_path_mtu_discovery 0

Add this to /etc/init.d/inetinit, after the other ndd command on line 18.

A7:  Another possible cause is IF the NFS SERVER is Ultrix, old AIX,
Stratus, and older SGI and you ONLY get this error on Solaris 2.4 and 2.5
clients, but the 2.3 and 4.X clients are OK.

The NFS Version 2 and 3 protocol allow for the NFS READDIR request to be
1048 bytes in length.  Some older implementations incorrect thought the
request had a max length of 1024.  To work around this, either mount
those problem servers with rsize=1024,wsize=1024 or add the following
to the NFS client's /etc/system file and reboot:

set nfs:nfs_shrinkreaddir=1

A8:  Oftentimes NFS SERVER NOT RESPONDING is an indication of another problem
on the NFS server, particularly on the disk subsystem.  If you have a
SPARCStorage Array, you must verify that you have the most recent
firmware and patches due to the volatility of that product.

Another general method that can be tried to is look at the output
from iostat -xtc 5 and check the svt_t field.  If this value goes
over 50.0 (50 msec) for a disk that is being used to serve NFS requests,
you might have found your bottleneck.  Consult the references in
Section 7 of this PSD for other possible NFS Server tuning hints.

NOTE:  NFS Server performance tuning services are only available
on a Time and Materials basis.

Q: Why can't I write to a NFS mounted file system as root?

A: Due to security concerns, the root user is given "nobody"
permissions when it tries to read from or write to a NFS file system.
This means that root has less access than any user, will only be
able to read from things with world read permissions, and will only be
able to write to things with world write permissions.

If you would like your machine to have normal root permissions to a
filesystem, the filesystem must be exported with the option
"root=clientmachine".

An alternative is to export the filesystem with the "anon=0" option.
This will allow everyone to mount the partition with full root
permissions.

Sections 3.1 and 3.2 show how to include options when exporting
filesystems.

Q1: Why do 'ls'es of NFS mounted directories sometimes get mangled on
    my SunOS machine?
Q2: Why do I get errors when looking at a NFS file on my SunOS
    machine?

A: By default, SunOS does not have UDP checksums enabled. This can
cause problems if NFS is being done over an extended distance,
especially if it is going across multiple routers. If you are seeing
very strange errors on NFS or are getting corruption of directories
when you view them, try turning UDP checksums on.

You can do so my editing the kernel file /usr/sys/netinet/in_proto.c,
changing the following:

  int  udp_cksum = 0            /* turn on to check & generate udp
checksums */

to:

  int  udp_cksum = 1            /* turn on to check & generate udp
checksums */

Afterwards, you will must build a new kernel, install it and
reboot. UDP checksums must be enabled on both the NFS client and NFS
server for it to have any effect.

This is only an issue on SunOS machines, as Solaris machines have UDP
checksums enabled by default.

Q1: Why do I get intermittent errors writing to an NFS partition?
Q2: Why do I get intermittent errors reading from an NFS partition?
Q3: Why do I get the following error on my NFS partition?

  "nfs read error on <machine> rpc: timed out"

A: These symptoms can all be caused by failures of soft mounts.
Soft mounts time out instead of logging an "NFS SERVER NOT RESPONDING"
message.  Because of this and other reasons, it is recommended that
you only mount non-critical read-only servers with soft mounts (e.g.
man pages).

To resolve the problem, you must solve the underlying problem
(See the section above on "NFS server not responding" for
troubleshooting
assistance.  Alternatively, you can mount the NFS server with hard,intr
instead of soft, but this will have the effect of causing applications
to hang instead of timeout when the NFS servers are unavailable or
unreachable.

 4.4: Problems Umounting Filesystems on a Client

Q: When I try and umount a partition, why do I get the following
error:

  /partition: Device busy

A: This means that someone is actively using the partition you are
trying to unmount. They might be running a program from it or they
might simply be sitting in a subdirectory of the partition.

In Solaris, you can run the command fuser to determine what processes
are using a partition:

  # fuser /test
  /test:     1997c    1985c

The above example shows that pids 1985 and 1997 are accessing the
/test partition. Either kill the processes or run fuser -k /test to
have fuser do this for you.

NOTES:  This functionality is not available under SunOS.  It does
not always identify an automounted process on Solaris.

In many cases, it is necessary to reboot a machine in order to clear
out all of the processes that could be making a file system busy.

 4.5: Interoperability Problems With Non-Sun Systems

The following problems are relevant to Suns that are doing mounts
from non-Sun systems.

Q: Why do I get the following error when mounting from my HP or SunOS
3.5 machine or other machine running an older version of NFS:

  nfsmount server/filesystem server not responding RPC authentication error 
why = invalid client credential.

A: Older versions of NFS only allowed users to be in eight groups or
less. Reduce root's number of groups to eight or less and the problem
will go away. Users planning to access this partition should also
reduce their number of groups to eight.

Q: When I NFS mount filesystems to my Sun, from my PC, why does the
Sun never see changes I make to those filesystems.

A: Most PC NFS servers do not seem to correctly notify their NFS
clients of changes made to their filesystems. It appears that this is
due to the fact that file timestamps on PCs are very coarse. If you
are having this problem, speak with the vendor of your PC
NFS product.

Q: Why do mounts from my SGI fail with "not a directory" ?

A: For some reason, certain versions of the SGI NFS server sometimes
begin using port 860 rather than 2049 for NFS. When this occurs,
mounts will fail. In order to get around this bug, always use the
"port" option, with 2049 as a value, when doing mounts from an SGI,
e.g.:

  mount -o port=2049 sgi:/partition /localpartition

If you are mounting from an SGI via autofs, be sure you have the
newest version of the kernel patch (101318-74 or better for 5.3,
101945-32 or better for 5.4), as older versions of the kernel patch
did not support the port option for autofs.

Q: Why can't I NFS mount from my old, old machine?

A: If you have a very old machine, it is probably running NFS version
1. Such machines often have problems talking to newer versions of NFS.
If you have a very old machine, speak with the manufacturer
to see if they've ported NFS version 2 or 3.

 4.6: Common NFS Server Errors

Q: Why do I get the following error when I run exportfs/shareall?

  exportfs: /var/opt: parent-directory (/var) already exported
  share_nfs: /var/opt: parent-directory (/var) already shared

A: NFS specs forbid you from exporting both a parent directory and a
sub-directory. If you try and export a sub-directory when the parent
directory is already exported, you will get the above error. The above
example showed an export of the subdirectory /var/opt being attempted,
after the directory /var was already available.

A very similar error will occur in the opposite case:

  exportfs: /var: sub-directory (/var/spool/mail) already exported

This shows the directory /var being exported after /var/spool/mail was
already available.

If you want to have both a parent directory and its sub-directory
exported, you must export just the parent directory. Among other
things, this means that you can not have different options on parent
and sub-directories, for example -ro on a parent directory and -rw on
a specific subdirectory.

Q: Why is my NFS server getting totally overrun by quota errors?

A: Solaris 2.4 experienced an error relating to way that quotas and
NFS interacted.  Obtain 101945-34 or later, if quota message from NFS
partitions are having a serious impact on your machine.

If you are running into this problem where your client is Solaris and
your server is SunOS, you will not have this option and it is
recommended that you simply upgrade your SunOS system.

Q: Why does the /etc/rmtab file get huge?

A: The rmtab contains the list of all the file systems currently being
mounted by remote machines. When a filesystem is unmounted by a remote
machine, the line in the rmtab is just commented out, not deleted.
This can make the rmtab file get very large, maybe even filling the
root partition.

If this is a problem at your site, add the following lines
to your rc, prior to the starting of the rpc.mountd:

  if [ -f /etc/rmtab ]   then
    sed -e "/^#/d" /etc/rmtab > /tmp/rmtab 2>/dev/null
    mv /tmp/rmtab /etc/rmtab >/dev/null 2>&1
  fi

This will cause the rmtab file to be trimmed every time the system boots.

 4.7: Common nfsd Error Message on NFS Servers

Q: Why do I get the following error message when nfsd starts?

  /usr/lib/nfs/nfsd[247]: netdir_getbyname (transport udp,
       host/serv \1/nfs), Bad file number

A: This problem is usually the result of an nfsd line not being in
your services map. Consult your naming service (files, nis, nis+) and
insert the following entry, if it is missing:

  nfsd            2049/udp        nfs             # NFS server daemon

...and at 2.5, you must also have:
  nfsd          2049/tcp        nfs

Q: Why do I get the following error message when nfsd starts?

/usr/lib/nfs/nfsd[2943]: t_bind to wrong address
/usr/lib/nfs/nfsd[2943]: Cannot establish NFS service over /dev/udp:  
transport setup problem.
/usr/lib/nfs/nfsd[2943]: t_bind to wrong address
/usr/lib/nfs/nfsd[2943]: Cannot establish NFS service over /dev/tcp:  
transport setup problem.
/usr/lib/nfs/nfsd[2943]: Could not start NFS service for any protocol. Exiting.

A: This problem is caused by trying to start a second nfsd when one is
already running.

 4.8: Common rpc.mountd Error Messages on NFS Servers

Q: Why do I constantly get the following error message on my NFS
server:

  Aug 15 13:13:56 servername mountd[930]: couldn't register TCP MOUNTPROG
  Aug 15 13:13:58 servername inetd[141]: mountd/rpc/udp server failing

A: This problem occurs most often on SunOS machines. It typically
means that you are starting rpc.mountd from the rc.local, but also
have a line in your inetd.conf:

  mountd/1       dgram   rpc/udp wait root /usr/etc/rpc.mountd   rpc.mountd

You can resolve this problem by commenting out the mountd line in the
/etc/inetd.conf file and then killing and restarting your inetd.

 4.9: Common rpc.lockd & rpc.statd Error Messages

Q: What does it mean when I get the following error:

  lock manager: rpc error (#): RPC: Program/version mismatch

A: Some of your systems are running up-to-date versions of lockd,
while others are outdated. Install the most up-to-date
lockd patch on all of your systems. See section 5.0 below for a list
of lockd patches.

Q: What does it mean when I get the following error:

  rpc.statd: cannot talk to statd on [machine]

A: Either, [machine] is down or it is no longer doing NFS services.
It's possible that the machine might still be around, but has changed its
name or something similar. If these changes are going to be
permanent, clear out the statmon directories on your
machine. Do this by rebooting the machine into single user mode and
running the following command:

  SunOS:
  rm /etc/sm/* /etc/sm.bak/*

  Solaris:
  rm /var/statmon/sm/* /var/statmon/sm.bak/*

Afterwards, execute reboot to bring your machine back up.

Alternatively, if you cannot put the system into single user mode,
- Kill the statd and lockd process
- clear out the "sm" and "sm.bak" directories"
- Restart statd and lockd in that order

Q: How can I fix these errors?  The SunOS 4.1.X lockd reports:

  lockd[136]: fcntl: error Stale NFS file handle
  lockd[136]: lockd: unable to do cnvt.

the lockd error message is different on Solaris 2.3 and 2.4:

  lockd: unable to do cnvt.
  _nfssys: error Stale NFS file handle

 Generally, this is caused by an error from a client.  The client
 has submitted a request for a lock on a stale file handle.  Sometimes,
 older or unpatched lockd clients will continually resubmit these
 requests.  See the "lockd debug hint" Section for help in
 identifying the client making the request.  See section 5.0 for info
 on the NFS and lockd patches.  If the client is a non-Sun,
 contact the client system vendor for their latest lockd patch.

Q: How can I fix the following errors:
     nlm1_reply: RPC unknown host
     create_client: no name for inet address 0x90EE4A14.
We also see
     nlm1_call: RPC: Program not registered
     create_client: no name for inet address 0x90EE4A14.

A: There are THREE items to check in order.

1.  This first answer applies if the hexadecimal address 0x90EE4A14
    corresponds to an IP address in use on your network and it not
    in your hosts database (/etc/hosts, NIS, NIS+ or DNS as appropriate).

    In this case, to 144.238.74.20.
    The customer does not have that host ID in his NIS+ hosts table.
    The customer can find out the host name for that IP address by using
    telnet to connect to the IP address, then getting the hostname.
    The customer then adds the entry to the NIS+ hosts table.

    Then verify that gethostbyaddr() was working with the new
    IP/hostname in NIS+ with:
      ping -s 144.238.74.20
    The responses interpret the IP address into the hostname.

2.  If you do the above and the messages continue, kill and
    restart the lockd as it appears lockd caches name service
    information.

3.  Patch levels:

Solaris 2.4:
101945-34 or better kernel jumbo patch
101977-04 or better lockd jumbo patch
102216-05 or better klm kernel locking patch (See note below)

Note:
Patch 102216-05 contains a fix for a bug that can cause this error message:
1164679 KLM doesn't initialize rsys & rpid correctly

Solaris 2.3:
101318-75 or better kernel jumbo patch

Q:  Why do I get the following error message on Solaris?

lockd[2269]:netdir_getbyname (transport udp, host/serv
\1/lockd), Resource temporarily unavailable
lockd[2269]: Cannot establish LM service over /dev/udp:
bind problem. Exiting.

A:  This is caused by missing entries for lockd in /etc/services,
the NIS services map, or the NIS+ services table.
Verify this with:
getent services lockd

If you don't get the lockd entries, add the following
entry to the appropriate services database if it does not exist:
lockd           4045/udp
lockd           4045/tcp

Check your /etc/nsswitch.conf file's services entry to determine
which services database you are using.

Q:  Why do I get the following error message on Solaris?

lockd[2947]: t_bind to wrong address
lockd[2947]: Cannot establish LM service over /dev/udp: bind problem. Exiting.

A:  This is caused by trying to start lockd when it is already running.
If you see this message at bootup, you must inspect your startup
scripts in /etc/rc2.d and /etc/rc3.d to determine the cause.

 4.10: NFS Related Shutdown Errors

Q: Why do I get the following error, when running 'shutdown' on my
Solaris machine:

  "showmount: machine: RPC:program not registered"

A: This is due to a bug in the /usr/sbin/shutdown command. shutdown
executes the showmount command as part of its scheme to warn other
machines that it will not be available. If the machine you executed
shutdown on is not a nfs server, shutdown will complain with the above
message. This will cause no impact to your machine, but if it annoys
you, you can run the older /usr/ucb/ shutdown program:

  # /usr/ucb/shutdown

Q: Why do I get the following error, when running 'shutdown' on my
Solaris machine:

  "nfs mount:machine(vold(PID###):server not responding:RPC not
registered"

A: This is due to a bug in vold, which causes it to be shutdown too
late. This will cause no impact to your machine, but if it annoys you,
you can stop vold before executing shutdown:

  # /etc/init.d/volmgt stop
  # shutdown

 4.11  NFS Performance Tuning

Q: How do I determine how many nfsds to run on a SunOS 4.1.X or on a
   Solaris 2.X system?

A:  It is difficult to provide NFS tuning in short a technical note,
but here are some general guidelines.  For more specific guidelines,
consult the O'Reilly and Associates book "Managing NFS and NIS",
the SunSoft Press book, "Sun Performance and Tuning", or the
"SMCC NFS Performance and Tuning Guide".  Ordering info is in
Section 7 of this PSD.

If you need NFS performance consulting assistance from SunService,
please refer to Sections 8 and 9 of this document on supportability
and support providers.

In SunOS 4.1.X, the number of nfsd's specifies
the number of nfsd processes that run.  In Solaris 2.X, the
number of nfsd's specifies the number of nfsd threads
that run inside the single nfsd Unix process.

Here are some general guidelines for SunOS 4.1.X:

To determine how many nfsds to run, use any of the
formulas below to pick a starting value.  Then use the
procedures below to adjust the number of nfsds until it
is right for the particular environment.

--------------------------------------------------------
  VARIATION                    FORMULA
--------------------------------------------------------
 Variation 1   #(disk spindles) + #(network interfaces)
--------------------------------------------------------
 Variation 2   4 for a desktop system that is both
               client and server,
               8 for a small dedicated server,
               16 for a large NFS and compute server,
               24 for a large NFS-only server
+-----------+------------------------------------------+
 Variation 3   2 * max#(simultaneous disk operations)
--------------------------------------------------------

On Solaris 2.X, this number will be different.  The SunSoft
press book recommends taking the highest number obtained by
applying the following three rules:

* Two NFS threads per active client process
* 32 NFS threads on a SPARCclassic server, 64 NFS threads per
  SuperSPARC processor.
* 16 NFS threads per ethernet, 160 per FDDI

The default for 2.X is 16 threads.

Q: What other guidelines and help is there on Tuning NFS?

A:  Consult the O'Reilly and Associates book "Managing NFS and NIS",
the SunSoft Press book, "Sun Performance and Tuning", or the
"SMCC NFS Performance and Tuning Guide".  Ordering info is in
Section 7 of this PSD.

5.0 Patches

 General Information on Patches

The following is the list of all of the NFS related patches for 4.1.3,
4.1.3_u1, 4.1.4, 2.3, 2.4, and 2.5.  If you are having NFS problems,
installing the patches is a good place to start, especially if you
recognize the general symptoms noted below.

In order for a machine to be stable, all of the recommended patches
should be installed as well. The list of recommended patches for your
operating system is available from sunsolve1.sun.com

 5.1: Core NFS Patches for SunOS 4.1.X

100173-13 SunOS 4.1.3: NFS Jumbo Patch
102177-04 SunOS 4.1.3_U1: NFS Jumbo Patch
102394-02 SunOS 4.1.4: NFS Jumbo Patch

  Resolve a large number of NFS problems. Should be installed on any
  machine doing NFS.

100988-05 SunOS 4.1.3: UFS File system and NFS locking Jumbo Patch.
101784-04 SunOS 4.1.3_U1: rpc.lockd/rpc.statd jumbo patch
102516-05 SunOS 4.1.4: UFS File system Jumbo Patch

  Fixes a wide variety of rpc.lockd and rpc.statd problems.

102264-02 SunOS 4.1.4: rpc.lockd patch for assertion failed panic

  Fixes an "Assertion failed" panic related to the lockd.

103275-01 SunOS 4.1.4: System with heavy NFS load may crash due to
                 IP driver bu

 5.2: Patches Related to NFS for SunOS

100361-04 SunOS 4.1.1 4.1.2 4.1.3: server not responding due to limits of

  Resolves an error that could cause "NFS server not responding"
  errors on a machine that had more than 500 machines in its arp cache.
  Only a problem at sites with very large local nets.

101849-01 SunOS 4.1.3: rpc.quotad is very slow on busy NFS servers

  Speeds up slow rpc.quotads on NFS servers.

 5.3: Core NFS Patches for Solaris

SOLARIS 2.3:

101318-81 SunOS 5.3: Jumbo patch for kernel (includes libc, lockd)

  Resolves a large number of problems involving both nfs and the
  lockd, as well as the related autofs program. Should be installed
  on any 5.3 machine, but is an absolute necessity on a machine doing
  NFS.

102654-01 SunOS 5.3: rmtab grows without bounds

  This patch solves problems where the mountd hangs up, but the nfsd
  continues to process NFS requests from existing NFS mounts.

103059-01 SunOS 5.3: automountd /dev rdev not in mnttab

  This patch fixes a variety of issues where the automounter loses
  entries from mnttab, often seen with lofs (loopback) mounts.

101930-01 SunOS 5.3: some files may not show up under cachefs

  This patch is required with the "autoclient" product, which is needed
  to cache the / and /usr file systems with cachefs.

102932-02 SunOS 5.3: statd dies intermittently

SOLARIS 2.4 and 2.4x86:

101945-42 SunOS 5.4: jumbo patch for kernel
101946-35 SunOS 5.4_x86: jumbo patch for kernel

  Resolves a large number of problems involving nfs, as well as the
  related autofs program. Should be installed on any 5.4 machine, but
  is an absolute necessity on a machine doing NFS.

102685-01 SunOS 5.4: lofs - causes problems with 400+ PC-NFS users

  This patch resolves some mountd hangs seen after sharing a lofs mount point.

101977-04 SunOS 5.4: lockd fixes
101978-03 SunOS 5.4_x86: lockd fixes

  Resolves various lockd error messages, as well as a lockd memory
  leak.

102216-07 SunOS 5.4: klmmod and rpcmod fixes

  Resolves problems with NFS file locking.  It is needed whenever
  patching lockd.

102769-03 SunOS 5.4: statd requires enhancements in support of HADF

  This patch is generally needed in high availability server application.

102209-01 SunOS 5.4: No way to cache the root and /usr file systems with
CacheFS
102210-01 SunOS 5.4_x86: No way to cache root & /usr file systems with
CacheFS

  This patch is required with the "autoclient" product, which is needed
  to cache the / and /usr file systems with cachefs.

102217-07 SunOS 5.4_x86: NFS client starts using unreserved UDP port numb

  Resolves a problem specific to the x86 port of 5.4, which caused NFS
  clients to begin using unreserved ports. [look up bug 1179403]

SOLARIS 2.5 and 2.5x86

103226-07 SunOS 5.5: /kernel/sys/nfs and /kernel/fs/nfs fixes
103227-06 SunOS 5.5_x86: /kernel: sys/nfs, fs/nfs & misc/nfssrv fixes
  This patch is needed for any Solaris 2.5 system w/ NFS

103325-02 SunOS 5.5: mount causes the system to panic Data fault

  This patch also fixes some file locking problems in klmmod

103477-02 SunOS 5.5: RPC: Unable to send/receive
103478-01 SunOS 5.5_x86: RPC: Unable to send/receive

SOLARIS 2.5.1, 2.5.1_x86, and 2.5.1_ppc
103609-02 SunOS 5.5.1: RPC: Unable to send/receive
103611-01 SunOS 5.5.1_ppc: RPC: Unable to send/receive
103610-01 SunOS 5.5.1_x86: RPC: Unable to send/receive

 5.4: Patches Related to NFS for Solaris

We STRONGLY recommend you install these patches, especially if you have
had any problems with "NFS SERVER NOT RESPONDING":

SOLARIS 2.3:

101546-01 SunOS 5.3: nfs: multiple quota -v may not return info or too slow

101581-02 SunOS 5.3: quotaon/quotaoff/quotacheck fixes
  Resolves a problem that caused rquotad to hang on some NFS systems and
  to resolve other quota issues.

101306-11 SunOS 5.3: Jumbo Patch for le & qe drivers
  This is a "must install" patch for systems with Ethernet.

102272-02 SunOS 5.3: Ethernet and ledmainit fixes
  Resolve dma problems with le interface, possible causes of NFS server hangs

101734-03 SunOS 5.3: iommu fixes for sun4m
 Resolve iommu problems mainly on Sparc 5, possible causes of NFS server hangs.

SOLARIS 2.4:

101973-23 SunOS 5.4: jumbo patch for libnsl and ypbind
  This patch resolves a variety of name service issues that can cause
  a 2.4 NFS server to not respond to certain requests.  This is a "must
have" 
  patch.

102001-11 SunOS 5.4: le, qe, be Ethernet driver Jumbo Patch
  This is a "must install" patch for systems with Ethernet.

102332-01 SunOS 5.4: ledma fix
  Resolve dma problems with le interface, possible causes of NFS server hangs

102038-02 SunOS 5.4: iommunex_dma_mctl Sparc 5 only
  Resolves iommu problems on Sparc 5, possible causes of NFS server hangs.

SOLARIS 2.5

102979-02 SunOS 5.5: /kernel/drv/be, /kernel/drv/hme and /kernel/drv/qe fixes
103244-03 SunOS 5.5: Fix for le driver

1、将PC预留一个盘FAT的格式，然后将fedroa的image拷贝至其中

2、用grub启动，将grubDOS的文件拷贝至才c:盘的根目录下，然后修改boot.ini追加启动grub的选项。

3、由grub引导系统，然后在根目录下输入root (hd0,0)

4、kernel /vmlinuz

5、initrd /intrid.img

6、boot

7、 

目录可以这样的安排

/

/boot

/swap

（另我很喜欢163.输入blog的版面，比QQ的好很多，希望163能开到）

1. Procure fish, any kind, length > 12 inches
2. Freeze it overnight
3. Sit in front of PC, run vi
4. Holding fish by the tail, smash it repeatedly against your forehead until you decide to give EMACS a try because the fish scales are flying around your head and it's starting to ache.

Menke, of course, was implying that not only vi was insanely obstinate but that vi users were obstinate as well for refusing to admit how they were inflicting upon themselves frozen-fish-against-the-noggin levels of brutalization.

It didn't take long for vi lovers return fire. One suggested Menke add this line to his instructions: "Type 'emacs' before step 1, so that by the time step 4 is done, it will have finally finished loading."

Now, was he trying to say the EMACS text editor was slow?

Like fight-fatigued battalions who come to a temporary truce but refuse to give up the war, vi and EMACS users keep an uneasy standoff in many Linux, SAGE and other computer-related virtual communities. It's the kind of standoff that may remain dormant for months, but it takes only the vaguest slight from one side for the flames to roil across the newsgroups and mailing lists once again. For just beneath their civil demeanors, each camp feels the editor they use is the best of all possible editors and those who use any other editor, particularly that other editor, are fools who would realize the error in their thinking if only pounded with enough mockery.

Now, a rift over which Unix text editor is God's Own Build may not seem significant given all the troubles of the world, a Coke vs. Pepsi standoff of no consequence, no motivator beyond simple group bonding ("Go Team!").

But why has this difference of views remained a divisor of programmer culture for more than two decades now? Why has it remained intact as the PC, graphical user interfaces, the mouse, the Internet and Open Source each altered the computation landscape?

"As far back I can remember both, the hacker population has been split 50/50 [between] EMACS [and] vi," emails Eric Raymond, who counts as many of his roles in the Open Source software and hacker communities as a long-time observer/participant anthropologist. "Pico, joe, MicroEmacs, and other editors have basically been down in the statistical noise during the whole period." Raymond can personally date the vi/EMACS split back to 1985 and stipulates that, in all likelihood, it went on long before that.

As early as 1991, Raymond recorded the vi vs. EMACS "holy war" in the Jargon File, perhaps the ultimate collection of hacker terminology.

When pressed, most people familiar with both editors will say the difference between the two is one of speed vs. flexibility, with vi users pointing to how darn quickly they can move around and EMACS lovers touting their immense number of options. Vi users deride EMACS for being unnecessarily ostentatious; EMACS users derided vi for being difficult to learn and limited in scope.

So the great text editor debate of our time comes down to the technical equivalent of "tastes great/less filling?" Well, yes, kind of. But like with all matters of religion -- or war -- the deeper you dig, the murkier the issues get.

But there is significance here. These editors are the tabula rasa upon which much of cyberspace has been built. That these tools, each designed to be transparent to the end user, are subject to such fierce and competing loyalties, reveals something about some primordial assumptions people have about the best ways of getting things done.

Vi: The editor that time forgot?

At first glance, outsiders might see vi as the editor that time forgot. It's not just that you have to open up a terminal window just to use the thing. That's the best way to get to EMACS, too. But even with the VIM, the updated version most vi users employ these days, one can't help but to marvel at (or become frustrated over) the sheer lack of intuitiveness of how it works.

Even the webmaster of the VI Lovers Home Page admits that the learning curve is steep. "Vi doesn't get fast before you know 25 commands or so," wrote Amsterdam native Thomer Gil, now working on a computer science Ph.d. at the Massachusetts Institute of Technology.

Gil's been likened by his office-mates to a "caveman wielding ax and club" for his use of VIM.

Of all vi's perceived shortcomings, perhaps the most noticeable is how you need to toggle the insert key just to type anything onto the screen. Vi has two modes: One is the "insert" mode where you can enter text. You get to that mode by hitting the "insert" key on the keyboard. But there is also the command mode where you can't enter text, but instead enter relevant commands. From insert mode, you can get there by hitting the escape key.

So imagine the unsuspecting first-time user typing away who accidentally hits the escape key, only to find that not only can he longer enter text, but his keystrokes are sending the program in strange directions.

The Jargon File dryly notes that this feature of vi "tends to frustrate new users no end, as it will neither take commands while expecting input text nor vice versa, and the default setup provides no indication of which mode the editor is in."

"Multiple modes freak people out," Gil admits.

Vi was written by Bill Joy in 1976, who forged it from two even more primitive editing tools, ed and ex. Vi stood for "visual interface," which in 1976 was in quite the bleeding edge in computing, according to a Joy interview in Linux Magazine.

"I was trying to make it usable over a 300-baud modem. That's also the reason you have all these funny commands. It just barely worked to use a screen editor over a modem, " Joy said "So the editor was optimized so that you could edit and feel productive when it was painting slower than you could think."

In that interview, Joy contrasted the development environment of vi to that of EMACS, which, he said was written for systems with blazing fiber-channel links and monster PDP-10's.

"So they could have funny commands with the screen shimmering and all that, and meanwhile, I'm sitting at home in sort of World War II surplus housing at Berkeley with a modem and a terminal that can just barely get the cursor off the bottom line," Joy said, perhaps sounding a bit envious. "People don't know that vi was written for a world that doesn't exist anymore."

Yet, while vi should have died out in the early '80s as network and processor speed increased, instead, it has flourished. The VI Pages lists close to 30 vi clones from elvis and VIM to such obscurities as WinVi and vigor.

Tim O'Reilly, mastermind behind the O'Reilly & Associates publishing company noted on the company's Ask Tim column that his company sells twice as many vi books than EMACS ones. Plus, whenever O'Reilly sponsors a vi. vs. EMACS paintball game at some convention, invariably twice as many volunteers sign up to defend the honor of vi than EMACS.

So what is the appeal? That's best described by the Cult of VI in which John Arundel writes, "Watching a vi guru doing some heavy editing on a file, as her fingers fly over the keys and textual transformations sweep across the screen, one could believe that one is in the presence of supernatural powers."

Gil publishes a few examples of this wizardry on his Web site. "A key concept in vi is combining a certain action (delete, copy to buffer, capitalize, etc.) with a movement (go to line 25, go to end of document, go to next occurrence of 'foo,' go to 2nd occurrence of character 'x' in this line, etc.)."

"Huh?" I email him.

Gil sends back an example: "If, for example, a document contains the lines: 'a b c d e f g h' and the cursor is location on 'b,' then I can type 'd/f<enter>.' "

The first "d" means delete, the "/" is a search function, so what this command will do is delete from b to f.

"No special circumstances required to use this . . . Delete words, sentences. Go back to where I was before. 'Oh no, jump back again. Undo what I did, redo it,' " Gil writes.

Gil stipulates you can do tricks like this one on EMACS, too. However, he says it requires memorization of unwieldy "funky Ctrl-X Ctrl-c Alt-F4 key combinations" to execute.

Another trick Gil reveals is how VI allows users move around in files. "The stupid way is using arrow keys; there are many other, more advanced, ways to move around," Gil writes. Among the advanced forms of carriage vi offers is the option to jet to the last or last few cursor jumps, or to the next occurrence of a particular word, or to the next sentence or paragraph.

Even the dual mode "feature" becomes transparent to users. About a year ago, A while back I interviewed Jon Lasser to write about his then-recently published book Think Unix, (the manuscript of which, he told me, was composed entirely in vi). The conversation eventually came around to vi, and I complained about the two modes.

Lasser explained that he saw no difference between working in vi and in word processors like StarOffice or Microsoft Word. In Word, when you move your pointer out of the screen area, you can't type in text. You have, in effect, moved from insert mode to command mode. "It's the same thing," he explained.

As O'Reilly wrote about vi: "Like a lot of things about UNIX, it only *seems* difficult."

More is more with EMACS?

When vi loyalist O'Reilly wrote in Ask Tim that he first shifted from EMACS to vi only after his customized EMACS profile was trashed, it was one of those subtle jabs vi users like to use against EMACS.

EMACS stands in sharp contrast to vi's pristine limitation of commands, with its almost infinite customizability. Given human nature being what it is, however, such power in the hands of users may not always be a best thing.

As the Emacs-Beginner-HOWTO puts it, EMACS can be a text editor, mail client, news reader, word processor, script editor, and integrated development environment for programming languages.

The key to this is the multiple modes, each with a unique command set, that EMACS offers. Want to check email? Just flip over to the email mode. Want to writing a program in C++? Use the C++ mode. Need to author some Web pages? Flip into the html-helper mode.

And on top of all this, you can also customize EMACS and even add new functions, usually through modifying the Lisp code.

All of which many vi users see as terribly presumptuous for what is supposed to be a simple text editor, not to mention distracting for the user. The ongoing joke about EMACS is that it is an operating system with a text editor attached.

"EMACS as such actually started out as a standards project," emails Guy Steele, one of the originators of EMACS, along with Richard Stallman, who later founded the Free Software Foundation.

The way Steele recalls, Stallman maintained an early editor for PDP-10 called TECO, which stood for "Text Editor and COrrector."Although certain keystrokes would perform editing commands, Stallman created a user-programmable table "such that each keystroke performed a lookup in the table describing what to do for that keystroke," according to Steele. "One option was to execute a user-specified TECO macro."

Using this macro functionality, users were programming custom sets of macros to be attached to various keystrokes, but this became problematic when programmers started collaborating on programs and found out they had few common keystrokes between them.

"The user community had become fragmented with respect to the skills of text (and program) editing," Steele writes. So Steele, along with David Moon and Stallman, took on the project of integrating all the ideas into a unified command set.

"I made up a matrix on paper and did a lot of running back and forth among the implementers and users of the various macro packages," Steele emails.

"I remember this very well," recalls Dan Weinreb, who was one of the first alpha testers of EMACS. "Guy had a clipboard with a piece of paper showing all the key bindings, and he carefully and diplomatically collected input and comments from everyone to put together the unified, standard key bindings."

After a few months, Steele, busy trying to finish his master's dissertation, handed the work over to Stallman. And the rest is history.

That the flexibility was baked in from the start gives EMACS its edge, say hardcore users.

"I think of EMACS as the Swiss Army Knife of editors," emails Debra Cameron, co-author of Learning GNU Emacs and president of Cameron Consulting. "It is a complete work environment, a microcosm. If you think of something you wish it did, you will probably find out (after looking around) that it already does it. If it doesn't, you can extend it and make it do what you wish it did."

Can't we all just get along?

So how does EMACS contrast to vi?

"I have seen very adept vi users do some pretty neat tricks, but I still think vi is (just) an editor, even if for some it is a great editor," emails Cameron. "[It] always, always works the same way. In this sense, vi is like McDonald's; no matter where you go, it is exactly the same."

"Do you want an editor that can be modified to your needs and quirks and which does many, many things or do you just want to be able to quickly edit files on any machine?" she asks. "For people who have to move around from one computer to another constantly, this consistency can be a real advantage."

In other words, EMACS = flexibility, whereas vi = uniformity?

Here's where things get murky.

"EMACS is certainly more complex than vi, but I don't believe it's more powerful in any sort of useful way, because vi was designed to be part of a UNIX system and to interact with those tools," counters Jon Lasser.

Mind you, for Lasser, "useful" means the way that vi allows you to read documents directly from a UNIX pipe from another process, "like you would in any other UNIX application," he explains. So, the arcane string of keystrokes "<esc> :r !ls<enter>" entered into vi (in command mode, remember) reads into the buffer the output from the "ls" program, or a listing of files from the current directory. And a pipe from any other UNIX program would work as well.

As for editing a large number of files automatically in vi, Lasser says that's why we have "sed, awk, and all of the other UNIX text-processing tools.

"Text processing is what UNIX was designed for, and vi was designed to be part of such a system," Lasser writes.

Maybe the underlying issue between EMACS and vi isn't one of uniformity versus flexibility at all. After all, both editors offer flexibility, its just that with vi, it's through UNIX itself, whereas EMACS achieves it by building on top of the system.

And, for that matter, the only point of flexibility anyway is to make the job go faster. If you wanted straightforward no-frills text processing, you could go with Pico, which offers just a blank screen and none of the newbie-confusing features of either vi or EMACS. What both of these editors offer are advanced ways of narrowing the gap between the speed of the fingers on the keyboard and the speed of the programmer's brain.

In other words, could it be that these editors offer the same thing, but demand different ways of thinking from their users? Vi requires the patience to learn its quirky ways, though once you master them, you're free to take your act to any UNIX system. EMACS endows you with mad freedoms in customizing your setup as you see fit, though if you're not careful, you'll become prisoner to your own configuration.

Sometime during the great hike of improving self-efficiency that all good programmers take, vi and EMACS users cross paths, each coming from a different direction. And when they meet, they usually throw stones at one another.

But it's all good.

"I don't think there is a strong difference in functionality. Both editors do a fine job and it just comes down to what people learn first," Gil writes. "Since most people know EMACS, they will teach others EMACS. Hence, most people use EMACS, etc."

And so the feud will continue ...

2004年4月20日最新版本的GCC编译器3.4.0发布了。目前，GCC可以用来编译C/C++、FORTRAN、JAVA、OBJC、ADA等语言的程序，可根据需要选择安装支持的语言。GCC 3.4.0比以前版本更好地支持了C++标准。本文以在Redhat Linux上安装GCC3.4.0为例，介绍了GCC的安装过程。

　　安装之前，系统中必须要有cc或者gcc等编译器，并且是可用的，或者用环境变量CC指定系统上的编译器。如果系统上没有编译器，不能安装源代码形式的GCC 3.4.0。如果是这种情况，可以在网上找一个与你系统相适应的如RPM等二进制形式的GCC软件包来安装使用。本文介绍的是以源代码形式提供的GCC软件包的安装过程，软件包本身和其安装过程同样适用于其它Linux和Unix系统。

　　系统上原来的GCC编译器可能是把gcc等命令文件、库文件、头文件等分别存放到系统中的不同目录下的。与此不同，现在GCC建议我们将一个版本的GCC安装在一个单独的目录下。这样做的好处是将来不需要它的时候可以方便地删除整个目录即可（因为GCC没有uninstall功能）；缺点是在安装完成后要做一些设置工作才能使编译器工作正常。在本文中我采用这个方案安装GCC 3.4.0，并且在安装完成后，仍然能够使用原来低版本的GCC编译器，即一个系统上可以同时存在并使用多个版本的GCC编译器。

　　按照本文提供的步骤和设置选项，即使以前没有安装过GCC，也可以在系统上安装上一个可工作的新版本的GCC编译器。

　　1. 下载

　　在GCC网站上（http://gcc.gnu.org/）或者通过网上搜索可以查找到下载资源。目前GCC的最新版本为 3.4.0。可供下载的文件一般有两种形式：gcc-3.4.0.tar.gz和gcc-3.4.0.tar.bz2，只是压缩格式不一样，内容完全一致，下载其中一种即可。

　　2. 解压缩

　　根据压缩格式，选择下面相应的一种方式解包（以下的“%”表示命令行提示符）：

　　% tar xzvf gcc-3.4.0.tar.gz
　　或者
　　% bzcat gcc-3.4.0.tar.bz2 | tar xvf -

　　新生成的gcc-3.4.0这个目录被称为源目录，用${srcdir}表示它。以后在出现${srcdir}的地方，应该用真实的路径来替换它。用pwd命令可以查看当前路径。

　　在${srcdir}/INSTALL目录下有详细的GCC安装说明，可用浏览器打开index.html阅读。

　　3. 建立目标目录
 
　　目标目录（用${objdir}表示）是用来存放编译结果的地方。GCC建议编译后的文件不要放在源目录${srcdir]中（虽然这样做也可以），最好单独存放在另外一个目录中，而且不能是${srcdir}的子目录。

　　例如，可以这样建立一个叫 gcc-build 的目标目录（与源目录${srcdir}是同级目录）：

　　% mkdir gcc-build
　　% cd gcc-build

　　以下的操作主要是在目标目录 ${objdir} 下进行。

　　4. 配置
 
　　配置的目的是决定将GCC编译器安装到什么地方（${destdir}），支持什么语言以及指定其它一些选项等。其中，${destdir}不能与${objdir}或${srcdir}目录相同。

　　配置是通过执行${srcdir}下的configure来完成的。其命令格式为（记得用你的真实路径替换${destdir}）：

　　% ${srcdir}/configure --prefix=${destdir} [其它选项]

　　例如，如果想将GCC 3.4.0安装到/usr/local/gcc-3.4.0目录下，则${destdir}就表示这个路径。

　　在我的机器上，我是这样配置的：

　　% ../gcc-3.4.0/configure --prefix=/usr/local/gcc-3.4.0 --enable-threads=posix --disable-checking --enable--long-long --host=i386-redhat-linux --with-system-zlib --enable-languages=c,c++,java

　　将GCC安装在/usr/local/gcc-3.4.0目录下，支持C/C++和JAVA语言，其它选项参见GCC提供的帮助说明。

　　5. 编译

　　% make

　　这是一个漫长的过程。在我的机器上（P4-1.6），这个过程用了50多分钟。

　　6. 安装

　　执行下面的命令将编译好的库文件等拷贝到${destdir}目录中（根据你设定的路径，可能需要管理员的权限）：

　　% make install

　　至此，GCC 3.4.0安装过程就完成了。

　　6. 其它设置

　　GCC 3.4.0的所有文件，包括命令文件（如gcc、g++）、库文件等都在${destdir}目录下分别存放，如命令文件放在bin目录下、库文件在lib下、头文件在include下等。由于命令文件和库文件所在的目录还没有包含在相应的搜索路径内，所以必须要作适当的设置之后编译器才能顺利地找到并使用它们。

　　6.1 gcc、g++、gcj的设置

　　要想使用GCC 3.4.0的gcc等命令，简单的方法就是把它的路径${destdir}/bin放在环境变量PATH中。我不用这种方式，而是用符号连接的方式实现，这样做的好处是我仍然可以使用系统上原来的旧版本的GCC编译器。

　　首先，查看原来的gcc所在的路径：

　　% which gcc

　　在我的系统上，上述命令显示：/usr/bin/gcc。因此，原来的gcc命令在/usr/bin目录下。我们可以把GCC 3.4.0中的gcc、g++、gcj等命令在/usr/bin目录下分别做一个符号连接：

　　% cd /usr/bin
　　% ln -s ${destdir}/bin/gcc gcc34
　　% ln -s ${destdir}/bin/g++ g++34
　　% ln -s ${destdir}/bin/gcj gcj34

　　这样，就可以分别使用gcc34、g++34、gcj34来调用GCC 3.4.0的gcc、g++、gcj完成对C、C++、JAVA程序的编译了。同时，仍然能够使用旧版本的GCC编译器中的gcc、g++等命令。

　　6.2 库路径的设置

　　将${destdir}/lib路径添加到环境变量LD_LIBRARY_PATH中，最好添加到系统的配置文件中，这样就不必要每次都设置这个环境变量了。

　　例如，如果GCC 3.4.0安装在/usr/local/gcc-3.4.0目录下，在RH Linux下可以直接在命令行上执行或者在文件/etc/profile中添加下面一句：

　　setenv LD_LIBRARY_PATH /usr/local/gcc-3.4.0/lib:$LD_LIBRARY_PATH

　　7. 测试
 
　　用新的编译命令（gcc34、g++34等）编译你以前的C、C++程序，检验新安装的GCC编译器是否能正常工作。

　　8. 根据需要，可以删除或者保留${srcdir}和${objdir}目录。

(Extract from Qt Documentation)

The tutorial examples are located in the Qt examples/tutorials/tutorial directory. If you installed a binary Qt package, pre-built examples were installed as well. If you built Qt yourself, the examples were built at the same time. In either case, there is a lot to be learned about using Qt by modifying and building the examples yourself.

Assuming you have copied an example's .cpp and .h files to an otherwise empty directory, and you have made your changes there, the next step is to create a Qt makefile in that directory. To create a Qt makefile, use qmake, the build tool supplied with Qt. Run the following two commands in the directory containing your modified sources to create the makefile.

 qmake -project
 qmake

The first command tells qmake to create a project (.pro) file. The second command tells qmake to use the .pro file to create a platform-specific makefile.

Now you can just run make (nmake if you are using Visual Studio) to compile the program, and then you can run your first Qt application!

GDB中文手册 
/****************************************************/
用GDB调试程序
GDB概述 2
使用GDB 5
GDB中运行UNIX的shell程序 8
在GDB中运行程序 8
调试已运行的程序 两种方法： 9
暂停 / 恢复程序运行 9
一、设置断点（BreakPoint） 9
二、设置观察点（WatchPoint） 10
三、设置捕捉点（CatchPoint） 10
四、维护停止点 11
五、停止条件维护 12
六、为停止点设定运行命令 12
七、断点菜单 13
八、恢复程序运行和单步调试 13
九、信号（Signals） 14
十、线程（Thread Stops） 15
查看栈信息 16
查看源程序 18
一、显示源代码 18
二、搜索源代码 19
三、指定源文件的路径 19
四、源代码的内存 20
查看运行时数据 21
一、表达式 21
二、程序变量 21
三、数组 22
四、输出格式 23
五、查看内存 23
六、自动显示 24
七、设置显示选项 25
GDB中关于显示的选项比较多，这里我只例举大多数常用的选项。 25
八、历史记录 27
九、GDB环境变量 28
十、查看寄存器 28
改变程序的执行 29
一、修改变量值 29
二、跳转执行 29
三、产生信号量 30
四、强制函数返回 30
五、强制调用函数 30
在不同语言中使用GDB 31
后记 32

GDB概述
GDB 是GNU开源组织发布的一个强大的UNIX下的程序调试工具。或许，各位比较喜欢那种图形界面

方式的，像VC、BCB等IDE的调试，但如果你是在 UNIX平台下做软件，你会发现GDB这个调试工具

有比VC、BCB的图形化调试器更强大的功能。所谓“寸有所长，尺有所短”就是这个道理。

一般来说，GDB主要帮忙你完成下面四个方面的功能：

1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。
2、可让被调试的程序在你所指定的调置的断点处停住。（断点可以是条件表达式）
3、当程序被停住时，可以检查此时你的程序中所发生的事。
4、动态的改变你程序的执行环境。

从上面看来，GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你

会发现GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调

试工具却有着图形化工具所不能完成的功能。让我们一一看来。

一个调试示例
——————

源程序：tst.c
1 #include <stdio.h>
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i<n; i++)
7 {
8 sum+=i;
9 }
10 return sum;
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
21 }
22
23 printf("result[1-100] = %d \n", result );
24 printf("result[1-250] = %d \n", func(250) );
25 }

编译生成执行文件：（Linux下）
hchen/test> cc -g tst.c -o tst

使用GDB调试：

hchen/test> gdb tst <---------- 启动GDB
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux"...
(gdb) l <-------------------- l命令相当于list，从第一行开始例出原码。
1 #include <stdio.h>
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i<n; i++)
7 {
8 sum+=i;
9 }
10 return sum;
(gdb) <-------------------- 直接回车表示，重复上一次命令
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
(gdb) break 16 <-------------------- 设置断点，在源程序第16行处。
Breakpoint 1 at 0x8048496: file tst.c, line 16.
(gdb) break func <-------------------- 设置断点，在函数func()入口处。
Breakpoint 2 at 0x8048456: file tst.c, line 5.
(gdb) info break <-------------------- 查看断点信息。
Num Type Disp Enb Address What
1 breakpoint keep y 0x08048496 in main at tst.c:16
2 breakpoint keep y 0x08048456 in func at tst.c:5
(gdb) r <--------------------- 运行程序，run命令简写
Starting program: /home/hchen/test/tst

Breakpoint 1, main () at tst.c:17 <---------- 在断点处停住。
17 long result = 0;
(gdb) n <--------------------- 单条语句执行，next命令简写。
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) n
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) c <--------------------- 继续运行程序，continue命令简写。
Continuing.
result[1-100] = 5050 <----------程序输出。

Breakpoint 2, func (n=250) at tst.c:5
5 int sum=0,i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p i <--------------------- 打印变量i的值，print命令简写。
$1 = 134513808
(gdb) n
8 sum+=i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$2 = 1
(gdb) n
8 sum+=i;
(gdb) p i
$3 = 2
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$4 = 3
(gdb) bt <--------------------- 查看函数堆栈。
#0 func (n=250) at tst.c:5
#1 0x080484e4 in main () at tst.c:24
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6
(gdb) finish <--------------------- 退出函数。
Run till exit from #0 func (n=250) at tst.c:5
0x080484e4 in main () at tst.c:24
24 printf("result[1-250] = %d \n", func(250) );
value returned is $6 = 31375
(gdb) c <--------------------- 继续运行。
Continuing.
result[1-250] = 31375 <----------程序输出。

Program exited with code 027. <--------程序退出，调试结束。
(gdb) q <--------------------- 退出gdb。
hchen/test>

好了，有了以上的感性认识，还是让我们来系统地认识一下gdb吧。
使用GDB
一般来说GDB主要调试的是C/C++的程序。要调试C/C++的程序，首先在编译时，我们必须要把调试

信息加到可执行文件中。使用编译器（cc/gcc/g++）的 -g 参数可以做到这一点。如：

> cc -g hello.c -o hello
> g++ -g hello.cpp -o hello

如果没有-g，你将看不见程序的函数名、变量名，所代替的全是运行时的内存地址。当你用-g把

调试信息加入之后，并成功编译目标代码以后，让我们来看看如何用gdb来调试他。

启动GDB的方法有以下几种：

1、gdb <program>
program也就是你的执行文件，一般在当然目录下。

2、gdb <program> core
用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。

3、gdb <program> <PID>
如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。gdb会自动attach

上去，并调试他。program应该在PATH环境变量中搜索得到。

GDB启动时，可以加上一些GDB的启动开关，详细的开关可以用gdb -help查看。我在下面只例举一

些比较常用的参数：

-symbols <file>
-s <file>
从指定文件中读取符号表。

-se file
从指定文件中读取符号表信息，并把他用在可执行文件中。

-core <file>
-c <file>
调试时core dump的core文件。

-directory <directory>
-d <directory>
加入一个源文件的搜索路径。默认搜索路径是环境变量中PATH所定义的路径。
启动gdb后，就你被带入gdb的调试环境中，就可以使用gdb的命令开始调试程序了，gdb的命令可

以使用help命令来查看，如下所示：

/home/hchen> gdb
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux".
(gdb) help
List of classes of commands:

aliases -- Aliases of other commands
breakpoints -- Making program stop at certain points
data -- Examining data
files -- Specifying and examining files
internals -- Maintenance commands
obscure -- Obscure features
running -- Running the program
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without stopping the program
user-defined -- User-defined commands

Type "help" followed by a class name for a list of commands in that class.
Type "help" followed by command name for full documentation.
Command name abbreviations are allowed if unambiguous.
(gdb)

gdb 的命令很多，gdb把之分成许多个种类。help命令只是例出gdb的命令种类，如果要看种类中

的命令，可以使用help < class>  命令，如：help breakpoints，查看设置断点的所有命令。也

可以直接help <command>来查看命令的帮助。

gdb中，输入命令时，可以不用打全命令，只用打命令的前几个字符就可以了，当然，命令的前几

个字符应该要标志着一个唯一的命令，在Linux下，你可以敲击两次TAB键来补齐命令的全称，如

果有重复的，那么gdb会把其例出来。

示例一：在进入函数func时，设置一个断点。可以敲入break func，或是直接就是b func
(gdb) b func
Breakpoint 1 at 0x8048458: file hello.c, line 10.

示例二：敲入b按两次TAB键，你会看到所有b打头的命令：
(gdb) b
backtrace break bt
(gdb)

示例三：只记得函数的前缀，可以这样：
(gdb) b make_ <按TAB键>
（再按下一次TAB键，你会看到:）
make_a_section_from_file make_environ
make_abs_section make_function_type
make_blockvector make_pointer_type
make_cleanup make_reference_type
make_command make_symbol_completion_list
(gdb) b make_
GDB把所有make开头的函数全部例出来给你查看。

示例四：调试C++的程序时，有可以函数名一样。如：
(gdb) b 'bubble( M-?
bubble(double,double) bubble(int,int)
(gdb) b 'bubble(
你可以查看到C++中的所有的重载函数及参数。（注：M-?和“按两次TAB键”是一个意思）

要退出gdb时，只用发quit或命令简称q就行了。
GDB中运行UNIX的shell程序
在gdb环境中，你可以执行UNIX的shell的命令，使用gdb的shell命令来完成：

shell <command string>
调用UNIX的shell来执行<command string>，环境变量SHELL中定义的UNIX的shell将会被用来执行

< command string>，如果SHELL没有定义，那就使用UNIX的标准shell：/bin/sh。（在 Windows

中使用 Command.com或cmd.exe）

还有一个gdb命令是make：
make <make-args>
可以在gdb中执行make命令来重新build自己的程序。这个命令等价于“shell make <make-args>

”。
在GDB中运行程序
当以gdb <program>方式启动gdb后，gdb会在PATH路径和当前目录中搜索<program>的源文件。如

要确认gdb是否读到源文件，可使用l或list命令，看看gdb是否能列出源代码。

在gdb中，运行程序使用r或是run命令。程序的运行，你有可能需要设置下面四方面的事。

1、程序运行参数。
set args 可指定运行时参数。（如：set args 10 20 30 40 50）
show args 命令可以查看设置好的运行参数。

2、运行环境。
path <dir> 可设定程序的运行路径。
show paths 查看程序的运行路径。
set environment varname [=value] 设置环境变量。如：set env USER=hchen
show environment [varname] 查看环境变量。

3、工作目录。
cd <dir> 相当于shell的cd命令。
pwd 显示当前的所在目录。

4、程序的输入输出。
info terminal 显示你程序用到的终端的模式。
使用重定向控制程序输出。如：run > outfile
tty命令可以指写输入输出的终端设备。如：tty /dev/ttyb

调试已运行的程序 两种方法：
1、在UNIX下用ps查看正在运行的程序的PID（进程ID），然后用gdb <program> PID格式挂接正在

运行的程序。
2、先用gdb <program>关联上源代码，并进行gdb，在gdb中用attach命令来挂接进程的PID。并用

detach来取消挂接的进程。
暂停 / 恢复程序运行
调试程序中，暂停程序运行是必须的，GDB可以方便地暂停程序的运行。你可以设置程序的在哪行

停住，在什么条件下停住，在收到什么信号时停往等等。以便于你查看运行时的变量，以及运行

时的流程。

当进程被gdb停住时，你可以使用info program 来查看程序的是否在运行，进程号，被暂停的原

因。

在gdb 中，我们可以有以下几种暂停方式：断点（BreakPoint）、观察点（WatchPoint）、捕捉

点（CatchPoint）、信号（Signals）、线程停止（Thread Stops）。如果要恢复程序运行，可以

使用c或是continue命令。
一、设置断点（BreakPoint）

我们用break命令来设置断点。正面有几点设置断点的方法：

break <function>
在进入指定函数时停住。C++中可以使用class::function或function(type,type)格式来指定函数

名。

break <linenum>
在指定行号停住。

break +offset
break -offset
在当前行号的前面或后面的offset行停住。offiset为自然数。

break filename:linenum
在源文件filename的linenum行处停住。

break filename:function
在源文件filename的function函数的入口处停住。

break *address
在程序运行的内存地址处停住。

break
break命令没有参数时，表示在下一条指令处停住。

break ... if <condition>
...可以是上述的参数，condition表示条件，在条件成立时停住。比如在循环境体中，可以设置

break if i=100，表示当i为100时停住程序。

查看断点时，可使用info命令，如下所示：（注：n表示断点号）
info breakpoints [n]
info break [n]
二、设置观察点（WatchPoint）
观察点一般来观察某个表达式（变量也是一种表达式）的值是否有变化了，如果有变化，马上停

住程序。我们有下面的几种方法来设置观察点：

watch <expr>
为表达式（变量）expr设置一个观察点。一量表达式值有变化时，马上停住程序。

rwatch <expr>
当表达式（变量）expr被读时，停住程序。

awatch <expr>
当表达式（变量）的值被读或被写时，停住程序。

info watchpoints
列出当前所设置了的所有观察点。
三、设置捕捉点（CatchPoint）
你可设置捕捉点来补捉程序运行时的一些事件。如：载入共享库（动态链接库）或是C++的异常。

设置捕捉点的格式为：

catch <event>
当event发生时，停住程序。event可以是下面的内容：
1、throw 一个C++抛出的异常。（throw为关键字）
2、catch 一个C++捕捉到的异常。（catch为关键字）
3、exec 调用系统调用exec时。（exec为关键字，目前此功能只在HP-UX下有用）
4、fork 调用系统调用fork时。（fork为关键字，目前此功能只在HP-UX下有用）
5、vfork 调用系统调用vfork时。（vfork为关键字，目前此功能只在HP-UX下有用）
6、load 或 load <libname> 载入共享库（动态链接库）时。（load为关键字，目前此功能只在

HP-UX下有用）
7、unload 或 unload <libname> 卸载共享库（动态链接库）时。（unload为关键字，目前此功

能只在HP-UX下有用）

tcatch <event>
只设置一次捕捉点，当程序停住以后，应点被自动删除。
四、维护停止点
上面说了如何设置程序的停止点，GDB中的停止点也就是上述的三类。在GDB中，如果你觉得已定

义好的停止点没有用了，你可以使用delete、clear、disable、enable这几个命令来进行维护。

clear
清除所有的已定义的停止点。

clear <function>
clear <filename:function>
清除所有设置在函数上的停止点。

clear <linenum>
clear <filename:linenum>
清除所有设置在指定行上的停止点。

delete [breakpoints] [range...]
删除指定的断点，breakpoints为断点号。如果不指定断点号，则表示删除所有的断点。range 表

示断点号的范围（如：3-7）。其简写命令为d。

比删除更好的一种方法是disable停止点，disable了的停止点，GDB不会删除，当你还需要时，

enable即可，就好像回收站一样。

disable [breakpoints] [range...]
disable所指定的停止点，breakpoints为停止点号。如果什么都不指定，表示disable所有的停止

点。简写命令是dis.

enable [breakpoints] [range...]
enable所指定的停止点，breakpoints为停止点号。

enable [breakpoints] once range...
enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动disable。
enable [breakpoints] delete range...
enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动删除。
五、停止条件维护
前面在说到设置断点时，我们提到过可以设置一个条件，当条件成立时，程序自动停止，这是一

个非常强大的功能，这里，我想专门说说这个条件的相关维护命令。一般来说，为断点设置一个

条件，我们使用if关键词，后面跟其断点条件。并且，条件设置好后，我们可以用condition命令

来修改断点的条件。（只有 break和watch命令支持if，catch目前暂不支持if）

condition <bnum> <expression>
修改断点号为bnum的停止条件为expression。

condition <bnum>
清除断点号为bnum的停止条件。

还有一个比较特殊的维护命令ignore，你可以指定程序运行时，忽略停止条件几次。

ignore <bnum> <count>
表示忽略断点号为bnum的停止条件count次。
六、为停止点设定运行命令
我们可以使用GDB提供的command命令来设置停止点的运行命令。也就是说，当运行的程序在被停

止住时，我们可以让其自动运行一些别的命令，这很有利行自动化调试。对基于GDB的自动化调试

是一个强大的支持。

commands [bnum]
... command-list ...
end

为断点号bnum指写一个命令列表。当程序被该断点停住时，gdb会依次运行命令列表中的命令。

例如：

break foo if x>0
commands
printf "x is %d\n",x
continue
end
断点设置在函数foo中，断点条件是x>0，如果程序被断住后，也就是，一旦x的值在foo函数中大

于0，GDB会自动打印出x的值，并继续运行程序。

如果你要清除断点上的命令序列，那么只要简单的执行一下commands命令，并直接在打个end就行

了。
七、断点菜单
在C ++中，可能会重复出现同一个名字的函数若干次（函数重载），在这种情况下，break

<function>不能告诉GDB要停在哪个函数的入口。当然，你可以使用break <function(type)>也就

是把函数的参数类型告诉GDB，以指定一个函数。否则的话， GDB会给你列出一个断点菜单供你选

择你所需要的断点。你只要输入你菜单列表中的编号就可以了。如：

(gdb) b String::after
[0] cancel
[1] all
[2] file:String.cc; line number:867
[3] file:String.cc; line number:860
[4] file:String.cc; line number:875
[5] file:String.cc; line number:853
[6] file:String.cc; line number:846
[7] file:String.cc; line number:735
> 2 4 6
Breakpoint 1 at 0xb26c: file String.cc, line 867.
Breakpoint 2 at 0xb344: file String.cc, line 875.
Breakpoint 3 at 0xafcc: file String.cc, line 846.
Multiple breakpoints were set.
Use the "delete" command to delete unwanted
breakpoints.
(gdb)

可见，GDB列出了所有after的重载函数，你可以选一下列表编号就行了。0表示放弃设置断点，1

表示所有函数都设置断点。
八、恢复程序运行和单步调试
当程序被停住了，你可以用continue命令恢复程序的运行直到程序结束，或下一个断点到来。也

可以使用step或next命令单步跟踪程序。

continue [ignore-count]
c [ignore-count]
fg [ignore-count]
恢复程序运行，直到程序结束，或是下一个断点到来。ignore-count表示忽略其后的断点次数。

continue，c，fg三个命令都是一样的意思。

step <count>
单步跟踪，如果有函数调用，他会进入该函数。进入函数的前提是，此函数被编译有debug信息。

很像VC等工具中的step in。后面可以加count也可以不加，不加表示一条条地执行，加表示执行

后面的count条指令，然后再停住。

next <count>
同样单步跟踪，如果有函数调用，他不会进入该函数。很像VC等工具中的step over。后面可以加

count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住。

set step-mode
set step-mode on
打开step-mode模式，于是，在进行单步跟踪时，程序不会因为没有debug信息而不停住。这个参

数有很利于查看机器码。

set step-mod off
关闭step-mode模式。

finish
运行程序，直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。

until 或 u
当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。

stepi 或 si
nexti 或 ni
单步跟踪一条机器指令！一条程序代码有可能由数条机器指令完成，stepi和nexti可以单步执行

机器指令。与之一样有相同功能的命令是 “display/i $pc” ，当运行完这个命令后，单步跟踪

会在打出程序代码的同时打出机器指令（也就是汇编代码）
九、信号（Signals）
信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是

UNIX，比较重要应用程序一般都会处理信号。UNIX 定义了许多信号，比如SIGINT表示中断字符信

号，也就是Ctrl+C的信号，SIGBUS表示硬件故障的信号；SIGCHLD表示子进程状态改变信号；

SIGKILL表示终止程序运行的信号，等等。信号量编程是UNIX下非常重要的一种技术。

GDB有能力在你调试程序的时候处理任何一种信号，你可以告诉GDB需要处理哪一种信号。你可以

要求GDB收到你所指定的信号时，马上停住正在运行的程序，以供你进行调试。你可以用GDB的

handle命令来完成这一功能。

handle <signal> <keywords...>
在GDB 中定义一个信号处理。信号<signal>可以以SIG开头或不以SIG开头，可以用定义一个要处

理信号的范围（如：SIGIO- SIGKILL，表示处理从SIGIO信号到SIGKILL的信号，其中包括SIGIO，

SIGIOT，SIGKILL三个信号），也可以使用关键字 all来标明要处理所有的信号。一旦被调试的程

序接收到信号，运行程序马上会被GDB停住，以供调试。其< keywords>可以是以下几种关键字的

一个或多个。

nostop
当被调试的程序收到信号时，GDB不会停住程序的运行，但会打出消息告诉你收到这种信号。
stop
当被调试的程序收到信号时，GDB会停住你的程序。
print
当被调试的程序收到信号时，GDB会显示出一条信息。
noprint
当被调试的程序收到信号时，GDB不会告诉你收到信号的信息。
pass
noignore
当被调试的程序收到信号时，GDB不处理信号。这表示，GDB会把这个信号交给被调试程序会处理

。
nopass
ignore
当被调试的程序收到信号时，GDB不会让被调试程序来处理这个信号。

info signals
info handle
查看有哪些信号在被GDB检测中。
十、线程（Thread Stops）
如果你程序是多线程的话，你可以定义你的断点是否在所有的线程上，或是在某个特定的线程。

GDB很容易帮你完成这一工作。

break <linespec> thread <threadno>
break <linespec> thread <threadno> if ...
linespec 指定了断点设置在的源程序的行号。threadno指定了线程的ID，注意，这个ID是GDB分

配的，你可以通过“info threads”命令来查看正在运行程序中的线程信息。如果你不指定

thread <threadno>则表示你的断点设在所有线程上面。你还可以为某线程指定断点条件。如：

(gdb) break frik.c:13 thread 28 if bartab > lim

当你的程序被GDB停住时，所有的运行线程都会被停住。这方便你你查看运行程序的总体情况。而

在你恢复程序运行时，所有的线程也会被恢复运行。那怕是主进程在被单步调试时。
查看栈信息
当程序被停住了，你需要做的第一件事就是查看程序是在哪里停住的。当你的程序调用了一个函

数，函数的地址，函数参数，函数内的局部变量都会被压入“栈”（Stack）中。你可以用GDB命

令来查看当前的栈中的信息。

下面是一些查看函数调用栈信息的GDB命令：

backtrace
bt
打印当前的函数调用栈的所有信息。如：

(gdb) bt
#0 func (n=250) at tst.c:6
#1 0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6

从上可以看出函数的调用栈信息：__libc_start_main --> main() --> func()

backtrace <n>
bt <n>
n是一个正整数，表示只打印栈顶上n层的栈信息。

backtrace <-n>
bt <-n>
-n表一个负整数，表示只打印栈底下n层的栈信息。

如果你要查看某一层的信息，你需要在切换当前的栈，一般来说，程序停止时，最顶层的栈就是

当前栈，如果你要查看栈下面层的详细信息，首先要做的是切换当前栈。

frame <n>
f <n>
n是一个从0开始的整数，是栈中的层编号。比如：frame 0，表示栈顶，frame 1，表示栈的第二

层。

up <n>
表示向栈的上面移动n层，可以不打n，表示向上移动一层。

down <n>
表示向栈的下面移动n层，可以不打n，表示向下移动一层。

上面的命令，都会打印出移动到的栈层的信息。如果你不想让其打出信息。你可以使用这三个命

令：

select-frame <n> 对应于 frame 命令。
up-silently <n> 对应于 up 命令。
down-silently <n> 对应于 down 命令。

查看当前栈层的信息，你可以用以下GDB命令：

frame 或 f
会打印出这些信息：栈的层编号，当前的函数名，函数参数值，函数所在文件及行号，函数执行

到的语句。

info frame
info f
这个命令会打印出更为详细的当前栈层的信息，只不过，大多数都是运行时的内内地址。比如：

函数地址，调用函数的地址，被调用函数的地址，目前的函数是由什么样的程序语言写成的、函

数参数地址及值、局部变量的地址等等。如：
(gdb) info f
Stack level 0, frame at 0xbffff5d4:
eip = 0x804845d in func (tst.c:6); saved eip 0x8048524
called by frame at 0xbffff60c
source language c.
Arglist at 0xbffff5d4, args: n=250
Locals at 0xbffff5d4, Previous frame's sp is 0x0
Saved registers:
ebp at 0xbffff5d4, eip at 0xbffff5d8

info args
打印出当前函数的参数名及其值。

info locals
打印出当前函数中所有局部变量及其值。

info catch
打印出当前的函数中的异常处理信息。
查看源程序
一、显示源代码
GDB  可以打印出所调试程序的源代码，当然，在程序编译时一定要加上-g的参数，把源程序信息

编译到执行文件中。不然就看不到源程序了。当程序停下来以后， GDB会报告程序停在了那个文

件的第几行上。你可以用list命令来打印程序的源代码。还是来看一看查看源代码的GDB命令吧。

list <linenum>
显示程序第linenum行的周围的源程序。

list <function>
显示函数名为function的函数的源程序。

list
显示当前行后面的源程序。

list -
显示当前行前面的源程序。

一般是打印当前行的上5行和下5行，如果显示函数是是上2行下8行，默认是10行，当然，你也可

以定制显示的范围，使用下面命令可以设置一次显示源程序的行数。

set listsize <count>
设置一次显示源代码的行数。

show listsize
查看当前listsize的设置。

list命令还有下面的用法：

list <first>, <last>
显示从first行到last行之间的源代码。

list , <last>
显示从当前行到last行之间的源代码。

list +
往后显示源代码。

一般来说在list后面可以跟以下这们的参数：

<linenum> 行号。
<+offset> 当前行号的正偏移量。
<-offset> 当前行号的负偏移量。
<filename:linenum> 哪个文件的哪一行。
<function> 函数名。
<filename:function> 哪个文件中的哪个函数。
<*address> 程序运行时的语句在内存中的地址。
二、搜索源代码
不仅如此，GDB还提供了源代码搜索的命令：

forward-search <regexp>
search <regexp>
向前面搜索。

reverse-search <regexp>
全部搜索。

其中，<regexp>就是正则表达式，也主一个字符串的匹配模式，关于正则表达式，我就不在这里

讲了，还请各位查看相关资料。
三、指定源文件的路径
某些时候，用-g编译过后的执行程序中只是包括了源文件的名字，没有路径名。GDB提供了可以让

你指定源文件的路径的命令，以便GDB进行搜索。

directory <dirname ... >
dir <dirname ... >
加一个源文件路径到当前路径的前面。如果你要指定多个路径，UNIX下你可以使用“:”，

Windows下你可以使用“;”。
directory
清除所有的自定义的源文件搜索路径信息。

show directories
显示定义了的源文件搜索路径。

四、源代码的内存
你可以使用info line命令来查看源代码在内存中的地址。info line后面可以跟“行号”，“函

数名”，“文件名:行号”，“文件名:函数名”，这个命令会打印出所指定的源码在运行时的内

存地址，如：

(gdb) info line tst.c:func
Line 5 of "tst.c" starts at address 0x8048456 <func+6> and ends at 0x804845d

<func+13>.

还有一个命令（disassemble）你可以查看源程序的当前执行时的机器码，这个命令会把目前内存

中的指令dump出来。如下面的示例表示查看函数func的汇编代码。

(gdb) disassemble func
Dump of assembler code for function func:
0x8048450 <func>: push %ebp
0x8048451 <func+1>: mov %esp,%ebp
0x8048453 <func+3>: sub $0x18,%esp
0x8048456 <func+6>: movl $0x0,0xfffffffc(%ebp)
0x804845d <func+13>: movl $0x1,0xfffffff8(%ebp)
0x8048464 <func+20>: mov 0xfffffff8(%ebp),%eax
0x8048467 <func+23>: cmp 0x8(%ebp),%eax
0x804846a <func+26>: jle 0x8048470 <func+32>
0x804846c <func+28>: jmp 0x8048480 <func+48>
0x804846e <func+30>: mov %esi,%esi
0x8048470 <func+32>: mov 0xfffffff8(%ebp),%eax
0x8048473 <func+35>: add %eax,0xfffffffc(%ebp)
0x8048476 <func+38>: incl 0xfffffff8(%ebp)
0x8048479 <func+41>: jmp 0x8048464 <func+20>
0x804847b <func+43>: nop
0x804847c <func+44>: lea 0x0(%esi,1),%esi
0x8048480 <func+48>: mov 0xfffffffc(%ebp),%edx
0x8048483 <func+51>: mov %edx,%eax
0x8048485 <func+53>: jmp 0x8048487 <func+55>
0x8048487 <func+55>: mov %ebp,%esp
0x8048489 <func+57>: pop %ebp
0x804848a <func+58>: ret
End of assembler dump.

查看运行时数据
在你调试程序时，当程序被停住时，你可以使用print命令（简写命令为p），或是同义命令

inspect来查看当前程序的运行数据。print命令的格式是：

print <expr>
print /<f> <expr>
<expr>是表达式，是你所调试的程序的语言的表达式（GDB可以调试多种编程语言），<f>是输出

的格式，比如，如果要把表达式按16进制的格式输出，那么就是/x。

一、表达式
print和许多GDB的命令一样，可以接受一个表达式，GDB会根据当前的程序运行的数据来计算这个

表达式，既然是表达式，那么就可以是当前程序运行中的const常量、变量、函数等内容。可惜的

是GDB不能使用你在程序中所定义的宏。

表达式的语法应该是当前所调试的语言的语法，由于C/C++是一种大众型的语言，所以，本文中的

例子都是关于C/C++的。（而关于用GDB调试其它语言的章节，我将在后面介绍）

在表达式中，有几种GDB所支持的操作符，它们可以用在任何一种语言中。

@
是一个和数组有关的操作符，在后面会有更详细的说明。

::
指定一个在文件或是一个函数中的变量。

{<type>} <addr>
表示一个指向内存地址<addr>的类型为type的一个对象。

二、程序变量
在GDB中，你可以随时查看以下三种变量的值：
1、全局变量（所有文件可见的）
2、静态全局变量（当前文件可见的）
3、局部变量（当前Scope可见的）

如果你的局部变量和全局变量发生冲突（也就是重名），一般情况下是局部变量会隐藏全局变量

，也就是说，如果一个全局变量和一个函数中的局部变量同名时，如果当前停止点在函数中，用

print显示出的变量的值会是函数中的局部变量的值。如果此时你想查看全局变量的值时，你可以

使用“::”操作符：

file::variable
function::variable
可以通过这种形式指定你所想查看的变量，是哪个文件中的或是哪个函数中的。例如，查看文件

f2.c中的全局变量x的值：

gdb) p 'f2.c'::x

当然，“::”操作符会和C++中的发生冲突，GDB能自动识别“::” 是否C++的操作符，所以你不

必担心在调试C++程序时会出现异常。

另外，需要注意的是，如果你的程序编译时开启了优化选项，那么在用GDB调试被优化过的程序时

，可能会发生某些变量不能访问，或是取值错误码的情况。这个是很正常的，因为优化程序会删

改你的程序，整理你程序的语句顺序，剔除一些无意义的变量等，所以在GDB调试这种程序时，运

行时的指令和你所编写指令就有不一样，也就会出现你所想象不到的结果。对付这种情况时，需

要在编译程序时关闭编译优化。一般来说，几乎所有的编译器都支持编译优化的开关，例如，GNU

的 C/C++编译器GCC，你可以使用“-gstabs”选项来解决这个问题。关于编译器的参数，还请查

看编译器的使用说明文档。
三、数组
有时候，你需要查看一段连续的内存空间的值。比如数组的一段，或是动态分配的数据的大小。

你可以使用GDB的“@”操作符，“@”的左边是第一个内存的地址的值，“@”的右边则你你想查

看内存的长度。例如，你的程序中有这样的语句：

int *array = (int *) malloc (len * sizeof (int));

于是，在GDB调试过程中，你可以以如下命令显示出这个动态数组的取值：

p *array@len

@的左边是数组的首地址的值，也就是变量array所指向的内容，右边则是数据的长度，其保存在

变量len中，其输出结果，大约是下面这个样子的：

(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

如果是静态数组的话，可以直接用print数组名，就可以显示数组中所有数据的内容了。

四、输出格式
一般来说，GDB会根据变量的类型输出变量的值。但你也可以自定义GDB的输出的格式。例如，你

想输出一个整数的十六进制，或是二进制来查看这个整型变量的中的位的情况。要做到这样，你

可以使用GDB的数据显示格式：

x 按十六进制格式显示变量。
d 按十进制格式显示变量。
u 按十六进制格式显示无符号整型。
o 按八进制格式显示变量。
t 按二进制格式显示变量。
a 按十六进制格式显示变量。
c 按字符格式显示变量。
f 按浮点数格式显示变量。

(gdb) p i
$21 = 101

(gdb) p/a i
$22 = 0x65

(gdb) p/c i
$23 = 101 'e'

(gdb) p/f i
$24 = 1.41531145e-43

(gdb) p/x i
$25 = 0x65

(gdb) p/t i
$26 = 1100101
五、查看内存
你可以使用examine命令（简写是x）来查看内存地址中的值。x命令的语法如下所示：

x/<n/f/u> <addr>

n、f、u是可选的参数。

n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。
f 表示显示的格式，参见上面。如果地址所指的是字符串，那么格式可以是s，如果地十是指令地

址，那么格式可以是i。
u  表示从当前地址往后请求的字节数，如果不指定的话，GDB默认是4个bytes。u参数可以用下面

的字符来代替，b表示单字节，h表示双字节，w表示四字节，g表示八字节。当我们指定了字节长

度后，GDB会从指内存定的内存地址开始，读写指定字节，并把其当作一个值取出来。

<addr>表示一个内存地址。

n/f/u三个参数可以一起使用。例如：

命令：x/3uh 0x54320 表示，从内存地址0x54320读取内容，h表示以双字节为一个单位，3表示三

个单位，u表示按十六进制显示。
六、自动显示
你可以设置一些自动显示的变量，当程序停住时，或是在你单步跟踪时，这些变量会自动显示。

相关的GDB命令是display。

display <expr>
display/<fmt> <expr>
display/<fmt> <addr>

expr是一个表达式，fmt表示显示的格式，addr表示内存地址，当你用display设定好了一个或多

个表达式后，只要你的程序被停下来，GDB会自动显示你所设置的这些表达式的值。

格式i和s同样被display支持，一个非常有用的命令是：

display/i $pc

$pc是GDB的环境变量，表示着指令的地址，/i则表示输出格式为机器指令码，也就是汇编。于是

当程序停下后，就会出现源代码和机器指令码相对应的情形，这是一个很有意思的功能。

下面是一些和display相关的GDB命令：

undisplay <dnums...>
delete display <dnums...>
删除自动显示，dnums意为所设置好了的自动显式的编号。如果要同时删除几个，编号可以用空格

分隔，如果要删除一个范围内的编号，可以用减号表示（如：2-5）

disable display <dnums...>
enable display <dnums...>
disable和enalbe不删除自动显示的设置，而只是让其失效和恢复。
info display
查看display设置的自动显示的信息。GDB会打出一张表格，向你报告当然调试中设置了多少个自

动显示设置，其中包括，设置的编号，表达式，是否enable。
七、设置显示选项
GDB中关于显示的选项比较多，这里我只例举大多数常用的选项。

set print address
set print address on
打开地址输出，当程序显示函数信息时，GDB会显出函数的参数地址。系统默认为打开的，如：

(gdb) f
#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
at input.c:530
530 if (lquote != def_lquote)

set print address off
关闭函数的参数地址显示，如：

(gdb) set print addr off
(gdb) f
#0 set_quotes (lq="<<", rq=">>") at input.c:530
530 if (lquote != def_lquote)

show print address
查看当前地址显示选项是否打开。

set print array
set print array on
打开数组显示，打开后当数组显示时，每个元素占一行，如果不打开的话，每个元素则以逗号分

隔。这个选项默认是关闭的。与之相关的两个命令如下，我就不再多说了。

set print array off
show print array

set print elements <number-of-elements>
这个选项主要是设置数组的，如果你的数组太大了，那么就可以指定一个<number-of-elements>

来指定数据显示的最大长度，当到达这个长度时，GDB就不再往下显示了。如果设置为0，则表示

不限制。

show print elements
查看print elements的选项信息。
set print null-stop <on/off>
如果打开了这个选项，那么当显示字符串时，遇到结束符则停止显示。这个选项默认为off。

set print pretty on
如果打开printf pretty这个选项，那么当GDB显示结构体时会比较漂亮。如：

$1 = {
next = 0x0,
flags = {
sweet = 1,
sour = 1
},
meat = 0x54 "Pork"
}

set print pretty off
关闭printf pretty这个选项，GDB显示结构体时会如下显示：

$1 = {next = 0x0, flags = {sweet = 1, sour = 1}, meat = 0x54 "Pork"}

show print pretty
查看GDB是如何显示结构体的。

set print sevenbit-strings <on/off>
设置字符显示，是否按“\nnn”的格式显示，如果打开，则字符串或字符数据按\nnn显示，如

“\065”。

show print sevenbit-strings
查看字符显示开关是否打开。

set print union <on/off>
设置显示结构体时，是否显式其内的联合体数据。例如有以下数据结构：

typedef enum {Tree, Bug} Species;
typedef enum {Big_tree, Acorn, Seedling} Tree_forms;
typedef enum {Caterpillar, Cocoon, Butterfly}
Bug_forms;

struct thing {
Species it;
union {
Tree_forms tree;
Bug_forms bug;
} form;
};

struct thing foo = {Tree, {Acorn}};

当打开这个开关时，执行 p foo 命令后，会如下显示：
$1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}}

当关闭这个开关时，执行 p foo 命令后，会如下显示：
$1 = {it = Tree, form = {...}}

show print union
查看联合体数据的显示方式

set print object <on/off>
在C++中，如果一个对象指针指向其派生类，如果打开这个选项，GDB会自动按照虚方法调用的规

则显示输出，如果关闭这个选项的话，GDB就不管虚函数表了。这个选项默认是off。

show print object
查看对象选项的设置。

set print static-members <on/off>
这个选项表示，当显示一个C++对象中的内容是，是否显示其中的静态数据成员。默认是on。

show print static-members
查看静态数据成员选项设置。

set print vtbl <on/off>
当此选项打开时，GDB将用比较规整的格式来显示虚函数表时。其默认是关闭的。

show print vtbl
查看虚函数显示格式的选项。
八、历史记录
当你用GDB的print查看程序运行时的数据时，你每一个print都会被GDB记录下来。GDB会以$1,

$2, $3 .....这样的方式为你每一个print命令编上号。于是，你可以使用这个编号访问以前的表

达式，如$1。这个功能所带来的好处是，如果你先前输入了一个比较长的表达式，如果你还想查

看这个表达式的值，你可以使用历史记录来访问，省去了重复输入。

九、GDB环境变量
你可以在GDB的调试环境中定义自己的变量，用来保存一些调试程序中的运行数据。要定义一个

GDB的变量很简单只需。使用GDB的set命令。GDB的环境变量和UNIX一样，也是以$起头。如：

set $foo = *object_ptr

使用环境变量时，GDB会在你第一次使用时创建这个变量，而在以后的使用中，则直接对其賦值。

环境变量没有类型，你可以给环境变量定义任一的类型。包括结构体和数组。

show convenience
该命令查看当前所设置的所有的环境变量。

这是一个比较强大的功能，环境变量和程序变量的交互使用，将使得程序调试更为灵活便捷。例

如：

set $i = 0
print bar[$i++]->contents

于是，当你就不必，print bar[0]->contents, print bar[1]-> contents地输入命令了。输入这

样的命令后，只用敲回车，重复执行上一条语句，环境变量会自动累加，从而完成逐个输出的功

能。
十、查看寄存器
要查看寄存器的值，很简单，可以使用如下命令：

info registers
查看寄存器的情况。（除了浮点寄存器）

info all-registers
查看所有寄存器的情况。（包括浮点寄存器）

info registers <regname ...>
查看所指定的寄存器的情况。

寄存器中放置了程序运行时的数据，比如程序当前运行的指令地址（ip），程序的当前堆栈地址

（sp）等等。你同样可以使用print命令来访问寄存器的情况，只需要在寄存器名字前加一个$符

号就可以了。如：p $eip。

改变程序的执行
一旦使用GDB挂上被调试程序，当程序运行起来后，你可以根据自己的调试思路来动态地在GDB中

更改当前被调试程序的运行线路或是其变量的值，这个强大的功能能够让你更好的调试你的程序

，比如，你可以在程序的一次运行中走遍程序的所有分支。
一、修改变量值
修改被调试程序运行时的变量值，在GDB中很容易实现，使用GDB的print命令即可完成。如：

(gdb) print x=4

x=4这个表达式是C/C++的语法，意为把变量x的值修改为4，如果你当前调试的语言是Pascal，那

么你可以使用Pascal的语法：x:=4。

在某些时候，很有可能你的变量和GDB中的参数冲突，如：

(gdb) whatis width
type = double
(gdb) p width
$4 = 13
(gdb) set width=47
Invalid syntax in expression.

因为，set width是GDB的命令，所以，出现了“Invalid syntax in  expression”的设置错误，

此时，你可以使用set var命令来告诉GDB，width不是你GDB的参数，而是程序的变量名，如：

(gdb) set var width=47

另外，还可能有些情况，GDB并不报告这种错误，所以保险起见，在你改变程序变量取值时，最好

都使用set var格式的GDB命令。
二、跳转执行
一般来说，被调试程序会按照程序代码的运行顺序依次执行。GDB提供了乱序执行的功能，也就是

说，GDB可以修改程序的执行顺序，可以让程序执行随意跳跃。这个功能可以由GDB的jump命令来

完：

jump <linespec>
指定下一条语句的运行点。<linespce>可以是文件的行号，可以是file:line格式，可以是+num这

种偏移量格式。表式着下一条运行语句从哪里开始。

jump <address>
这里的<address>是代码行的内存地址。

注意，jump命令不会改变当前的程序栈中的内容，所以，当你从一个函数跳到另一个函数时，当

函数运行完返回时进行弹栈操作时必然会发生错误，可能结果还是非常奇怪的，甚至于产生程序

Core Dump。所以最好是同一个函数中进行跳转。

熟悉汇编的人都知道，程序运行时，有一个寄存器用于保存当前代码所在的内存地址。所以，

jump命令也就是改变了这个寄存器中的值。于是，你可以使用“set $pc”来更改跳转执行的地址

。如：

set $pc = 0x485
三、产生信号量
使用singal命令，可以产生一个信号量给被调试的程序。如：中断信号Ctrl+C。这非常方便于程

序的调试，可以在程序运行的任意位置设置断点，并在该断点用GDB产生一个信号量，这种精确地

在某处产生信号非常有利程序的调试。

语法是：signal <singal>，UNIX的系统信号量通常从1到15。所以<singal>取值也在这个范围。

single命令和shell的kill命令不同，系统的kill命令发信号给被调试程序时，是由GDB截获的，

而single命令所发出一信号则是直接发给被调试程序的。
四、强制函数返回
如果你的调试断点在某个函数中，并还有语句没有执行完。你可以使用return命令强制函数忽略

还没有执行的语句并返回。

return
return <expression>
使用return命令取消当前函数的执行，并立即返回，如果指定了<expression>，那么该表达式的

值会被认作函数的返回值。
五、强制调用函数
call <expr>
表达式中可以一是函数，以此达到强制调用函数的目的。并显示函数的返回值，如果函数返回值

是void，那么就不显示。
另一个相似的命令也可以完成这一功能——print，print后面可以跟表达式，所以也可以用他来

调用函数，print和call的不同是，如果函数返回void，call则不显示，print则显示函数返回值

，并把该值存入历史数据中。
在不同语言中使用GDB
GDB 支持下列语言：C, C++, Fortran, PASCAL, Java, Chill, assembly, 和 Modula- 2。一般

说来， GDB会根据你所调试的程序来确定当然的调试语言，比如：发现文件名后缀为“.c”的，

GDB会认为是C程序。文件名后缀为“.C, .cc, .cp,  .cpp, .cxx, .c++”的，GDB会认为是C++程

序。而后缀是“.f, .F”的，GDB会认为是Fortran程序，还有，后缀为如果是“.s, .S”的会认

为是汇编语言。

也就是说，GDB会根据你所调试的程序的语言，来设置自己的语言环境，并让GDB的命令跟着语言

环境的改变而改变。比如一些GDB命令需要用到表达式或变量时，这些表达式或变量的语法，完全

是根据当前的语言环境而改变的。例如C/C++中对指针的语法是*p，而在Modula-2中则是p^。并且

，如果你当前的程序是由几种不同语言一同编译成的，那到在调试过程中，GDB也能根据不同的语

言自动地切换语言环境。这种跟着语言环境而改变的功能，真是体贴开发人员的一种设计。

下面是几个相关于GDB语言环境的命令：

show language
查看当前的语言环境。如果GDB不能识为你所调试的编程语言，那么，C语言被认为是默认的环境

。

info frame
查看当前函数的程序语言。

info source
查看当前文件的程序语言。

如果GDB没有检测出当前的程序语言，那么你也可以手动设置当前的程序语言。使用set language

命令即可做到。

当set language命令后什么也不跟的话，你可以查看GDB所支持的语言种类：

(gdb) set language
The currently understood settings are:

local or auto Automatic setting based on source file
c Use the C language
c++ Use the C++ language
asm Use the Asm language
chill Use the Chill language
fortran Use the Fortran language
java Use the Java language
modula-2 Use the Modula-2 language
pascal Use the Pascal language
scheme Use the Scheme language

于是你可以在set language后跟上被列出来的程序语言名，来设置当前的语言环境。