Linux嵌入式开发与应用

欢迎来到Linux嵌入式开发与应用>>　　 | 首页 资源中心 | Database | Linux | 生活趣谈 | 嵌入式开发 | 一般分类 | ITPUB论坛

QT开发

发表人:upczap | 发表时间: 2007年六月24日, 22:19

QT开发群 42164870 ，欢迎QT开发爱好者加入该群！！

有经验大家共同学习！


分类: ( Linux ) :: 评论 (9) :: 静态链接网址 :: 引用 (0)

自制一小型的linux系统mylinux

发表人:upczap | 发表时间: 2007年六月02日, 18:57

通过grub引导程序引导编译后的内核文件bzImage,把制作的文件系统变成ramdisk镜像文件,通过内存加载镜像文件完成文件系统的注入；其中的命令通过编译busybox生成bin,sbin文件；注意：

内核文件+文件系统镜像文件+grub引导程序<=1440K

详细步骤：

1. 软盘上安装引导器（grub）

具体操作如下：

# mke2fs /dev/fd0

创建了 ext2 文件

# mount /dev/fd0 /mnt/floppy

现在，创建一些目录，并将一些关键文件复制到软盘：

# mkdir /mnt/floppy/boot

# mkdir /mnt/floppy/boot/grub

# cp /boot/grub/stage1 /mnt/floppy/boot/grub

# cp /boot/grub/stage2 /mnt/floppy/boot/grub

运行grub命令

在 grub> 提示符处，输入：

grub> root (fd0)

grub> setup (fd0)

grub> quit

引导盘完成。

2 配置busybox

新建一个目录存放资料：

#mkdir /floppylinux

用make menuconfig配置busybox

#cp busybox-1.00.tar.gz /floppylinux

#cd /floppylinux

#tar xvfz busybox-1.00.tar.gz

#cd busybox-1.00

#make menuconfig

下面是需要编译进busybox的功能选项,

General Configuration应该选的选项

Show verbose applet usage messages

Runtime SUID/SGID configuration via /etc/busybox.conf

Build Options

Build BusyBox as a static binary (no shared libs)

Installation Options

Don't use /usr

其他选项都是一些linux基本命令选项默认

配置好后退出并保存.

编译并安装busybox

#make

#make install

编译好后在busybox目录下生成子目录_install,里面的内容:

drwxr-xr-x 2 root root 4096 11月 24 15:28 bin

lrwxrwxrwx 1 root root 11 11月 24 15:28 linuxrc -> bin/busybox

drwxr-xr-x 2 root root 4096 11月 24 15:28 sbin

其中可执行文件busybox在bin目录下,其他的都是指向他的符号链接.

3 制作根文件系统

建立临时目录,该目录为软盘的文件系统

#mkdir //tmp/floppy-linux

将busybox下的_install目录下的文件复制过来：

#cp ./_install /tmp/floppy-linux –r

#cd /tmp/floppy-linux

# mkdir dev etc etc/init.d proc mnt tmp var

# chmod 755 dev etc etc/init.d bin mnt tmp var

# chmod 555 proc

# cd dev

# mknod tty c 5 0

# mknod console c 5 1

# chmod 666 tty console

# mknod tty0 c 4 0

# chmod 666 tty0

# mknod ram0 b 1 0

# chmod 600 ram0

# mknod fd0 b 2 0

# chmod 600 fd0

# mknod null c 1 3

# chmod 666 null

建启动配置文件：

/etc/inittab,

/etc/init.d/rcS,

/etc/fstab

/boot/grub.conf

/boot/menu.lst

其中

#ln –s grub.conf menu.lst

initab:

::sysinit:/etc/init.d/rcS

::askfirst:/bin/sh

rcS:

#!/bin/sh

mount –a

# chmod 755 rc.sysinit

fstab:

proc /proc proc defaults 0 0

grub.conf:

timeout 10

default 0

title FloppyLinux 　　root (fd0)　　kernel /boot/bzImage　　initrd /initrd.img.gz

4 制作Ramdisk的镜像文件：

# dd if=/dev/zero of=/dev/ram1

dd: 正在写入 ‘/dev/ram1’: 设备上没有空间

读入了 8193+0 个块

输出了 8192+0 个块

#mke2fs -m0 /dev/ram1

#mkdir /mnt/ram

#mount /dev/ram1 /mnt/ram

将先前做好的floppylinux根文件系统拷贝到ram1上.

#cp -R /tmp/floppy-linux /* /mnt/ram

#umount /dev/ram1

# dd if=/dev/ram1 of=/tmp/floppy-linux /initrd.img

# file initrd.img

initrd.img: Linux rev 1.0 ext2 filesystem data

用loop设备来把他重新挂装到文件系统里:

# mount -o loop initrd.img /mnt/ram/

查看/mnt/ram下的内容,和/tmp/floppy-linux /下的一模一样

# ls /mnt/ram

bin dev etc lost+found mnt proc sbin tmp var

#umount /mnt/ram

压缩initrd.img印象文件

# gzip -v9 initrd.img

initrd.img: 90.1% -- replaced with initrd.img.gz

查看压缩后的大小:

# ls -lh initrd.img.gz

只有406K

5编译linux系统内核

#cp linux-2.4.20.bz2 /usr/src/

#cd /usr/src

#tar xfvj linux-2.4.20.bz2

#ln -s linux-2.4.20 linux

进入linux源代码目录:

#cd linux

清理源代码树:

#make mrproper

运行配置程序:

#make menuconfig

code maturity level options

先选择N,当我们配置好常规的东西,要加入framebuffer支持时再将这一项选择Y,如果不在code maturity level options选择为Y,将不能配置framebuffer.

Loadable module support

选择N,为了简化系统的制作,我在这个项目中不选择可加载内核模块的支持.

processor type and features

processor family 中选择386CPU

其他选项都选择N.

General setup

networking support 选择Y

PCI support 选择Y

System V ipc 选择Y

systrl support选择Y

kernel support for ELF 选择Y

其余内容都可以选择N,

chnology devices (MTD)

Parallel port support

Plug and Play configuration

以上三个大项中的所有内容选择N

block devices

Normal floppy disk support

Loopback device support

RAM disk support

initial RAM disk (initrd) support

Per partition statics in /proc/partitions

以上几项选择Y,其余全部选择N.

Multi-device support (RAID and LVM)

Cryptography support (CryptoAPI)

这两个大项全部选择N

Networking options

这一大项中,只需要把下列项目编译进内核:

Packet socket :mmapped IO

TCP/IP networking

Telephony Support 选择N

ATA/IDE/MFM/RLL support

选择Y,然后下面的'IDE,ATA and ATAPI Block Devices'按钮就被激活

下面几项选择Y,其余都可以是N.

Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support

Include IDE/ATA-2 DISK support

Auto-Geometry Resizing support

Include IDE/ATA CDROM support

SCSI support

Fusion MPT device support

IEEE 1394(FireWire) support

I2O device support

全部选择N

Network device support

选择Y

然后点Ethernet(10 or 100 Mbit)按钮选择网卡驱动(Reltek8139)

Amateur Radio support

IrDA (infrared) support

ISDN subsystem

Old CD-ROM drivers (not SCSI,not IDE)

Input core support

全部选择N

Charcter devices

除了Virtual terminal和Support for console on terminal两项,其他全选N

Multimedia devices

Crypto Hardware support

全部选择N.

File sytems

选择其中有三个:

/proc file system support.

Second extended fs support BabyLinux的基本文件系统.

ISO 9660 CDROM filesytem support用光盘.

Console drivers

.前面三个全部选择Y,

Frame-buffer support按钮是灰色的不能选,别急,回到第一个大选项:

Code maturity level options 选择Y,就可以激活这个按钮了.

下面几个选项需要选择Y:

Support for framebuffer devices

VESA VGA graphics console

Support only 8 pixels wide fonts

剩下的几个大项全部选N

保存后退出,配置程序会自动生成一个隐藏的配置文件.config

#make dep

#make bzImage

bzImage为654K

6 整合启动盘

#cp bzImage /mnt/floppy/boot

#cp /tmp/floppy-linux/initrd.img.gz /mnt/floppy

全部文件（文件夹）如下：

/lost+found/

/boot/

/boot/grub/

/boot/grub/stage1

/boot/grub/stage2

/boot/grub/menu.lst

/boot/grub/grub.conf

/boot/bzImage

/initrd.img.gz

五实验遇到问题与总结

1,在制作启动盘的时候，运行grub命令后，进入grub界面后，运行:

grub>setup (fd0)

结果有时可能会出错，可能是软盘出问题，换张软盘

2，软盘制作完成后，重启机器，在grub开始进行引导时可能出现错误：

Error 16: Inconsistent filesystem strutwre

这个也是软盘的问题

3，在编译的内核时，有时可能不通过，在Redhet9.0(kernel-2.4.20)下用gcc-3.3.3就能编译通过2.4.20版本的内核，而在Fedora Core 2下用gcc-3.4.2就不行，可能是gcc的版本问题。


分类: ( Linux ) :: 评论 (1) :: 静态链接网址 :: 引用 (0)

Linux下的多线程编程

发表人:upczap | 发表时间: 2007年五月28日, 08:39

1 引言
　　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。
　　为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。
　　使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。
　　使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
　　除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：
　　1) 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
　　2) 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
　　3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
　　下面我们先来尝试编写一个简单的多线程程序。
2 简单的多线程编程
　　Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序example1.c。

/* example.c*/
#include <stdio.h>
#include <pthread.h>
void thread(void)
{
int i;
for(i=0;i<3;i++)
printf("This is a pthread.n");
}

int main(void)
{
pthread_t id;
int i,ret;
ret=pthread_create(&id,NULL,(void *) thread,NULL);
if(ret!=0){
printf ("Create pthread error!n");
exit (1);
}
for(i=0;i<3;i++)
printf("This is the main process.n");
pthread_join(id,NULL);
return (0);
}

我们编译此程序：
gcc example1.c -lpthread -o example1
运行example1，我们得到如下结果：
This is the main process.
This is a pthread.
This is the main process.
This is the main process.
This is a pthread.
This is a pthread.
再次运行，我们可能得到如下结果：
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.

　　前后两次结果不一样，这是两个线程争夺CPU资源的结果。上面的示例中，我们使用到了两个函数，　　pthread_create和pthread_join，并声明了一个pthread_t型的变量。
　　pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：
　　typedef unsigned long int pthread_t;
　　它是一个线程的标识符。函数pthread_create用来创建一个线程，它的原型为：
　　extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,
　　void *(*__start_routine) (void *), void *__arg));
　　第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。
　　函数pthread_join用来等待一个线程的结束。函数原型为：
　　extern int pthread_join __P ((pthread_t __th, void **__thread_return));
　　第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。它的函数原型为：
　　extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
　　唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。
　　在这一节里，我们编写了一个最简单的线程，并掌握了最常用的三个函数pthread_create，pthread_join和pthread_exit。下面，我们来了解线程的一些常用属性以及如何设置这些属性。

3 修改线程的属性
　　在上一节的例子里，我们用pthread_create函数创建了一个线程，在这个线程中，我们使用了默认参数，即将该函数的第二个参数设为NULL。的确，对大多数程序来说，使用默认属性就够了，但我们还是有必要来了解一下线程的有关属性。
　　属性结构为pthread_attr_t，它同样在头文件/usr/include/pthread.h中定义，喜欢追根问底的人可以自己去查看。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。属性对象主要包括是否绑定、是否分离、堆栈地址、堆栈大小、优先级。默认的属性为非绑定、非分离、缺省1M的堆栈、与父进程同样级别的优先级。
　　关于线程的绑定，牵涉到另外一个概念：轻进程（LWP：Light Weight Process）。轻进程可以理解为内核线程，它位于用户层和系统层之间。系统对线程资源的分配、对线程的控制是通过轻进程来实现的，一个轻进程可以控制一个或多个线程。默认状况下，启动多少轻进程、哪些轻进程来控制哪些线程是由系统来控制的，这种状况即称为非绑定的。绑定状况下，则顾名思义，即某个线程固定的"绑"在一个轻进程之上。被绑定的线程具有较高的响应速度，这是因为CPU时间片的调度是面向轻进程的，绑定的线程可以保证在需要的时候它总有一个轻进程可用。通过设置被绑定的轻进程的优先级和调度级可以使得绑定的线程满足诸如实时反应之类的要求。
　　设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。下面的代码即创建了一个绑定的线程。
#include <pthread.h>
pthread_attr_t attr;
pthread_t tid;

