Xianfeng Design: 四月 2007

2007年4月29日星期日

Linux remote desktop （远程桌面）控制

这里我要说的不是telnet,rsh之类的远程控制工具,而是指远程控制桌面应用.

　　X window比MS windows先进的地方是,X window是个基于网络的的图形视窗系统,本身就具有远程控制的强大功能.用户在远程系统上登录执行X 应用程序,并将Xclients执行的结果传回本地主机.这就是我下面要介绍的Remote X

一、Remote X

　　假设本地主机ip为172.16.1.1,远程的主机ip为172.16.1.2

　　第一步,在本地主机上的任意一个xterm中执行xhost,用来允许远程的其它主机可以和本地主机的X server联网:

　　xhost + 172.16.1.2

　　如果不指定任何ip地址,则表示权限完全放开,这会带来安全问题,要小心!

　　第二步,确认本地主机的xfs是运行的.用ps检查一下进程.

　　第三步,从本地主机(172.16.1.1)上通过网络登录到远程主机172.16.1.2上,你用telnet,ssh,rsh都可以.设置DISPLAY变量.

　　export DISPLAY=172.16.1.1:0

　　第四步,现在可以使用远程主机上的X 应用程序了.

　　这么样,很方便吧,但是你还不能掌控整个桌面环境,这个工作就交给vnc吧!Remote X 在局域网上运行效果很不错,普通的电话拨号就不用试了,速度太慢了。
　　
二、vnc

　　我相信有不少人在windows环境用过pcanywhere,但你想不想用一个免费的,可以在linux,win9x/nt上都可以使用的pcanywhere,这就是vnc.

　　vnc就是vitual network computing的缩写,它支持许多操作平台,甚至可在浏览器中操作.

　　我主要介绍vncviewer的用法,以及用linux远程控制linux或nt.

　　vnc client通过架构在tcp/ip上的vnc协议与vnc server沟通,通过认证后,把X server的桌面环境,输入设备,和X 资源交给vncserver掌控,vnc server将桌面环境通过vnc 协议送给vnc client端.让vnc client来操纵vnc server桌面环境和输入设备.

　　首先下载到vnc的linux版本和windows版本.

　　当前的linux版本是vnc-3.3.3r1_x86_linux_2.0.tgz

　　当前的windows版本是vnc-3.3.3r7_x86_win32.zip

1.安装linux版的vnc
　　(1)安装

　　tar zxvf vnc-3.3.3r1_x86_linux_2.0.tgz
　　cd vnc_x86_linux_2.0
　　cp *vnc* /usr/local/bin/
　　mkdir /usr/local/vnc
　　cp -r classes/ /usr/local/vnc/

　　(2)设置vnc server的访问密码

　　vncpasswd

　　(3)启动vnc server

　　vncserver

　　注意运行后显示的信息,记下所用的端口号,一般从1开始,因为0被x server占用了.现在,你就能提供vnc服务了.vnc client的用法等会介绍.

　　2、安装nt版的vnc
　　1)安装
　　解开vnc-3.3.3r7_x86_win32.zip包后,会产生winvnc和vncviewer两个目录.winvnc目录中是vnc server的安装程序,vncviewer目录中是vnc client的安装序.我只关心vnc server,在winvnc目录中执行setup即可.

　　2)设置
　　首先执行install default registry settings.
　　run winvnc(app mode)就是执行vnc server
　　这时可看到winvnc运行的小图标,用鼠标右键点击图标,在properties/incoming connections中设定密码.默认配置即可.
　　现在,你的nt就能提供vnc服务了.

　　3、使用vncviewer

　　vnc server启动成功后,你就可用vncviewer来远程控制桌面了.

　　vncviewer xxx.xxx.xxx.xxx:display number

　　例如,vncviewer 172.16.1.2:1

　　按要求输入密码就可以看到远程的桌面了.

　　注意:viewers需要在16位色的显示模式下工作，如果您的操作系统中没上16位色，那么请您及时的调整您计算机的显示模式。不然vncviewer无法正常工作。

　　4、linux版vnc server的改进.

　　linux上的vnc server内定的桌面管理环境是twm,实在是太简陋了.
　　修改$HOME/.vnc/xstartup这个文件.
　　把所有内容的行前加上#,再在接尾部份加上:
　　startkde &
　　你当然可用你喜好的桌面代替.我这是用kde来代替twm,速度会慢少少,但用起来方便不少.
　　注意要重新启动vnc server.

　　5、通过浏览器使用vnc

　　通过浏览器使用vnc,要注意端口号的变化.
　　假设vnc server是172.16.1.2:1的话,那么,可用浏览器访问http://172.16.1.2:5801
　　端口号=display number + 5800
　　好了,心动不如行动,just do it !

改变网络接口的速度和协商方式的工具miitool 和ethtool (v0.1b)

1、mii-tool 配置网络设备协商方式的工具；

1.1 mii-tool 介绍；

mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

有时网卡需要配置协商方式，比如10/100/1000M的网卡半双工、全双工、自动协商的配置。但大多数的网络设备是不用我们来修改协商，因为大多数网络设置接入的时候，都采用自动协商来解决相互通信的问题。不过自动协商也不是万能的，有时也会出现错误，比如丢包率比较高，这时就要我们来指定网卡的协商方式。

mii-tool 就是能指定网卡的协商方式。下面我们说一说mii-tool的用法；

1.2 mii-tool 的用法；

mii-tool 在更改网络设备通信协商方式的方法比较简单，用 -v 参数来查看网络接口的状态；看下面的例子；

mii-tool 更改网络接口协商的方法；

[root@localhost ~]# mii-tool --help
usage: mii-tool [-VvRrwl] [-A media,... | -F media] [interface ...]
-V, --version display version information
-v, --verbose more verbose output 注：显示网络接口的信息；
-R, --reset reset MII to poweron state 注：重设MII到开启状态；
-r, --restart restart autonegotiation 注：重启自动协商模式；
-w, --watch monitor for link status changes 注：查看网络接口连接的状态变化；
-l, --log with -w, write events to syslog 注：写入事件到系统日志；
-A, --advertise=media,... advertise only specified media 注：指令特定的网络接口；
-F, --force=media force specified media technology 注：更改网络接口协商方式；
media: 100baseT4, 100baseTx-FD, 100baseTx-HD, 10baseT-FD, 10baseT-HD,
(to advertise both HD and FD) 100baseTx, 10baseT

＊实例一：查看网络接口的协商状态；

[root@localhost ~]# mii-tool -v eth0eth0: negotiated 100baseTx-FD, link ok product info: vendor 00:00:00, model 0 rev 0 basic mode: autonegotiation enabled basic status: autonegotiation complete, link ok capabilities: 100baseTx-FD 100baseTx-HD 10baseT-FD 10baseT-HD advertising: 100baseTx-FD 100baseTx-HD 10baseT-FD 10baseT-HD link partner: 100baseTx-FD 100baseTx-HD 10baseT-FD 10baseT-HD flow-control

注：上面的例子，我们可以看得到是自动协商。注意红字的部份；

＊实例二：更改网络接口协商方式；

更改网络接口的协商方式，我们要用到－F选项，后面可以接 100baseT4, 100baseTx-FD, 100baseTx-HD, 10baseT-FD, 10baseT-HD等参数；

如果我们想把网络接口eth0改为 1000Mb/s全双工的模式应该怎么办呢？

[root@localhost ~]# mii-tool -F 100baseTx-FD[root@localhost ~]#mii-tool -v eth0eth0: 100 Mbit, full duplex, link ok product info: vendor 00:00:00, model 0 rev 0 basic mode: 100 Mbit, full duplex basic status: link ok capabilities: 100baseTx-FD 100baseTx-HD 10baseT-FD 10baseT-HD advertising: 100baseTx-FD 100baseTx-HD 10baseT-FD 10baseT-HD

注：是不是已经改过来了？当然，我们也一样用ethtool 工具来更改，比如执行下面的命令；

[root@localhost ~]# ethtool -s eth0 speed 100 duplex full

2、ethtool 工具关于网络协商功能介绍；

ethtool - Display or change ethernet card settings（ethtool 是用来显示和更改网卡设置的工具）；这个工具比较复杂，功能也特别多。由于洋文比较难懂。所以我们还是把网络设备协商方式的设置方法说一说。

2.1 ethtool 显示网络端口设置功能；

这个功能比较好办。就是ethtool 后面直接接网絽接口就行；比如下面的例子；

[root@localhost ~]# ethtool eth0
Settings for eth0:
Supported ports: [ TP MII ]
Supported link modes: 10baseT/Half 10baseT/Full
100baseT/Half 100baseT/Full
Supports auto-negotiation: Yes
Advertised link modes: 10baseT/Half 10baseT/Full
100baseT/Half 100baseT/Full
Advertised auto-negotiation: No 注：自动协商关闭
Speed: 100Mb/s 注：速度 100Mb
Duplex: Full 注：全双工
Port: MII
PHYAD: 32
Transceiver: internal
Auto-negotiation: off
Supports Wake-on: pumbg
Wake-on: d
Current message level: 0x00000007 (7)
Link detected: yes 注：eth0已经激活；

2.2 ethtool 设置网卡的协商模式；

在ethtool的-h帮助中我们查看到有这样的帮助信息；

