BlogJava-Calvin's Tech Space-随笔分类-Linux

[转]unix/linux中的dup()系统调用

calvin — Tue, 13 Dec 2011 06:20:00 GMT

在linux纷繁复杂的内核代码中，sys_dup()的代码也许称得上是最简单的之一了，但是就是这么一个简单的系统调用，却成就了unix/linux系统最著名的一个特性：输入/输出重定向。
sys_dup()的主要工作就是用来“复制”一个打开的文件号，使两个文件号都指向同一个文件。既然说简单，我们就首先来看一下它的代码（定义在fs/fcntl.c中）：

1 asmlinkage long sys_dup(unsigned int fildes)
2 {
3     int ret = -EBADF;
4     struct file * file = fget(fildes);
5
6     if (file)
7         ret = dupfd(file, 0);
8     return ret;
9 }
10

而sys_dup()的主体是dupfd()（定义在同一个文件中）：

1 static int dupfd(struct file *file, int start)
2 {
3     struct files_struct * files = current->files;
4     int ret;
5
6     ret = locate_fd(files, file, start);
7     if (ret < 0)
8         goto out_putf;
9     allocate_fd(files, file, ret);
10     return ret;
11
12 out_putf:
13     write_unlock(&files->file_lock);
14     fput(file);
15     return ret;
16 }
17

注：dup和dup2的原型如下：
#include

int dup(int file_descriptor);
int dup2(int file_descriptor1, int file_descriptor2)
dup返回的文件描述符总是取最小的可用值
dup2返回的文件描述符或者与file_descriptor2相同，或者是第一个大于该参数的可用值。

    而这么一个简单的系统调用是如何完成重定向这个艰巨的任务的呢？我们不妨先看个例子。
    当我们在shell下输入如下命令：“echo hello!”，这条命令要求shell进程执行一个可执行文件echo，参数为“hello!”。当shell接收到命令之后，先找到 bin/echo，然后fork()出一个子进程让他执行bin/echo，并将参数传递给它，而这个进程从shell继承了三个标准文件，即标准输入（stdin），标准输出（stdout）和标准出错信息（stderr），他们三个的文件号分别为0、1、2。而至于echo进程的工作很简单，就是将参数“hello!”写到标准输出文件中去，通常都是我们的显示器上。但是如果我们将命令改成“echo hello! > foo”，则在执行时输出将会被重定向到磁盘文件foo中（注：重定向于文件描述符有关）。我们假定在此之前该shell进程只有三个标准文件打开，文件号分别为0、1、2，以上命令行将按如下序列执行：
    (1) 打开或创建磁盘文件foo，如果foo中原来有内容，则清除原来内容，其文件号为3。
    (2) 通过dup()复制文件stdout，即将文件号1出的file结构指针复制到文件号4处，目的是将stdout的file指针暂时保存一下
    (3) 关闭stdout，即1号文件，但是由于4号文件对stdout也同时有个引用，所以stdout文件并未真正关闭，只是腾出1号文件号位置。
    (4) 通过dup()，复制3号文件（即磁盘文件foo），由于1号文件关闭，其位置空缺，故3号文件被复制到1号，即进程中原来指向stdout的指针指向了foo。
    (5) 通过系统调用fork()和exec()创建子进程并执行echo，子进程在执行echo前夕关闭3号和4号文件，只留下0、1、2三个文件，请注意，这时的1号文件已经不是stdout而是磁盘文件foo了。当echo想向stdout文件写入“hello!”时自然就写入到了foo中。
    (6) 回到shell后，关闭指向foo的1号与3号文件文件，再用dup()和close()将2号恢复至stdout，这样shell就恢复了0、1、2三个标准输入/输出文件。

    由此可见，当echo程序（或其他）在运行的时候并不知道stdout（对于stdin和stderr同样）指向什么，进程与实际输出文件或设备的结合是在运行时由其父进程“包办”的。这样就简化了子进程的程序设计，因为在设计时只要跟三个逻辑上存在的文件打交道就可以了。可能有人会觉得这很像面向对象中的多态和重载，没有什么新奇之处，但是如果你活在30甚至40年前，可能你会改变你的看法。

calvin 2011-12-13 14:20 发表评论

Ubuntu10.04安装无线网卡ath9k_htc驱动

calvin — Tue, 18 Oct 2011 05:55:00 GMT

我的USB无线网卡型号为TL_WN721N，插在Ubuntu10.04上没有反应。据说10.10以后插上就可以用了，没有测试。

第一步确定ath9k_htc驱动支持你的网卡型号
http://linuxwireless.org/en/users/Drivers/ath9k_htc/devices 列出了支持的型号列表，你可以通过lsusb查看自己的网卡型号是否在列表当中。