/*初始化属性值，均设为默认值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

pthread_create(&tid, &attr, (void *) my_function, NULL);

　　线程的分离状态决定一个线程以什么样的方式来终止自己。在上面的例子中，我们采用了线程的默认属性，即为非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。设置线程分离状态的函数为pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）。第二个参数可选为PTHREAD_CREATE_DETACHED（分离线程）和 PTHREAD _CREATE_JOINABLE（非分离线程）。这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timewait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait（）之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。
　　另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。下面即是一段简单的例子。
#include <pthread.h>
#include <sched.h>
pthread_attr_t attr;
pthread_t tid;
sched_param param;
int newprio=20;

pthread_attr_init(&attr);
pthread_attr_getschedparam(&attr, &param);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, &param);
pthread_create(&tid, &attr, (void *)myfunction, myarg);
　　
4 线程的数据处理
　　和进程相比，线程的最大优点之一是数据的共享性，各个进程共享父进程处沿袭的数据段，可以方便的获得、修改数据。但这也给多线程编程带来了许多问题。我们必须当心有多个不同的进程访问相同的变量。许多函数是不可重入的，即同时不能运行一个函数的多个拷贝（除非使用不同的数据段）。在函数中声明的静态变量常常带来问题，函数的返回值也会有问题。因为如果返回的是函数内部静态声明的空间的地址，则在一个线程调用该函数得到地址后使用该地址指向的数据时，别的线程可能调用此函数并修改了这一段数据。在进程中共享的变量必须用关键字volatile来定义，这是为了防止编译器在优化时（如gcc中使用-OX参数）改变它们的使用方式。为了保护变量，我们必须使用信号量、互斥等方法来保证我们对变量的正确使用。下面，我们就逐步介绍处理线程数据时的有关知识。

4.1 线程数据
　　在单线程的程序里，有两种基本的数据：全局变量和局部变量。但在多线程程序里，还有第三种数据类型：线程数据（TSD: Thread-Specific Data）。它和全局变量很象，在线程内部，各个函数可以象使用全局变量一样调用它，但它对线程外部的其它线程是不可见的。这种数据的必要性是显而易见的。例如我们常见的变量errno，它返回标准的出错信息。它显然不能是一个局部变量，几乎每个函数都应该可以调用它；但它又不能是一个全局变量，否则在A线程里输出的很可能是B线程的出错信息。要实现诸如此类的变量，我们就必须使用线程数据。我们为每个线程数据创建一个键，它和这个键相关联，在各个线程里，都使用这个键来指代线程数据，但在不同的线程里，这个键代表的数据是不同的，在同一个线程里，它代表同样的数据内容。
　　和线程数据相关的函数主要有4个：创建一个键；为一个键指定线程数据；从一个键读取线程数据；删除键。
　　创建键的函数原型为：
　　extern int pthread_key_create __P ((pthread_key_t *__key,
　　void (*__destr_function) (void *)));
　　第一个参数为指向一个键值的指针，第二个参数指明了一个destructor函数，如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个键上的内存块。这个函数常和函数pthread_once ((pthread_once_t*once_control, void (*initroutine) (void)))一起使用，为了让这个键只被创建一次。函数pthread_once声明一个初始化函数，第一次调用pthread_once时它执行这个函数，以后的调用将被它忽略。

　　在下面的例子中，我们创建一个键，并将它和某个数据相关联。我们要定义一个函数createWindow，这个函数定义一个图形窗口（数据类型为Fl_Window *，这是图形界面开发工具FLTK中的数据类型）。由于各个线程都会调用这个函数，所以我们使用线程数据。
/* 声明一个键*/
pthread_key_t myWinKey;
/* 函数 createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 调用函数createMyKey，创建键*/
pthread_once ( & once, createMyKey) ;
/*win指向一个新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* 对此窗口作一些可能的设置工作，如大小、位置、名称等*/
setWindow(win);
/* 将窗口指针值绑定在键myWinKey上*/
pthread_setpecific ( myWinKey, win);
}

/* 函数 createMyKey，创建一个键，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}

/* 函数 freeWinKey，释放空间*/
void freeWinKey ( Fl_Window * win){
delete win;
}

　　这样，在不同的线程中调用函数createMyWin，都可以得到在线程内部均可见的窗口变量，这个变量通过函数pthread_getspecific得到。在上面的例子中，我们已经使用了函数pthread_setspecific来将线程数据和一个键绑定在一起。这两个函数的原型如下：
　　extern int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer));
　　extern void *pthread_getspecific __P ((pthread_key_t __key));
　　这两个函数的参数意义和使用方法是显而易见的。要注意的是，用pthread_setspecific为一个键指定新的线程数据时，必须自己释放原有的线程数据以回收空间。这个过程函数pthread_key_delete用来删除一个键，这个键占用的内存将被释放，但同样要注意的是，它只释放键占用的内存，并不释放该键关联的线程数据所占用的内存资源，而且它也不会触发函数pthread_key_create中定义的destructor函数。线程数据的释放必须在释放键之前完成。

4.2 互斥锁
　　互斥锁用来保证一段时间内只有一个线程在执行一段代码。必要性显而易见：假设各个线程向同一个文件顺序写入数据，最后得到的结果一定是灾难性的。
　　我们先看下面一段代码。这是一个读/写程序，它们公用一个缓冲区，并且我们假定一个缓冲区只能保存一条信息。即缓冲区只有两个状态：有信息或没有信息。

void reader_function ( void );
void writer_function ( void );

char buffer;
int buffer_has_item=0;
pthread_mutex_t mutex;
struct timespec delay;
void main ( void ){
pthread_t reader;
/* 定义延迟时间*/
delay.tv_sec = 2;
delay.tv_nec = 0;
/* 用默认属性初始化一个互斥锁对象*/
pthread_mutex_init (&mutex,NULL);
pthread_create(&reader, pthread_attr_default, (void *)&reader_function), NULL);
writer_function( );
}

void writer_function (void){
while(1){
/* 锁定互斥锁*/
pthread_mutex_lock (&mutex);
if (buffer_has_item==0){
buffer=make_new_item( );
buffer_has_item=1;
}
/* 打开互斥锁*/
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}

void reader_function(void){
while(1){
pthread_mutex_lock(&mutex);
if(buffer_has_item==1){
consume_item(buffer);
buffer_has_item=0;
}
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
　　这里声明了互斥锁变量mutex，结构pthread_mutex_t为不公开的数据类型，其中包含一个系统分配的属性对象。函数pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，须调用函数pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函数pthread_mutexattr_settype用来设置互斥锁属性。前一个函数设置属性pshared，它有两个取值，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进程中的线程同步，后者用于同步本进程的不同线程。在上面的例子中，我们使用的是默认属性PTHREAD_PROCESS_ PRIVATE。后者用来设置互斥锁类型，可选的类型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机制，一般情况下，选用最后一个默认属性。
　　pthread_mutex_lock声明开始用互斥锁上锁，此后的代码直至调用pthread_mutex_unlock为止，均被上锁，即同一时间只能被一个线程调用执行。当一个线程执行到pthread_mutex_lock处时，如果该锁此时被另一个线程使用，那此线程被阻塞，即程序将等待到另一个线程释放此互斥锁。在上面的例子中，我们使用了pthread_delay_np函数，让线程睡眠一段时间，就是为了防止一个线程始终占据此函数。
　　上面的例子非常简单，就不再介绍了，需要提出的是在使用互斥锁的过程中很有可能会出现死锁：两个线程试图同时占用两个资源，并按不同的次序锁定相应的互斥锁，例如两个线程都需要锁定互斥锁1和互斥锁2，a线程先锁定互斥锁1，b线程先锁定互斥锁2，这时就出现了死锁。此时我们可以使用函数pthread_mutex_trylock，它是函数pthread_mutex_lock的非阻塞版本，当它发现死锁不可避免时，它会返回相应的信息，程序员可以针对死锁做出相应的处理。另外不同的互斥锁类型对死锁的处理不一样，但最主要的还是要程序员自己在程序设计注意这一点。

4.3 条件变量　　前一节中我们讲述了如何使用互斥锁来实现线程间数据的共享和通信，互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线承间的同步。
　　条件变量的结构为pthread_cond_t，函数pthread_cond_init（）被用来初始化一个条件变量。它的原型为：
　　extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
　　其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指针。结构pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，默认值是PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用。注意初始化条件变量只有未被使用时才能重新初始化或被释放。释放一个条件变量的函数为pthread_cond_ destroy（pthread_cond_t cond）。　
　　函数pthread_cond_wait（）使线程阻塞在一个条件变量上。它的函数原型为：
　　extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
　　pthread_mutex_t *__mutex));
　　线程解开mutex指向的锁并被条件变量cond阻塞。线程可以被函数pthread_cond_signal和函数pthread_cond_broadcast唤醒，但是要注意的是，条件变量只是起阻塞和唤醒线程的作用，具体的判断条件还需用户给出，例如一个变量是否为0等等，这一点我们从后面的例子中可以看到。线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。这个过程一般用while语句实现。
　　另一个用来阻塞线程的函数是pthread_cond_timedwait（），它的原型为：
　　extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
　　pthread_mutex_t *__mutex, __const struct timespec *__abstime));
　　它比函数pthread_cond_wait（）多了一个时间参数，经历abstime段时间后，即使条件变量不满足，阻塞也被解除。
　　函数pthread_cond_signal（）的原型为：
　　extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
　　它用来释放被阻塞在条件变量cond上的一个线程。多个线程阻塞在此条件变量上时，哪一个线程被唤醒是由线程的调度策略所决定的。要注意的是，必须用保护条件变量的互斥锁来保护这个函数，否则条件满足信号又可能在测试条件和调用pthread_cond_wait函数之间被发出，从而造成无限制的等待。下面是使用函数pthread_cond_wait（）和函数pthread_cond_signal（）的一个简单的例子。

pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count　() {
pthread_mutex_lock (&count_lock);
while(count==0)
pthread_cond_wait( &count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock (&count_lock);
}

increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
　　count值为0时，decrement函数在pthread_cond_wait处被阻塞，并打开互斥锁count_lock。此时，当调用到函数increment_count时，pthread_cond_signal（）函数改变条件变量，告知decrement_count（）停止阻塞。读者可以试着让两个线程分别运行这两个函数，看看会出现什么样的结果。
　　函数pthread_cond_broadcast（pthread_cond_t *cond）用来唤醒所有被阻塞在条件变量cond上的线程。这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用这个函数。

4.4 信号量　　信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。当公共资源增加时，调用函数sem_post（）增加信号量。只有当信号量值大于０时，才能使用公共资源，使用后，函数sem_wait（）减少信号量。函数sem_trywait（）和函数pthread_ mutex_trylock（）起同样的作用，它是函数sem_wait（）的非阻塞版本。下面我们逐个介绍和信号量有关的一些函数，它们都在头文件/usr/include/semaphore.h中定义。
　　信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数sem_init（）用来初始化一个信号量。它的原型为：
　　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
　　sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。
　　函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不在阻塞，选择机制同样是由线程的调度策略决定的。
　　函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem )是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。
　　函数sem_destroy(sem_t *sem)用来释放信号量sem。
　　下面我们来看一个使用信号量的例子。在这个例子中，一共有4个线程，其中两个线程负责从文件读取数据到公共的缓冲区，另两个线程从缓冲区读取数据作不同的处理（加和乘运算）。
/* File sem.c */
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAXSTACK 100
int stack[MAXSTACK][2];
int size=0;
sem_t sem;
/* 从文件1.dat读取数据，每读一次，信号量加一*/
void ReadData1(void){
FILE *fp=fopen("1.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*从文件2.dat读取数据*/
void ReadData2(void){
FILE *fp=fopen("2.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*阻塞等待缓冲区有数据，读取数据后，释放空间，继续等待*/
void HandleData1(void){
while(1){
sem_wait(&sem);
printf("Plus:%d+%d=%dn",stack[size][0],stack[size][1],
stack[size][0]+stack[size][1]);
--size;
}
}

void HandleData2(void){
while(1){
sem_wait(&sem);
printf("Multiply:%d*%d=%dn",stack[size][0],stack[size][1],
stack[size][0]*stack[size][1]);
--size;
}
}
int main(void){
pthread_t t1,t2,t3,t4;
sem_init(&sem,0,0);
pthread_create(&t1,NULL,(void *)HandleData1,NULL);
pthread_create(&t2,NULL,(void *)HandleData2,NULL);
pthread_create(&t3,NULL,(void *)ReadData1,NULL);
pthread_create(&t4,NULL,(void *)ReadData2,NULL);
/* 防止程序过早退出，让它在此无限期等待*/
pthread_join(t1,NULL);
}

　　在Linux下，我们用命令gcc -lpthread sem.c -o sem生成可执行文件sem。 我们事先编辑好数据文件1.dat和2.dat，假设它们的内容分别为1 2 3 4 5 6 7 8 9 10和 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ，我们运行sem，得到如下的结果：
Multiply:-1*-2=2
Plus:-1+-2=-3
Multiply:9*10=90
Plus:-9+-10=-19
Multiply:-7*-8=56
Plus:-5+-6=-11
Multiply:-3*-4=12
Plus:9+10=19
Plus:7+8=15
Plus:5+6=11

　　从中我们可以看出各个线程间的竞争关系。而数值并未按我们原先的顺序显示出来这是由于size这个数值被各个线程任意修改的缘故。这也往往是多线程编程要注意的问题。

5 小结
　　多线程编程是一个很有意思也很有用的技术，使用多线程技术的网络蚂蚁是目前最常用的下载工具之一，使用多线程技术的grep比单线程的grep要快上几倍，类似的例子还有很多。希望大家能用多线程技术写出高效实用的好程序来。


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

Linux下的段错误产生的原因及调试方法

发表人:upczap | 发表时间: 2007年三月28日, 16:43

Linux下的段错误产生的原因及调试方法

简而言之,产生段错误就是访问了错误的内存段，一般是你没有权限，或者根本就不存在对应的物理内存,尤其常见的是访问0地址.

一般来说,段错误就是指访问的内存超出了系统所给这个程序的内存空间，通常这个值是由gdtr来保存的，他是一个48位的寄存器，其中的32位是保存由它指向的gdt表，后13位保存相应于gdt的下标，最后3位包括了程序是否在内存中以及程序的在cpu中的运行级别,指向的gdt是由以64位为一个单位的表，在这张表中就保存着程序运行的代码段以及数据段的起始地址以及与此相应的段限和页面交换还有程序运行级别还有内存粒度等等的信息。一旦一个程序发生了越界访问，cpu就会产生相应的异常保护，于是segmentation fault就出现了.

在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的

1)访问系统数据区，尤其是往 系统保护的内存地址写数据
最常见就是给一个指针以0地址
2)内存越界(数组越界，变量类型不一致等) 访问到不属于你的内存区域

解决方法

我们在用C/C++语言写程序的时侯，内存管理的绝大部分工作都是需要我们来做的。实际上，内存管理是一个比较繁琐的工作，无论你多高明，经验多丰富，难 免会在此处犯些小错误，而通常这些错误又是那么的浅显而易于消除。但是手工“除虫”（debug），往往是效率低下且让人厌烦的，本文将就"段错误"这个 内存访问越界的错误谈谈如何快速定位这些"段错误"的语句。
下面将就以下的一个存在段错误的程序介绍几种调试方法：

1 dummy_function (void)
2 {
3 unsigned char *ptr = 0x00;
4 *ptr = 0x00;
5 }
6
7 int main (void)
8 {
9 dummy_function ();
10
11 return 0;
12 }
作为一个熟练的C/C++程序员，以上代码的bug应该是很清楚的，因为它尝试操作地址为0的内存区域，而这个内存区域通常是不可访问的禁区，当然就会出错了。我们尝试编译运行它:
xiaosuo@gentux test $ ./a.out
段错误
果然不出所料，它出错并退出了。
1.利用gdb逐步查找段错误:
这种方法也是被大众所熟知并广泛采用的方法，首先我们需要一个带有调试信息的可执行程序，所以我们加上“-g -rdynamic"的参数进行编译，然后用gdb调试运行这个新编译的程序,具体步骤如下:
xiaosuo@gentux test $ gcc -g -rdynamic d.c
xiaosuo@gentux test $ gdb ./a.out
GNU gdb 6.5
Copyright (C) 2006 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 "i686-pc-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".

(gdb) r
Starting program: /home/xiaosuo/test/a.out

Program received signal SIGSEGV, Segmentation fault.
0x08048524 in dummy_function () at d.c:4
4 *ptr = 0x00;
(gdb)
哦？！好像不用一步步调试我们就找到了出错位置d.c文件的第4行，其实就是如此的简单。
从这里我们还发现进程是由于收到了SIGSEGV信号而结束的。通过进一步的查阅文档(man 7 signal)，我们知道SIGSEGV默认handler的动作是打印”段错误"的出错信息，并产生Core文件，由此我们又产生了方法二。
2.分析Core文件：
Core文件是什么呢？
The default action of certain signals is to cause a process to terminate and produce a core dump file, a disk file containing an image of the process's memory at the time of termination. A list of the signals which cause a process to dump core can be found in signal(7).
以 上资料摘自man page(man 5 core)。不过奇怪了，我的系统上并没有找到core文件。后来，忆起为了渐少系统上的拉圾文件的数量（本人有些洁癖，这也是我喜欢Gentoo的原因 之一），禁止了core文件的生成，查看了以下果真如此，将系统的core文件的大小限制在512K大小，再试:
xiaosuo@gentux test $ ulimit -c
0
xiaosuo@gentux test $ ulimit -c 1000
xiaosuo@gentux test $ ulimit -c
1000
xiaosuo@gentux test $ ./a.out
段错误 (core dumped)
xiaosuo@gentux test $ ls
a.out core d.c f.c g.c pango.c test_iconv.c test_regex.c
core文件终于产生了，用gdb调试一下看看吧:
xiaosuo@gentux test $ gdb ./a.out core
GNU gdb 6.5
Copyright (C) 2006 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 "i686-pc-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".


warning: Can't read pathname for load map: 输入/输出错误.
Reading symbols from /lib/libc.so.6...done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/ld-linux.so.2...done.
Loaded symbols for /lib/ld-linux.so.2
Core was generated by `./a.out'.
Program terminated with signal 11, Segmentation fault.
#0 0x08048524 in dummy_function () at d.c:4
4 *ptr = 0x00;
哇，好历害，还是一步就定位到了错误所在地，佩服一下Linux/Unix系统的此类设计。
接着考虑下去，以前用windows系统下的ie的时侯，有时打开某些网页，会出现“运行时错误”，这个时侯如果恰好你的机器上又装有windows的编译器的话，他会弹出来一个对话框，问你是否进行调试，如果你选择是，编译器将被打开，并进入调试状态，开始调试。
Linux下如何做到这些呢？我的大脑飞速地旋转着，有了，让它在SIGSEGV的handler中调用gdb，于是第三个方法又诞生了:
3.段错误时启动调试:
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>

void dump(int signo)
{
char buf[1024];
char cmd[1024];
FILE *fh;

snprintf(buf, sizeof(buf), "/proc/%d/cmdline", getpid());
if(!(fh = fopen(buf, "r")))
exit(0);
if(!fgets(buf, sizeof(buf), fh))
exit(0);
fclose(fh);
if(buf[strlen(buf) - 1] == 'n')
buf[strlen(buf) - 1] = '';
snprintf(cmd, sizeof(cmd), "gdb %s %d", buf, getpid());
system(cmd);

exit(0);
}

void
dummy_function (void)
{
unsigned char *ptr = 0x00;
*ptr = 0x00;
}

int
main (void)
{
signal(SIGSEGV, &dump);
dummy_function ();

return 0;
}
编译运行效果如下:
xiaosuo@gentux test $ gcc -g -rdynamic f.c
xiaosuo@gentux test $ ./a.out
GNU gdb 6.5
Copyright (C) 2006 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 "i686-pc-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".

Attaching to program: /home/xiaosuo/test/a.out, process 9563
Reading symbols from /lib/libc.so.6...done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/ld-linux.so.2...done.
Loaded symbols for /lib/ld-linux.so.2
0xffffe410 in __kernel_vsyscall ()
(gdb) bt
#0 0xffffe410 in __kernel_vsyscall ()
#1 0xb7ee4b53 in waitpid () from /lib/libc.so.6
#2 0xb7e925c9 in strtold_l () from /lib/libc.so.6
#3 0x08048830 in dump (signo=11) at f.c:22
#4 <signal handler called>
#5 0x0804884c in dummy_function () at f.c:31
#6 0x08048886 in main () at f.c:38
怎么样？是不是依旧很酷？
以上方法都是在系统上有gdb的前提下进行的，如果没有呢？其实glibc为我们提供了此类能够dump栈内容的函数簇，详见/usr/include/execinfo.h（这些函数都没有提供man page，难怪我们找不到），另外你也可以通过gnu的手册进行学习。
4.利用backtrace和objdump进行分析:
重写的代码如下:
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

/* A dummy function to make the backtrace more interesting. */
void
dummy_function (void)
{
unsigned char *ptr = 0x00;
*ptr = 0x00;
}

void dump(int signo)
{
void *array[10];
size_t size;
char **strings;
size_t i;

size = backtrace (array, 10);
strings = backtrace_symbols (array, size);

printf ("Obtained %zd stack frames.n", size);

for (i = 0; i < size; i++)
printf ("%sn", strings[i]);

free (strings);

exit(0);
}

int
main (void)
{
signal(SIGSEGV, &dump);
dummy_function ();

return 0;
}
编译运行结果如下：
xiaosuo@gentux test $ gcc -g -rdynamic g.c
xiaosuo@gentux test $ ./a.out
Obtained 5 stack frames.
./a.out(dump+0x19) [0x80486c2]
[0xffffe420]
./a.out(main+0x35) [0x804876f]
/lib/libc.so.6(__libc_start_main+0xe6) [0xb7e02866]
./a.out [0x8048601]
这次你可能有些失望,似乎没能给出足够的信息来标示错误,不急,先看看能分析出来什么吧,用objdump反汇编程序,找到地址0x804876f对应的代码位置:
xiaosuo@gentux test $ objdump -d a.out

8048765: e8 02 fe ff ff call 804856c <signal@plt>
804876a: e8 25 ff ff ff call 8048694 <dummy_function>
804876f: b8 00 00 00 00 mov $0x0,%eax
8048774: c9 leave
我们还是找到了在哪个函数(dummy_function)中出错的,信息已然不是很完整,不过有总比没有好的啊!
后记:
本文给出了分析"段错误"的几种方法,不要认为这是与孔乙己先生的"回"字四种写法一样的哦,因为每种方法都有其自身的适用范围和适用环境,请酌情使用,或遵医嘱。


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

Linux 下 C 语言编程

发表人:upczap | 发表时间: 2007年三月26日, 22:52

Linux 下 C 语言编程

Linux的发行版中包含了很多软件开发工具。 它们中的很多是用于 C 和 C++应用程序开发的。 本文介绍了在 Linux 下能用于 C 应用程序开发和调试的工具。 本文的主旨是介绍如何在 Linux 下使用 C 编译器和其他 C 编程工具, 而非 C 语言编程的教程。 在本文中你将学到以下知识：
· 什么是 C
· GNU C 编译器
· 用 gdb 来调试GCC应用程序
你也能看到随 Linux 发行的其他有用的 C 编程工具。 这些工具包括源程序美化程序(pretty print programs), 附加的调试工具, 函数原型自动生成工具(automatic function prototypers)。
注意： 源程序美化程序(pretty print programs)自动帮你格式化源代码产生始终如一的缩进格式。
什么是 C?
C 是一种在 UNIX 操作系统的早期就被广泛使用的通用编程语言。 它最早是由贝尔实验室的 Dennis Ritchie 为了 UNIX 的辅助开发而写的, 开始时 UNIX 是用汇编语言和一种叫 B 的语言编写的。 从那时候起, C 就成为世界上使用最广泛计算机语言。
C 能在编程领域里得到如此广泛支持的原因有以下一些：
· 它是一种非常通用的语言。 几乎你所能想到的任何一种计算机上都有至少一种能用的 C 编译器。 并且它的语法和函数库在不同的平台上都是统一的, 这个特性对开发者来说很有吸引力。
· 用 C 写的程序执行速度很快。
· C 是所有版本的UNIX上的系统语言。
C 在过去的二十年中有了很大的发展。 在80年代末期美国国家标准协会(American National Standards Institute)发布了一个被称为 ANSI C 的 C 语言标准。这更加保证了将来在不同平台上的 C 的一致性。 在80年代还出现了一种 C 的面向对象的扩展称为 C++。 C++ 将在另一篇文章 "C++ 编程"中描述。
Linux 上可用的 C 编译器是 GNU C 编译器, 它建立在自由软件基金会的编程许可证的基础上, 因此可以自由发布。 你能在 Linux 的发行光盘上找到它。
GNU C 编译器
随 Slackware Linux 发行的 GNU C 编译器(GCC)是一个全功能的 ANSI C 兼容编译器。 如果你熟悉其他操作系统或硬件平台上的一种 C 编译器, 你将能很快地掌握 GCC。 本节将介绍如何使用 GCC 和一些 GCC 编译器最常用的选项。
使用 GCC
通常后跟一些选项和文件名来使用 GCC 编译器。 gcc 命令的基本用法如下：
gcc [options] [filenames]
命令行选项指定的操作将在命令行上每个给出的文件上执行。 下一小节将叙述一些你会最常用到的选项。
GCC 选项
GCC 有超过100个的编译选项可用。 这些选项中的许多你可能永远都不会用到, 但一些主要的选项将会频繁用到。 很多的 GCC 选项包括一个以上的字符。 因此你必须为每个选项指定各自的连字符, 并且就象大多数 Linux 命令一样你不能在一个单独的连字符后跟一组选项。 例如, 下面的两个命令是不同的：
gcc -p -g test.c
gcc -pg test.c
第一条命令告诉 GCC 编译 test.c 时为 prof 命令建立剖析(profile)信息并且把调试信息加入到可执行的文件里。 第二条命令只告诉 GCC 为 gprof 命令建立剖析信息。
当你不用任何选项编译一个程序时, GCC 将会建立(假定编译成功)一个名为 a.out 的可执行文件。 例如, 下面的命令将在当前目录下产生一个叫 a.out 的文件：
gcc test.c
你能用 -o 编译选项来为将产生的可执行文件指定一个文件名来代替 a.out。 例如, 将一个叫 count.c 的 C 程序编译为名叫 count 的可执行文件, 你将输入下面的命令：
gcc -o count count.c
注意： 当你使用 -o 选项时, -o 后面必须跟一个文件名。
GCC 同样有指定编译器处理多少的编译选项。 -c 选项告诉 GCC 仅把源代码编译为目标代码而跳过汇编和连接的步骤。 这个选项使用的非常频繁因为它使得编译多个 C 程序时速度更快并且更易于管理。 缺省时 GCC 建立的目标代码文件有一个 .o 的扩展名。
-S 编译选项告诉 GCC 在为 C 代码产生了汇编语言文件后停止编译。 GCC 产生的汇编语言文件的缺省扩展名是 .s 。 -E 选项指示编译器仅对输入文件进行预处理。 当这个选项被使用时, 预处理器的输出被送到标准输出而不是储存在文件里。
优化选项
当你用 GCC 编译 C 代码时, 它会试着用最少的时间完成编译并且使编译后的代码易于调试。 易于调试意味着编译后的代码与源代码有同样的执行次序, 编译后的代码没有经过优化。 有很多选项可用于告诉 GCC 在耗费更多编译时间和牺牲易调试性的基础上产生更小更快的可执行文件。 这些选项中最典型的是-O 和 -O2 选项。
-O 选项告诉 GCC 对源代码进行基本优化。 这些优化在大多数情况下都会使程序执行的更快。 -O2 选项告诉 GCC 产生尽可能小和尽可能快的代码。 -O2 选项将使编译的速度比使用 -O 时慢。 但通常产生的代码执行速度会更快。
除了 -O 和 -O2 优化选项外, 还有一些低级选项用于产生更快的代码。 这些选项非常的特殊, 而且最好只有当你完全理解这些选项将会对编译后的代码产生什么样的效果时再去使用。 这些选项的详细描述, 请参考 GCC 的指南页, 在命令行上键入 man gcc 。
调试和剖析选项
GCC 支持数种调试和剖析选项。 在这些选项里你会最常用到的是 -g 和 -pg 选项。
-g 选项告诉 GCC 产生能被 GNU 调试器使用的调试信息以便调试你的程序。 GCC 提供了一个很多其他 C 编译器里没有的特性, 在 GCC 里你能使 -g 和 -O (产生优化代码)联用。 这一点非常有用因为你能在与最终产品尽可能相近的情况下调试你的代码。 在你同时使用这两个选项时你必须清楚你所写的某些代码已经在优化时被 GCC 作了改动。 关于调试 C 程序的更多信息请看下一节"用 gdb 调试 C 程序" 。
-pg 选项告诉 GCC 在你的程序里加入额外的代码, 执行时, 产生 gprof 用的剖析信息以显示你的程序的耗时情况。 关于 gprof 的更多信息请参考 "gprof" 一节。
用 gdb 调试 GCC 程序
Linux 包含了一个叫 gdb 的 GNU 调试程序。 gdb 是一个用来调试 C 和 C++ 程序的强力调试器。 它使你能在程序运行时观察程序的内部结构和内存的使用情况。 以下是 gdb 所提供的一些功能：
· 它使你能监视你程序中变量的值。
· 它使你能设置断点以使程序在指定的代码行上停止执行。
· 它使你能一行行的执行你的代码。
在命令行上键入 gdb 并按回车键就可以运行 gdb 了, 如果一切正常的话, gdb 将被启动并且你将在屏幕上看到类似的内容：
GDB is free software and you are welcome to 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.
GDB 4.14 (i486-slakware-linux), Copyright 1995 Free Software Foundation, Inc.
(gdb)
当你启动 gdb 后, 你能在命令行上指定很多的选项。 你也可以以下面的方式来运行 gdb ：
gdb
当你用这种方式运行 gdb , 你能直接指定想要调试的程序。 这将告诉gdb 装入名为 fname 的可执行文件。 你也可以用 gdb 去检查一个因程序异常终止而产生的 core 文件, 或者与一个正在运行的程序相连。 你可以参考 gdb 指南页或在命令行上键入 gdb -h 得到一个有关这些选项的说明的简单列表。
为调试编译代码(Compiling Code for Debugging)
为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息。 调试信息包含你程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号。 gdb 利用这些信息使源代码和机器码相关联。
在编译时用 -g 选项打开调试选项。
gdb 基本命令
gdb 支持很多的命令使你能实现不同的功能。 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令。 想了解 gdb 的详细使用请参考 gdb 的指南页。
表 27.1. 基本 gdb 命令.
命令描述
file 装入想要调试的可执行文件。
kill 终止正在调试的程序。
list 执行一行源代码但不进入函数内部。
next 执行一行源代码但不进入函数内部。
step执行一行源代码而且进入函数内部。
run执行当前被调试的程序
quit 终止 gdb
watch 使你能监视一个变量的值而不管它何时被改变。
break 在代码里设置断点, 这将使程序执行到这里时被挂起。
make 使你能不退出 gdb 就可以重新产生可执行文件。
shell 使你能不离开 gdb 就执行 UNIX shell 命令。
gdb 支持很多与 UNIX shell 程序一样的命令编辑特征。 你能象在 bash 或 tcsh里那样按 Tab 键让 gdb 帮你补齐一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令。 你也能用光标键上下翻动历史命令。
gdb 应用举例
本节用一个实例教你一步步的用 gdb 调试程序。 被调试的程序相当的简单, 但它展示了 gdb 的典型应用。
下面列出了将被调试的程序。 这个程序被称为 greeting , 它显示一个简单的问候, 再用反序将它列出。
#include
main ()
{
char my_string[] = "hello there";
my_print (my_string);
my_print2 (my_string);
}
void my_print (char *string)
{
printf ("The string is %sn", string);
}
void my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size - i] = string[i];
string2[size+1] = `';
printf ("The string printed backward is %sn", string2);
}
用下面的命令编译它：
gcc -o test test.c
这个程序执行时显示如下结果：
The string is hello there
The string printed backward is
输出的第一行是正确的, 但第二行打印出的东西并不是我们所期望的。 我们所设想的输出应该是：
The string printed backward is ereht olleh
由于某些原因, my_print2 函数没有正常工作。 让我们用 gdb 看看问题究竟出在哪儿, 先键入如下命令：
gdb greeting
注意： 记得在编译 greeting 程序时把调试选项打开。
如果你在输入命令时忘了把要调试的程序作为参数传给 gdb , 你可以在 gdb 提示符下用 file 命令来载入它：
(gdb) file greeting
这个命令将载入 greeting 可执行文件就象你在 gdb 命令行里装入它一样。
这时你能用 gdb 的 run 命令来运行 greeting 了。 当它在 gdb 里被运行后结果大约会象这样：
(gdb) run
Starting program： /root/greeting
The string is hello there
The string printed backward is
Program exited with code 041
这个输出和在 gdb 外面运行的结果一样。 问题是, 为什么反序打印没有工作? 为了找出症结所在, 我们可以在 my_print2 函数的 for 语句后设一个断点, 具体的做法是在 gdb 提示符下键入 list 命令三次, 列出源代码：
(gdb) list
(gdb) list
(gdb) list
技巧： 在 gdb 提示符下按回车健将重复上一个命令。
第一次键入 list 命令的输出如下：
1 #include
2
3 main ()
4 {
5 char my_string[] = "hello there";
6
7 my_print (my_string);
8 my_print2 (my_string);
9 }
10
如果按下回车, gdb 将再执行一次 list 命令, 给出下列输出：
11 my_print (char *string)
12 {
13 printf ("The string is %sn", string);
14 }
15
16 my_print2 (char *string)
17 {
18 char *string2;
19 int size, i;
20
再按一次回车将列出 greeting 程序的剩余部分：
21 size = strlen (string);
22 string2 = (char *) malloc (size + 1);
23 for (i = 0; i < size; i++)
24 string2[size - i] = string[i];
25 string2[size+1] = `';
26 printf ("The string printed backward is %sn", string2);
27 }
根据列出的源程序, 你能看到要设断点的地方在第24行, 在 gdb 命令行提示符下键入如下命令设置断点：
(gdb) break 24
gdb 将作出如下的响应：
Breakpoint 1 at 0x139： file greeting.c, line 24
(gdb)
现在再键入 run 命令, 将产生如下的输出：
Starting program： /root/greeting
The string is hello there
Breakpoint 1, my_print2 (string = 0xbfffdc4 "hello there") at greeting.c ：24
24 string2[size-i]=string[i]
你能通过设置一个观察 string2[size - i] 变量的值的观察点来看出错误是怎样产生的, 做法是键入：
(gdb) watch string2[size - i]
gdb 将作出如下回应：
Watchpoint 2： string2[size - i]
现在可以用 next 命令来一步步的执行 for 循环了：
(gdb) next
经过第一次循环后, gdb 告诉我们 string2[size - i] 的值是 `h`。 gdb 用如下的显示来告诉你这个信息：
Watchpoint 2, string2[size - i]
Old value = 0 `00'
New value = 104 `h'
my_print2(string = 0xbfffdc4 "hello there") at greeting.c：23
23 for (i=0; i
这个值正是期望的。 后来的数次循环的结果都是正确的。 当 i=10 时, 表达式 string2[size - i] 的值等于 `e`, size - i 的值等于 1, 最后一个字符已经拷到新串里了。
如果你再把循环执行下去, 你会看到已经没有值分配给 string2[0] 了, 而它是新串的第一个字符, 因为 malloc 函数在分配内存时把它们初始化为空(null)字符。 所以 string2 的第一个字符是空字符。 这解释了为什么在打印 string2 时没有任何输出了。
现在找出了问题出在哪里, 修正这个错误是很容易的。 你得把代码里写入 string2 的第一个字符的的偏移量改为 size - 1 而不是 size。 这是因为 string2 的大小为 12, 但起始偏移量是 0, 串内的字符从偏移量 0 到 偏移量 10, 偏移量 11 为空字符保留。
为了使代码正常工作有很多种修改办法。 一种是另设一个比串的实际大小小 1 的变量。 这是这种解决办法的代码：
#include
main ()
{
char my_string[] = "hello there";
my_print (my_string);
my_print2 (my_string);
}
my_print (char *string)
{
printf ("The string is %sn", string);
}
my_print2 (char *string)
{
char *string2;
int size, size2, i;
size = strlen (string);
size2 = size -1;
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size2 - i] = string[i];
string2[size] = `';
printf ("The string printed backward is %sn", string2);
}
另外的 C 编程工具
Slackware Linux 的发行版中还包括一些我们尚未提到的 C 开发工具。 本节将介绍这些工具和它们的典型用法。
xxgdb
xxgdb 是 gdb 的一个基于 X Window 系统的图形界面。 xxgdb 包括了命令行版的 gdb 上的所有特性。 xxgdb 使你能通过按按钮来执行常用的命令。 设置了断点的地方也用图形来显示。
你能在一个 Xterm 窗口里键入下面的命令来运行它：
xxgdb
你能用 gdb 里任何有效的命令行选项来初始化 xxgdb 。 此外 xxgdb 也有一些特有的命令行选项, 表 27.2 列出了这些选项。
表 27.2. xxgdb 命令行选项.
选 项 描 述
db_name 指定所用调试器的名字, 缺省是 gdb。
db_prompt 指定调试器提示符, 缺省为 gdb。
gdbinit 指定初始化 gdb 的命令文件的文件名, 缺省为 .gdbinit。
nx 告诉 xxgdb 不执行 .gdbinit 文件。
bigicon 使用大图标。
calls
你可以在 sunsite.unc.edu FTP 站点用下面的路径：
/pub/Linux/devel/lang/c/calls.tar.Z
来取得 calls , 一些旧版本的 Linux CD-ROM 发行版里也附带有。 因为它是一个有用的工具, 我们在这里也介绍一下。 如果你觉得有用的话, 从 BBS, FTP, 或另一张CD-ROM 上弄一个拷贝。 calls 调用 GCC 的预处理器来处理给出的源程序文件, 然后输出这些文件的里的函数调用树图。
注意： 在你的系统上安装 calls , 以超级用户身份登录后执行下面的步骤： 1． 解压和 untar 文件。 2．cd 进入 calls untar 后建立的子目录。 3．把名叫 calls 的文件移动到 /usr/bin 目录。 4．把名叫 calls.1 的文件移动到目录 /usr/man/man1 。 5．删除 /tmp/calls 目录。 这些步骤将把 calls 程序和它的指南页安装载你的系统上。
当 calls 打印出调用跟踪结果时, 它在函数后面用中括号给出了函数所在文件的文件名：
main [test.c]
如果函数并不是向 calls 给出的文件里的, calls 不知道所调用的函数来自哪里, 则只显示函数的名字：
printf
calls 不对递归和静态函数输出。 递归函数显示成下面的样子：
fact <<< recursive in factorial.c >>>
静态函数象这样显示：
total [static in calculate.c]
作为一个例子, 假设用 calls 处理下面的程序：
#include
main ()
{
char my_string[] = "hello there";
my_print (my_string);
my_print2(my_string);
}
my_print (char *string)
{
printf ("The string is %sn", string);
}
my_print2 (char *string)
{
char *string2;
int size, size2, i;
size = strlen (string);
size2 = size -1;
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size2 - i] = string[i];
string2[size] = `';
printf ("The string printed backward is %sn", string2);
}
将产生如下的输出：
1 main [test.c]
2 my_print [test.c]
3 printf
4 my_print2 [test.c]
5 strlen
6 malloc
7 printf
calls 有很多命令行选项来设置不同的输出格式, 有关这些选项的更多信息请参考 calls 的指南页。 方法是在命令行上键入 calls -h 。
cproto
cproto 读入 C 源程序文件并自动为每个函数产生原型申明。 用 cproto 可以在写程序时为你节省大量用来定义函数原型的时间。
如果你让 cproto 处理下面的代码：
#include
main ()
{
char my_string[] = "hello there";
my_print (my_string);
my_print2(my_string);
}
my_print (char *string)
{
printf ("The string is %sn", *string);
}
my_print2 (char *string)
{
char *string2;
int size, size2, i;
size = strlen (string);
size2 = size -1;
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size2 - i] = string[i];
string2[size] = `';
printf ("The string printed backward is %sn", string2);
}
你将得到下面的输出：
/* test.c */
int main(void);
int my_print(char *string);
int my_print2(char *string);
这个输出可以重定向到一个定义函数原型的包含文件里。
indent
indent 实用程序是 Linux 里包含的另一个编程实用工具。 这个工具简单的说就为你的代码产生美观的缩进的格式。 indent 也有很多选项来指定如何格式化你的源代码。这些选项的更多信息请看indent 的指南页, 在命令行上键入 indent -h 。
下面的例子是 indent 的缺省输出：
运行 indent 以前的 C 代码：
#include
main () {
char my_string[] = "hello there";
my_print (my_string);
my_print2(my_string); }
my_print (char *string)
{
printf ("The string is %sn", *string);
}
my_print2 (char *string) {
char *string2;
int size, size2, i;
size = strlen (string);
size2 = size -1;
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size2 - i] = string[i];
string2[size] = `';
printf ("The string printed backward is %sn", string2);
}
运行 indent 后的 C 代码：
#include
main ()
{
char my_string[] = "hello there";
my_print (my_string);
my_print2 (my_string);
}
my_print (char *string)
{
printf ("The string is %sn", *string);
my_print2 (char *string)
{
char *string2;
int size, size2, i;
size = strlen (string);
size2 = size -1;
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size2 - i] = string[i];
string2[size] = `';
printf ("The string printed backward is %sn", string2);
}
indent 并不改变代码的实质内容, 而只是改变代码的外观。 使它变得更可读, 这永远是一件好事。
gprof
gprof 是安装在你的 Linux 系统的 /usr/bin 目录下的一个程序。 它使你能剖析你的程序从而知道程序的哪一个部分在执行时最费时间。
gprof 将告诉你程序里每个函数被调用的次数和每个函数执行时所占时间的百分比。 你如果想提高你的程序性能的话这些信息非常有用。
为了在你的程序上使用 gprof, 你必须在编译程序时加上 -pg 选项。 这将使程序在每次执行时产生一个叫 gmon.out 的文件。 gprof 用这个文件产生剖析信息。
在你运行了你的程序并产生了 gmon.out 文件后你能用下面的命令获得剖析信息：
gprof
参数 program_name 是产生 gmon.out 文件的程序的名字。
技巧： gprof 产生的剖析数据很大, 如果你想检查这些数据的话最好把输出重定向到一个文件里。
f2c 和 p2c
f2c 和 p2c 是两个源代码转换程序。 f2c 把 FORTRAN 代码转换为 C 代码, p2c 把 Pascal 代码转换为 C 代码。 当你安装 GCC 时这两个程序都会被安装上去。
如果你有一些用 FORTRAN 或 Pascal 写的代码要用 C 重写的话, f2c 和 p2c 对你非常有用。 这两个程序产生的 C 代码一般不用修改就直接能被 GCC 编译。
如果要转换的 FORTRAN 或 Pascal 程序比较小的话可以直接使用 f2c 或 p2c 不用加任何选项。 如果要转换的程序比较庞大, 包含很多文件的话你可能要用到一些命令行选项。
在一个 FORTRAN 程序上使用 f2c , 输入下面的命令：
f2c my_fortranprog.f
注意： f2c 要求被转换的程序的扩展名为 .f 或 a .F 。
要把一个Pascal 程序装换为 C 程序, 输入下面的命令：
p2c my_pascalprogram.pas
这两个程序产生的 C 源代码的文件名都和原来的文件名相同, 但扩展名由 .f 或 .pas 变为 .c 。