ethtool -s DEVNAME \
[ speed 10|100|1000 ] \
[ duplex half|full ] \
[ port tp|aui|bnc|mii|fibre ] \
[ autoneg on|off ] \

＊实例一：把网卡eth0 速度改为10Mb/s，采用半双工；

[root@cuc03 beinan]# ethtool -s eth1 speed 10 duplex half[root@cuc03 beinan]# ethtool eth1Settings for eth1: Supported ports: [ TP MII ] Supported link modes: 10baseT/Half 10baseT/Full 100baseT/Half 100baseT/Full Supports auto-negotiation: Yes Advertised link modes: 10baseT/Half 10baseT/Full 100baseT/Half 100baseT/Full Advertised auto-negotiation: No Speed: 10Mb/s 注：速度 10M/s Duplex: Half 注：半双工 Port: MII PHYAD: 32 Transceiver: internal Auto-negotiation: off Supports Wake-on: pumbg Wake-on: d Current message level: 0x00000007 (7) Link detected: no 注：eth1没有激活；

＊实例二：把网卡eth0 速度改为100Mb/s，采用全双工；

[root@cuc03 beinan]# ethtool -s eth1 speed 100 duplex full [root@cuc03 beinan]# ethtool eth1Settings for eth1: Supported ports: [ TP MII ] Supported link modes: 10baseT/Half 10baseT/Full 100baseT/Half 100baseT/Full Supports auto-negotiation: Yes Advertised link modes: 10baseT/Half 10baseT/Full 100baseT/Half 100baseT/Full Advertised auto-negotiation: No Speed: 100Mb/s 注：速度 100M/s Duplex: Full 注：全双工 Port: MII PHYAD: 32 Transceiver: internal Auto-negotiation: off Supports Wake-on: pumbg Wake-on: d Current message level: 0x00000007 (7) Link detected: no 注：eth1网卡没有激活；

实例解读 linux 网卡驱动

在此仅仅讨论网络设备驱动的一般写法，有关硬件部分的相关代码由于硬件规格不同，予以省略。有什么地方错误，或补充，欢迎大家提出。

1, 驱动模块的加载和卸载

如果网络设备（包括wireless）是PCI规范的，则先是向内核注册该PCI设备(pci_register_driver)，然后由pci_driver数据结构中的probe函数指针所指向的侦测函数来初始化该PCI设备，并且同时注册和初始化该网络设备。

如果网络设备（包括wireless）是PCMCIA规范的，则先是向内核注册该PCMCIA设备 (register_pccard_driver)，然后driver_info_t数据结构中的attach函数指针所指向的侦测函数来初始化该 PCMCIA设备，并且同时注册和初始化该网络设备。

static int __init tg3_init(void)
{
//先注册成PCI设备，并初始化，如果是其他的ESIA，PCMCIA，用其他函数
return pci_module_init(&tg3_driver);
}

static void __exit tg3_cleanup(void)
{
pci_unregister_driver(&tg3_driver);//注销PCI设备
}

module_init(tg3_init); //驱动模块的加载
module_exit(tg3_cleanup); //驱动模块的卸载

申明为PCI设备：
static struct pci_driver tg3_driver = {
.name = DRV_MODULE_NAME,
.id_table = tg3_pci_tbl, //此驱动所支持的网卡系列，vendor_id, device_id
.probe = tg3_init_one, //初始化网络设备的回调函数
.remove = __devexit_p(tg3_remove_one), //注销网络设备的回调函数
.suspend = tg3_suspend, //设备挂起函数
.resume = tg3_resume //设备恢复函数
};

2，PCI设备探测函数probe，初始化网络设备
static int __devinit tg3_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{

//初始化设备，使I/O，memory可用，唤醒设备
pci_enable_device(pdev);

//申请内存空间，配置网卡的I/O，memory资源
pci_request_regions(pdev, DRV_MODULE_NAME);
pci_set_master(pdev);

//设置DMA属性
pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff);

//网卡 I/O,memory资源的启始地址
tg3reg_base = pci_resource_start(pdev, 0);

//网卡I/O,memory资源的大小
tg3reg_len = pci_resource_len(pdev, 0);

//分配并设置网络设备
dev = alloc_etherdev(sizeof(*tp));

//申明为内核设备模块
SET_MODULE_OWNER(dev);

//初始化私有结构中的各成员值
tp = dev->priv;
tp->pdev = pdev;
tp->dev = dev;
……
//锁的初始化
spin_lock_init(&tp->lock);

//映射I/O,memory地址到私有域中的寄存器结构
tp->regs = (unsigned long) ioremap(tg3reg_base, tg3reg_len);
dev->irq = pdev->irq;

//网络设备回调函数赋值
dev->open = tg3_open;
dev->stop = tg3_close;
dev->get_stats = tg3_get_stats;
dev->set_multicast_list = tg3_set_rx_mode;
dev->set_mac_address = tg3_set_mac_addr;
dev->do_ioctl = tg3_ioctl;
dev->tx_timeout = tg3_tx_timeout;
dev->hard_start_xmit= tg3_start_xmit;

//网卡的MAC地址赋值dev->addr
tg3_get_device_address(tp);

//注册网络设备
register_netdev(dev);

//把网络设备指针地址放入PCI设备中的设备指针中
pci_set_drvdata(pdev, dev);
}

3，注销网络设备
static void __devexit tg3_remove_one(struct pci_dev *pdev)
{
struct net_device *dev = pci_get_drvdata(pdev);
//注销网络设备
unregister_netdev(dev);
//取消地址映射
iounmap((void *) ((struct tg3 *)(dev->priv))->regs);
//释放网络设备
kfree(dev);
//释放PCI资源
pci_release_regions(pdev);
//停用PCI设备
pci_disable_device(pdev);
//PCI设备中的设备指针赋空
pci_set_drvdata(pdev, NULL);
}

4，打开网络设备
static int tg3_open(struct net_device *dev)
{
//分配一个中断
request_irq(dev->irq, tg3_interrupt, SA_SHIRQ, dev->name, dev);

/* int request_irq(unsigned int irq,
void (*handler)(int irq, void *dev_id, struct pt_regs *regs),
unsigned long irqflags,
const char * devname,
void *dev_id);

irq是要申请的硬件中断号。在Intel平台，范围0--15。
handler是向系统登记的中断处理函数。这是一个回调函数，中断发生时，系统调用这个函数，传入的参数包括硬件中断号，device id，寄存器值。
dev_id就是下面的request_irq时传递给系统的参数dev_id。
irqflags 是中断处理的一些属性。比较重要的有 SA_INTERRUPT，标明中断处理程序是快速处理程序(设置SA_INTERRUPT)还是慢速处理程序(不设置SA_INTERRUPT)。快速处理程序被调用时屏蔽所有中断。慢速处理程序不屏蔽。还有一个SA_SHIRQ属性，设置了以后运行多个设备共享中断。dev_id在中断共享时会用到。一般设置为这个设备的device结构本身或者NULL。中断处理程序可以用dev_id找到相应的控制这个中断的设备，或者用rq2dev_map找到中断对应的设备。*/

//初始化硬件
tg3_init_hw(tp);

//初始化收包和发包的缓冲区
tg3_init_rings(tp);

//初始化定时器
init_timer(&tp->timer);
tp->timer.expires = jiffies + tp->timer_offset;
tp->timer.data = (unsigned long) tp;
tp->timer.function = tg3_timer; //超时回调函数
add_timer(&tp->timer);

//允许网卡开始传输包
netif_start_queue(dev);
}

5，关闭网络设备
static int tg3_close(struct net_device *dev)
{
//停止网卡传输包
netif_stop_queue(dev);
netif_carrier_off(tp->dev);
//去除定时器
del_timer_sync(&tp->timer);
//释放收包和发包的缓冲区
tg3_free_rings(tp);
//释放中断
free_irq(dev->irq, dev);
}

6，硬件处理数据包发送
static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
len = (skb->len - skb->data_len);
//以DMA方式向网卡物理设备传输包。如果是wireless的话，需要根据802.11协议及硬件的规范从新填充
//硬件帧头，然后提交给硬件发送。
mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
tp->tx_buffers[entry].skb = skb;
pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
//硬件发送
tg3_set_txd(tp, entry, mapping, len, base_flags, mss_and_is_end);
//记录发包开始时间
dev->trans_start = jiffies;
}

7，中断处理收包，发包
static void tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
//如果要收包
tg3_rx(tp);
//如果要发包
tg3_tx(tp);
}

8，发包
static void tg3_tx(struct tg3 *tp)
{
struct tx_ring_info *ri = &tp->tx_buffers[sw_idx];
struct sk_buff *skb = ri->skb;
//以DMA方式向网卡传输包完毕
pci_unmap_single(tp->pdev, pci_unmap_addr(ri, mapping),
(skb->len - skb->data_len), PCI_DMA_TODEVICE);
ri->skb = NULL;
dev_kfree_skb_irq(skb);
}