第二步安装firmwire
从这里下载htc_9271.fw，拷贝到/lib/firmwire下

第三步安装compact wireless
安装compact wireless有打包好的deb包，从这里下载GUI Program to install ath9k_htc，安装完后直接运行，等待安装完成重启机器就可以了。
爱折腾的也可以到http://wireless.kernel.org/download/
最新的compact wireless驱动，然后编译安装：
sudo make
sudo make install
sudo make unload
sudo make load ath9k_htc
重启机器即可。

http://forum.ubuntu.com.cn/viewtopic.php?f=116&t=326568&p=2388841
http://blog.chinaunix.net/space.php?uid=20620288&do=blog&id=2691282

calvin 2011-10-18 13:55 发表评论

Process state codes in ps output

calvin — Wed, 08 Jun 2011 09:38:00 GMT

Code	Meaning
D	Uninterruptible sleep (usually IO)
R	Running or runnable (on run queue)
S	Interruptible sleep (waiting for an event to complete)
T	Stopped, either by a job control signal or because it is being traced.
W	paging (not valid since the 2.6.xx kernel)
X	dead (should never be seen)
Z	Defunct (“zombie”) process, terminated but not reaped by its parent.

For BSD formats and when the stat keyword is used, additional characters may be displayed:

Code	Meaning
<	high-priority (not nice to other users)
N	low-priority (nice to other users)
L	has pages locked into memory (for real-time and custom IO)
s	is a session leader
l	is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)
+	is in the foreground process group

Process in D state

If there are a lot of processes in D state in your system, then something is wrong with it.

What is D state and a process state in general? A process in Linux can be in several states: running, sleeping, etc. Running process runs on a CPU just now, sleeping process waits for its turn on CPU or for some other event. Using ps command you can obtain information about state of each process in the system: STAT column shows that:

# ps a
  PID TTY      STAT   TIME COMMAND
 4975 tty1     Ss+    0:00 /sbin/mingetty tty1
 4976 tty2     Ss+    0:00 /sbin/mingetty tty2
 6202 pts/0    Ss+    0:01 -bash
10312 pts/1    Ss     0:00 -bash
  639 pts/1    R+     0:00 ps a

First big S stands for Sleeping, R stands for running ("+" means that the process is foreground and small "s" means that the process is session leader, but it is not relevant for this article).

D state occurs then the process is in uninterruptible sleep. This state is bad, because you can't do anything with the process in D state. Fortunately, process normally remains in such state not for so long. But if you have a heap of D state processes then some logic in system is disrupt. If that is happening, the very important thing is to determine where this unlucky sleep occurs. It is easy to do with ps command with l option. WCHAN column shows the name of the kernel function where the process is sleeping:

# ps axl | grep D
F   UID   PID  PPID PRI  NI    VSZ   RSS WCHAN  STAT TTY        TIME COMMAND
vass     13478  7.2  0.0   1732   624 pts/1    D+   17:36   0:00 find ./

http://wiki.preshweb.co.uk/doku.php?id=linux:psflags
http://wiki.openvz.org/Processes_in_D_state

calvin 2011-06-08 17:38 发表评论

Shell heredoc

calvin — Thu, 26 May 2011 10:12:00 GMT

一个here document就是一段带有特殊目的的代码段. 它使用IO重定向的形式将一个命令序列传递到一个交互程序或者命令中, 比如frp，cat或者ex文本编辑器.
interactive-program <command #1
command #2
...
delimiter

默认情况下，变量会被替换：
$ cat << EOF
> Working dir $PWD
> EOF
Working dir /home/user

如果delimiter用双引号引起来，则不会有变量替换：
$ cat << "EOF"
> Working dir $PWD
> EOF
Working dir $PWD

重定向符号 << 可以使用 <<- ，在这种情况下，heredoc 文本中的前导 tab 字符会被删除，但是空格不会被删除！

注意：
结束标记前一定不能有任何空格或者tab，否则执行失败！

heredoc 另外一个比较有用的是显示消息块，如Usage信息：

cat <
参考：
http://tldp.org/LDP/abs/html/here-docs.html
http://febird.iteye.com/blog/588509
http://en.wikipedia.org/wiki/Here_document

calvin 2011-05-26 18:12 发表评论

shell逐行处理文本

calvin — Tue, 17 May 2011 08:59:00 GMT

对输入的文本按行读取并进行处理，可使用如下代码：

1 cat data.dat | while read line
2 do
3     echo "File: ${line}"
4 done
5
6 while read line
7 do
8     echo "File: ${line}"
9 done < data.dat

如果输入文本每行中没有空格，也可以采用以下两种进行处理，代码如下：