分类: ( Linux ) :: 评论 (5) :: 静态链接网址 :: 引用 (0)

Linux下C语言编程基础(Makefile)

发表人:upczap | 发表时间: 2007年三月26日, 22:47

Linux下C语言编程基础(Makefile)

假设我们有下面这样的一个程序，源代码如下： 

/* main.c */ 

#include "mytool1.h" 

#include "mytool2.h" 

int main(int argc，char **argv) 

{ 

mytool1_print("hello")； 

mytool2_print("hello")； 

} 

/* mytool1.h */ 

#ifndef _MYTOOL_1_H 

#define _MYTOOL_1_H 

void mytool1_print(char *print_str)； 

#endif 

/* mytool1.c */ 

#include "mytool1.h" 

void mytool1_print(char *print_str) 

{ 

printf("This is mytool1 print %s "，print_str)； 

} 

/* mytool2.h */ 

#ifndef _MYTOOL_2_H 

#define _MYTOOL_2_H 

void mytool2_print(char *print_str)； 

#endif 

/* mytool2.c */ 

#include "mytool2.h" 

void mytool2_print(char *print_str) 

{ 

printf("This is mytool2 print %s "，print_str)； 

}

当然由于这个程序很短，我们可以这样来编译: 

gcc -c main.c 

gcc -c mytool1.c 