9，收包
static int tg3_rx(struct tg3 *tp, int budget)
{
struct sk_buff *copy_skb;
//分配一个包
copy_skb = dev_alloc_skb(len + 2);
copy_skb->dev = tp->dev;
//修改包头空间
skb_reserve(copy_skb, 2);
//加入数据到包中
skb_put(copy_skb, len);
//以DMA方式从网卡传输回数据
pci_dma_sync_single(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
memcpy(copy_skb->data, skb->data, len);
skb = copy_skb;
//解析包的协议
skb->protocol = eth_type_trans(skb, tp->dev);
//把包送到协议层
netif_rx(skb);
//记录收包时间
tp->dev->last_rx = jiffies;
}

10, 读取包的网卡收发包的状态，统计数据
static struct net_device_stats *tg3_get_stats(struct net_device *dev)
{
//从硬件相关的寄存器读取数据，累加
//stats->rx_packets, stats->tx_packets, stats->rx_bytes, stats->tx_bytes等
}

11, 用户的ioctl命令系统调用
static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
struct mii_ioctl_data *data = (struct mii_ioctl_data *)&ifr->ifr_data;
switch(cmd) {
//ethtool程序命令的调用
case SIOCETHTOOL:
return tg3_ethtool_ioctl(dev, (void *) ifr->ifr_data);
//mii程序命令的调用
case SIOCGMIIREG: {
err = tg3_readphy(tp, data->reg_num & 0x1f, &mii_regval)
data->val_out = mii_regval;
return err;
}
……
}
}

12, PCI设备的挂起和恢复函数
static int tg3_suspend(struct pci_dev *pdev, u32 state)
{
//停用网卡的中断寄存器
tg3_disable_ints(tp);
//停止网卡收发包
netif_device_detach(dev);
//停止网卡某些硬件，fireware的一些功能
tg3_halt(tp);
//设置网卡的电源状态
tg3_set_power_state(tp, state);
}

static int tg3_resume(struct pci_dev *pdev)
{
//恢复网卡电源
tg3_set_power_state(tp, 0);
//允许网卡收发包
netif_device_attach(dev);
//初始化收发包的缓冲区
tg3_init_rings(tp);
//初始化网卡硬件
tg3_init_hw(tp);
//打开网卡中断寄存器
tg3_enable_ints(tp);
}

13，参数设置
在驱动程序里还提供一些方法供系统对设备的参数进行设置和读取信息。一般只有超级用户(root)权限才能对设备参数进行设置。设置方法有：

tg3_set_mac_addr (dev->set_mac_address)
当用户调用ioctl类型为SIOCSIFHWADDR时是要设置这个设备的mac地址。一般对mac地址的设置没有太大意义的。

dev->set_config()
当用户调用ioctl时类型为SIOCSIFMAP时，系统会调用驱动程序的set_config方法
用户会传递一个ifmap结构包含需要的I/O、中断等参数。

总结：

所有的Linux网络驱动程序遵循通用的接口。
设计时采用的是面向对象的方法。一个设备就是一个对象(net_device 结构)，它内部有自己的数据和方法。一个网络设备最基本的方法有初始化,发送和接收。

Linux网络驱动程序的体系结构可以划分为四层：
网络协议接口，网络设备接口，设备驱动功能，网络设备和网络媒介层

网络驱动程序，最主要的工作就是完成设备驱动功能层。
在Linux中所有网络设备都抽象为一个接口，这个接口提供了对所有网络设备的操作集合。
由数据结构struct net_device来表示网络设备在内核中的运行情况，即网络设备接口。
它既包括纯软件网络设备接口，如环路（Loopback），也包括硬件网络设备接口，如以太网卡。

而由以dev_base为头指针的设备链表来集体管理所有网络设备，该设备链表中的每个元素代表一个网络设备接口。数据结构 net_device中有很多供系统访问和协议层调用的设备方法，包括初始化,打开和关闭网络设备的open和stop函数，处理数据包发送的 hard_start_xmit函数，以及中断处理函数等。

网络设备在Linux里做专门的处理。Linux的网络系统主要是基于BSD unix的socket机制。在系统和驱动程序之间定义有专门的数据结构(sk_buff)进行数据的传递。系统里支持对发送数据和接收数据的缓存，提供流量控制机制，提供对多协议的支持。

Linux环境进程间通信:共享内存

共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。

采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据[1]：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

Linux的 2.2.x内核支持多种共享内存方式，如mmap()系统调用，Posix共享内存，以及系统V共享内存。linux发行版本如Redhat 8.0支持mmap()系统调用及系统V共享内存，但还没实现Posix共享内存，本文将主要介绍mmap()系统调用及系统V共享内存API的原理及应用。

一、内核怎样保证各个进程寻址到同一个共享内存区域的内存页面

1、 page cache及swap cache中页面的区分：一个被访问文件的物理页面都驻留在page cache或swap cache中，一个页面的所有信息由struct page来描述。struct page中有一个域为指针mapping ，它指向一个struct address_space类型结构。page cache或swap cache中的所有页面就是根据address_space结构以及一个偏移量来区分的。

2、文件与address_space结构的对应：一个具体的文件在打开后，内核会在内存中为之建立一个struct inode结构，其中的i_mapping域指向一个address_space结构。这样，一个文件就对应一个address_space结构，一个 address_space与一个偏移量能够确定一个page cache 或swap cache中的一个页面。因此，当要寻址某个数据时，很容易根据给定的文件及数据在文件内的偏移量而找到相应的页面。

3、进程调用mmap()时，只是在进程空间内新增了一块相应大小的缓冲区，并设置了相应的访问标识，但并没有建立进程空间到物理页面的映射。因此，第一次访问该空间时，会引发一个缺页异常。

4、对于共享内存映射情况，缺页异常处理程序首先在swap cache中寻找目标页（符合address_space以及偏移量的物理页），如果找到，则直接返回地址；如果没有找到，则判断该页是否在交换区 (swap area)，如果在，则执行一个换入操作；如果上述两种情况都不满足，处理程序将分配新的物理页面，并把它插入到page cache中。进程最终将更新进程页表。
注：对于映射普通文件情况（非共享映射），缺页异常处理程序首先会在page cache中根据address_space以及数据偏移量寻找相应的页面。如果没有找到，则说明文件数据还没有读入内存，处理程序会从磁盘读入相应的页面，并返回相应地址，同时，进程页表也会更新。

5、所有进程在映射同一个共享内存区域时，情况都一样，在建立线性地址与物理地址之间的映射之后，不论进程各自的返回地址如何，实际访问的必然是同一个共享内存区域对应的物理页面。
注：一个共享内存区域可以看作是特殊文件系统shm中的一个文件，shm的安装点在交换区上。

上面涉及到了一些数据结构，围绕数据结构理解问题会容易一些。

二、mmap()及其相关系统调用

mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

注：实际上，mmap()系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。

1、mmap()系统调用形式如下：

void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )
参数fd为即将映射到进程空间的文件描述字，一般由open()返回，同时，fd可以指定为-1，此时须指定flags参数中的MAP_ANON，表明进行的是匿名映射（不涉及具体的文件名，避免了文件的创建及打开，很显然只能用于具有亲缘关系的进程间通信）。len是映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起。prot 参数指定共享内存的访问权限。可取如下几个值的或：PROT_READ（可读） , PROT_WRITE （可写）, PROT_EXEC （可执行）, PROT_NONE（不可访问）。flags由以下几个常值指定：MAP_SHARED , MAP_PRIVATE , MAP_FIXED，其中，MAP_SHARED , MAP_PRIVATE必选其一，而MAP_FIXED则不推荐使用。offset参数一般设为0，表示从文件头开始映射。参数addr指定文件应被映射到进程空间的起始地址，一般被指定一个空指针，此时选择起始地址的任务留给内核来完成。函数的返回值为最后文件映射到进程空间的地址，进程可直接操作起始地址为该值的有效地址。这里不再详细介绍mmap()的参数，读者可参考mmap()手册页获得进一步的信息。

2、系统调用mmap()用于共享内存的两种方式：

（1）使用普通文件提供的内存映射：适用于任何进程之间；此时，需要打开或创建一个文件，然后再调用mmap()；典型调用代码如下：

 fd=open(name, flag, mode);if(fd<0)>ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0); 通过mmap()实现共享内存的通信方式有许多特点和要注意的地方，我们将在范例中进行具体说明。 