1 for line in $(cat data.dat)
2 do
3     echo "File: ${line}"
4 done
5
6 for line in `cat data.dat`
7 do
8     echo "File: ${line}"
9 done

如输入文本行中包括空格，那么会以空格来区分开多个元素，结果就不是按行读取了。

当然如果只是单纯的数据或文本的按行读取和显示的话，使用awk命令会更为方便。

http://witmax.cn/shell-read-line.html

calvin 2011-05-17 16:59 发表评论

Upgrade Alsa(1.0.24) on Ubuntu10.04

calvin — Sun, 15 May 2011 09:37:00 GMT

问题现象：
笔记本外放有声音，插上耳机没有声音

系统声卡信息为：
$ lspci -v|grep -i audio
00:1b.0 Audio device: Intel Corporation 5 Series/3400 Series Chipset High Definition Audio (rev 05)
$ cat /proc/asound/card0/codec* | grep Codec
Codec: IDT 92HD81B1X5
Codec: Intel G45 DEVIB

google一通，有帖子说要修改 /etc/modprobe.d/alsa-base.conf
加上：
alias snd-card-0 snd-hda-intel
alias sound-slot-0 snd-hda-intel
options snd-hda-intel model=hp(这里需要找到和你机器匹配的mode)
options snd-hda-intel enable_msi=1

重启后不管用。

查看机器上的alsa驱动的版本：
cat /proc/asound/version
显示版本为1.0.21，怀疑是不是版本太低了，于是尝试更新alsa驱动版本，搜索到这篇帖子：
http://monespaceperso.org/blog-en/2010/05/02/upgrade-alsa-1-0-23-on-ubuntu-lucid-lynx-10-04/
升级alsa驱动为1.0.24版本后，故障排除。
$ cat /proc/asound/version
Advanced Linux Sound Architecture Driver Version 1.0.24.
Compiled on May 15 2011 for kernel 2.6.32-31-generic (SMP).

只是不知道为什么设备信息变成了：
$ cat /proc/asound/card0/codec* | grep Codec
Codec: IDT 92HD81B1X5
Codec: Intel IbexPeak HDMI

calvin 2011-05-15 17:37 发表评论

tar命令小结

calvin — Sat, 14 May 2011 06:03:00 GMT

默认情况下，tar命令可以用来将文件打包为.tar包或者用来解开.tar包。tar命令也可以调用其它压缩算法从而支持gzip,bzip2等等。
tar命令有几种主要模式：
* 打包：
tar cf allfile.tar *.jpg

* 解包到指定的目录：
tar xf allfile.tar -C ~/Pictures

* 列出tar包中的所有文件：
tar tf allfile.tar

* 往已有的tar包中增加新文件：
tar rf allfile.tar *.png

使用tar命令处理其它压缩算法
* gzip(.tar.gz或者.tgz)
tar zcf allfile.tar.gz *.jpg
tar zxf allfile.tar.gz -C ~/Pictures

* bzip2(.tar.bz2或者.bz2)
tar jcf allfile.tar.bz2 *.jpg
tar jxf allfile.tar.bz2 -C ~/Pictures

归档里面的所有文件均是相对引用，归档解压缩（释放）在了当前目录。归档文件总是释放到当前目录，为的是防止破坏文件系统中重名的文件。
如果想覆盖的话，在归档和解压时请使用-P参数：
tar zcvf mysql.tar.gz -P /var/lib/mysql
tar -Pzxvf mysql.tar.gz(这会覆盖本地的/var/lib/mysql目录)

Tar炸弹

攻击者利用绝对路径，或者“tar -cf bomb.tar *”的方式创建的tar文件，然后诱骗受害者在根目录下解压，或者使用绝对路径解压。可能使受害系统上已有的文件被覆盖掉，或者导致当前工作目录凌乱不堪，这就是所谓的“tar炸弹”。因此，要养成良好的解压习惯：

解压前用“t”查看tar的文件内容。
拒绝使用绝对路径。
新建一个临时子目录，然后在这个子目录里解压。

calvin 2011-05-14 14:03 发表评论

hide title bar firefox 4.0.1 on Ubuntu linux

calvin — Wed, 11 May 2011 14:25:00 GMT

Google一通，发现所谓lHideChrome，Hide Caption之类插件都是浮云，最后发现一个给力的，如下：
下载userChromeJS插件：http://downloads.mozdev.org/userchromejs/userChromeJS-1.3.xpi
编辑：
~/.mozilla/firefox/XXXXXX.default/chrome/userChrome.js：