gcc -c mytool2.c 

gcc -o main main.o mytool1.o mytool2.o

这样的话我们也可以产生main程序，而且也不是很麻烦。但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说，这个很容易解决啊，我写一个SHELL脚本，让它帮我去完成不就可以了。是的对于这个程序来说，是可以起到作用的。但是当我们把事情想的更复杂一点，如果我们的程序有几百个源程序的时候，难道也要编译器重新一个一个的去编译?

为此，聪明的程序员们想出了一个很好的工具来做这件事情，这就是make。我们只要执行以下make，就可以把上面的问题解决掉。在我们执行make之前，我们要先编写一个非常重要的文件。--Makefile。对于上面的那个程序来说，可能的一个Makefile的文件是：

# 这是上面那个程序的Makefile文件: 

main：main.o mytool1.o mytool2.o 

gcc -o main main.o mytool1.o mytool2.o 

main.o：main.c mytool1.h mytool2.h 

gcc -c main.c 

mytool1.o：mytool1.c mytool1.h 

gcc -c mytool1.c 

mytool2.o：mytool2.c mytool2.h 

gcc -c mytool2.c

有了这个Makefile文件，不论我们什么时候修改了源程序当中的什么文件，我们只要执行make命令，我们的编译器都只会去编译和我们修改的文件有关的文件，其它的文件它连理都不想去理的。

下面我们学习Makefile是如何编写的。

在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明。一般的格式是：

target：components

TAB rule

第一行表示的是依赖关系。第二行是规则。

比如说我们上面的那个Makefile文件的第二行。

main：main.o mytool1.o mytool2.o

表示我们的目标(target)main的依赖对象(components)是main.o mytool1.omytool2.o 当倚赖的对象在目标修改后修改的话，就要去执行规则一行所指定的命令。就象我们的上面那个Makefile第三行所说的一样要执行 gcc-o main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键

Makefile有三个非常有用的变量。分别是$@，$^，$<代表的意义分别是：

$@--目标文件，$^--所有的依赖文件，$<--第一个依赖文件。

如果我们使用上面三个变量，那么我们可以简化我们的Makefile文件为：

# 这是简化后的Makefile

main：main.o mytool1.o mytool2.o

gcc -o $@ $^

main.o：main.c mytool1.h mytool2.h

gcc -c $<

mytool1.o：mytool1.c mytool1.h

gcc -c $<

mytool2.o：mytool2.c mytool2.h

gcc -c $<

经过简化后,我们的Makefile是简单了一点，不过人们有时候还想简单一点。这里我们学习一个Makefile的缺省规则

.c.o：

gcc -c $<

这个规则表示所有的 .o文件都是依赖与相应的.c文件的。例如mytool.o依赖于mytool.c这样Makefile还可以变为：

# 这是再一次简化后的Makefile

main：main.o mytool1.o mytool2.o

gcc -o $@ $^

.c.o：

gcc -c $<

好了，我们的Makefile 也差不多了，如果想知道更多的关于Makefile的规则，可以查看相应的文档。


分类: ( Linux ) :: 评论 (2) :: 静态链接网址 :: 引用 (0)

在linux操作系统下用C语言编程

发表人:upczap | 发表时间: 2007年三月26日, 22:43

在linux操作系统下用C语言编程

这篇文章介绍在LINUX下进行C语言编程所需要的基础知识.在这篇文章当中,我们将会学到以下内容:
源程序编译
Makefile的编写
程序库的链接
程序的调试
头文件和系统求助

--------------------------------------------------------------------------------
1.源程序的编译
在Linux下面,如果要编译一个C语言源程序,我们要使用GNU的gcc编译器. 下面我们以一个实例来说明如何使用gcc编译器.
假设我们有下面一个非常简单的源程序(hello.c):
int main(int argc,char **argv)
{
printf("Hello Linuxn");
}

要编译这个程序,我们只要在命令行下执行:
gcc -o hello hello.c
gcc 编译器就会为我们生成一个hello的可执行文件.执行./hello就可以看到程序的输出结果了.命令行中
gcc表示我们是用gcc来编译我们的源程序,-o 选项表示我们要求编译器给我们输出的可执行文件名为hello
而hello.c是我们的源程序文件. gcc编译器有许多选项,一般来说我们只要知道其中的几个就够了. -o选项我们已经知道了,表示我们要求输出的可执行文件名.
-c选项表示我们只要求编译器输出目标代码,而不必要输出可执行文件. -g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息. 知道了这三个选项,我们就可以编译我们自己所写的简单的源程序了,如果你想要知道更多的选项,可以查看gcc的帮助文档,那里有着许多对其它选项的详细说明.
2.Makefile的编写
假设我们有下面这样的一个程序,源代码如下:

/* main.c */
#include "mytool1.h"
#include "mytool2.h"

int main(int argc,char **argv)
{
mytool1_print("hello");
mytool2_print("hello");
}

/* mytool1.h */
#ifndef _MYTOOL_1_H
#define _MYTOOL_1_H

void mytool1_print(char *print_str);

#endif

/* mytool1.c */
#include "mytool1.h"
void mytool1_print(char *print_str)
{
printf("This is mytool1 print %sn",print_str);
}

/* mytool2.h */
#ifndef _MYTOOL_2_H
#define _MYTOOL_2_H

void mytool2_print(char *print_str);

#endif

/* mytool2.c */
#include "mytool2.h"
void mytool2_print(char *print_str)
{
printf("This is mytool2 print %sn",print_str);
}


当然由于这个程序是很短的我们可以这样来编译
gcc -c main.c
gcc -c mytool1.c
gcc -c mytool2.c
gcc -o main main.o mytool1.o mytool2.o
这样的话我们也可以产生main程序,而且也不时很麻烦.但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)
那么我们难道还要重新输入上面的命令?也许你会说,这个很容易解决啊,我写一个SHELL脚本,让她帮我去完成不就可以了.是的对于这个程序来说,是可以
起到作用的.但是当我们把事情想的更复杂一点,如果我们的程序有几百个源程序的时候,难道也要编译器重新一个一个的去编译? 为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是make.我们只要执行以下make,就可以把上面的问题解决掉.在我们执行
make之前,我们要先编写一个非常重要的文件.--Makefile.对于上面的那个程序来说,可能的一个Makefile的文件是: # 这是上面那个程序的Makefile文件
main:main.o mytool1.o mytool2.o
gcc -o main main.o mytool1.o mytool2.o
main.o:main.c mytool1.h mytool2.h
gcc -c main.c
mytool1.o:mytool1.c mytool1.h
gcc -c mytool1.c
mytool2.o:mytool2.c mytool2.h
gcc -c mytool2.c

有了这个Makefile文件,不过我们什么时候修改了源程序当中的什么文件,我们只要执行make命令,我们的编译器都只会去编译和我们修改的文件有关的文件,其它的文件她连理都不想去理的.
下面我们学习Makefile是如何编写的.
在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明.一般的格式是:
target: components
TAB rule

第一行表示的是依赖关系.第二行是规则.
比如说我们上面的那个Makefile文件的第二行
main:main.o mytool1.o mytool2.o
表示我们的目标(target)main的依赖对象(components)是main.o mytool1.o mytool2.o
当倚赖的对象在目标修改后修改的话,就要去执行规则一行所指定的命令.就象我们的上面那个Makefile第三行所说的一样要执行 gcc -o
main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键 Makefile有三个非常有用的变量.分别是$@,$^,$

int main(int argc,char **argv)
{
double value;
printf("Value:%fn",value);
}

这个程序相当简单,但是当我们用 gcc -o temp temp.c 编译时会出现下面所示的错误.
/tmp/cc33Kydu.o: In function `main':
/tmp/cc33Kydu.o(.text+0xe): undefined reference to `log'
collect2: ld returned 1 exit status