（2） 使用特殊文件提供匿名内存映射：适用于具有亲缘关系的进程之间；由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用fork()。那么 在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注 意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。
对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可，参见范例2。
3、系统调用munmap()
int munmap( void * addr, size_t len )
该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小。当映射关系解除后，对原来映射地址的访问将导致段错误发生。
4、系统调用msync()
int msync ( void * addr , size_t len, int flags)
一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。
三、mmap()范例
下 面将给出使用mmap()的两个范例：范例1给出两个进程通过映射普通文件实现共享内存通信；范例2给出父子进程通过匿名映射实现共享内存。系统调用 mmap()有许多有趣的地方，下面是通过mmap（）映射普通文件实现进程间的通信的范例，我们通过该范例来说明mmap()实现共享内存的特点及注意 事项。
范例1：两个进程通过映射普通文件实现共享内存通信
范例 1包含两个子程序：map_normalfile1.c及map_normalfile2.c。编译两个程序，可执行文件分别为 map_normalfile1及map_normalfile2。两个程序通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。 map_normalfile2试图打开命令行参数指定的一个普通文件，把该文件映射到进程的地址空间，并对映射后的地址空间进行写操作。 map_normalfile1把命令行参数指定的文件映射到进程地址空间，然后对映射后的地址空间执行读操作。这样，两个进程通过命令行参数指定同一个 文件来实现共享内存方式的进程间通信。
下面是两个程序代码：
/*-------------map_normalfile1.c-----------*/#include #include #include #include typedef struct{ char name[4]; int  age;}people;main(int argc, char** argv) // map a normal file as shared mem:{ int fd,i; people *p_map; char temp;  fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777); lseek(fd,sizeof(people)*5-1,SEEK_SET); write(fd,"",1);  p_map = (people*) mmap( NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 ); close( fd ); temp = 'a'; for(i=0; i<10; age =" 20+i;">#include #include #include typedef struct{ char name[4]; int  age;}people;main(int argc, char** argv) // map a normal file as shared mem:{ int fd,i; people *p_map; fd=open( argv[1],O_CREAT|O_RDWR,00777 ); p_map = (people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); for(i = 0;i<10;i++)>map_normalfile1.c 首先定义了一个people数据结构，（在这里采用数据结构的方式是因为，共享内存区的数据往往是有固定格式的，这由通信的各个进程决定，采用结构的方式 有普遍代表性）。map_normfile1首先打开或创建一个文件，并把文件的长度设置为5个people结构大小。然后从mmap()的返回地址开 始，设置了10个people结构。然后，进程睡眠10秒钟，等待其他进程映射同一个文件，最后解除映射。
map_normfile2.c只是简单的映射一个文件，并以people数据结构的格式从mmap()返回的地址处读取10个people结构，并输出读取的值，然后解除映射。
分别把两个程序编译成可执行文件map_normalfile1和map_normalfile2后，在一个终端上先运行./map_normalfile2 /tmp/test_shm，程序输出结果如下：
initialize overumap ok
在map_normalfile1输出initialize over 之后，输出umap ok之前，在另一个终端上运行map_normalfile2 /tmp/test_shm，将会产生如下输出(为了节省空间，输出结果为稍作整理后的结果)：
name: b age 20; name: c age 21; name: d age 22; name: e age 23; name: f age 24;name: g age 25; name: h age 26; name: I age 27; name: j age 28; name: k age 29;
在map_normalfile1 输出umap ok后，运行map_normalfile2则输出如下结果：
name: b age 20; name: c age 21; name: d age 22; name: e age 23; name: f age 24;name: age 0; name: age 0; name: age 0; name: age 0; name: age 0;
从程序的运行结果中可以得出的结论
1、 最终被映射文件的内容的长度不会超过文件本身的初始大小，即映射不能改变文件的大小；
2、 可以用于进程通信的有效地址空间大小大体上受限于被映射文件的大小，但不完全受限于文件大小。打开文件被截短为5个people结构大小，而在 map_normalfile1中初始化了10个people数据结构，在恰当时候（map_normalfile1输出initialize over 之后，输出umap ok之前）调用map_normalfile2会发现map_normalfile2将输出全部10个people结构的值，后面将给出详细讨论。
注： 在linux中，内存的保护是以页为基本单位的，即使被映射文件只有一个字节大小，内核也会为映射分配一个页面大小的内存。当被映射文件小于一个页面大小 时，进程可以对从mmap()返回地址开始的一个页面大小进行访问，而不会出错；但是，如果对一个页面以外的地址空间进行访问，则导致错误发生，后面将进 一步描述。因此，可用于进程间通信的有效地址空间大小不会超过文件大小及一个页面大小的和。
3、 文件一旦被映射后，调用mmap()的进程对返回地址的访问是对某一内存区域的访问，暂时脱离了磁盘上文件的影响。所有对mmap()返回地址空间的操作 只在内存中有意义，只有在调用了munmap()后或者msync()时，才把内存中的相应内容写回磁盘文件，所写内容仍然不能超过文件的大小。
范例2：父子进程通过匿名映射实现共享内存
#include #include #include #include typedef struct{ char name[4]; int  age;}people;main(int argc, char** argv){ int i; people *p_map; char temp; p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0); if(fork() == 0) {  sleep(2);  for(i = 0;i<5;i++) age =" 100;" temp =" 'a';" i =" 0;i<5;i++)" age="20+i;">考察程序的输出结果，体会父子进程匿名共享内存：
child read: the 1 people's age is 20child read: the 2 people's age is 21child read: the 3 people's age is 22child read: the 4 people's age is 23child read: the 5 people's age is 24parent read: the first people,s age is 100umapumap ok
四、对mmap()返回地址的访问
前 面对范例运行结构的讨论中已经提到，linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大 小由mmap()的len参数指定，注意，进程并不一定能够对全部新增空间都能进行有效访问。进程能够访问的有效地址大小取决于文件被映射部分的大小。简 单的说，能够容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，能够有效访问的地址空间大小。超过这个空间大小，内核会根据 超过的严重程度返回发送不同的信号给进程。可用如下图示说明：
 

 
注意：文件被映射部分而不是整个文件决定了进程能够访问的空间大小，另外，如果指定文件的偏移部分，一定要注意为页面大小的整数倍。下面是对进程映射地址空间的访问范例：
#include #include #include #include typedef struct{ char name[4]; int  age;}people;main(int argc, char** argv){ int fd,i; int pagesize,offset; people *p_map;  pagesize = sysconf(_SC_PAGESIZE); printf("pagesize is %d\n",pagesize); fd = open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777); lseek(fd,pagesize*2-100,SEEK_SET); write(fd,"",1); offset = 0; //此处offset = 0编译成版本1；offset = pagesize编译成版本2 p_map = (people*)mmap(NULL,pagesize*3,PROT_READ|PROT_WRITE,MAP_SHARED,fd,offset); close(fd);  for(i = 1; i<10; age =" 100;" age =" 100;" age =" 100;">如 程序中所注释的那样，把程序编译成两个版本，两个版本主要体现在文件被映射部分的大小不同。文件的大小介于一个页面与两个页面之间（大小为： pagesize*2-99），版本1的被映射部分是整个文件，版本2的文件被映射部分是文件大小减去一个页面后的剩余部分，不到一个页面大小(大小为： pagesize-99)。程序中试图访问每一个页面边界，两个版本都试图在进程空间中映射pagesize*3的字节数。
版本1的输出结果如下：
pagesize is 4096access page 1 overaccess page 1 edge over, now begin to access page 2access page 2 overaccess page 2 overaccess page 2 edge over, now begin to access page 3Bus error  //被映射文件在进程空间中覆盖了两个页面，此时，进程试图访问第三个页面
版本2的输出结果如下：
pagesize is 4096access page 1 overaccess page 1 edge over, now begin to access page 2Bus error  //被映射文件在进程空间中覆盖了一个页面，此时，进程试图访问第二个页面
结论：采用系统调用mmap()实现进程间通信是很方便的，在应用层上接口非常简洁。内部实现机制区涉及到了linux存储管理以及文件系统等方面的内容，可以参考一下相关重要数据结构来加深理解。在本专题的后面部分，将介绍系统v共享内存的实现。
参考文献：
[1] Understanding the linux Kernel, 2nd Edition, By Daniel P. Bovet, Marco Cesati , 对各主题阐述得重点突出，脉络清晰。
[2] UNIX网络编程第二卷：进程间通信，作者：W.Richard Stevens，译者：杨继张，清华大学出版社。对mmap()有详细阐述。
[3] Linux内核源代码情景分析（上），毛德操、胡希明著，浙江大学出版社，给出了mmap()相关的源代码分析。
[4]mmap()手册

2007年4月28日星期六

Linux 汇编语言开发指南

http://blog.csdn.net/fengyv/archive/2005/12/29/565136.aspx

一、简介

作为最基本的编程语言之一，汇编语言虽然应用的范围不算很广，但重要性却勿庸置疑，因为它能够完成许多其它语言所无法完成的功能。就拿 Linux 内核来讲，虽然绝大部分代码是用 C 语言编写的，但仍然不可避免地在某些关键地方使用了汇编代码，其中主要是在 Linux 的启动部分。由于这部分代码与硬件的关系非常密切，即使是 C 语言也会有些力不从心，而汇编语言则能够很好扬长避短，最大限度地发挥硬件的性能。

大多数情况下 Linux 程序员不需要使用汇编语言，因为即便是硬件驱动这样的底层程序在 Linux 操作系统中也可以用完全用 C 语言来实现，再加上 GCC 这一优秀的编译器目前已经能够对最终生成的代码进行很好的优化，的确有足够的理由让我们可以暂时将汇编语言抛在一边了。但实现情况是 Linux 程序员有时还是需要使用汇编，或者不得不使用汇编，理由很简单：精简、高效和 libc 无关性。假设要移植 Linux 到某一特定的嵌入式硬件环境下，首先必然面临如何减少系统大小、提高执行效率等问题，此时或许只有汇编语言能帮上忙了。

汇编语言直接同计算机的底层软件甚至硬件进行交互，它具有如下一些优点：

能够直接访问与硬件相关的存储器或 I/O 端口；
能够不受编译器的限制，对生成的二进制代码进行完全的控制；
能够对关键代码进行更准确的控制，避免因线程共同访问或者硬件设备共享引起的死锁；
能够根据特定的应用对代码做最佳的优化，提高运行速度；
能够最大限度地发挥硬件的功能。