(function() {
var win_ctrl = document.getElementById("window-controls");
win_ctrl.setAttribute("fullscreencontrol", "false");
win_ctrl.setAttribute("hidden", "false");

var mainWindow = document.getElementById("main-window");
mainWindow.setAttribute("hidechrome", "true");

})();

That's all.

calvin 2011-05-11 22:25 发表评论

禁用touchpad

calvin — Tue, 03 May 2011 17:13:00 GMT

xinput --list

查找触摸板的id：
⎡ Virtual core pointer id=2 [master pointer (3)]
⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)]
⎜ ↳ USB Optical Mouse id=10 [slave pointer (2)]
⎜ ↳ PS/2 Synaptics TouchPad id=13 [slave pointer (2)]
⎜ ↳ Macintosh mouse button emulation id=14 [slave pointer (2)]
⎣ Virtual core keyboard id=3 [master keyboard (2)]
↳ Virtual core XTEST keyboard id=5 [slave keyboard (3)]
↳ Power Button id=6 [slave keyboard (3)]
↳ Video Bus id=7 [slave keyboard (3)]
↳ Video Bus id=8 [slave keyboard (3)]
↳ Power Button id=9 [slave keyboard (3)]
↳ HP Webcam-101 id=11 [slave keyboard (3)]
↳ AT Translated Set 2 keyboard id=12 [slave keyboard (3)]

触摸板的ID为13，
禁用：
代码:
xinput set-prop 13 "Device Enabled" 0

启用：
代码:
xinput set-prop 13 "Device Enabled" 1

calvin 2011-05-04 01:13 发表评论

shell字符串比较

calvin — Wed, 13 Apr 2011 10:04:00 GMT