出现这个错误是因为编译器找不到log的具体实现.虽然我们包括了正确的头文件,但是我们在编译的时候还是要连接确定的库.在Linux下,为了
使用数学函数,我们必须和数学库连接,为此我们要加入 -lm 选项. gcc -o temp temp.c
-lm这样才能够正确的编译.也许有人要问,前面我们用printf函数的时候怎么没有连接库呢?是这样的,对于一些常用的函数的实现,gcc编译器会自
动去连接一些常用库,这样我们就没有必要自己去指定了. 有时候我们在编译程序的时候还要指定库的路径,这个时候我们要用到编译器的
-L选项指定路径.比如说我们有一个库在 /home/hoyt/mylib下,这样我们编译的时候还要加上
-L/home/hoyt/mylib.对于一些标准库来说,我们没有必要指出路径.只要它们在起缺省库的路径下就可以了.系统的缺省库的路径/lib
/usr/lib /usr/local/lib 在这三个路径下面的库,我们可以不指定路径. 还有一个问题,有时候我们使用了某个函数,但是我们不知道库的名字,这个时候怎么办呢?很抱歉,对于这个问题我也不知道答案,我只有一个傻办
法.首先,我到标准库路径下面去找看看有没有和我用的函数相关的库,我就这样找到了线程(thread)函数的库文件(libpthread.a).
当然,如果找不到,只有一个笨方法.比如我要找sin这个函数所在的库. 就只好用 nm -o /lib/*.so|grep
sin>~/sin 命令,然后看~/sin文件,到那里面去找了.
在sin文件当中,我会找到这样的一行libm-2.1.2.so:00009fa0 W sin 这样我就知道了sin在
libm-2.1.2.so库里面,我用 -lm选项就可以了(去掉前面的lib和后面的版本标志,就剩下m了所以是 -lm).
如果你知道怎么找,请赶快告诉我,我回非常感激的.谢谢! 4.程序的调试
我们编写的程序不太可能一次性就会成功的,在我们的程序当中,会出现许许多多我们想不到的错误,这个时候我们就要对我们的程序进行调试了.
最常用的调试软件是gdb.如果你想在图形界面下调试程序,那么你现在可以选择xxgdb.记得要在编译的时候加入
-g选项.关于gdb的使用可以看gdb的帮助文件.由于我没有用过这个软件,所以我也不能够说出如何使用.
不过我不喜欢用gdb.跟踪一个程序是很烦的事情,我一般用在程序当中输出中间变量的值来调试程序的.当然你可以选择自己的办法,没有必要去学别人的.现
在有了许多IDE环境,里面已经自己带了调试器了.你可以选择几个试一试找出自己喜欢的一个用.
5.头文件和系统求助
有时候我们只知道一个函数的大概形式,不记得确切的表达式,或者是不记得着函数在那个头文件进行了说明.这个时候我们可以求助系统.
比如说我们想知道fread这个函数的确切形式,我们只要执行 man fread
系统就会输出着函数的详细解释的.和这个函数所在的头文件说明了. 如果我们要write这个函数的说明,当我们执行man
write时,输出的结果却不是我们所需要的.
因为我们要的是write这个函数的说明,可是出来的却是write这个命令的说明.为了得到write的函数说明我们要用 man 2 write.
2表示我们用的write这个函数是系统调用函数,还有一个我们常用的是3表示函数是C的库函数. 记住不管什么时候,man都是我们的最好助手.

 查看全文

分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

linux系统密码忘记后的５种方法

发表人:upczap | 发表时间: 2007年三月25日, 12:09

linux系统密码忘记后的５种方法

一. lilo引导
1. 在出现 lilo: 提示时键入 linux single
Boot: linux single

2. 回车可直接进入linux单用户模式
3. vi /etc/passwd
删除root项中的密码
(这里也可以直接使用passwd命令重新设置root的密码)
4. reboot重启，root密码为空
二. grub引导
1. 在出现grub画面时，选择linux引导项，然后按e键
2. 选择以kernel开头的一行，再按e 键，在此行的末尾，按空格键后输入single，以回车键来退出编辑模式；
3. 回车返回，然后按b键启动，即可直接进入linux单用户模式
4. vi /etc/passwd
删除root项中的密码
(这里也可以直接使用passwd命令重新设置root的密码)
5、reboot重启，root密码为空

三、可以使用linux启动软盘引导
出现boot后，输入linux single
可进入单用户模式；
修改或删除root密码；
四、使用Linux 系统安装盘
　　如果你既没做系统启动软盘，同时多系统的引导LILO 和GRUB 又被删除，那么只能使用Linux 系统安装盘来恢复root的密码。
　　用第一张Linux 系统安装盘启动，出现boot 提示符后输入：
　oot: linux rescue
　　此时系统进入救援模式，然后根据提示完成：
　　1.选择语言和键盘格式；
　　2.选择是否配置网卡，一般系统因网络不需要，所以可以选择否跳过网卡配置；
　　3 . 选择是否让系统查找硬盘上的Redhat Linux 系统，选择继续；
　　4.系统显示硬盘上的系统已经被找到，并挂载在/mnt/sysimage 下；
　　5.进入拯救状态，可重新设置root 的密码：
　　# chroot/mnt/sysimage (让系统成为根环境)
　　# cd /mnt/sysimage
　　# passwd root
五、如果不怕麻烦的话，还可以把安装linux的硬盘卸下后挂到其他系统环境下 同样是去修改/etc/passwd文件，修改过后保存即可；
注：
1、在不同的linux系统下输入single的方式和方法可能有区别，希望能自己去尝试；
2、除了需要修改/etc/passwd文件外，可能也需要修改/etc/shadow文件，这是/etc/passwd密码文件的投影文件；

分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

Linux系统利用SSH远程控制安全问题

发表人:upczap | 发表时间: 2007年三月24日, 08:03

网络被攻击，很多情况是由于服务器提供了Telnet服务引起的。的确，对于UNIX系统，如果要远程管理它，必定要使用远程终端，而要使用远程终端，自然要在服务器上启动Telnet服务。但是Telnet服务有一个致命的弱点——它以明文的方式传输用户名及口令，所以，很容易被别有用心的人窃取口令。目前，一种有效代替Telnet服务的有用工具就是SSH服务。SSH客户端与服务器端通讯时，用户名及口令均进行了加密，有效防止了对口令的窃听。本文向大家介绍运行在常用操作系统上的SSH服务器软件包的使用。

　　首先，SSH软件包由两部分组成，一部分是服务器端软件包，另一部分是客户软件包。针对UNIX、Linux系统，这两个软件包是分开打包在两个不同的文件中的。在Windows 9x/NT/2000中，也分为两部分，不同之处在于，服务器软件包只能运行在Windows NT及Windows 2000 Server以上的版本中，而客户端SSH可以运行在所有的Windows系统中。此外，SSH还分为SSH1及SSH2两个版本，SSH1是一个完全免费的软件包，而SSH2在商业使用时则要付费。由其命名也可知SSH1是第一版，它的功能没有SSH2强大，但是，由于它是免费的，所以广泛地使用在很多网站中。SSH2中加入了很多功能，并且兼容SSH1服务器，可以对SSH1的客户端提供很好的服务支持。所以，如果你的系统中安装了SSH2，那就没有必要再安装SSH1软件包了。

UNIX/Linux下SSH2安装步骤

　　1.下载软件包，下载地址www.ssh.com，下载最新软件包SSH2，最好下载源程序软件包自己进行自行编译。

　　2.解压及安装：


　　
　　　　# tar -zxvf ssh2-2.4.0.tar.gz
　　
　　　　# cd ssh2-2.4.0
　　
　　　　# ./configure
　　
　　　　# make
　　
　　　　#make install

　　
　　安装完成。这一过程实际上将服务器软件包及客户端软件一起安装了，不必再次安装客户端软件包。

　　已编译好的二进制软件包以rpm格式存放在ftp://ftp.ssh.com/pub/ssh/rpm目录下。它是一个给非商业用户使用的软件包，软件包名称为：ssh-2.4.0-1.i386.rpm，其中包含了对X Window的支持，另一个不支持X Window的软件包为ssh-2.4.0-1nox.i386.rpm，下载后可以直接安装。安装程序将SSH2软件包安装在/usr/local/bin及/usr/local/sbin下。

Windows NT上安装SSH

　　在NT及Windows 2000 Server环境下，可选择的服务器软件有：Vshell、ssh2-2.4.0.win-server。Vshell是由Van Dyke提供的一个可以在Windows NT/2000环境下提供SSH2服务器的软件包，其下载地址如下：http://www.vandyke.com/download/index.html。另一个运行在Windows环境下的SSH服务器是SSHWinServer.exe，可以直接从ftp://ftp.ssh.com/pub/ssh目录下下载。

Windows环境下的安装十分简单，本文不再多介绍。

　　与UNIX不同，在Windows环境下，需要分别安装服务器及客户端软件包。运行在Windows环境下的客户端软件，也可以从以上两个站点下载得到，文件名分别为SecureCRT及SSHWin-2.4.0-pl2。

　　关于密钥的准备工作

　　A.服务器端产生用户的自己的加密密钥及对外公开使用的公钥。在UNIX环境下，产生密钥的方法如下：

-keygen

　　要求用户输入一个长的认证字串，这个字串的功能同password相当，但是，它更长，一般是在20个字符以内。再次输入相同的字串以确认输入的正确，之后，系统产生一对密钥及公钥。将公钥复制到本地，以便客户端对服务器发送的信息进行解密用。当然，如果你不复制，在第一次登录时，服务器会将它的公钥自动推给客户机，以便客户机能对服务器提供的信息进行解密识别。

　　B.客户端产生用户的加密密钥及公钥。客户端产生自己的密钥及公钥的方法与服务器端相同。而Windows环境下的一些支持SSH的客户端软件都采用自己生成的方法，具体情况各不相同，但是可以肯定的是所有的支持SSH的客户端都可以而且必须产生。以sshWin2.4为例说明如下：

　　打开选单：Edit→Settings→Globe settings→User keys→Generate New keypairs，按照提示会自动产生新的密钥及公钥对。

　　最后，将客户机产生的公钥复制到服务端的主机上用户的目录中(在UNIX下应为/home/usrname/.ssh2目录中)。不同的版本的SSH对公钥及密钥的文件名有特定的要求，具体情况请阅读软件包中的安装说明。

启动SSH服务器

　　在UNIX/Linux环境下，服务器程序放置在/usr/local/sbin目录下，启动方法如下：


　　
　　　　# sshd
　　
　　　　# ps x
　

　
　　可以看到SSHD已经启动了。如果不希望每次重启动系统，都要手工运行启动SSHD，则可以自己写一个脚本，放置在init.d目录下，让系统启动后，自动执行SSHD服务的启动工作。或者直接在rc.local中加入一行/usr/local/sbin/sshd也可。Windows NT/2000/下启动SSH2 Server，运行程序组中的start SSH2 Server即可。

使用SSH

　　客户端在UNIX/Linux系统中就是SSH，存放在/usr/local/bin目录下。其中有SSH1、SSH2、scp等客户端工具，使用SSH登录远程主机方法如下：

host.ip.of.remote

　　如同使用Telnet一样，不同之处是要求用户输入认证字串，如果认证字串通过了认证，则用户直接登录成功；如果不成功，则是要求用户输入系统口令。口令认证成功后，用户也可以成功登录系统。从使用上看，与Telnet没有什么不同之处。而且有了SSH客户端软件，如果你要上传文件，不必向以前一样再开一个FTP窗口，再次认证，然后上传文件。使用SSH客户端自带的scp工具，就可以直接将文件上传到远端服务器上。使用方法如下：

host1:dir/filename host2:/home/abc/filename

　　在Windows系统中，可供使用的SSH客户端有：SecurCRT，也即CRT的支持SSH的版本(下载地址：http://www.vandyke.com/)，这是一个很好的支持SSH的远程终端，它同时支持SSH1及SSH2。用户可以根据服务器端自由选择，让它支持相应的标准。

　　另一个可供选择的是ssh.com提供的客户端，下载地址：ftp://ftp.ssh.com/pub/ssh/SSHWin-2.4.0-pl2.exe，这是新版本的SSH2客户端。

　　另外，还有支持SSH的FTP客户端工具，其中sshwin-2.4中就有一个SSH Secure File Transfer Client，它可以用来在两个主机之间传输加密后的文件。也即scp的功能。配合SecureCRT的也有一个相应的支持SSH的FTP工具，其名称为：SecureFX，可以从www.vandyke.com/下载使用。

　　由于种种原因，一些支持SSH的GUI客户端不一定会很好地支持以上各个服务器，大家可以自行组合以上工具，找到适合自己的工具。一般来说，在UNIX下的客户端对各种服务器的支持是最好的。通常在选择服务器及客户端软件时，最好选择同一软件商的产品，这样不会出现不兼容的问题。

　　需要补充的是，如果你既想使用SSH2又不想付费，那么一个可供选择的自由软件是Openssh，它是一个遵守GPL协议的软件包，同时支持SSH1及SSH2标准，是另一个被广泛使用的SSH软件包(可以从www.openssh.com下载)。Openssh的最新版本为Openssh-2.5.1，提供全部源码。不过，在编译前，应仔细阅读其说明文件。编译过程中要用到zlib及openssl两个软件包，用户首先需要下载并安装它们，之后再编译openssh。具体过程请阅读软件包中的install文件。


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

自己做一个迷你型Linux操作系统

发表人:upczap | 发表时间: 2007年三月24日, 07:59

自己做一个迷你型Linux操作系统

本文要构建的这个迷你型的 Linux 系统只能在一台特定的单机上运行，如果读者朋友们有兴趣的话，在这个系统的基础上加以改进，是可以构建出通用的、可以在大多数常规 PC 机上即插即用的系统来的。但是这已经不在本文的话题之内了，读者朋友们如果有兴趣，可以通过我的电子邮件和我讨论其中的细节问题。

　　我们的目标 Linux 系统运行在一台普通的 Intel 386 PC 机上，可以有硬盘，也可以不要硬盘，而用 Flash Disk 来代替。如果是用 Flash 盘的话，需要能够支持从 Flash 盘启动，而且 Flash 盘的大小要在 16M 字节或者以上。我们希望用户一开机启动，就直接进入 X Window 图形界面，运行事先指定好的程序。不需要用户输入用户名和密码进行登录。

　　我们设定的这个目标有点像一个 X Terminal 终端工作站。稍加改进，还可以做成干脆无盘的形式，也就是说，连 16M 的 Flash 盘也不要了。不过，这也超出了本文的话题了。读者朋友们如果有兴趣，可以来信和我进行讨论。

　　系统启动

　　因为我们要考虑从 Flash 盘进行启动，所以我们选择用 LILO 作为我们的 Boot Loader，而不选用 GRUB。这是考虑到 GRUB 有较强的对硬盘和文件系统的识别能力，而 Flash 盘到底不是标准的硬盘，并且我们选用的文件系统 GRUB 又不一定认识，搞不好的话 GRUB 反会弄巧成拙。而 LILO 就简单的多了，它在硬盘开始的 MBR 写入一个小程序，这个小程序不经过文件系统，直接从硬盘扇区号，读出 Kernel Image 装入内存。这样，保险系数就大大增加。并且也给了我们自由选用文件系统的余地。那么，我们要如何安装 LILO 呢?

　　首先，我们要找一块普通的 800M 左右的 IDE 硬盘，连在目标机器的 IDE 线上。这样在我们的目标机器上，IDE1 上挂的是 Flash 盘，IDE2 上挂的是一块工作硬盘。我们用标准的步骤在 IDE2 的标准硬盘上装上一个 Debian GNU/Linux 系统。当然，如果读者朋友们手头没有 Debian，也可以装 Red Hat 系统。装好工作系统之后，要首先做一些裁减工作，把不必要的 Service 和 X Window 等等东西都删掉。这样做的目的是增进系统启动速度，因为我们在后面的工作中，肯定要不停的重新启动机器，所以启动速度对我们的工作效率是很关键的。

　　装好工作系统之后，在 Falsh 盘上做一个 Ext2 文件系统，这个用 mke2fs 这个命令就可以完成。由于 Flash 盘是接在 IDE1 上的，所以在 Linux 里面，它的身份是 /dev/hda。本文作者在操作的时候，把整个 Flash 盘划分了一个整个的分区，所以，调用 mke2fs 的时候，处理的是 /dev/hda1。读者朋友们应该可以直接在 /dev/hda 上做一个 Ext2 文件系统，而不用事先分区。

　　在 Flash 盘上做好了文件系统之后，就可以把一个编译好的内核映像文件 vmlinuz 拷贝到 Flash 盘上了。注意，必须要先把这个 vmlinuz 映像文件拷贝到 Flash 盘上，然后才能在 Flash 盘上安装 LILO。不然的话，LILO 到时候可是会 LILILILI 打结巴的，因为它会找不到 Kernel Image 在 Flash 盘上的位置的，那样的话 Flash 盘也就启动不起来了。还有，如果读者朋友们在 Flash 盘上用的是一个压缩的文件系统的话，到时候 LILO 也会出问题，它虽然能正确的找到 Kernel Image 在硬盘上的起始位置，但是它却没有办法处理被文件系统重新压缩过的这个 Kernel Image，不知道该如何把它展开到内存中去。

　　把 Kernel Image 拷贝过去以后，我们就可以动手编辑一份 lilo.conf 文件，这份文件可以就放在工作系统上就行了。但是注意在 lilo.conf 中索引的文件名的路径可要写对。这些路径名都是在工作系统上看上去的路径名。比如，如果 Flash 盘 Mount 在 /mnt 目录下面，那么，在 lilo.conf 中，vmlinuz 的路径名就是 /mnt/vmlinuz。注意这一点千万不要搞错。不然的话，如果一不小心把工作系统的 LILO 给破坏掉了，那就麻烦了。编辑好了 lilo.conf，然后再运行 lilo 命令，注意，要告诉它用这个新的 lilo.conf 文件，而不要用 /etc/lilo.conf。

　　安装好 LILO 之后，我们可以立即重新启动，测试一下。首先在 BIOS 里面，设置成从 IDE1 开始启动，如果我们看到 LILO 的提示符，按回车后还能看到 Kernel 输出的消息，这就算是 LILO 的安装成功了。记得这个操作的方法，以后每次我们更新 Flash 盘上的 Kernel Image，都记得要更新 LILO。也就是说，要重新运行一遍 lilo 命令。

　　编译内核

　　试验成功 LILO 的安装以后，我们开始考虑编译一个新的内核。当然，要编译新的内核，我们首先要进入我们的工作系统。这里有两个办法进入工作系统，一是在 BIOS 里面设置从 IDE2 启动，当然，这就要求当初安装工作系统的时候，要把 LILO 安装在 /dev/hdb 上;另一个办法是还是从 IDE1 启动，不改变 BIOS 的设置，但是在看到 LILO 的提示符的时候，要键入 linux root=/dev/hdb1，最前面的 linux 是在 lilo.conf 里面定义的一个 entry，我们只采用这个 entry 所指定的 Kernel Image，但是用 /dev/hdb1 作为 root 文件系统。两个办法可能有的时候一个比另一个好，更方便一些。这就要看具体的情况了。不过，它们的设置并不是互相冲突的。

　　在编译内核的时候，由于我们的内核是只有一台机器使用的，所以我们应该对它的情况了如指掌;另外一方面，为了减低不必要的复杂性，我们决定不用 kernel module 的支持，而把所有需要的东西直接编译到内核的里面。这样编译出来的内核，在一台普通的 586 主板上，把所有必要的功能都加进去，一般也不到 800K 字节。所以，这个办法是可行的。而且减低了 init scripts 的复杂程度。从运行方面来考虑，由于需要的 kernel 代码反正是要装载到内存中的，所以并不会引起内存的浪费。

　　在我们的目标平台上，我们希望使用 USB 存储设备。还有一点要注意的，就是对 Frame buffer 的支持。这主要是为了支持 XFree86。一般说来，如果我们的显卡是 XFree86 直接支持的，那当然最好，也就不需要 frame buffer 的内核支持。但是如果 XFree86 不支持我们的显卡，我们可以考虑用 VESA 模式。但是 XFree86 的 VESA 卡支持运行起来不太漂亮，还有安全方面的问题，有时在启动和退出 X Window 的时候会出现花屏。所以我们可以采用 kernel 的 vesa 模式的 frame buffer，然后用 xfree86 的 linux frame buffer 的驱动程序。这样一般就看不到花屏的现象了，而且安全方面也没有任何问题。

　　devfs 也是我们感兴趣的话题。如果 kernel 不使用 devfs，那么系统上的 root 文件系统就要有 /dev 目录下面的所有内容。这些内容可以用 /dev/MAKEDEV 脚本来建立，也可以用 mknod 手工一个一个来建。这个方法有其自身的好处。但是它的缺点是麻烦，而且和 kernel 的状态又并不一致。相反的，如果使用了 devfs，我们就再也不用担心 /dev 目录下面的任何事情了。/dev 目录下面的项目会有 kernel 的代码自己负责。实际使用起来的效果，对内存的消耗并不明显。所以我们选择 devfs。

　　busybox

　　有了 LILO 和 kernel image 之后，接下来，我们要安排 root 文件系统。由于 flash 盘的空间只有 16M 字节，可以说，这是对我们最大的挑战。这里首先要向大家介绍小型嵌入式 Linux 系统安排 root 文件系统时的一个常用的利器：BusyBox。

　　Busybox 是 Debian GNU/Linux 的大名鼎鼎的 Bruce Perens 首先开发，使用在 Debian 的安装程序中。后来又有许多 Debian developers 贡献力量，这其中尤推 busybox 目前的维护者 Erik Andersen，他患有癌症，可是却是一名优秀的自由软件开发者。

　　Busybox 编译出一个单个的独立执行程序，就叫做 busybox。但是它可以根据配置，执行 ash shell 的功能，以及几十个各种小应用程序的功能。这其中包括有一个迷你的 vi 编辑器，系统不可或缺的 /sbin/init 程序，以及其他诸如 sed, ifconfig, halt, reboot, mkdir, mount, ln, ls, echo, cat ... 等等这些都是一个正常的系统上必不可少的，但是如果我们把这些程序的原件拿过来的话，它们的体积加在一起，让人吃不消。可是 busybox 有全部的这么多功能，大小也不过 100K 左右。而且，用户还可以根据自己的需要，决定到底要在 busybox 中编译进哪几个应用程序的功能。这样的话，busybox 的体积就可以进一步缩小了。

　　使用 busybox 也很简单。只要建一个符号链接，比方 ln -s /bin/busybox /bin/ls，那么，执行 /bin/ls 的时候，busybox 就会执行 ls 的功能，也会按照 ls 的方式处理命令行参数。又比如 ln -s /bin/busybox /sbin/init，这样我们就有了系统运行不可或缺的 /sbin/init 程序了。当然，这里的前提是，你在 busybox 中编译进去了这两个程序的功能。

　　这里面要提出注意的一点是，busybox 的 init 程序所认识的 /etc/inittab 的格式非常简单，而且和常规的 inittab 文件的格式不一样。所以读者朋友们在为这个 busybox 的 init 写 inittab 的时候，要注意一下不同的语法。至于细节，就不在我们这里多说了，请大家参考 Busybox 的用户手册。

　　从启动到进入 shell

　　busybox 安装好以后，我们就可以考虑重新启动，一直到进入 shell 提示符了。这之前，我们要准备一下 /etc 目录下的几个重要的文件，而且要把 busybox 用到的 library 也拷贝过来。

　　用 ldd 命令，后面跟要分析的二进制程序的路径名，就可以知道一个二进制程序，或者是一个 library 文件之间的互相依赖关系，比如 busybox 就依赖于 libc.so 和 ld-linux.so ，我们有了这些知识，就可把动手把所有需要的 library 拷贝到 flash 盘上。由于我们的 flash 盘说大不大，说小倒也不小，有 16M 字节之多。我们直接就用 Glibc 的文件也没有太多问题。如果读者朋友们有特殊的需要，觉得 Glibc 太庞大了的话，可以考虑用 uClibc，这是一个非常小巧的 libc 库，功能当然没有 Glibc 全，但是足够一个嵌入式系统使用了。本文就不再介绍 uClibc 了。

　　库程序拷贝过来以后，我们就可以考虑系统启动的步骤了。启动的时候，先是 lilo，接下来就是 kernel，kernel 初始化之后，就调用 /sbin/init，然后由 init 解释 /etc/inittab 运行各种各样的东西。inittab 会指导 init 去调用一个最重要的系统初始化程序 /etc/init.d/rcS，我们将要在 rcS 中完成各个文件系统的 mount，此外，还有在 rcS 中调用 dhcp 程序，把网络架起来。rcS 执行完了以后，init 就会在一个 console 上，按照 inittab 的指示开一个 shell，或者是开 getty + login，这样用户就会看到提示输入用户名的提示符。我们这里为了简单起见，先直接进入 shell，然后等到调试成功以后，再改成直接进入 X Window。

　　关于 inittab 的语法，我们上面已经提到过了，希望读者朋友们去查权威的 busybox 的用户手册。这里，我们先要讲一下文件系统的构成情况。

　　安排文件系统

　　大家已经看到，我们的 root 文件系统为了避免麻烦，用的是标准的 ext2 文件系统。由于我们的硬盘空间很小，只有不到 16M，而且我们还要在上面放上 X Window，所以，如果我们全部用 ext2 的话，Flash 盘的有限空间会很快耗尽。我们唯一的选择是采用一个适当的压缩文件系统。考虑到 /usr 目录下面的内容在系统运行的时候，是不需要被改写的。我们决定选择只读的压缩文件系统 cramfs 来容纳 /usr 目录下面的全部内容。

　　cramfs 是 Linus Torvalds 本人开发的一个适用于嵌入式系统的小文件系统。由于它是只读的，所以，虽然它采取了 zlib 做压缩，但是它还是可以做到高效的随机读取。既然 cramfs 不会影响系统读取文件的速度，又是一个高度压缩的文件系统，对于我们，它就是一个相当不错的选择了。

　　我们首先把 /usr 目录下的全部内容制成一个 cramfs 的 image 文件。这可以用 mkcramfs 命令完成。得到了这个 usr.img 文件之后，我们还要考虑怎样才能在系统运行的时候，把这个 image 文件 mount 上来，成为一个可用的文件系统。由于这个 image 文件不是一个通常意义上的 block 设备，我们必须采用 loopback 设备来完成这一任务。具体说来，就是在前面提到的 /etc/init.d/rcS 脚本的前面部分，加上一行 mount 命令：


　　mount -o loop -t cramfs /usr.img /usr

　　这样，就可以经由 loopback 设备，把 usr.img 这个 cramfs 的 image 文件 mount 到 /usr 目录上去了。哦，对了，由于要用到 loopback 设备，读者朋友们在编译内核的时候，别忘了加入内核对这个设备的支持。对于系统今后的运行来说，这个 mount 的效果是透明的。cramfs 的压缩效率一般都能达到将近 50%，而我们的系统上绝大部分的内容是位于 /usr 目录下面，这样一来，原本可能要用到 18M 的 Flash 盘，现在可能只需要 11M 就可以了。一个 14M 的 /usr 目录，给压缩成了仅仅 7M。

　　上面考虑了压缩问题，下面还要考虑到，Flash 盘毕竟不像普通硬盘，多次的擦写毕竟不太好，所以我们考虑，在需要多次擦写的地方，使用内存来做。这个任务，我们考虑用 tmpfs 来完成。至于 tmpfs 和经典的 ramdisk 的比较，我们这里就不多说了。一般说来，tmpfs 更加灵活一些，tmpfs 的大小不像 ramdisk，可以顺着用户的需要增长或者缩小。我们选择把 /tmp、/var 等几个目录做成 tmpfs。这只需要我们在 /etc/fstab 里面加上两行类似下面的文字就可以了：


　　none /var tmpfs default 0 0

　　然后别忘了在 /etc/init.d/rcS 里面靠近开头的地方，加上 mount -a。这样，就可以把 /etc/fstab 里面指定的所有的文件系统都 mount 上来了。

　　X Window

　　进行到这里，读者朋友们可能会以为，X Window 的安装可能会很复杂。其实不然，由于我们上面的架子搭好了，X Window 的安装非常简单，只需要把几个关键的程序拷贝过来就可以了。一般说来，只需要 /usr/X11R6 目录下面的 bin 和 lib 两个目录。然后，根据用户各自的需要，还可以做大幅的裁减。比如，如果你的局域网上有一个开放的 xfs 字体服务器的话，你可以把所有本地的字体都删掉，而使用远端的字体服务器。如果只需要运行有限的程序，别忘了把没有用的 library 都删掉。此外，还可以把多余的 X Window 的 driver 都删掉，只保留本机的显示卡所需要的 driver 就可以了。当然，这一关免不了要做多次测试。

　　其它技巧

　　如果你的工作系统式在另外一台机器上，通过局域网和本机互联的话，ssh 是一个不错的工具。此外，ssh 中带的 scp 用起来和普通的 cp 拷贝程序差不多，非常方便。用 ssh 和 scp 来共享文件，远程试验，你就可以不需要在办公室里跑来跑去的了。

　　如果你需要一个 MS Windows 上运行的 X Server 和 xfs 字体服务器，可以考虑包括在 Red Hat 的 Cygwin 工具箱中的 XFree86 系统。


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

Linux操作系统中的七件超厉害的武器

发表人:upczap | 发表时间: 2007年三月21日, 08:07

Linux操作系统中的七件超厉害的武器

Linux是一套免费使用和自由传播的类UNIX操作系统，主要用于基于Intel x86系列CPU的计算机上。Linux系统是由全世界各地的成千上万的程序员设计和实现的，其目的是建立不受任何商品化软件的版权所制约的、全世界都能自由使用的UNIX兼容产品。也许有些准备和正在使用Linux的朋友对为什么使用Linux并不十分了解。本文试就这一问题给出答案，让人们真正了解Linux带给我们的七件武器。Linux对比于商业软件，对学习者来说有一个境界上的差异，这个差异用一句话概述就是：以无法为有法，以无限为有限。这个境界上的差异也就是Linux七种武器的精华所在。

　　一、拳头——编程能力

　　Linux产生于一群真正的黑客。尽管人们习惯于认为Linus是Linux的缔造者，在linux包含的数以千计的文件中，也有一个名为Credits的文件记录了主要的Linux Hacker们的姓名和电子邮件地址(这个列表中包含了100多个名字，世界各地的都有)，但没有人说得清究竟有多少人参与了Linux的改进。这一游戏到今天并没有随着时间的推移而停止，相反却因为Linux的日益流行而爱好者甚众。因此开始使用Linux就犹如加入了一个高手如云的编程组织。你可以通过互联网随时了解来自地球的某一个角落的该领域的最新进展；如果你的英文足够好，加入一个讨论组，你就可以得到不知来自什么地方的神密高手的点拨。由于GPL的存在，你还可以得到开放的源代码，从而不用发愁学习资料的来源。　　

　　随着更多专业公司的介入，Linux可以提供的开发工具的功能也越发强大。如TurboLinux就具有强大的应用程序开发环境，提供了各种开发应用程序的工具，具有对多种语言如：C、C++、Java、Perl、Tcl/tk、Python和Fortran 77的编译器/解释器，以及集成开发环境、调试和其他开发工具。再如Janus Software公司开发的被称为Linux版VB的Phoenix Object Basic，它是一套独特的面向对象的Linux RAD(Rapid Application Development,快速应用软件开发工具)。它综合了Python和Perl等面向对象编程语言的强大功能，同时，提供了类似Visual Basic的易用性。熟悉Windows环境下Visual Basic的编程者都可以顺利地使用Phoenix Object Basic。LynuxWorks公司的VisualLynux可以和微软的Visual C++相媲美，它集成了微软Visual C++开发工具以支持Linux操作系统的产品，它不但兼容LynuxWorks公司的BlueCat Linux，而且还兼容其他的Linux 2.2.12版本。LynuxWorks公司甚至声称从此Visual C++就具备了开发嵌入式Linux应用程序的能力。嵌入式Linux系统现在相当热门，已经广泛地应用在各式各样的通信基础产品。我想可能有些Visual C++的使用者看到这里已经动了心，想要尝试一把了。　　

　　强大的开发工具+开放源代码+高手点拨，结果是什么呢？想来编程狂热分子已经心知肚明。因此强烈建议对编程有狂爱、总喜欢用程序解决问题的人使用Linux，去拥有Linux提供的第一件武器——编程能力。

　　二、多情环——组网能力

　　Linux的组网能力非常强大，它的TCP/IP代码是最高级的。Linux提供了对于当前的TCP/IP协议的完全支持，并且包括了对下一代Internet.协议Ipv6的支持。Linux内核还包括了IP防火墙代码、IP防伪、IP服务质量控制及许多安全特性。这些特性可以和像Cisco这样的公司提供的高端路由设备的特性相媲美。此外，利用Redhat Linux提供的Samba组(并不是RedHat Linux独有)，Linux可以作为Windows客户机的打印和文件服务器，还可以用做NT的文件和打印服务器。运用Linux包含的AppleTalk模块，Linux甚至可以作为一个Macintosh客户机的文件和打印服务器。让Apache这个世界上应用范围最广的Web服务器软件系统跑在linux上，你就可以运行自己的Intranet或者Internet web服务器。Linux还包含了一个Ftp服务程序、一个电子邮件传输代理程序以及，POP和IMAP邮件服务程序。如果你愿意，你还可以在Internet上免费获得一个Linux的LDAP服务程序。面对如此强大的网络功能，我们强烈建议对构造网络有兴趣的人掌握Linux的第二件武器—组网能力。

　　三、长生剑—创新能力　　

　　“如果你总是使用微软的开发工具，你一生只能做个操作人员。”这话一点都不假。Linux是自由软件，而自由软件和非自由软的区别在于：　　

　　1.自由软件是开放的，成千上万的人可以检查这个软件，快速地找到并修改其错误码。

　　2.最终用户可以按照自己的意愿自定义自由软件，有特殊需要的用户也可以完全按照他们认为合适的方式定制自己的Linux。

　　3.自由软件为了防止重复发明，通过共享源代码和思想来节省很多工作量。　　

　　以上这些特性是不是对有想法的好事者有莫大的吸引力？不仅如此，Linux由于自身的优点，应用领域也越来越广泛。如最近嵌入式Linux的应用相当热门，已广泛应用于包括笔记本电脑、连网装置、网络电视等在内的各式各样的通信基础产品，而嵌入式操作系统正日益成为一种势不可挡的流行趋势，最终电脑、通讯、家电会因为它的存在而成为一体。这些也为有想法的好事者提供了更广阔的发挥空间。在梦想就是力量的今天，没有了创新能力是不可想象的。因此强烈建议那些具有较强的钻研精神，喜欢刨根问底的好事者学习使用Linux，利用Linux提供的第三件武器—创新能力。　　

　　四、碧玉刀——UNIX能力　　

　　人们所以选择Linux的又一个重要原因是在于它的UNIX兼容性。由于Linux是一套自由软件，用户可以无偿地得到它及其源代码，无偿地获得大量的应用程序，还可以任意地修改和补充它们。这对用户学习、了解UNIX操作系统的内核非常有益。可以说Linux为广大用户提供了一个在家里学习和使用UNIX操作系统的廉价的机会。　　

　　现在有了许多CD-ROM供应商和软件公司对Linux操作系统的支持，Linux成为UNIX系统在个人计算机上的一个代用品。在用户级，Linux与UNIX非常相似，可以说了解UNIX，就了解了Linux的大部分内容；在编程级，大多数应用程序只需要很少的工作就可以在Linux和UNIX间转换。而且Linux也有意设计为与UNIX兼容，从而便于利用UNIX软件的主体。Linux能够很好地与其他UNIX机器相互操作，它使用了像RPC(远程过程调用)和NFS(网络文件系统)这样的标准UNIX服务。Linux还继承了UNIX的灵活性和可定制性，使其适合于广泛的应用程序，包括适应于传统的服务器和桌面应用程序，以及像嵌入式系统这样的不常见的应用程序。　　

　　因此，如果一个用户在公司上班的时候在UNIX系统上编程，或者在工作中是一位UNIX的系统管理员，他就可以在家里安装一套UNIX的兼容系统，即Linux系统。在家中使用Linux就能够完成一些工作任务。而急于通过Linux的学习掌握UNIX的目的想必不用多说了，在这个网络人才因稀缺而身价倍增的年代，想靠技术吃饭又不想掌握服务器端技术的人才是真正的傻瓜。

　　五、离别钩——怀旧能力　　

　　在这个IT技术日新月异的年代，怀旧应该不是一个好习惯，尽管怀旧可以有一种很不错的情调。但慢慢地我们发现我们不得不怀旧了，因为我们去年刚买的电脑现在已经老掉牙了。尽管每个IT厂商都嚷着他们的产品可以有效地降低我们的TCO(总拥有成本)，可我们手里设备的折旧速度还是在不断加快。如果你肯听我的，我会说这世上从来就没有救世主，还是试试我推荐的Linux吧。　　

　　Linux非常小，可以有效地利用硬件。Linux的最小安装仅需要4MB内存，而你也可以在你的486机器上安装Linux并将其用做防火墙或Web服务器。我读到的Linux名著中甚至记载了有人用二手386建立了路由器和防火墙。Linux内核允许在运行时装载和卸载硬件的驱动程序。这样因为不必装载全部的驱动程序，就可以最大化地使用内存。总之Linux可以使老机器获得新生，节省我们的财力。因此强烈建议那些跑Windows像蜗牛一样慢的电脑的机主们学习Linux。　　

　　六、霸王枪——稳定能力　　

　　运行Linux的机器启动一次可以运行数月。Linux提供了完全的内存保护，每个进程都运行在自己的虚拟地址空间中，并且不会损坏其他进程或内核使用的地址空间。任务与内核间也是相互隔离，即行为不良或编写不良的程序只能毁坏自己。因此被破坏的进程几乎不可能使系统崩溃。Linux在和Windows98和NT在安全性的较量中占有上风，和Windows2000的情况又怎么样呢？资深的系统安全分析家指出：Windows 2000在网络系统，服务器连接方面的工作准备不足，Linux仍然是目前最安全的操作系统。资深的系统安全分析家还预计到今年年底Windows 2000才能完成测试、除虫工作，目前比较安全的操作系统仍然是商业版本的UNIX和Linux。资深的系统安全分析家肯定地认为：在未来的5年里，Linux将成为最安全的操作系统。到2005年，管理和使用Linux将是一件十分容易的事情。　　

　　现在可以说Linux是一个非常坚固的系统了，因此强烈建议对于Windows的蓝屏死机极为厌恶的人学习Linux，使用Linux提供的第六件武器——稳定能力。　　

　　七、孔雀翎——支付能力

　　Linux提供的第七件武器和金钱有关，这是一个不容回避的问题。因为价格原因，每个人都可以拥有正版的Linux。此外Linux还是一个完全开放的系统。它支持各种像POSIX标准这样的开放标准和TCP/IP的Internet工程任务组标准。由于避免了专有的API(应用程序接口)和协议，可以减少对单一供应商的依赖。这样就不会出现像使用专用系统的情况：一旦犯了错误，只能继续使用原来的系统供用商的产品。也就是不会出现先享受低价，而在后期需要付出高额服务费的情况。因此强烈建议不想花太多的钱，又想使用正版软件的人学习和使用Linux。


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

VI编辑器的用法

发表人:upczap | 发表时间: 2007年三月20日, 21:02

VI编辑器的用法

光标控制命令

命令 光标移动


h或^h 向左移一个字符
j或^j或^n 向下移一行
k或^p 向上移一行
l或空格 向右移一个字符
G 移到文件的最后一行
nG 移到文件的第n行
w 移到下一个字的开头
W 移到下一个字的开头，忽略标点符号
b 移到前一个字的开头
B 移到前一个字的开头，忽略标点符号
L 移到屏幕的最后一行
M 移到屏幕的中间一行
H 移到屏幕的第一行
e 移到下一个字的结尾
E 移到下一个字的结尾，忽略标点符号
( 移到句子的开头
) 移到句子的结尾
{ 移到段落的开头
} 移到下一个段落的开头
0或| 移到当前行的第一列
n| 移到当前行的第n列
^ 移到当前行的第一个非空字符
$ 移到当前行的最后一个字符
+或return 移到下一行的第一个字符
- 移到前一行的第一个非空字符


在vi中添加文本

命令 插入动作

a 在光标后插入文本
A 在当前行插入文本
i 在光标前插入文本
I 在当前行前插入文本
o 在当前行的下边插入新行
O 在当前行的上边插入新行
:r file 读入文件file内容，并插在当前行后
:nr file 读入文件file内容，并插在第n行后
escape 回到命令模式
^v char 插入时忽略char的指定意义，这是为了插入特殊字符


在vi中删除文本

命令 删除操作
x 删除光标处的字符，可以在x前加上需要删除的字符数目
nx 从当前光标处往后删除n个字符
X 删除光标前的字符，可以在X前加上需要删除的字符数目
nX 从当前光标处往前删除n个字符
dw 删至下一个字的开头
ndw 从当前光标处往后删除n个字
dG 删除行，直到文件结束
dd 删除整行
ndd 从当前行开始往后删除
db 删除光标前面的字
ndb 从当前行开始往前删除n字
:n,md 从第m行开始往前删除n行
d或d$ 从光标处删除到行尾
dcursor_command 删除至光标命令处，如dG将从当产胆行删除至文件的末尾
^h或backspace 插入时，删除前面的字符
^w 插入时，删除前面的字


修改vi文本

每个命令前面的数字表示该命令重复的次数

命令 替换操作
rchar 用char替换当前字符
R text escape 用text替换当前字符直到换下Esc键
stext escape 用text代替当前字符
S或cctext escape 用text代替整行
cwtext escape 将当前字改为text
Ctext escape 将当前行余下的改为text
cG escape 修改至文件的末尾
ccursor_cmd text escape 从当前位置处到光标命令位置处都改为text


在vi中查找与替换

命令 查找与替换操作
/text 在文件中向前查找text
?text 在文件中向后查找text
n 在同一方向重复查找
N 在相反方向重复查找
ftext 在当前行向前查找text
Ftext 在当前行向后查找text
ttext 在当前行向前查找text，并将光标定位在text的第一个字符
Ttext 在当前行向后查找text，并将光标定位在text的第一个字符
:set ic 查找时忽略大小写
:set noic 查找时对大小写敏感
:s/oldtext/newtext 用newtext替换oldtext
:m,ns/oldtext/newtext 在m行通过n，用newtext替换oldtext
& 重复最后的:s命令
:g/text1/s/text2/text3 查找包含text1的行，用text3替换text2
:g/text/command 在所有包含text的行运行command所表示的命令
:v/text/command 在所有不包含text的行运行command所表示的命令


在vi中复制文本

命令 复制操作
yy 将当前行的内容放入临时缓冲区
nyy 将n行的内容放入临时缓冲区
p 将临时缓冲区中的文本放入光标后
P 将临时缓冲区中的文本放入光标前
"(a-z)nyy 复制n行放入名字为圆括号内的可命名缓冲区，省略n表示当前行
"(a-z)ndd 删除n行放入名字为圆括号内的可命名缓冲区，省略n表示当前行
"(a-z)p 将名字为圆括号的可命名缓冲区的内容放入当前行后
"(a-z)P 将名字为圆括号的可命名缓冲区的内容放入当前行前


在vi中撤消与重复

命令 撤消操作
u 撤消最后一次修改
U 撤消当前行的所有修改
. 重复最后一次修改
, 以相反的方向重复前面的f、F、t或T查找命令
; 重复前面的f、F、t或T查找命令
"np 取回最后第n次的删除(缓冲区中存有一定次数的删除内容，一般为9)
n 重复前面的/或?查找命令
N 以相反方向重复前面的/或?命令


保存文本和退出vi

命令 保存和/或退出操作
:w 保存文件但不退出vi
:w file 将修改保存在file中但不退出vi
:wq或ZZ或:x 保存文件并退出vi
:q! 不保存文件，退出vi
:e! 放弃所有修改，从上次保存文件开始再编辑


vi中的选项

选项 作用
:set all 打印所有选项
:set nooption 关闭option选项
:set nu 每行前打印行号
:set showmode 显示是输入模式还是替换模式
:set noic 查找时忽略大小写
:set list 显示制表符(^I)和行尾符号
:set ts=8 为文本输入设置tab stops
:set window=n 设置文本窗口显示n行


vi的状态

选项 作用
:.= 打印当前行的行号
:= 打印文件中的行数
^g 显示文件名、当前的行号、文件的总行数和文件位置的百分比
:l 使用字母"l"来显示许多的特殊字符，如制表符和换行符


在文本中定位段落和放置标记

选项 作用
{ 在第一列插入{来定义一个段落
[[ 回到段落的开头处
]] 向前移到下一个段落的开头处
m(a-z) 用一个字母来标记当前位置，如用mz表示标记z
'(a-z) 将光标移动到指定的标记，如用'z表示移动到z


在vi中连接行

选项 作用
J 将下一行连接到当前行的末尾
nJ 连接后面n行


光标放置与屏幕调整

选项 作用
H 将光标移动到屏幕的顶行
nH 将光标移动到屏幕顶行下的第n行
M 将光标移动到屏幕的中间
L 将光标移动到屏幕的底行
nL 将光标移动到屏幕底行上的第n行
^e(ctrl+e) 将屏幕上滚一行
^y 将屏幕下滚一行
^u 将屏幕上滚半页
^d 将屏幕下滚半页
^b 将屏幕上滚一页
^f 将屏幕下滚一页
^l 重绘屏幕
z-return 将当前行置为屏幕的顶行
nz-return 将当前行下的第n行置为屏幕的顶行
z. 将当前行置为屏幕的中央
nz. 将当前行上的第n行置为屏幕的中央
z- 将当前行置为屏幕的底行
nz- 将当前行上的第n行置为屏幕的底行


vi中的shell转义命令

选项 作用
:!command 执行shell的command命令，如:!ls
:!! 执行前一个shell命令
:r!command 读取command命令的输入并插入，如:r!ls会先执行ls，然后读入内容
:w!command 将当前已编辑文件作为command命令的标准输入并执行command命令，如:w!grep all
:cd directory 将当前工作目录更改为directory所表示的目录
:sh 将启动一个子shell，使用^d(ctrl+d)返回vi
:so file 在shell程序file中读入和执行命令


vi中的宏与缩写
(避免使用控制键和符号，不要使用字符K、V、g、q、v、*、=和功能键)

选项 作用
:map key command_seq 定义一个键来运行command_seq，如:map e ea，无论什么时候都可以e移到一个字的末尾来追加文本
:map 在状态行显示所有已定义的宏
:umap key 删除该键的宏
:ab string1 string2 定义一个缩写，使得当插入string1时，用string2替换string1。当要插入文本时，键入string1然后按Esc键，系统就插入了string2
:ab 显示所有缩写
:una string 取消string的缩写


在vi中缩进文本

选项 作用
^i(ctrl+i)或tab 插入文本时，插入移动的宽度，移动宽度是事先定义好的
:set ai 打开自动缩进
:set sw=n 将移动宽度设置为n个字符
n<< 使n行都向左移动一个宽度
n>> 使n行都向右移动一个宽度，例如3>>就将接下来的三行每行都向右移动一个移动宽度


分类: ( Linux ) :: 评论 (0) :: 静态链接网址 :: 引用 (0)
Valid XHTML 1.0 Strict and CSS. Powered by pLog
Design by Blog.lvwo.com