同时还应该认识到，汇编语言是一种层次非常低的语言，它仅仅高于直接手工编写二进制的机器指令码，因此不可避免地存在一些缺点：

编写的代码非常难懂，不好维护；
很容易产生 bug，难于调试；
只能针对特定的体系结构和处理器进行优化；
开发效率很低，时间长且单调。

Linux 下用汇编语言编写的代码具有两种不同的形式。第一种是完全的汇编代码，指的是整个程序全部用汇编语言编写。尽管是完全的汇编代码，Linux 平台下的汇编工具也吸收了 C 语言的长处，使得程序员可以使用 #include、#ifdef 等预处理指令，并能够通过宏定义来简化代码。第二种是内嵌的汇编代码，指的是可以嵌入到C语言程序中的汇编代码片段。虽然 ANSI 的 C 语言标准中没有关于内嵌汇编代码的相应规定，但各种实际使用的 C 编译器都做了这方面的扩充，这其中当然就包括 Linux 平台下的 GCC。

二、Linux 汇编语法格式

绝大多数 Linux 程序员以前只接触过DOS/Windows 下的汇编语言，这些汇编代码都是 Intel 风格的。但在 Unix 和 Linux 系统中，更多采用的还是 AT&T 格式，两者在语法格式上有着很大的不同：

1、在 AT&T 汇编格式中，寄存器名要加上 '%' 作为前缀；而在 Intel 汇编格式中，寄存器名不需要加前缀。例如：

AT&T 格式	Intel 格式
pushl %eax	push eax

2、在 AT&T 汇编格式中，用 '$' 前缀表示一个立即操作数；而在 Intel 汇编格式中，立即数的表示不用带任何前缀。例如：

AT&T 格式	Intel 格式
pushl $1	push 1

3、AT&T 和 Intel 格式中的源操作数和目标操作数的位置正好相反。在 Intel 汇编格式中，目标操作数在源操作数的左边；而在 AT&T 汇编格式中，目标操作数在源操作数的右边。例如：

AT&T 格式	Intel 格式
addl $1, %eax	add eax, 1

4、在 AT&T 汇编格式中，操作数的字长由操作符的最后一个字母决定，后缀'b'、'w'、'l'分别表示操作数为字节（byte，8 比特）、字（word，16 比特）和长字（long，32比特）；而在 Intel 汇编格式中，操作数的字长是用 "byte ptr" 和 "word ptr" 等前缀来表示的。例如：

AT&T 格式	Intel 格式
movb val, %al	mov al, byte ptr val

5、在 AT&T 汇编格式中，绝对转移和调用指令（jump/call）的操作数前要加上'*'作为前缀，而在 Intel 格式中则不需要。
远程转移指令和远程子调用指令的操作码，在 AT&T 汇编格式中为 "ljump" 和 "lcall"，而在 Intel 汇编格式中则为 "jmp far" 和 "call far"，即：

AT&T 格式	Intel 格式
ljump $section, $offset	jmp far section:offset
lcall $section, $offset	call far section:offset

与之相应的远程返回指令则为：

AT&T 格式	Intel 格式
lret $stack_adjust	ret far stack_adjust

6、在 AT&T 和 intel 汇编格式中，内存操作数的寻址方式是

AT&T 格式	Intel 格式
section:disp(base, index, scale)	section:[base + index*scale + disp]

由于 Linux 工作在保护模式下，用的是 32 位线性地址，所以在计算地址时不用考虑段基址和偏移量，而是采用如下的地址计算方法：

disp + base + index * scale

7、下面是一些内存操作数的例子：

AT&T 格式	Intel 格式
movl -4(%ebp), %eax	mov eax, [ebp - 4]
movl array(, %eax, 4), %eax	mov eax, [eax*4 + array]
movw array(%ebx, %eax, 4), %cx	mov cx, [ebx + 4*eax + array]
movb $4, %fs:(%eax)	mov fs:eax, 4

三、Hello World!

真不知道打破这个传统会带来什么样的后果，但既然所有程序设计语言的第一个例子都是在屏幕上打印一个字符串 "Hello World!"，那我们也以这种方式来开始介绍 Linux 下的汇编语言程序设计。

在 Linux 操作系统中，你有很多办法可以实现在屏幕上显示一个字符串，但最简洁的方式是使用 Linux 内核提供的系统调用。使用这种方法最大的好处是可以直接和操作系统的内核进行通讯，不需要链接诸如 libc 这样的函数库，也不需要使用 ELF 解释器，因而代码尺寸小且执行速度快。

Linux 是一个运行在保护模式下的 32 位操作系统，采用 flat memory 模式，目前最常用到的是 ELF 格式的二进制代码。一个 ELF 格式的可执行程序通常划分为如下几个部分：.text、.data 和 .bss，其中 .text 是只读的代码区，.data 是可读可写的数据区，而 .bss 则是可读可写且没有初始化的数据区。代码区和数据区在 ELF 中统称为 section，根据实际需要你可以使用其它标准的 section，也可以添加自定义 section，但一个 ELF 可执行程序至少应该有一个 .text 部分。下面给出我们的第一个汇编程序，用的是 AT&T 汇编语言格式：

例1. AT&T 格式

#hello.s
.data # 数据段声明
msg : .string "Hello, world!\\n" # 要输出的字符串
len = . - msg # 字串长度

.text # 代码段声明
.global _start # 指定入口函数

_start: # 在屏幕上显示一个字符串
movl $len, %edx # 参数三：字符串长度
movl $msg, %ecx # 参数二：要显示的字符串
movl $1, %ebx # 参数一：文件描述符(stdout)
movl $4, %eax # 系统调用号(sys_write)
int $0x80 # 调用内核功能

# 退出程序
movl $0,%ebx # 参数一：退出代码
movl $1,%eax # 系统调用号(sys_exit)
int $0x80 # 调用内核功能

初次接触到 AT&T 格式的汇编代码时，很多程序员都认为太晦涩难懂了，没有关系，在 Linux 平台上你同样可以使用 Intel 格式来编写汇编程序：

例2. Intel 格式

; hello.asm
section .data ; 数据段声明
msg db "Hello, world!", 0xA ; 要输出的字符串
len equ $ - msg ; 字串长度

section .text ; 代码段声明
global _start ; 指定入口函数

_start: ; 在屏幕上显示一个字符串
mov edx, len ; 参数三：字符串长度
mov ecx, msg ; 参数二：要显示的字符串
mov ebx, 1 ; 参数一：文件描述符(stdout)
mov eax, 4 ; 系统调用号(sys_write)
int 0x80 ; 调用内核功能

; 退出程序
mov ebx, 0 ; 参数一：退出代码
mov eax, 1 ; 系统调用号(sys_exit)
int 0x80 ; 调用内核功能

上面两个汇编程序采用的语法虽然完全不同，但功能却都是调用 Linux 内核提供的 sys_write 来显示一个字符串，然后再调用 sys_exit 退出程序。在 Linux 内核源文件 include/asm-i386/unistd.h 中，可以找到所有系统调用的定义

四、Linux 汇编工具

Linux 平台下的汇编工具虽然种类很多，但同 DOS/Windows 一样，最基本的仍然是汇编器、连接器和调试器。

1.汇编器

汇编器（assembler）的作用是将用汇编语言编写的源程序转换成二进制形式的目标代码。Linux 平台的标准汇编器是 GAS，它是 GCC 所依赖的后台汇编工具，通常包含在 binutils 软件包中。GAS 使用标准的 AT&T 汇编语法，可以用来汇编用 AT&T 格式编写的程序：

[xiaowp@gary code]$ as -o hello.o hello.s

Linux 平台上另一个经常用到的汇编器是 NASM，它提供了很好的宏指令功能，并能够支持相当多的目标代码格式，包括 bin、a.out、coff、elf、 rdf 等。NASM 采用的是人工编写的语法分析器，因而执行速度要比 GAS 快很多，更重要的是它使用的是 Intel 汇编语法，可以用来编译用 Intel 语法格式编写的汇编程序：

[xiaowp@gary code]$ nasm -f elf hello.asm

2.链接器

由汇编器产生的目标代码是不能直接在计算机上运行的，它必须经过链接器的处理才能生成可执行代码。链接器通常用来将多个目标代码连接成一个可执行代码，这样可以先将整个程序分成几个模块来单独开发，然后才将它们组合(链接)成一个应用程序。 Linux 使用 ld 作为标准的链接程序，它同样也包含在 binutils 软件包中。汇编程序在成功通过 GAS 或 NASM 的编译并生成目标代码后，就可以使用 ld 将其链接成可执行程序了：

[xiaowp@gary code]$ ld -s -o hello hello.o

3.调试器

有人说程序不是编出来而是调出来的，足见调试在软件开发中的重要作用，在用汇编语言编写程序时尤其如此。Linux 下调试汇编代码既可以用 GDB、 DDD 这类通用的调试器，也可以使用专门用来调试汇编代码的 ALD(Assembly Language Debugger)。

从调试的角度来看，使用 GAS 的好处是可以在生成的目标代码中包含符号表(symbol table)，这样就可以使用 GDB 和 DDD 来进行源码级的调试了。要在生成的可执行程序中包含符号表，可以采用下面的方式进行编译和链接：