比较两个字符串是否相等的办法是：
if [ "$test"x = "test"x ]; then
这里的关键有几点：
1 使用单个等号，也可以使用两个等号
2 注意到等号两边各有一个空格：这是unix shell的要求
3 注意到"$test"x最后的x，这是特意安排的，因为当$test为空的时候，上面的表达式就变成了x = testx，显然是不相等的。而如果没有这个x，表达式就会报错：[: =: unary operator expected

以上在android shell下不能运行，android shell不认识。

calvin 2011-04-13 18:04 发表评论

Ubuntu安装sun-java5-jdk

calvin — Thu, 17 Mar 2011 04:58:00 GMT

Ubuntu 9.10以上版本中，Ubuntu去除了对sun-java5-jdk的支持，如果必须安装sun-java5-jdk。那么可以采用如下方法：

1.编辑/etc/apt/sources.list文件，将安装源更改为Ubuntu 9.04的安装源为：

deb http://archive.Ubuntu.com/ubuntu/ jaunty main restricted universe multiverse
deb http://archive.Ubuntu.com/ubuntu/ jaunty-security main restricted universe multiverse
deb http://archive.Ubuntu.com/ubuntu/ jaunty-updates main restricted universe multiverse
deb http://archive.Ubuntu.com/ubuntu/ jaunty-proposed main restricted universe multiverse
deb http://archive.Ubuntu.com/ubuntu/ jaunty-backports main restricted universe multiverse
deb-src http://archive.Ubuntu.com/ubuntu/ jaunty main restricted universe multiverse
deb-src http://archive.Ubuntu.com/ubuntu/ jaunty-security main restricted universe multiverse
deb-src http://archive.Ubuntu.com/ubuntu/ jaunty-updates main restricted universe multiverse
deb-src http://archive.Ubuntu.com/ubuntu/ jaunty-proposed main restricted universe multiverse

2. sudo apt-get install sun-java5-jdk

calvin 2011-03-17 12:58 发表评论

[转]ioctl函数的作用

calvin — Wed, 02 Mar 2011 16:28:00 GMT

特殊的read,write, 当你用read，write不能完成某一功能时，就用ioctl

[转载]来源http://www.linuxeden.com/edu/doctext.php?docid=1860

我这里说的ioctl函数是在驱动程序里的，因为我不知道还有没有别的场合用到了ioctl，
所以就规定了我们讨论的范围。为什么要写篇文章呢，是因为我前一阵子被ioctl给搞混
了，这几天才弄明白它，于是在这里清理一下头脑。

一、什么是ioctl。
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就
是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数
如下：
int ioctl(int fd, ind cmd, …)；
其中fd就是用户程序打开设备时使用open函数返回的文件标示符，cmd就是用户程序对设
备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，有或没有是和
cmd的意义相关的。
ioctl函数是文件结构中的一个属性分量，就是说如果你的驱动程序提供了对ioctl的支
持，用户就可以在用户程序中使用ioctl函数控制设备的I/O通道。【所以说这些cmd不能和内核中的相同，否则就有冲突了】

二、 ioctl的必要性
如果不用ioctl的话，也可以实现对设备I/O通道的控制，但那就是蛮拧了。例如，我们可
以在驱动程序中实现write的时候检查一下是否有特殊约定的数据流通过，如果有的话，
那么后面就跟着控制命令（一般在socket编程中常常这样做）。但是如果这样做的话，会
导致代码分工不明，程序结构混乱，程序员自己也会头昏眼花的。
所以，我们就使用ioctl来实现控制的功能。要记住，用户程序所作的只是通过命令码告
诉驱动程序它想做什么，至于怎么解释这些命令和怎么实现这些命令，这都是驱动程序要
做的事情。

三、 ioctl如何实现
这是一个很麻烦的问题，我是能省则省。要说清楚它，没有四五千字是不行的，所以我这
里是不可能把它说得非常清楚了，不过如果有读者对用户程序怎么和驱动程序联系起来感
兴趣的话，可以看我前一阵子写的《write的奥秘》。读者只要把write换成ioctl，就知
道用户程序的ioctl是怎么和驱动程序中的ioctl实现联系在一起的了。
我这里说一个大概思路，因为我觉得《Linux设备驱动程序》这本书已经说的非常清楚
了，但是得化一些时间来看。
在驱动程序中实现的ioctl函数体内，实际上是有一个switch{case}结构，每一个case对
应一个命令码，做出一些相应的操作。怎么实现这些操作，这是每一个程序员自己的事
情，因为设备都是特定的，这里也没法说。关键在于怎么样组织命令码，因为在ioctl中
命令码是唯一联系用户程序命令和驱动程序支持的途径。
命令码的组织是有一些讲究的，因为我们一定要做到命令和设备是一一对应的，这样才不
会将正确的命令发给错误的设备，或者是把错误的命令发给正确的设备，或者是把错误的
命令发给错误的设备。这些错误都会导致不可预料的事情发生，而当程序员发现了这些奇
怪的事情的时候，再来调试程序查找错误，那将是非常困难的事情。
所以在Linux核心中是这样定义一个命令码的组织结构：
____________________________________
| 设备类型 | 序列号 | 方向 |数据尺寸|
|----------|--------|------|--------|
| 8 bit | 8 bit |2 bit |8~14 bit|
|----------|--------|------|--------|

这样一来，一个命令就变成了一个整数形式的命令码。但是命令码非常的不直观，所以
Linux Kernel中提供了一些宏，这些宏可根据便于理解的字符串生成命令码，或者是从
命令码得到一些用户可以理解的字符串以标明这个命令对应的设备类型、设备序列号、数
据传送方向和数据传输尺寸。

这些宏我就不在这里解释了，具体的形式请读者察看Linux核心源代码中的和，文件里给
除了这些宏完整的定义。这里我只多说一个地方，那就是"幻数"。
幻数是一个字母，数据长度也是8，所以就用一个特定的字母来标明设备类型，这和用一
个数字是一样的，只是更加利于记忆和理解。就是这样，再没有更复杂的了。
更多的说了也没有，读者还是看一看源代码吧，推荐各位阅读《Linux 设备驱动程序》所
带源代码中的short一例，因为它比较短小，功能比较简单，可以看明白ioctl的功能和细
节。

四、 cmd参数如何得出
这里确实要说一说，cmd参数在用户程序端由一些宏根据设备类型、序列号、传送方向、
数据尺寸等生成，这个整数通过系统调用传递到内核中的驱动程序，再由驱动程序使用解
码宏从这个整数中得到设备的类型、序列号、传送方向、数据尺寸等信息，然后通过
switch{case}结构进行相应的操作。
要透彻理解，只能是通过阅读源代码，我这篇文章实际上只是一个引子。Cmd参数的组织
还是比较复杂的，我认为要搞熟它还是得花不少时间的，但是这是值得的，驱动程序中最
难的是对中断的理解。

五、小结
ioctl其实没有什么很难的东西需要理解，关键是理解cmd命令码是怎么在用户程序里生成
并在驱动程序里解析的，程序员最主要的工作量在switch{case}结构中，因为对设备的
I/O控制都是通过这一部分的代码实现的。

参考资料：
1．《Linux 设备驱动程序》，鲁宾尼著，中国电力出版社。
2．《write的奥秘》，coly，真情流露(202.204.7.235)->电脑技术->Linux技术。

calvin 2011-03-03 00:28 发表评论

[转]基于FrameBuffer的直接写屏

calvin — Wed, 02 Mar 2011 16:26:00 GMT

1.将FrameBuffer配置成800x600x16色的显示模式
在/boot/grub/menu.lst中的kernel加入vga=0x314
//test.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char **argv){
int fb_fd=0;
char *fbdev="/dev/fb0";
if((fd_fd=open(fbdev,O_RDWR))<0){
printf("open FrameBuffer device failed."n");
return -1;
}
printf("open FrameBuffer device successfully!"n");
close(fb_fd);
}

编译后执行一下，看看当前内核是否支持FrameBuffer机制.
设备打开成功后要获取相当的参数，使用ioctl，会填充以下结构体，
在linux/fb.h中定义的
struct fb_fix_screeninfo
struct fb_var_screeninfo
struct fb_cmap
从fs.h中可看出

#define FBIOGET_VSCREENINFO 0x4600
#define FBIOGET_FSCREENINFO 0x4602

我们就用这两条命令获取相当的参数信息
//test.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/fb.h>
int main(int argc,char **argv){
int fb_fd=0;
char *env="/dev/fb0";
struct fb_fix_screeninfo fb_fixinfo;
struct fb_var_screeninfo fb_varinfo;
if((fb_fd=open(env,O_RDWR))<0){
  printf("Error:open FrameBuffer device:%s"n",env);
  return -1;
}else{
  printf("OK:open FrameBuffer device:%s"n",env);
}
if(ioctl(fb_fd,FBIOGET_FSCREENINFO,&fb_fixinfo)==-1){
  printf("Error:FBIOGET_FSCREENINFO"n");
  goto fail;
}
printf("ioctl FBIOGET_FSCREENINFO ok"n");
printf("id=%s"n",fb_fixinfo.id);
printf("smem_start=%#x"n",fb_fixinfo.smem_start);
printf("mem_len=%d"n",fb_fixinfo.smem_len);
printf("type=%d"n",fb_fixinfo.type);
printf("type_aux=%d"n",fb_fixinfo.type_aux);
printf("visual=%d"n",fb_fixinfo.visual);
printf("xpanstep=%d"n",fb_fixinfo.xpanstep);
printf("ypanstep=%d"n",fb_fixinfo.ypanstep);
printf("ywrapstep=%d"n",fb_fixinfo.ywrapstep);
printf("line_length=%d"n",fb_fixinfo.line_length);
printf("mmio_start=%#x"n",fb_fixinfo.mmio_start);
printf("mmio_len=%#x"n",fb_fixinfo.mmio_len);
printf("accel=%d"n",fb_fixinfo.accel);
printf("reserved[0]=%d"n",fb_fixinfo.reserved[0]);
printf("reserved[1]=%d"n",fb_fixinfo.reserved[1]);
printf("reserved[2]=%d"n",fb_fixinfo.reserved[2]);
if(ioctl(fb_fd,FBIOGET_VSCREENINFO,&fb_varinfo)==-1){
  printf("Error:ioctl:FBIOGET_VSCREENINFO"n");
  goto fail;
}
printf("ioctl FBIOGET_VSCREENINFO ok"n");
printf("xres=%d"n",fb_varinfo.xres);
printf("yres=%d"n",fb_varinfo.yres);
printf("xres_virtual=%d"n",fb_varinfo.xres_virtual);
printf("yres_virtual=%d"n",fb_varinfo.yres_virtual);
printf("xoffset=%d"n",fb_varinfo.xoffset);
printf("yoffset=%d"n",fb_varinfo.yoffset);
printf("bits_per_pixel=%d"n",fb_varinfo.bits_per_pixel);
printf("grayscale=%d"n",fb_varinfo.grayscale);
printf("red=%#x"n",fb_varinfo.red);
printf("green=%#x"n",fb_varinfo.green);
printf("blue=%#x"n",fb_varinfo.blue);
printf("transp=%d"n",fb_varinfo.transp);
printf("nonstd=%d"n",fb_varinfo.nonstd);
printf("activate=%d"n",fb_varinfo.activate);
printf("height=%d"n",fb_varinfo.height);
printf("width=%d"n",fb_varinfo.width);
printf("accel_flags=%d"n",fb_varinfo.accel_flags);
printf("pixclock=%d"n",fb_varinfo.pixclock);
printf("left_margin=%d"n",fb_varinfo.left_margin);
printf("right_margin=%d"n",fb_varinfo.right_margin);
printf("upper_margin=%d"n",fb_varinfo.upper_margin);
printf("lower_margin=%d"n",fb_varinfo.lower_margin);
printf("hsync_len=%d"n",fb_varinfo.hsync_len);
printf("vsync_len=%d"n",fb_varinfo.vsync_len);
printf("sync=%d"n",fb_varinfo.sync);
printf("vmode=%d"n",fb_varinfo.vmode);
printf("rotate=%d"n",fb_varinfo.rotate);
printf("reserved[0]=%d"n",fb_varinfo.reserved[0]);
printf("reserved[1]=%d"n",fb_varinfo.reserved[1]);
printf("reserved[2]=%d"n",fb_varinfo.reserved[2]);
printf("reserved[3]=%d"n",fb_varinfo.reserved[3]);
printf("reserved[4]=%d"n",fb_varinfo.reserved[4]);

close(fb_fd);
return 0;
fail:
close(fb_fd);
return -1;
}

从输出结果来看xres=800,yres=600,从这里可以看出这个FrameBuffer的最大值为800x600
得到framebuffer的信息后，我们开辟一段内存，然后映射framebuffer的内存,
这样当向这段内存写入信息时，framebuffer中就会写入相同的数据，也就会有数据表示的图像显示在屏幕上。
例：在屏幕上显示一个渐变窗体

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <errno.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
int flush_screen(char *buf,char *framebuf,int width,int height);
int main(int argc, char *argv[])
{
        int fb_fd=0;
        struct fb_fix_screeninfo fb_fixinfo;
        struct fb_var_screeninfo fb_varinfo;
    char *fb_addr;
    unsigned long fb_size;
    char *buffer;
    int i=0;
       if((fb_fd=open("/dev/fb0", O_RDWR))<0){
         printf("open framebuffer device failed."n");
         return -1;
       }
    printf("open framebuffer device ok"n");

        if(ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fixinfo) == -1)
        {
                printf("ioctl FBIOGET_FSCREENINFO failed."n");
                return -1;
        }
    printf("ioctl FBIOGET_FSCREENINFO ok"n");
        if(ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_varinfo) == -1)
        {
                printf("ioctl FBIOGET_VSCREENINFO failed."n");
                return -1;
        }
    printf("ioctl FBIOGET_VSCREENINFO ok"n");
        fb_size = fb_varinfo.yres * fb_fixinfo.line_length;   //整个framebuffer的大小
        fb_addr = (char *)mmap(NULL, fb_size, PROT_READ|PROT_WRITE,MAP_SHARED, fb_fd, 0); //将framebuffer的物理地址映射到进程地址空间
        buffer=(char*)malloc(fb_varinfo.yres * fb_fixinfo.line_length); //申请一个缓冲区，采用双缓冲方式
    for(i=0;i<=0xff;i+=0x0f){
          memset(buffer,i,fb_varinfo.yres * fb_fixinfo.line_length);
          flush_screen(buffer,fb_addr,fb_varinfo.xres,fb_varinfo.yres);
      sleep(1);
    }
        if (!fb_addr)
                exit(1);
        free(buffer);
        return 0;
}

int flush_screen(char *buf,char *framebuf,int width,int height)
{
                char *t_data = buf;
                char *t_fb_addr = framebuf;
                int bytew= width<<1;
                while(--height >= 0)
                {
                        memcpy(t_fb_addr,t_data,bytew);
                        t_fb_addr += width;
                        t_data += width;
                }
}

编译后，运行看一下结果，尽量在字符模式下运行
vi /etc/inittab将运行级别改为3
重启后，运行一下看看结果。

参考链接：
http://www.blogjava.net/lihao336/admin/EditPosts.aspx?postid=345547

calvin 2011-03-03 00:26 发表评论

[转]Linux的帧缓冲设备(Framebuffer)简介

calvin — Wed, 02 Mar 2011 16:19:00 GMT

Linux的帧缓冲设备(Framebuffer)简介

帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节。这些都是由Framebuffer设备驱动来完成的。
帧缓冲驱动的应用广泛，在linux的桌面系统中，Xwindow服务器就是利用帧缓冲进行窗口的绘制。尤其是通过帧缓冲可显示汉字点阵，成为Linux汉化的唯一可行方案。
    Linux FrameBuffer 本质上只是提供了对图形设备的硬件抽象，在开发者看来，FrameBuffer 是一块显示缓存，往显示缓存中写入特定格式的数据就意味着向屏幕输出内容。所以说FrameBuffer就是一块白板。例如对于初始化为16 位色的FrameBuffer 来说， FrameBuffer中的两个字节代表屏幕上一个点，从上到下，从左至右，屏幕位置与内存地址是顺序的线性关系。
    帧缓存可以在系统存储器(内存)的任意位置，视频控制器通过访问帧缓存来刷新屏幕。帧缓存也叫刷新缓存 Frame buffer 或 refresh buffer, 这里的帧(frame)是指整个屏幕范围。
    帧缓存有个地址，是在内存里。我们通过不停的向frame buffer中写入数据，显示控制器就自动的从frame buffer中取数据并显示出来。全部的图形都共享内存中同一个帧缓存。
    CPU指定显示控制器工作，则显示控制器根据CPU的控制到指定的地方去取数据和指令，目前的数据一般是从显存里取，如果显存里存不下，则从内存里取，内存也放不下，则从硬盘里取，当然也不是内存放不下，而是为了节省内存的话，可以放在硬盘里，然后通过指令控制显示控制器去取。帧缓存 Frame Buffer，里面存储的东西是一帧一帧的，显卡会不停的刷新Frame Buffer, 这每一帧如果不捕获的话，则会被丢弃，也就是说是实时的。这每一帧不管是保存在内存还是显存里，都是一个显性的信息，这每一帧假设是800x600的分辨率，则保存的是800x600个像素点，和颜色值。
    显示器可以显示无限种颜色，目前普通电脑的显卡可以显示32位真彩、24位真彩、16位增强色、256色。除256色外，大家可以根据自己的需要在显卡的允许范围之内随意选择。很多用户有一种错误概念，认为256色是最高级的选项，而实际上正好相反。256色是最低级的选项，它已不能满足彩色图像的显示需要。16位不是16种颜色，而是2的16次平方(256×256)种颜色，但256色就是256(2的8次平方)种颜色。所以16位色要比256色丰富得多。
    帧缓冲设备对应的设备文件为 /dev/fb*，如果系统有多个显示卡，Linux下还可支持多个帧缓冲设备，最多可达32 个，分别为/dev/fb0到/dev/fb31，而/dev/fb则为当前缺省的帧缓冲设备，通常指向/dev/fb0。当然在嵌入式系统中支持一个显示设备就够了。帧缓冲设备为标准字符设备，主设备号为29，次设备号则从0到31。分别对应/dev/fb0-/dev/fb31。通过/dev/fb，应用程序的操作主要有这几种：
1．读/写（read/write）/dev/fb：相当于读/写屏幕缓冲区。例如用 cp /dev/fb0 tmp命令可将当前屏幕的内容拷贝到一个文件中，而命令cp tmp > /dev/fb0 则将图形文件tmp显示在屏幕上。
2．映射（map）操作：由于Linux工作在保护模式，每个应用程序都有自己的虚拟地址空间，在应用程序中是不能直接访问物理缓冲区地址的。为此， Linux在文件操作 file_operations结构中提供了mmap函数，可将文件的内容映射到用户空间。对于帧缓冲设备，则可通过映射操作，可将屏幕缓冲区的物理地址映射到用户空间的一段虚拟地址中，之后用户就可以通过读写这段虚拟地址访问屏幕缓冲区，在屏幕上绘图了。实际上，使用帧缓冲设备的应用程序都是通过映射操作来显示图形的。由于映射操作都是由内核来完成，下面我们将看到，帧缓冲驱动留给开发人员的工作并不多。
3． I/O控制：对于帧缓冲设备，对设备文件的ioctl操作可读取/设置显示设备及屏幕的参数，如分辨率，显示颜色数，屏幕大小等等。ioctl的操作是由底层的驱动程序来完成的。
在应用程序中，操作/dev/fb的一般步骤如下：

1．打开/dev/fb设备文件。
2．用ioctrl操作取得当前显示屏幕的参数，如屏幕分辨率，每个像素点的比特数。根据屏幕参数可计算屏幕缓冲区的大小。
3．将屏幕缓冲区映射到用户空间。
4．映射后就可以直接读写屏幕缓冲区，进行绘图和图片显示了。

典型程序段如下：

1 #include
2 int main()
3 {
4 int fbfd = 0;
5 struct fb_var_screeninfo vinfo;
6 struct fb_fix_screeninfo finfo;
7 long int screensize = 0;
8 /*打开设备文件*/
9 fbfd = open("/dev/fb0", O_RDWR);
10 /*取得屏幕相关参数*/
11 ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo);
12 ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo);
13 /*计算屏幕缓冲区大小*/
14 screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;
15 /*映射屏幕缓冲区到用户地址空间*/
16 fbp=(char*)mmap(0,screensize,PROT_READ|PROT_WRITE,MAP_SHARED, fbfd, 0);
17 /*下面可通过fbp指针读写缓冲区*/
18 }

calvin 2011-03-03 00:19 发表评论

使用mutt发送邮件

calvin — Mon, 24 Jan 2011 18:14:00 GMT

1.安装msmtp
配置~/.msmtprc
account default
host smtp.yourprovider.example
from you@yourprovider.example

auth login
user JoeExample
password Secret

可使用msmtp --host=smtp.yourprovider.example --serverinfo 来查看server的信息

2.安装mutt
配置～/.muttrc

set sendmail="/usr/bin/msmtp"
set from=you@yourprovider.example
set editor=vim

calvin 2011-01-25 02:14 发表评论