[xiaowp@gary code]$ as --gstabs -o hello.o hello.s
[xiaowp@gary code]$ ld -o hello hello.o

执行 as 命令时带上参数 --gstabs 可以告诉汇编器在生成的目标代码中加上符号表，同时需要注意的是，在用 ld 命令进行链接时不要加上 -s 参数，否则目标代码中的符号表在链接时将被删去。

在 GDB 和 DDD 中调试汇编代码和调试 C 语言代码是一样的，你可以通过设置断点来中断程序的运行，查看变量和寄存器的当前值，并可以对代码进行单步跟踪。

汇编程序员通常面对的都是一些比较苛刻的软硬件环境，短小精悍的ALD可能更能符合实际的需要，因此下面主要介绍一下如何用ALD来调试汇编程序。首先在命令行方式下执行ald命令来启动调试器，该命令的参数是将要被调试的可执行程序：

[xiaowp@gary doc]$ ald hello
Assembly Language Debugger 0.1.3
Copyright (C) 2000-2002 Patrick Alken

hello: ELF Intel 80386 (32 bit), LSB, Executable, Version 1 (current)
Loading debugging symbols...(15 symbols loaded)
ald>

当 ALD 的提示符出现之后，用 disassemble 命令对代码段进行反汇编：

ald> disassemble -s .text
Disassembling section .text (0x08048074 - 0x08048096)
08048074 BA0F000000 mov edx, 0xf
08048079 B998900408 mov ecx, 0x8049098
0804807E BB01000000 mov ebx, 0x1
08048083 B804000000 mov eax, 0x4
08048088 CD80 int 0x80
0804808A BB00000000 mov ebx, 0x0
0804808F B801000000 mov eax, 0x1
08048094 CD80 int 0x80

上述输出信息的第一列是指令对应的地址码，利用它可以设置在程序执行时的断点：

ald> break 0x08048088
Breakpoint 1 set for 0x08048088

断点设置好后，使用 run 命令开始执行程序。ALD 在遇到断点时将自动暂停程序的运行，同时会显示所有寄存器的当前值：

ald> run
Starting program: hello
Breakpoint 1 encountered at 0x08048088
eax = 0x00000004 ebx = 0x00000001 ecx = 0x08049098 edx = 0x0000000F
esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000
ds = 0x0000002B es = 0x0000002B fs = 0x00000000 gs = 0x00000000
ss = 0x0000002B cs = 0x00000023 eip = 0x08048088 eflags = 0x00000246

Flags: PF ZF IF

08048088 CD80 int 0x80

如果需要对汇编代码进行单步调试，可以使用 next 命令：

ald> next
Hello, world!
eax = 0x0000000F ebx = 0x00000000 ecx = 0x08049098 edx = 0x0000000F
esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000
ds = 0x0000002B es = 0x0000002B fs = 0x00000000 gs = 0x00000000
ss = 0x0000002B cs = 0x00000023 eip = 0x0804808F eflags = 0x00000346

Flags: PF ZF TF IF

0804808F B801000000 mov eax, 0x1

若想获得 ALD 支持的所有调试命令的详细列表，可以使用 help 命令：

ald> help
Commands may be abbreviated.
If a blank command is entered, the last command is repeated.
Type `help ' for more specific information on .

General commands
attach clear continue detach disassemble
enter examine file help load
next quit register run set
step unload window write

Breakpoint related commands
break delete disable enable ignore
lbreak tbreak

五、系统调用

即便是最简单的汇编程序，也难免要用到诸如输入、输出以及退出等操作，而要进行这些操作则需要调用操作系统所提供的服务，也就是系统调用。除非你的程序只完成加减乘除等数学运算，否则将很难避免使用系统调用，事实上除了系统调用不同之外，各种操作系统的汇编编程往往都是很类似的。

在 Linux 平台下有两种方式来使用系统调用：利用封装后的 C 库（libc）或者通过汇编直接调用。其中通过汇编语言来直接调用系统调用，是最高效地使用 Linux 内核服务的方法，因为最终生成的程序不需要与任何库进行链接，而是直接和内核通信。

和 DOS 一样，Linux 下的系统调用也是通过中断（int 0x80）来实现的。在执行 int 80 指令时，寄存器 eax 中存放的是系统调用的功能号，而传给系统调用的参数则必须按顺序放到寄存器 ebx，ecx，edx，esi，edi 中，当系统调用完成之后，返回值可以在寄存器 eax 中获得。

所有的系统调用功能号都可以在文件 /usr/include/bits/syscall.h 中找到，为了便于使用，它们是用 SYS_ 这样的宏来定义的，如 SYS_write、SYS_exit 等。例如，经常用到的 write 函数是如下定义的：

ssize_t write(int fd, const void *buf, size_t count);

该函数的功能最终是通过 SYS_write 这一系统调用来实现的。根据上面的约定，参数 fb、buf 和 count 分别存在寄存器 ebx、 ecx 和 edx 中，而系统调用号 SYS_write 则放在寄存器 eax 中，当 int 0x80 指令执行完毕后，返回值可以从寄存器 eax 中获得。

或许你已经发现，在进行系统调用时至多只有 5 个寄存器能够用来保存参数，难道所有系统调用的参数个数都不超过 5 吗？当然不是，例如 mmap 函数就有 6 个参数，这些参数最后都需要传递给系统调用 SYS_mmap：

void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);

当一个系统调用所需的参数个数大于 5 时，执行int 0x80 指令时仍需将系统调用功能号保存在寄存器 eax 中，所不同的只是全部参数应该依次放在一块连续的内存区域里，同时在寄存器 ebx 中保存指向该内存区域的指针。系统调用完成之后，返回值仍将保存在寄存器 eax 中。

由于只是需要一块连续的内存区域来保存系统调用的参数，因此完全可以像普通的函数调用一样使用栈(stack)来传递系统调用所需的参数。但要注意一点， Linux 采用的是 C 语言的调用模式，这就意味着所有参数必须以相反的顺序进栈，即最后一个参数先入栈，而第一个参数则最后入栈。如果采用栈来传递系统调用所需的参数，在执行int 0x80 指令时还应该将栈指针的当前值复制到寄存器 ebx中。

六、命令行参数

在 Linux 操作系统中，当一个可执行程序通过命令行启动时，其所需的参数将被保存到栈中：首先是 argc，然后是指向各个命令行参数的指针数组 argv，最后是指向环境变量的指针数据 envp。在编写汇编语言程序时，很多时候需要对这些参数进行处理，下面的代码示范了如何在汇编代码中进行命令行参数的处理：

例3. 处理命令行参数

# args.s
.text
.globl _start

_start:
popl %ecx # argc

vnext:
popl %ecx # argv
test %ecx, %ecx # 空指针表明结束
jz exit

movl %ecx, %ebx
xorl %edx, %edx
strlen:
movb (%ebx), %al
inc %edx
inc %ebx
test %al, %al
jnz strlen
movb $10, -1(%ebx)

movl $4, %eax # 系统调用号(sys_write)
movl $1, %ebx # 文件描述符(stdout)
int $0x80

jmp vnext

exit:
movl $1,%eax # 系统调用号(sys_exit)
xorl %ebx, %ebx # 退出代码
int $0x80

ret

七、GCC 内联汇编

用汇编编写的程序虽然运行速度快，但开发速度非常慢，效率也很低。如果只是想对关键代码段进行优化，或许更好的办法是将汇编指令嵌入到 C 语言程序中，从而充分利用高级语言和汇编语言各自的特点。但一般来讲，在 C 代码中嵌入汇编语句要比"纯粹"的汇编语言代码复杂得多，因为需要解决如何分配寄存器，以及如何与C代码中的变量相结合等问题。

GCC 提供了很好的内联汇编支持，最基本的格式是：

__asm__("asm statements");

例如：
__asm__("nop");

如果需要同时执行多条汇编语句，则应该用"\\n\\t"将各个语句分隔开，例如：

__asm__( "pushl %%eax \\n\\t"
"movl $0, %%eax \\n\\t"
"popl %eax");

通常嵌入到 C 代码中的汇编语句很难做到与其它部分没有任何关系，因此更多时候需要用到完整的内联汇编格式：

__asm__("asm statements" : outputs : inputs : registers-modified);

插入到 C 代码中的汇编语句是以":"分隔的四个部分，其中第一部分就是汇编代码本身，通常称为指令部，其格式和在汇编语言中使用的格式基本相同。指令部分是必须的，而其它部分则可以根据实际情况而省略。

在将汇编语句嵌入到C代码中时，操作数如何与C代码中的变量相结合是个很大的问题。GCC采用如下方法来解决这个问题：程序员提供具体的指令，而对寄存器的使用则只需给出"样板"和约束条件就可以了，具体如何将寄存器与变量结合起来完全由GCC和GAS来负责。

在GCC 内联汇编语句的指令部中，加上前缀'%'的数字(如%0，%1)表示的就是需要使用寄存器的"样板"操作数。指令部中使用了几个样板操作数，就表明有几个变量需要与寄存器相结合，这样GCC和GAS在编译和汇编时会根据后面给定的约束条件进行恰当的处理。由于样板操作数也使用'%'作为前缀，因此在涉及到具体的寄存器时，寄存器名前面应该加上两个'%'，以免产生混淆。

紧跟在指令部后面的是输出部，是规定输出变量如何与样板操作数进行结合的条件，每个条件称为一个"约束"，必要时可以包含多个约束，相互之间用逗号分隔开就可以了。每个输出约束都以'='号开始，然后紧跟一个对操作数类型进行说明的字后，最后是如何与变量相结合的约束。凡是与输出部中说明的操作数相结合的寄存器或操作数本身，在执行完嵌入的汇编代码后均不保留执行之前的内容，这是GCC在调度寄存器时所使用的依据。

输出部后面是输入部，输入约束的格式和输出约束相似，但不带'='号。如果一个输入约束要求使用寄存器，则GCC在预处理时就会为之分配一个寄存器，并插入必要的指令将操作数装入该寄存器。与输入部中说明的操作数结合的寄存器或操作数本身，在执行完嵌入的汇编代码后也不保留执行之前的内容。

有时在进行某些操作时，除了要用到进行数据输入和输出的寄存器外，还要使用多个寄存器来保存中间计算结果，这样就难免会破坏原有寄存器的内容。在GCC内联汇编格式中的最后一个部分中，可以对将产生副作用的寄存器进行说明，以便GCC能够采用相应的措施。

下面是一个内联汇编的简单例子：

例4.内联汇编

/* inline.c */

int main()
{
int a = 10, b = 0;

__asm__ __volatile__("movl %1, %%eax;\\n\\r"
"movl %%eax, %0;"
:"=r"(b) /* 输出 */
:"r"(a) /* 输入 */
:"%eax"); /* 不受影响的寄存器 */

printf("Result: %d, %d\\n", a, b);
}

上面的程序完成将变量a的值赋予变量b，有几点需要说明：

变量b是输出操作数，通过%0来引用，而变量a是输入操作数，通过%1来引用。
输入操作数和输出操作数都使用r进行约束，表示将变量a和变量b存储在寄存器中。输入约束和输出约束的不同点在于输出约束多一个约束修饰符'='。
在内联汇编语句中使用寄存器eax时，寄存器名前应该加两个'%'，即%%eax。内联汇编中使用%0、%1等来标识变量，任何只带一个'%'的标识符都看成是操作数，而不是寄存器。
内联汇编语句的最后一个部分告诉GCC它将改变寄存器eax中的值，GCC在处理时不应使用该寄存器来存储任何其它的值。
由于变量b被指定成输出操作数，当内联汇编语句执行完毕后，它所保存的值将被更新。
在内联汇编中用到的操作数从输出部的第一个约束开始编号，序号从0开始，每个约束记数一次，指令部要引用这些操作数时，只需在序号前加上'%'作为前缀就可以了。需要注意的是，内联汇编语句的指令部在引用一个操作数时总是将其作为32位的长字使用，但实际情况可能需要的是字或字节，因此应该在约束中指明正确的限定符：

限定符	意义
"m"、"v"、"o"	内存单元
"r"	任何寄存器
"q"	寄存器eax、ebx、ecx、edx之一
"i"、"h"	直接操作数
"E"和"F"	浮点数
"g"	任意
"a"、"b"、"c"、"d"	分别表示寄存器eax、ebx、ecx和edx
"S"和"D"	寄存器esi、edi
"I"	常数（0至31）

八、小结

Linux 操作系统是用C语言编写的，汇编只在必要的时候才被人们想到，但它却是减少代码尺寸和优化代码性能的一种非常重要的手段，特别是在与硬件直接交互的时候，汇编可以说是最佳的选择。Linux提供了非常优秀的工具来支持汇编程序的开发，使用GCC的内联汇编能够充分地发挥C语言和汇编语言各自的优点。

九、参考资料

在网站http://linuxassembly.org上可以找到大量的Linux汇编资源。
软件包binutils提供了as和ld等实用工具，其相关信息可以在网站http://sources.redhat.com/binutils/上找到。
NASM是Intel格式的汇编器，其相关信息可以在网站http://nasm.sourceforge.net上找到。
ALD是一个短小精悍的汇编调试器，其相关信息可以在网站http://dunx1.irt.drexel.edu/~psa22/ald.html上找到。
intel2gas是一个能够将Intel汇编格式转换成AT&T汇编格式的小工具，其相关信息可以在网站http://www.niksula.cs.hut.fi/~mtiihone/intel2gas/上找到。
IBM developerWorks上有一篇介绍GCC内联汇编的文章(http://www-900.ibm.com/developerworks/cn/linux/sdk/assemble/inline/index_eng.shtml)。

Linux系统下USB摄像头驱动开发

http://blog.csdn.net/fengyv/archive/2006/05/22/749761.aspx

一、 Linux系统中的USB摄像头驱动程序

USB摄像头以其良好的性能和低廉的价格得到广泛应用。同时因其灵活、方便的特性，易于集成到嵌入式系统中。但是如果使用现有的符合Video for Linux标准的驱动程序配合通用应用程序，难以充分利用USB带宽，帧速不高，不易满足实时监控等要求。本文首先介绍在Linux系统下USB摄像头驱动编制的一般方法，然后说明在此基础上如何提高帧速。

USB设备驱动程序完全符合通用设备驱动的准则，不同的是内核提供了一些特别的API函数，方便驱动注册、销毁自己，例如usb_reSister()和usb_dereSister()；2．4版的内核还提供了对于hotplug的支持。

1．1 USB摄像头驱动的一般编写方法

摄像头属于视频类设备。在目前的Linux核心中，视频部分的标准是Video for Linux(简称V4L)。这个标准其实定义了一套接口，内核、驱动、应用程序以这个接口为标准进行交流。目前的V4L涵盖了视、音频流捕捉及处理等内容，USB摄像头也属于它支持的范畴。

因此，USB摄像头的驱动应当与内核提供的视频驱动挂钩。即首先在驱动中声明一个video_device结构，并为其指定文件操作函数指针数组．fops，向系统注册。在应用程序发出文件操作的相关命令时，核心根据这些指针调用相应函数，并将该结构作为参数传递给它们。这样，就完成了驱动和核心之间的通信。例如：

static struct video_device vdev_template＝{……}；

/／声明video_device，指出挂接驱动

static struct file_operations ov511_fops＝{……}；

／／声明本驱动的文件操作函数指针

struct video_device*vdev＝video_devdata(file)；

／／从文件指针中提取出video_device结构

在video_device结构中，有一个私有指针priv，可以将它指向一块保留内存。在这块内存中，保存着本驱动、本设备的相关初始化信息。这块内存的申请、初始化、指针指向等工作都是在USB驱动的枚举函数.probe中完成。这样，在枚举函数将控制权返还给系统后，因为内核不销毁保留内存，所以驱动仍然保留着自己的信息。这点与Windows系统中WDM驱动有异曲同工之处。当然，在驱动卸载函数中，应当将申请的各块内存全部释放。

1．2 使用双URB轮流通信

众所周知，USBl．1总线标准定义了控制、中断、批量、等时等四种管道。对于时间性极强但是准确度要求不高的视频捕捉应用来说，摄像头应当使用等时传输方式。为了尽可能快地得到图像数据，应当在URB中指定USB_ISO_ASAP标志。

urb->transfer_flags＝USB_ISO_ASAP；／／尽可能快地发出本URB

Linux系统中任何USB传输都通过URB实现。为提高速度，可以考虑扩大URB的缓冲，这样可以降低每个USB事务中握手信息所占比例，提高有效数据的传输速度。但是受限于总线带宽和具体的USB设备芯片，单纯扩大URB的缓冲不能无限制地解决问题。具体分析一下USB传输在操作系统中的实现：每次传输都要包括URB的建立、发出、回收、数据整理等阶段，这些时间不产生有效数据。因此可以建立两个URB，在等待一个URB被回收时，也就是图像正在被传感器采集时，处理、初始化另一个URB，并在回收后立刻将其发出。两个URB交替使用，大大减少了额外时间。工作流程如图1所示。

这个过程是在URB的完成例程中实现的，有两点需要注意：首先处理再次初始化的代码时间不能长，否则会造成完成例程的重人，如果确实来不及，可以在完成例程中设定标志，例如“数据采集好”旗语，由应用程序使用阻塞ioctl()来查询该旗语并做处理；其次由于CPU可能会在完成例程中停留较长时间，系统负担较大，可以在．open函数中初始化两个URB并将其发出，有限度地减轻系统负担。

1．3 使用双帧缓冲提高效率

Linux系统中，文件操作通常是由read、write等系统调用来完成。这些系统调用在驱动中的解决方法就是用copy_to_user()、copy_from_user()等函数在核态、户态内存空间中互相拷贝。但是对于大批量的图像数据，采用拷贝的方法显然会增加时间开销，因此用内存映射的方法解决。首先使用vmalloc()申请足够大的核态内存，将其作为图像数据缓冲空间，两个URB带回的图像数据在这里暂存；然后使用remap_page_range()函数将其逐页映射到用户空间中。户态的图像处理程序使用mmap()函数，直接读写核态图像缓冲内存，大大减少额外开销。

图像数据的处理可能要花费比较长的时间，不同的算法对于数据保留时间的要求也不一样。因此可以申请两帧图像缓冲，在处理一帧图像的同时，将两个URB带回的数据全部填充到另一帧缓冲中，这样可以免去时间冲突上的麻烦。

值得注意的是：这种方法要求时刻持有当前帧的序号、每一帧的起始地址等信息，不能将两帧图像混淆。这些信息可以保存在保留内存中，当前帧的数据整理、序号改变在URB完成例程中实现。

二、 V4L标准的改进

V4L标准目前已经发展到第二版V4L2，其基本思路与V4L相同。

2．1 标准分析

根据V4L标准，户态程序在需要一帧图像时，CPU的走向如图2。CPU按照123456的顺序完成一个循环。在这里，有一个细节被忽略：在完成例程中，也就是图2中步骤6，该URB被立刻发出，但是由于这时用户程序正在阻塞等待，没办法再次提出获得图像的申请，因此在判断有无新请求时，判断的结果必然是当前无请求，导致下一个URB带回的数据被驱动丢弃；由于核态、户态的切换需要一定的时间，加上户态多进程同步等开销，等到应用程序能够再次发出获得一副图像的申请时，已经有不止一个URB带回的数据被丢弃掉，这些URB包含的数据正好是新一帧图像的开始部分。因此驱动必须等到再下一帧图像才能保存数据、缓冲。这样凭白损失了一帧图像，帧速最少下降一半。

2．2 改进思路：不间断采集

为了解决这个问题，可以改进V4L标准作，使其增加新的功能：通过新的参数，让ioetl()函数通知驱动不间断采集、缓冲图像数据，轮流保存在两帧缓冲区中，并在一帧图像采集好后，设定“图像采集好”旗语。户态程序只需要发出一次“获得图像”请求，就可以通过阻塞等待该旗语，不断获得图像。在采集结束后，再次通过新的参数，让驱动停止缓冲即可。CPU工作流程图如图3。

注意到图2、图3，两种“判断有无新请求”的不同，即可发现新方法假定一直有请求，因此不丢弃每个URB带回的数据，轮流保存在两个帧缓冲内。

V4L已经作为约定俗成的标准被内核支持，因此如果使用全新的参数，工作量将相当巨大，并且不能和现有的应用程序兼容。考虑到现有的图像采集应用程序使用VIDIOCMCAPTURE作为参数，并提供帧序号，要求驱动将图像保存到指定序号的帧缓冲内。由于驱动通常仅仅提供几帧缓冲，因此该序号不会大于某个数字，如10。因此可以继续使用VIDIOCMCAPTURE参数，搭配较大的序号来表示新增的功能，例如用10000和10001来分别表示开始和停止缓冲图像数据的要求。驱动在收到VIDIOCMCAPTURE要求后，检查这个序号。如果小于10000，则按照正常的方法处理，否则按照改进方法。这种思路可以有效解决兼容性问题。

2．3 实验结果
在赛扬366、USBl．1接口的计算机平台上，采用上述不间断采集改进V4L标准，配合双URB、双帧缓冲等方法后，帧速提高两倍有余，有效数据传输速度达960KB／s，接近等时传输方式下USB总线的带宽极限。推荐阅读：《rh9实现视频的捕获》，该文档中有详细的代码

rh9 环境下实现linux视频的捕获

http://blog.csdn.net/fengyv/archive/2006/04/28/695616.aspx

rh9 环境下实现linux视频的捕获，并存为bmp格式。
推荐阅读：《Linux系统下USB摄像头驱动开发》《linux声音设备编程实例》

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

/* */

/* v4lgrab.h */

/* */

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

#ifndef __V4LGRAB_H__

#define __V4LGRAB_H__

#include

//typedef enum { FALSE = 0, TRUE = 1, OK = 2} BOOL;

//#define SWAP_HL_WORD(x) {(x) = ((x)<<8)>>8);}

//#define SWAP_HL_DWORD(x) {(x) = ((x)<<24)>>24) | (((x)&0xff0000)>>8) | (((x)&0xff00)<<8);}

#define FREE(x) if((x)){free((x));(x)=NULL;}

typedef unsigned char BYTE;

typedef unsigned short WORD;

typedef unsigned long DWORD;

#pragma pack(1)

typedef struct tagBITMAPFILEHEADER{

WORD bfType; // the flag of bmp, value is "BM"

DWORD bfSize; // size BMP file ,unit is bytes

DWORD bfReserved; // 0

DWORD bfOffBits; // must be 54

}BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{

DWORD biSize; // must be 0x28

DWORD biWidth; //

DWORD biHeight; //

WORD biPlanes; // must be 1

WORD biBitCount; //

DWORD biCompression; //

DWORD biSizeImage; //

DWORD biXPelsPerMeter; //

DWORD biYPelsPerMeter; //

DWORD biClrUsed; //

DWORD biClrImportant; //

}BITMAPINFOHEADER;

typedef struct tagRGBQUAD{

BYTE rgbBlue;

BYTE rgbGreen;

BYTE rgbRed;

BYTE rgbReserved;

}RGBQUAD;

#if defined(__cplusplus)

extern "C" { /* Make sure we have C-declarations in C++ programs */

#endif

//if successful return 1,or else return 0

int openVideo();

int closeVideo();

//data 用来存储数据的空间, size空间大小

void getVideoData(unsigned char *data, int size);

#if defined(__cplusplus)

}

#endif

#endif //__V4LGRAB_H___

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

/* */

/* v4lgrab.c */

/* */

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

#include

#include "v4lgrab.h"

#define TRUE 1

#define FALSE 0

#define WIDTHBYTES(i) ((i+31)/32*4)

#define FILE_VIDEO "/dev/video0"

//#define BMP "image.bmp"

#define IMAGEWIDTH 176

#define IMAGEHEIGHT 144

static int fd;

static struct video_capability cap;

static struct video_window win;

static struct video_picture vpic;

int openVideo()

{

//Open video device

fd = open(FILE_VIDEO, O_RDONLY);

if (fd <>

perror(FILE_VIDEO);

return (FALSE);

}

//Get capabilities

if (ioctl(fd, VIDIOCGCAP, &cap) <>

perror("VIDIOGCAP");

printf("(" FILE_VIDEO " not a video4linux device?)\n");

close(fd);

return (FALSE);

}

//Get the video overlay window

if (ioctl(fd, VIDIOCGWIN, &win) <>

perror("VIDIOCGWIN");

close(fd);

return (FALSE);

}

//Set the video overlay window

win.width = IMAGEWIDTH;

win.height = IMAGEHEIGHT;

if(ioctl(fd, VIDIOCSWIN, &win) <0)>

perror("VIDIOCSWIN");

close(fd);

return (FALSE);;

}

//Get picture properties

if (ioctl(fd, VIDIOCGPICT, &vpic) <>

perror("VIDIOCGPICT");

close(fd);

return (FALSE);

}

// if (cap.type & VID_TYPE_MONOCHROME) {

// } else {

vpic.depth=24;

vpic.palette=VIDEO_PALETTE_RGB24;

if(ioctl(fd, VIDIOCSPICT, &vpic) <>

printf("Unable to find a supported capture format.\n");

return (FALSE);

}

// }

return (TRUE);

}

int closeVideo()

{

if(fd != -1) {

close(fd);

return (TRUE);

}

return (FALSE);

}

void getVideoData(unsigned char *data, int size)

{

size = read(fd, data, size);

}

int main(int argc, char ** argv)

{

FILE * fp;

BITMAPFILEHEADER bf;

BITMAPINFOHEADER bi;

unsigned char * buffer;

int i;

fp = fopen(BMP, "wb");

if(!fp){

perror(BMP);

exit(1);

}

if(openVideo() == FALSE) {

return(-1);

}

//Set BITMAPINFOHEADER

bi.biSize = 40;

bi.biWidth = win.width;

bi.biHeight = win.height;

bi.biPlanes = 1;

bi.biBitCount = 24;

bi.biCompression = 0;

bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;

bi.biXPelsPerMeter = 0;

bi.biYPelsPerMeter = 0;

bi.biClrUsed = 0;

bi.biClrImportant = 0;

//Set BITMAPFILEHEADER

bf.bfType = 0x4d42;

bf.bfSize = 54 + bi.biSizeImage;

bf.bfReserved = 0;

bf.bfOffBits = 54;

buffer = malloc(bi.biSizeImage);

if (!buffer) {

printf("Out of memory.\n");

exit(1);

}

for(i=0; i<20;>

getVideoData(buffer, bi.biSizeImage);

fwrite(&bf, 14, 1, fp);

fwrite(&bi, 40, 1, fp);

fwrite(buffer, bi.biSizeImage, 1, fp);

printf("get bmp form video\t[OK]\n");

fclose(fp);

closeVideo();

return 0;

}

订阅：博文 (Atom)

Xianfeng Design

2007年4月29日星期日

Linux remote desktop （远程桌面）控制

改变网络接口的速度和协商方式的工具miitool 和ethtool (v0.1b)

实例解读 linux 网卡驱动

Linux环境进程间通信:共享内存

2007年4月28日星期六

Linux 汇编语言开发指南

Linux系统下USB摄像头驱动开发

rh9 环境下实现linux视频的捕获

标签

博客归档

我的收藏夹

我的简介