Edwick

2011年5月17日 SZLUG 月度聚会

2011-05-18T22:53:00.003+08:00

这次聚会的主题是 ubuntu release party，除了展示 Ubuntu Natty 的变革，Unity 桌面
的特性外，我们在现场还动手安装了 Ubuntu on LiveUSB 系统，另外还讨论了 SZLUG 的发
展和现行出现的问题。

相册集：
http://www.flickr.com/photos/62891604@N02/sets/72157626599796761/

主题

SZLUG 历史、发展与现状, by Wick

Wick个人介绍
为什么是我
SZLUG 历史
SZLUG 发展
问题探讨
和我们保持联系

介绍 Ubuntu Natty, by Wick

快速介绍Ubuntu历史
我与Ubuntu
Ubuntu Natty 的改进与变革
- Unity桌面环境
- Banshee
- Office gets more libre!
- linux 2.6.38, and a killer patch!
- 2D unity 接口
- 改进的 Ubuntu One 界面
- 改进的软件中心
- 拥抱QT
增强体验： Unity小技巧
- Unity Plugin in Compiz
- Ubuntu Tweak 选项微调

Ubuntu installfest

展示 Ubuntu LiveUSB 的安装和使用

自由讨论阶段

Anders: SZLUG 发展的建议
黄略: 嵌入式合作开发项目
海波：深圳 Linux 软件平台

Kernel Module Loading Order

2011-05-18T22:32:00.001+08:00

> Is there any way to find out the module loading order? Who decide which module

> is loaded first?

It's random and there is no way to specify the order unless you make one
module a dependancy of the other.

http://lists.kernelnewbies.org/pipermail/kernelnewbies/2011-May/001730.html

五一节假日汕头之行 Shantou Tour on May Day Holiday

2011-05-18T22:17:00.004+08:00

4/30-5/2 南澳自驾游

行程

Day 1. 汕头地区
1. 5h30m 路程，从罗湖到达汕头
2. 早餐：粿条，非常新鲜呐
3. 休息，喝茶
4. 10:00 午饭：海鲜大餐
5. 13:30 莱芜客运码头
6. 14:10 乘风破浪，登陆南澳岛
7. 关帝庙，展南亭，清澳湾洗浴
8. 00:30 夜宿展南亭
Day 2. 南澳岛
1. 8：30 起床。户外洗漱
2. 早饭&午饭：丰富的县城小吃，白粥，粿条
3. 后宅镇，前江码头，云澳村，青澳湾
4. 青澳度假村，享受美丽海岸
5. 雄镇关古城墙
6. 风能发电站观景台
7. 龙滨路大吃大排档。丁螺，薄壳，海瓜子，鱿鱼仔
8. 回到后宅镇旅馆冲凉
9. 再宿展南亭
Day 3. 南澳岛，回程
1. 8：30 起床。水土不服，拉肚子啦
2. 沮丧，汽车熄火，南澳推车一日游
3. 南澳环岛公路北段，黄花山森林公园，九尖山
4. 13：30 离开南澳岛
5. 午饭大餐：海生大排档
6. 汕头市区行：购置海特产
7. 21：30 离开汕头

感受

事实上，汕头并不是想象中一个荒僻的小岛。实际它是广东唯一一个海岛县，八千年前就早有人存在，海岛上有金银岛，宋井，雄镇关等等历史古迹，所以南澳游会很像一个人文景观丰富的小岛。

因此，南澳是一个可以待段日子的地方，贝类海鲜非常丰富，管你吃个新鲜吃个饱；而且可以有很多逛的地方：风能发电厂，青澳湾等等都是非常优美的免费景点。海滩更是随处可见，这对于城市人来说特别奢侈。

遗憾

首先，南澳人都特别排外。这种源于小作坊小工厂的意识形态，在对待外地人时候更加严重。

比如定旅馆，这里的价格高的离谱，双人标间给叫到200以上，南澳宾馆的标间打到540，而且不爱打理；海鲜排挡对外人来说甚至不给杀价；真是郁闷。

其次，天气也让人很扫兴。我们在南澳的两个整天，都是大雾弥漫，空气湿热，气压很高，除了影响心情。对于拍友是个天杀的遗憾。天气不作美，再好的片子也出不来。

最后，南澳岛环保意识非常之薄弱，走完全岛几乎都没有什么垃圾桶，更没有人定点清理。要知道很多景点都是收费的，那么收费之后谁来管理呢。要重点批驳一下，就是厕所实在太少了，岛上很多野生地点环境太糟糕，完全影响县城形象。

HOWTO disable failsafe mode in Openwrt

2011-04-27T23:23:00.001+08:00

https://forum.openwrt.org/viewtopic.php?id=28227

$ edit package/base-files/files/lib/preinit/30_failsafe_wait

and make ...

intersection and union： find the difference between two directories

2011-04-27T23:15:00.002+08:00

Usage: ./cmpdir d1 d2

`sort' just sort the lines alphabetically. the key is uniq

SZLUG April monthly meeting

2011-04-27T23:08:00.002+08:00

There are three main topics during the meeting.

Rockins's topic is a very good starting-point, even including the study case, TP-LINK's hiring ads.

Bring up Vxworks on a MIPS core, by Rockins Chen

why vxworks: see pro and con below
1. pro: simplicity, high quality code, document everything
2. con: proprietary, less existed package, inactive community
basic:
1. multi-tasking
2. inter-task
3. communication
4. mm(first-fit)
5. IO system, UNIX-like file/dir/device, POSIX AIO …
6. fs: dosFs, rawFs, tapeFs, cdromFs, TSFs, TrueFFS for flash devices
7. network: TCP/IP, 802.1x, IPSec, NAT/NAPT, OSPF, Firewall, PPP …
A glance of VxWorks
1. libdrv.a, libnet.a, libarch.a, libos.a, libwind.a
2. all = libxxx.a + BSP = libxxx.a + bootcode + basic device driver
bootcode: arch dependent code
1. Cache, TLB, GRs in CPU, CP0's regs, PLL, DDR
2. watchdog, Exception/Interrupt, RTC, GPIO
case 1: slow loop on SPI flash
case 2: busy stuck of interrupt
1. MIPS CPU has 4 general purpose timer
case 3: load delay shot on MIPS R3000
case 4: stochastically stuch when jumping to vxworks
case 5: stochastically soft reboot failure due to PLL switch
1. resolution x3
importance of bsp:
1. availablity
2. reliability
3. stability
4. performance
things bsp engineer need to know (!!!)
1. arch: Instuctions, Pipeline, cache, exception/interrupt
2. Mem: SDRAM, DDR, NOR/NAND
3. Bus: UART, JTAG, SPI
4. Misc: PLL, Timer, GPIO, watchdog, DMA
5. OS & toolchain
6. Debug: ICE, debugger
Time for questions:
1. cache coherency
2. SoC problem
3. how and how hard to be a bsp engineer

SZLUG and the cloud computing platform, by Haibo Zhang

6281 and QNAP system image, by sniperpr

Market positioning of 6281
Collaborative development with a Shanghai guy
Introduction of QNAP image

IOWAIT - 测试IO性能的标尺

2011-04-12T23:35:00.002+08:00

有个客户给我发邮件，告知我，他们曾对自己的板子和现在正在测试的 Marvell 6281 主板进行对比测试。发现磁盘I/O操作时候的CPU空闲时间有出入。询问是否是6281的IO效率太低了。

mpstat 数据如下：

Marvell 6281
CPU %usr %nice %sys %iowait %irq %soft %idle
all 0.00 0.00 5.98 93.69 0.00 0.33 0.00
all 0.00 0.00 3.65 96.01 0.00 0.33 0.00
all 0.66 0.00 7.97 89.37 0.00 1.99 0.00
M5000
CPU %usr %nice %sys %iowait %irq %soft %idle
all 17.67 0.00 22.33 0.00 0.00 0.00 60.00 
all 11.33 0.00 22.00 0.00 0.00 0.00 66.67
all 7.33 0.00 16.33 0.00 0.00 0.00 76.33

客户认为M5000的 iowait 为0，那么CPU等待IO完成的时间是没有的，因此他的磁盘性能很好，CPU不去干预；而6281的iowait%太高，CPU都在等，磁盘效率低下。

误区：CPU在 iowait 的时候傻等

这里最要命的就是 iowait 概念。参考 mpstat 手册

CPU 的时间片在 mpstat 眼中划分为很多种类，在UP(unique processor)系统中

%usr + %nice + %sys + %iwoait + %irq + %soft + %steal + %guest + %idle = 100%

%usr, CPU 运行用户程序的时间比
%nice, CPU 运行修改过进程优先级的用户程序时间比
%sys， CPU 运行内核程序的时间比
%iowait, 显示CPU在拥有磁盘I/O请求时候的_空闲_时间比
…
%idle，现实CPU没有磁盘I/O请求时候的_空闲_时间比

而其中的 %usr + %nice + %sys 是真正CPU在忙的时间，而其他都属于空闲期。由上可知， 6281 在磁盘测试的时候使用了 0+0+5.98 = 5.98% 的CPU时间来处理I/O请求，而 M5000 则使用了 17.63+0+22.33 = 40%，很明显 M5000 的磁盘IO更加占用CPU时间。

iowait 指标

%iowait 同样也属于空闲期，但是细分成了属于等待磁盘I/O完成的空闲时间，CPU不会傻等。一旦CPU有其他请求，他会立刻响应。

高的 iowait 代表 CPU早早完成了IO请求的处理而等待磁盘IO的完成。一旦 iowait 逼近 100%，则代表CPU够闲的同时磁盘IO性能过低，总结为磁盘IO成了系统瓶颈。

而M5000 花费了 40% 的CPU 时间来处理请求，这个时候IO传输已经完成，他根本没有等待时间。这显得 CPU 性能相对磁盘IO反而心力不足，在密集型IO请求的系统中 CPU 会显得很吃力。

调校 IO 性能

IO性能的调校有超多的方法

硬件形成磁盘阵列 raidx
hdparm 微调磁盘性能
选用合适的 IO scheduler (/sys/block/sda/queue/scheduler)

同样也可以配合以下工具来试试

mpstat，适用于 SMP 系统下的监控工具，包含在 sysstat
iostat，可以察看IO都写请求的次数等详细数据，包含在sysstat
sar, 可以查看网络 IO 性能数据
oprofile，可定制的系统微调工具，工作方式类似与 systemtap
fio
nmon
iozone

物理简史之爱因斯坦相对论

2011-03-24T00:54:00.001+08:00

注明：略微看了一下物理简史，算是一个科普吧。

背景介绍

二十世纪两大理论，是对牛顿力学的革命

量子论
相对论

光波有介质吗？以太的存在？

波动说，需要介质，christian huygens
微粒说，不需要介质，newton
电磁说，麦克斯韦，赫兹
光子说，解释了电磁说中的光电效应，爱因斯坦

爱因斯坦1905四部论文

光电效应的解释，引入光子概念 NOBEL
利用统计力学来解释布朗运动，证明了原子的存在
狭义相对论
质能方程式

爱因斯坦1907长篇论文

运动中的质量会变大，速度越大，加速度越小，这样没有超越光速的可能
质能方程式 E=mc^2

狭义相对论

狭义相对论原理（公理） by Einstein in 1905

相对性原理：所有“惯性参考架构”，对物理而言，无主从之别
光速不变远离：真空中的光速，在任何“惯性参考架构”中皆是同值

所谓“惯性参考架构”，适用于牛顿力学中则指重力世界，但是架构不指有一个。狭义相对论的推导成果有：

否定以太，因为没有绝对静止和绝对速度
不能测得的量，不能称之为物理量，也不能成为物理研究的对象
推导出洛仁兹转换式
“四度空间”。时间和空间是实在的，并且可以有限度的转换，不能截然分别
物体不可以追上光，光速是所有速度的极限

等效原理：局部（短时间、小范围）而言，重力场与参考架构的加速度是等效的

广义相对论

广义相对论 by Einstein in 1915

爱因斯坦方程式 Guv = kMuv
弯曲的时空
重力场
光之红位移与光之偏折

狭义相对性原理虽然把伽利略相对性原理推广到了整个物理领域，但并不能包括非惯性参考系。爱因斯坦把相对性原理推广到一切参考系。

2011 磨房深圳百公里体验

2011-03-22T11:45:00.001+08:00

有幸能够在2011年参加闻名遐迩的深圳百公里活动。百公里是一个涉及参赛者，义工，公
安，组织者，医护人员的庞大项目，参加这样的活动意义非凡。

百公里的具体安排
百公里的活动时间是3月19日19:00至3月20日19:00，签到节点是深圳湾体育中心-红岭路口-
梧桐山村-大梅沙海滨公园-溪涌驿站-官湖驿站-金沙湾大酒店。其中深圳湾体育中心作为A
组起点，而大梅沙海滨公园作为B组起点，全长为96.3KM。大约有来自社会的三千多人参加
了活动。

我的经历
我并没有跑完全程，和tommy两人奋发图强，只是达成了从A组起点到盐田关的50KM。
节点1，红岭路口，小腿开始发酸。靠红牛觉得还能撑住。
节点2，梧桐山村，脚掌酸痛，而且疼痛积聚到大腿处，并且开始了痛苦的石板路历程。
节点3，从盐田关坐车到达大梅沙海滨公园，其实也是放弃了前行。脚掌刺痛完全无法移动。
节点6，直接坐车到达了金沙湾终点站，顺便领略大牛的风采。

我的消耗
右腿护膝，临时购买
左边绑腿 from Tommy
头灯 from 苏打
红牛 x4 from 官方赠饮
一碗西红柿鸡蛋面
一盒巧克力豆
少量零食

百公里的最大敌人
脚掌疼痛 -- 大部分人无法避免，这需要你更换不同的袜子，鞋垫(甚至鞋子)，定点休息抬脚让血液回流
大小腿酸痛 -- 必须加强平时锻炼，比如磨房22KM，38KM和一些长途拉练
脚趾间的摩擦起泡 -- 女孩多遇此问题，这需要给每个脚趾做包扎
装备 -- 护膝，护踝，必不可少，最好有背带，眼睛，帽子
体力 -- 这并不是一个大问题。保持一个星期的正常休眠即可
困顿 -- 只要不停下来就不会有难题，因为红牛赞助商不尽的补助
技巧 -- 变换动作可以减缓持续单调运动的磨损，用上你可以用到的所有静走技巧吧
背负 -- 当然越少越好

官方论坛 http://www.doyouhike.net/forum/sz100km/
路线大图 http://dl.doyouhike.net/sz100km/2011/2011_100km.jpg

SZLUG 月度聚会，一月讨论张乐的谷歌Offer

2011-03-18T10:54:00.004+08:00

时间：2011年1月16日星期六下午2点－5点
地点：深圳清华研究生院 CI-101 教室
议题：张乐－我如何拿到的google offer
报名：https://groups.google.com/group/szlug/browse_thread/thread/0c5f22cb97b510f1

实到：本次聚会有25人到场(合照人数加上我)，但是没人登记，我无法列出名字了。

由于本次聚会主题只有张乐的offer一个，我觉得当然他来作自然比较合适。但是因为被批
作笔记很勤力，麻哥告诉我要作个summary，我就姑且充数叙述一下。

张乐终于拿到谷歌总部的Offer，这种Offer对中国开发者看起来几乎是要一步踏进国安局一
样不可思议。因此这次会议的主题就只有张乐来讲述：到底使如何拿到谷歌Offer的。

张乐讲演的时间达到2:30小时，期间的议题非常多，我先列个总表。

=== 主题 ===
- 简介SRE, Site Reliability Engineering
* 职责：系统维护，保证软件服务的正常稳定运行
* 一要兼顾系统管理，二要精通软件编程
- 如何拿到 Google Offer
* LinkedIn，这是一个很好的开始
* 无征兆之下接到猎头联系电话
- 面试经历
* 2010/8，联系和第一次面试。
* 2010/9月初，电话面试 with a Google SRE
* 2010/10/1，很正式的美国总部面试 at SanFrancisco!!!
* 附加面试。 Hiring Committee ...
* 最后的录用。 Execution Committee ...
* 薪水问题。张乐：我们有glassdoor.com
- 前往美国
* 办理护照和签证，H1-B，H4
* 谷歌的行程安排，机票，酒店，出租车，吃饭……
* 痛苦的时差问题
- 乐少开始宣传邪恶的美帝
* 美国税务，住宿，买车买房
* 美国绿卡的拿到，H1-B的6年期限
* 硅谷游： San Jose，Stanford 大学，Oracle，Apple，Cisco ...
- 提问题时间
* 国内IT的前景 - 做出别人无法替代的东西
* 张乐的内核之路
* 英语学习之道
* 香港IT环境如何？
* 顺带关注同行业界。 newsycombinator@twitter
- Working in IT industry is a bless
* 催促大家努力，IT有个很好的明天
* 榜样：程任全同学(already in Cisco)，张乐同学...

下面重点讲述谷歌面试题

=== 谷歌面试题简述 ===
- 第一次电话面试
* 自我评价，给自己评级。从1到10给自己打分
* 简单问题: 比如面向对象……
- 第二次电话面试 with a Google SRE
* 具体文本在 google docs
* 口述程序分析结果: fork前后安插print语句
* 分析程序: ping 过程，揭示从shell执行、DNS code、socket……到打印结果一系列过程
- 正式的美国总部面试 at SanFrancisco
* 1/5 系统管理问题: Linux API，信号
* 2/5 脚本语言: ，自选语言实现pkill和tail
* 3/5 trouble shooting: ?
* 4/5 C编程: 分析程序，自己编写一个myopen（考点：LD_PRELOAD）
* 5/5 数据库问题: 提取100w个执行最多的SQL语句（external merge sort）
- 附加面试
* C编程: 判断字符串是否为UTF-8

作为一个中国小公司的IT行业者，显然会被SRE这样的名词搞蒙，但是看起来出题并不是太
难，事实上SRE是一个着重光度的一个职位。以后可以多多注重这些方面，相信对将来面试
一定会有帮助。

更大层面上，如何树立方向才是重要的事情。如何如所述那样做出别人无法复制的东西，自
然自己也是无法替代。记住这个目标吧，中国的IT行业者。

SZLUG 年底小聚，迎接jserv先生

2011-03-18T10:51:00.001+08:00

这次讨论组的聚会安排在了12月26日，西方圣诞节后的第一个星期日，这天是为了迎接一个
台湾的大牛，他就是来自台湾 0xlab 公司的黄敬群先生。

黄敬群(Jim Huang)，又称 Jserv，涉足非常多的自由软件领域。非常出名的项目有：台湾
芯Andes，OpenMoko项目，LXDE项目，0xdroid 维护人，Android贡献者等。主页介绍
* http://jserv.sayya.org/
* http://blog.linux.org.tw/jserv/
* http://tw.linkedin.com/in/job4jserv
* http://wiki.debian.org.tw/User:jserv

其实这次只是见面小觑，jserv并没有作任何讨论主题的准备，因此大家就瞎聊海聊。因此
场面很热闹，星巴克当时的人也超多。因为星巴克的员工告知不允许拍照和录像，因此不能
提供录像上传了。

其他讨论的主题有
- OpenMoko 停止开发？ jserv: 原因保密
- Oppo Real 新方案？ jserv: 保密
- 深圳和台湾有什么区别？ jserv: PCB华强北直接卖？台湾做不到
- linux_pro： 6281项目？我也作！还有MV 78100，Freesale，atheros
- 山寨平板跑 Android，这货太让人吃惊了！
- Linux 厂商的生态系统 with Anders Ma, linux_pro ...
- 乐少要去谷歌总部了！

Syntax Highlighter Test

2011-03-18T10:07:00.007+08:00

TEST, all test

via http://www.bloggermint.com/2010/02/how-to-add-syntax-highlighter-for-bloggerblogspot/

Ifconfig 如何获得流量统计信息

2009-03-27T09:38:00.001+08:00

本文旨在讲解 Ifconfig 流量信息的获得。将通过 Ifconfig 代码阅读来跟踪流量统计的来源，这将贯通网络模块，proc文件系统，到硬件设备驱动来探寻这些信息的来源和流向。

Ifconfig

Ifconfig是 net-tools的一个组件。 net-tools 为 GNU/Linux 提供控制网络子系统的很多重要工具(arp, ifconfig, netstat...)，他几乎成为所有发行版必备的软件。

来看他的输出情况。包含了基本的网卡信息，内核网络配置。除此之外，还包括了流量统计信息。笔者开始就抱有非常疑惑的信息，Ifconfig是如何做到这一点的？这样一个高层的应用程序难道和网卡紧密相连么？正是由于这样的疑问，我才开始了阅读代码的过程。

wick@ ~: sudo ifconfig eth0
eth0      Link encap:以太网  硬件地址 00:e0:4c:43:d4:8d
         inet 地址:192.168.16.91  广播:192.168.16.255  掩码:255.255.255.0
         inet6 地址: fe80::2e0:4cff:fe43:d48d/64 Scope:Link
         UP BROADCAST RUNNING MULTICAST  MTU:1500  跃点数:1
         接收数据包:20825 错误:0 丢弃:0 过载:0 帧数:0
         发送数据包:35057 错误:0 丢弃:0 过载:0 载波:0
         碰撞:0 发送队列长度:1000
         接收字节:2225064 (2.2 MB)  发送字节:50827282 (50.8 MB)
         中断:23 基本地址:0xb800

本篇实例讲解使用到了 —- net-tools-1.60 源码，可以在官方网站找到

http://packages.debian.org/sid/net-tools

linux-2.6.29 代码

http://kernel.org

net-tools/ifconfig.c

NET_LIB = $(NET_LIB_PATH)/lib$(NET_LIB_NAME).a


ifconfig:    $(NET_LIB) ifconfig.o
       $(CC) $(LDFLAGS) -o ifconfig ifconfig.o $(NLIB) $(RESLIB)

来自 net-tools 的Makefile告诉我们，ifconfig工具的链接很简单。除了一个库文件以外，只需要ifconfig.o。默认情况下，没有指明 obj 文件生成方式的，都只是需要单个同名的C 源码文件 ifconfig.c。

尽快找寻main文件中的参数选项，我们只需要找到列举 eth0 信息的选项分支，其他赶快跳过。在ifconfig.c:288后以下段落，是我们关注的参数解析过程。

    /* Create a channel to the NET kernel. */
   if ((skfd = sockets_open(0)) < 0) {
       perror("socket");
       exit(1);
   }

   /* Do we have to show the current setup? */
   if (argc == 0) {
       int err = if_print((char *) NULL);
       (void) close(skfd);
       exit(err < 0);
   }
   /* No. Fetch the interface name. */
   spp = argv;
   safe_strncpy(ifr.ifr_name, *spp++, IFNAMSIZ);
   if (*spp == (char *) NULL) {
       int err = if_print(ifr.ifr_name);
       (void) close(skfd);
       exit(err < 0);
   }

首先，调用NET_LIB中的 sockets_open 函数创建 socket 链接；然后在无参数的情况下， if_print 打印所有网络接口信息；如果有参数，则将参数作为接口名称，将会打印对应接口信息。后者将是我们 `ifconfig eth0' 的参数情况，而 if_print 是唯一调用函数。

同一个文件(ifconfig.c)就可以看到if_print函数，看起来很简洁。

static int if_print(char *ifname)
{
   int res;

   if (ife_short)
   printf(_("Iface   MTU Met    RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg\n"));

   if (!ifname) {
   res = for_all_interfaces(do_if_print, &opt_a);
   } else {
   struct interface *ife;

   ife = lookup_interface(ifname);
   res = do_if_fetch(ife);
   if (res >= 0)
       ife_print(ife);
   }
   return res;
}

首先，如果ife_short有效，则打印表头。这是网络接口信息的简洁模式，使用`ifconfig -s'的效果正式如此，`-s'将设置 ife_short = 1，这在main函数解析参数时候已经完成。然后，分析参数，我们这里的ifname就是"eth0"，因此进入else分支。

下面深入到lookup_interfaces (lib/interfaces.c)

struct interface *lookup_interface(char *name)
{
   struct interface *ife = NULL;

   if (if_readlist_proc(name) < 0)
       return NULL;
   ife = add_interface(name);
   return ife;
}

紧跟着是 if_readlist_proc 和 add_interface，一个个来。

static int if_readlist_proc(char *target)
{
   static int proc_read;
   FILE *fh;
   char buf[512];
   struct interface *ife;
   int err;

   if (proc_read)
       return 0;
   if (!target)
       proc_read = 1;

   fh = fopen(_PATH_PROCNET_DEV, "r");
   if (!fh) {
       fprintf(stderr, _("Warning: cannot open %s (%s). Limited output.\n"),
           _PATH_PROCNET_DEV, strerror(errno));
       return if_readconf();
   }
   fgets(buf, sizeof buf, fh);    /* eat line */
   fgets(buf, sizeof buf, fh);

#if 0                /* pretty, but can't cope with missing fields */
   fmt = proc_gen_fmt(_PATH_PROCNET_DEV, 1, fh,
              "face", "",    /* parsed separately */
              "bytes", "%lu",
              "packets", "%lu",
              "errs", "%lu",
              "drop", "%lu",
              "fifo", "%lu",
              "frame", "%lu",
              "compressed", "%lu",
              "multicast", "%lu",
              "bytes", "%lu",
              "packets", "%lu",
              "errs", "%lu",
              "drop", "%lu",
              "fifo", "%lu",
              "colls", "%lu",
              "carrier", "%lu",
              "compressed", "%lu",
              NULL);
   if (!fmt)
   return -1;
#else
   procnetdev_vsn = procnetdev_version(buf);
#endif

   err = 0;
   while (fgets(buf, sizeof buf, fh)) {
   char *s, name[IFNAMSIZ];
   s = get_name(name, buf);
   ife = add_interface(name);
   get_dev_fields(s, ife);
   ife->statistics_valid = 1;
   if (target && !strcmp(target,name))
       break;
   }
   if (ferror(fh)) {
   perror(_PATH_PROCNET_DEV);
   err = -1;
   proc_read = 0;
   }

#if 0
   free(fmt);
#endif
   fclose(fh);
   return err;
}

一大长串，这该是我们现在遇到的最长的函数了，但是这个方法远远比想象的要简单的多，文件I/O就占据了老长。这个方法就是读取网络接口的列表，从那儿读取呢？我们一眼就看到了 ————

fh = fopen(_PATH_PROCNET_DEV, "r");

在 lib/pathnames.h 中看到其芳踪

#define _PATH_PROCNET_DEV "/proc/net/dev"

首先，探测是否已经检测过网络接口列表，咱们不作浪费时间的无用功。然后读取 /proc/net/dev，跳过文件的前两行。为啥？自己瞅瞅就知道了。

wick@ ~: cat /proc/net/dev
Inter-|   Receive                                                |  Transmit
face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
   lo:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0
 eth0: 3342410   31393    0    0    0     0          0         0 76194593   52347    0    0    0     0       0          0
 eth1:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0

接着解析参数，将得到的所有接口加入到列表中去（add_interface），然后依据格式填充 ife结构体(get_dev_fields)。这个结构体是自定义的，可以看到这个结构体是一个链表结构。get_dev_fields方法填充的是其中一个成员结构体，他在人群中是那么的耀眼：

struct user_net_device_stats stats;

他包含的就是统计信息数据，这些数据的来源就是/proc/net/dev。我们作的仅仅是读取这个文件信息而已……

你要问，还有其他的信息呢？诸如IP地址，MAC地址，ifconfig如何知道我的网卡是无线有线的呢？你就需要去看 if_fetch 函数了。从中你可以看到大量的ioctl调用，一切豁然开朗。

linux/net/core/dev.c

立刻来到内核的领地。

以上总结到统计数据信息的位置坐落于 /proc/net/dev，他是被谁写入的呢？要理解这个问题，你得先理解 PROC 文件系统。介于时间和能力原因，我只能大概解释， PROC 是内核和用户空间通讯的又一个接口，PROC fs是一个由软件创建的文件系统，我们需要追根溯源到创建 /proc/net/dev 的代码文件。

如果要问我是如何找到创建软件的代码？我不知道。我只知道最蠢的方法，google 和 grep。

好吧我是直接grep的……于是找到了 /net/core/dev.c。

/*
*    Called from the PROCfs module. This now uses the new arbitrary sized
*    /proc/net interface to create /proc/net/dev
*/
static int dev_seq_show(struct seq_file *seq, void *v)
{
   if (v == SEQ_START_TOKEN)
       seq_puts(seq, "Inter-|   Receive                            "
                 "                    |  Transmit\n"
                 " face |bytes    packets errs drop fifo frame "
                 "compressed multicast|bytes    packets errs "
                 "drop fifo colls carrier compressed\n");
   else
       dev_seq_printf_stats(seq, v);
   return 0;
}

我们直接看到这段，注释就包含了 /proc/net/dev 信息，由此可见，友好详细的注释是多么多么的重要啊…… 直接看方法，dev_seq_show 是文件中定义的struct seq_operations dev_seq_ops的成员，这就提到了 proc提供的seq接口，他使用简单的迭代器方法，使用 seq_open -> read_proc 就可以直接输出 proc文件的接口信息。如果你不熟悉 PROCfs 和 seq_file 接口，这一部分会有点凹口。

简单来说，当你使用open等系统调用打开 /proc/net/dev 的时候，系统将调用 seq_open 函数；相似的，当你使用read时，内核会使用 seq_show 来将实际数据传递到用户空间。我们的 `cat /proc/net/dev' 输出，就是这里的 dev_seq_show 打印的。

接着，是 dev_seq_show 中调用的 dev_seq_printf_stats 方法，他仅仅使用到了一个函数。不用多说，继续深入到dev_get_stats，他将是core模块此行的终点。

/**
*    dev_get_stats    - get network device statistics
*    @dev: device to get statistics from
*
*    Get network statistics from device. The device driver may provide
*    its own method by setting dev->netdev_ops->get_stats; otherwise
*    the internal statistics structure is used.
*/
const struct net_device_stats *dev_get_stats(struct net_device *dev)
{
   const struct net_device_ops *ops = dev->netdev_ops;

   if (ops->ndo_get_stats)
       return ops->ndo_get_stats(dev);
   else
       return &dev->stats;
}
EXPORT_SYMBOL(dev_get_stats);

多么有爱的注释啊……如果定义了设备驱动的 get_stats 方法，就调用 get_stats 调用获得信息，如果没有，直接返回设备写好的数据结构。

在这里真的需要强调注释的好处，简短的两句话，可以让代码的可读性激增啊！

感动之后，我们进入驱动，我现在使用的网卡是8139，相关的驱动是 8139too.c。

linux/drivers/net/8139too.c

8139too 驱动直接包含在内核里了，我们立刻去关怀他的 get_stats 函数。

static const struct net_device_ops rtl8139_netdev_ops = {
   .ndo_open        = rtl8139_open,
   .ndo_stop        = rtl8139_close,
   .ndo_get_stats        = rtl8139_get_stats,
   .ndo_validate_addr    = eth_validate_addr,
   .ndo_set_mac_address     = eth_mac_addr,
   .ndo_start_xmit        = rtl8139_start_xmit,
   .ndo_set_multicast_list    = rtl8139_set_rx_mode,
   .ndo_do_ioctl        = netdev_ioctl,
   .ndo_tx_timeout        = rtl8139_tx_timeout,
#ifdef CONFIG_NET_POLL_CONTROLLER
   .ndo_poll_controller    = rtl8139_poll_controller,
#endif
};

哦，简单直接，rtl8139_get_stats

static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
{
   struct rtl8139_private *tp = netdev_priv(dev);
   void __iomem *ioaddr = tp->mmio_addr;
   unsigned long flags;

   if (netif_running(dev)) {
       spin_lock_irqsave (&tp->lock, flags);
       dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
       RTL_W32 (RxMissed, 0);
       spin_unlock_irqrestore (&tp->lock, flags);
   }

   return &dev->stats;
}

这个函数实体只是重写了 dev->stats.rx_missed_errors，其他的信息我们直接 return。网卡状态信息 struct net_device_stats 已经在网卡驱动的其他操作方法中即时更新了。

总结

Ifconfig 使用了简单的文件I/O控制，读取 /proc/net/dev 文件来打印流量统计信息。此文件是 PROCfs 的一个组成，他的操作方法在代码 net/core/dev.c 中，其中 seq 接口的 show 方法可能调用了网卡设备驱动的 get_status 驱动方法来获得网卡信息。这些信息在网卡操作中会即时更新。

SCSI和SATA

2009-03-17T17:35:00.012+08:00

SCSI

概念

Small Computer System Interface, 它是一组在电脑和外围设备间实现物理连接和数据传输的标准集合。SCSI标准定义了命令、协议、电子和光学接口，它可以连接大量的外围设备。

SCSI 隐藏了物理设备接口的复杂性，算是一种智能设备
SCSI 是一个并行设备，可以将 8-16个SCSI设备连接到一根单独的总线
SCSI 是带缓冲的接口，使用了设备间的握手信号，支持出错检查
SCSI 是一个点对点设备，协议已经定义了三组标准：主机对主机，主机对外围设备，外围设备对外围设备

（两个SCSI连接器，via wikipedia）

SCSI历史

SCSI SPI，SCSI是个很老的协议（1981），至今经历了三代协议变换，也定义了三套标准SCSI1, 2, 3，SPI是对并行SCSI接口的统称。到了2008年，SPI开始被SAS所取代
SSA，现行的串行SCSI标准有三个，SSA，FC-AL，SAS，他们从SPI中独立出来，使用串口传输。
SAS, Serial Attached SCSI 是串行标准中最具活力的一个
iSCSI，在此不做讨论

ATA/ATAPI

概念

AT Attachment / AT Attachment Packet Interface (ATA/ATAPI) 是一套专门连接大容量存储介质的标准集合，这些设备包括有硬盘、固态硬盘、光驱等等。

ATA/ATAPI历史

IDE(ATA-1), 1994年，ANSI统一了IDE接口，诞生了ATA-1
EIDE(ATA-2), 西部电子公布了EIDE标准，催生出1996的ATA-2标准
ATAPI 是ATA标准的里程碑，它定义了一系列拓展命令，大大加强了ATA接口。他更可回应SCSI命令，被称之为"会说话的SCSI"。这个协议也叫"ATA/ATAPI-4"
Parell ATA, 2003年，SATA诞生了，由于他的出现，我们把以前的ATA称之为PATA。 ATA标准要求电缆长度最大为46cm，这限制了计算机存储技术的发挥。
Serial ATA, 2007年度，SATA已经全面取代PATA，它是现行ATA接口市场上的主流。注意，此时的Serial ATA的规范中就包含了SCSI SAS部分

（7孔SATA缆线和主板SATA接口，via Wikipedia）

SCSI和SATA

SCSI和SATA相比，速率要快上一些，但是其总线结构很复杂，自然成本也较高。SCSI总线支持多个驱动器连接（多个通道，一个通道连接7-15个设备）。而SATA只支持一对一，除非使用端口倍加器。

性能上看，SATA 3Gb/s 提供了 300MB/s 的传输速率，而SCSI可以达到 320MB/s，而且SCSI 驱动器可以提供更高的持久式吞吐量；兼容性上看，SATA 一般保留了向 SAS 的兼容性，而 SCSI 是不能直连到SATA总线上的。

总体上看，SATA总线更简单，保留了向SAS的兼容性，而且仍旧保持较高速率。SCSI的功能更强，拓展性更高，但其成本也较高。

索引

翻阅 C99 标准

2009-03-10T17:51:00.001+08:00

自从C89之后，C语言就没有经过大的改变。相比之下，C++的特性却是一天一个样儿，作为C 语言的超集，C++至今拥有了大量的特性，和多家库支持。为使C一样与时俱进，ISO 在99年制定了ISO/IEC 9899:1999，被后来称之为C99。

C99的重要更新有：

inline 方法
不一定需要在代码块开始位置定义变量
更多的类型支持：比如 long long int等扩展整形，复数类型等
支持变长数组
使用"//"但行注释
新的库函数，比如snprintf
新的头文件，比如stdbool.h
引入通用类型的数学方法，（tgmath.h, 包含math.h和complex.h，两者通吃）
改进的IEEE浮点支持
制定的初始化方法
混合迭代器
variadic 宏支持(不清楚)
restrict 支持，允许更深的代码优化

尽管C99也已经过去了10年，在我第一次摸的时候还是感觉很凹口和生疏，一方面自己的基础还是很薄弱，一方面标准性的文档往往追求经准而晦涩难懂。相信随着以后的学习，那些诸如multibyte char之类的字眼还会出现在我面前。

WIKIPEDIA:

http://en.wikipedia.org/wiki/c99

Open-Std 标准文档：

http://www.open-std.org/JTC1/SC22/WG14/www/standards.html#9899

GCC C99 Status:

http://gcc.gnu.org/c99status.html

EP93xx GPIO interface

2009-02-20T17:48:00.004+08:00

名词

AMBA是EP93xx采用的内部总线结构，他包含一个高速总线(AHB)和一个低速总线(APB)。

AHB (Advanced High-Performance Bus)，包含一个高速内部总线时钟，用来同步协处理器、MMU、cache、DMA控制器和其他内存模块。

APB (Advanced Peripheral Bus)，此总线就来连接一些低速并行设备，比如UART和GPIO。 AHB 和 APB 使用 AMBA 架构中的 AHB/APB 总线连接，

GPIO (General Purpose I/O)，GPIO在EP93xx中是APB的一个子模块，他提供简单的LED控制，可实现非常基础的调试功能（相当于printk?）。

GPIO

GPIO 包含两种类型和8个接口。

标准GPIO (port C, D, E, G, H)。每个端口包含两组寄存器
1. data reg x1
2. data direction reg x1
增强型的GPIO（EGPIO, port A, B, F)，包含三种寄存器
1. data reg x1
2. data direction reg x1
3. intr reg and status regs x?

标准GPIO的每个端口都包含一个8位数据寄存器（data regs）和另外的8位数据方向寄存器 (datadirection regs)。而EGPIO还会多包含一组8位中断控制寄存器。

ABF端口还包括了七个多余的寄存器。

GPIO Interrupt Enable registers (GPIOAIntEn, GPIOBIntEn, GPIOFIntEn)
GPIO Interrupt Type 1 registers (GPIOAIntType1, GPIOBIntType1, GPIOFIntType1)
GPIO Interrupt Type 2 registers (GPIOAIntType2, GPIOBIntType2, GPIOFIntType2)
GPIO End-Of-Interrupt registers (GPIOAEOI, GPIOBEOI, GPIOFEOI)
GPIO Debounce registers (GPIOADB, GPIOBDB, GPIOFDB)
Interrupt Status registers (IntStsA, IntStsB, IntStsF)
Raw Interrupt Status registers (RawIntStsA, RawIntStsB, RawIntStsF)

GPIO 初始化

系统复位的时候，GPIO 会执行初始化。

所有端口的 data reg 和 data direction reg 都将清零，设置为 input 方式
Port E[1:0] 用来表示 RDLED 和 GRLED，他们将会被置高，也就是 0x11
Port G[3:2] 用来表示 SLA[1:0] 输出，他们被置低。
Port G[1:0] 用来表示 EEDAT 和 EECLK，设置为 input 方式
所有的中断控制寄存器和祛抖动寄存器都被清零

GPIO端口和针脚映射

EP93xx的阵脚情况不一样，后继版本的板子总是多了点，下面只是列出EP9301/EP9302的针脚映射：

主板针脚名称	位于GPIO模块上的端口
EGPIO[7:0]	Port A
EGPIO[15:8]	Port B
GRLED1	Port E0
RDLED2	Port E1
EECLK3	Port G0
EEDAT4	Port G1

GPIO 寄存器映射

鉴于GPIO寄存器很多，我也就不列出来了。

只是说几个要点。

PADR ― PHDR，数据寄存器
- 读取这些寄存器将会返回GPIO模块输入端口的值（由PXDDR控制），默认情况是缺省端口映射下的端口状态信息。
PEDR，他的bit[1:0]提供了LED 驱动方法，默认是0x11
RAWSTATUSx，共三个寄存器。显示了无关针脚的读取状态

寄存器索引

略

引用

EP9302 User's Guide

新章：试用LXDE Desktop Environment

2009-02-17T21:39:00.002+08:00

闲聊

好了，很长时间没写字，我都不知道如何动笔了。

其实不是不想写，也非过年过皮实了，而是这些天都在忙活。从过年来，天天加班到九点，回到家里还要折腾自己的小窝，面对邪恶的加菲，我在家里几乎无所事事。但是我也没闲着，天天折腾到两三点，至于我干什么？我在折腾这两年累计的东西呢。

就说今天干了什么吧。

新手接触 LXDE

我今天测试了一下新的桌面环境LXDE，这是来自彼岸的台湾同胞洪任谕开发的（他同时也是 PC Man文件管理器的作者）。LXDE是非常小巧的羽量级桌面环境，他的桌面组建加载的很少，这样本身的代码量就比较小（加起来总共只有9M左右），这样运行起来就很快很快。

LXDE采用了openbox作为窗口管理器，这个东西也是非常的迅速。使用的文件浏览器是看家的 pcmanfm，一些官方维护的组件如下：

PCManFM，文件管理器，类似于Nautilus
LXLauncher，一个快速启动面板
LXPanel，简洁的桌面面板，类似于 gnome-panel
LXSession，会话管理器
LXAppearance，主题管理器
LXSessionEdit，进化的任务管理器
Leafpad，默认的记事本
Xarchiver，内嵌的归档管理器
GPicView
LXTerminal
LXTask
LXNM
Openbox
LXRandr，屏幕管理器，可以管理多个屏幕的分辨率，刷新频率等等，大赞！
LXShortCut，用来快捷方式
LXMusic
LXDE Common
GtkNetCat

希望

目前的LXDE还是太少，跟树大根深的GNOME自然无法比，但是LXDE有着很多的先天优势。对于我来说，LXDE还需要改进的是：一个快捷键管理工具，虽然你可以手动编辑 ~/.config/openbox/lxde-rc.xml；一个很好的桌面字体渲染引擎；采用更多的轻量级应用软件，比如Office，画图等等；增强PCMan文件管理器功能，当然这要建立在不牺牲速度和性能的基础之上，毕竟这是LXDE的设计哲学。

安装 LXDE 请看：

http://en.gentoo-wiki.com/wiki/LXDE

追踪 LXDE 社区线索：

http://www.lxde.org/join_lxde_community

截图

游历深圳博物馆 (Shenzhen Museum)

2009-01-18T17:33:00.013+08:00

深圳博物馆位于福田区市民中心的东部，新馆于12月25日开馆，由此免费向公众开放。

博物馆主题重要的有三个，古代深圳、近代深圳和深圳民俗文化，以此分别设置三个主题展
厅。这三个展厅相当相当的长，里面的玩意儿非常之多，很对得起2.4亿的造价啊。。。

我和大黄俊丽三人浩浩荡荡的来到深圳博物馆，开始长游，因为展品繁多，地形复杂。我只
说说几个非常重要的 ————

中国国家典藏精品展览
先是一楼，中国国家典藏精品展览。你可以看到很多在历史书里翻看到的东西，包括四羊方
尊、战神之鸟、铜面具、青瓷莲花尊等等等等。未能想到在这里就见到我朝思暮想的宝贝啊～

四羊方尊，在历史书籍里的出境率非常之高。

战神之鸟，基本看不出来是只鸟。

编钟，1952年中国首次使用编钟演奏了《东方红》。

兵马俑，让我想起了The Mummy!

金缕玉衣，大黄坏坏的给了这样一个特写。

重点的重点啊！青瓷莲花尊的做工非常精美呐，介绍词给的非常庄严——涅磐之舟！

民俗文化厅
然后是二楼，民俗文化展厅，里面展示深圳古色古香的民俗风情。里面大多来自清朝和近代
的一些民间情景，其中各个情景中的泥偶人物非常逼真。第一次看到的时候吓我一跳:(

官员展示农耕的场景。

古代展厅
这个似乎在说深圳的悠长历史，可是我印象中这是深圳的薄弱之处。抱歉，我这里没有好的
素材。

近代展厅
此展厅讲述深圳从鸦片战争以来的发展历史。

民国时期的成绩单，看看那时候的科目：国语，算术，历史，自然，地理，图画，美术等等
……

旧式缝纫机。我真的不觉得很旧，因为老妈还有一个缝纫机，形状神似。

罗湖火车站的旧景。

抗日战争中使用的武器，我总以为解放军最先进的是驳壳枪……

现代展厅
深圳所具备的魅力，毫无疑问被定格在了现代。作为改革开放的试点城市，深圳引进外资，
对外开放，成就了神话般的成长速度。这个地方看到的东西就非常新奇了。

恨死这家伙，把我照片拍的血肉模糊……

模拟的深圳特区全景，包括了关内的四个区。

超级乐高机器人！太太太酷了，我还在szlug里贴给他们看呐，只可惜我不能碰它:P

展示深圳金融系统推出的各种卡：银穗卡，一卡通，信用卡。教条内容：2000年深圳率先建
立以银行、证券、保险为主体，其他类型金融机构并存的现代金融体系。

深圳湾码头，被大堆的集装箱所淹没。

这一切的始作俑者，邓公。

谢谢欣赏。

初学sed

2009-01-09T18:19:00.002+08:00

sed, awk等等UNIX下的工具初看显得晦涩又难用，就些命令行搞那么复杂干哈子呀。

不过一旦掌握以后就能发现给日常操作带来很大好处，那些简洁高效的命令行可都有着悠久的历史了……

因此在学习他们之前，告诫自己：Don't get confuSed~

这里的例子全部来自ibm developerworks。
http://www.ibm.com/developerworks/linux/library/l-sed1.html

# 基本篇
sed -e 'd' /etc/services #删除所有行，因此没有输出
sed -e '1d' /etc/services | more #删除第一行
sed -e '1,10d' /etc/services | more #删除1-10行

# 正则篇
sed -e '/^#/d' /etc/services | more #删除注释
sed -n -e '/regexp/p' /path/to/my/test/file | more #打印匹配regexp的行
#-n 标示只打印regexp匹配字符，-e针对文本，-f将指定sed 脚本

#标准的正则符号有
# ^: matches all begin with...
# $: matches the end of the line...
# .: matches any single char
# *: will match zero or more occurences of the previous char
# []: matches all the characters inside the []

sed -n -e '/BEGIN/,/END/p' /my/test/file | more
#打印一个范围，首行包含BEGIN, 尾行包含END

sed -ne '/main[[:space:]]*(/,/^)/p' tmp.c
#打印main函数

# 替换篇
sed -e 's/foo/bar/' myfile.txt #找到第一个foo，替换为bar
sed -e 's/foo/bar/g' myfile.txt #全局替换
sed -e '1,10s/foo/bar/g' myfile.txt
sed -e '/^$/,/^END/s/foo/bar/g' myfile.txt
#以最前的空行为开始，END字符结束

sed -e 's:/usr/local:/usr:g' myfile.txt
#改变操作服为`:'

sed -e 's/<[^>]*>//g' myfile.html
#原文本: This is what I want
#改变后: This is what I want.

sed -e 's/.*/ralph said: &/' myfile.html
#在所有首行添加"ralph said: "

sed -e 's/\(.*\) \(.*\) \(.*\)'/Victor \1-\2 Von \3/' myfile.txt
#原文本:
# foo bar oni
# eeny meeny miny
#改变后:
# Victor foo-bar Von oni
# Victor eeny-meeny Von miny

sed一般用来 (via builder.com)—

Double/triple-space a file
转化DOS/UNIX 的新行（newline）
删除前后的空格
在所有/全部行上进行取代操作
删除连续的空行
删除文件开头和结尾的空行

ARM Linux 启动过程 (1)

2008-12-25T10:55:00.005+08:00

此系列记录了ARM Linux从Bootloader部分到Linux初始化，然后进入C环境的一段坎坷历程。作为第一部分，我将从RedBoot开开始。RedBoot是嵌入式中应用广泛的Bootloader，他将作为此系列的序章。

RedBoot (bootloader)

概述
RedBoot所作的工作

概述

（本示例讲解基于ARM9的Cirrus EP9302） Bootloader 在 ARM 中依然是加电后的第一道程序，其作用简单，相当于 PC 机器上的 BIOS 固件程序。Bootloader 负责完成系统初始化，它将非易失性储存器中的 Linux 内核拷贝到 RAM 中去，然后跳转到内核的第一道指令，将控制权交给内核。从这个意义上讲，嵌入式 Bootloader 要做的事情比 x86 等机器多很多。

一般ARM Linux的第一条指令地址是0x0000_0000，而通常嵌入式系统会将FLASH等存储寄存器映射到这个地址，而Bootloader就位于该存储器顶端，这保证了Bootloader的顺利执行。

以 RedBoot for EP93xx 为例，EP93xx 采用 NAND Flash 作为存储介质，在 RedBoot 中可以罗列存储器的根目录如下：

RedBoot> fis init
Name              FLASH addr  Mem addr    Length      Entry point
RedBoot           0x60000000  0x60000000  0x00040000  0x00000000
RedBoot config    0x60FC0000  0x60FC0000  0x00001000  0x00000000
FIS directory     0x60FE0000  0x60FE0000  0x00020000  0x00000000
zImage            0x60040000  0x00080000  0x00120000  0x00080000
ramdisk           0x60140000  0x00800000  0x00800000  0x00800000

这里可以看出在 Flash 文件系统中存储了他的系统文件 RedBoot（内核）、RedBoot config（设置信息）、FIS directory（系统目录），另外就是 Linux 的内核 zImage 和内存盘 ramdisk.gz。

RedBoot做的工作

SDRAM初始化，没有内存，啥东西也玩不转 (cyg/hal/hal_platform_setup.h)
初始化串口 (hal/arch/ARCH/src/hal_diag.c)
检测处理器类型 (宏指定，cdl/hal_ARCH_MACHINE.cdl)
设置Linux启动参数 (hal/ARCH/arch/src/redboot_linux_exec.c)
将Linux内核装载到内存中，跳转执行

启动内核

启动内核函数do_exec的这段代码在 hal/ARCH/arch/src/redboot_linux_exec.c，最重要的就是末尾处的内联汇编语句：

    asm volatile (
      CYGARC_HAL_MMU_OFF(%5)
      "__tramp_start__:\n"
      " cmp %1,%4;\n"       // Default kernel load address. Relocate
        " beq 2f;\n"          // kernel image there if necessary, and
        " cmp %2,#0;\n"       // if size is non-zero
        " beq 2f;\n"
      "1:\n"
      " ldr r0,[%1],#4;\n"
      " str r0,[%4],#4;\n"
      " subs %2,%2,#4;\n"
      " bne 1b;\n"
      "2:\n"
      " mov r0,#0;\n"       // Set board type
        " mov r1,%3;\n"       // Machine type
        " mov r2,%6;\n"       // Kernel parameters
        " mov pc,%0;\n"       // Jump to kernel
        "__tramp_end__:\n"
      : :
      "r"(entry),
      "r"(CYGARC_PHYSICAL_ADDRESS(base_addr)),
      "r"(length),
      "r"(CYGHWR_REDBOOT_ARM_MACHINE_TYPE),
#ifdef CYGHWR_HAL_ARM_EDB93XX_VARIANT
      "r"((CYGHWR_REDBOOT_ARM_LINUX_EXEC_ADDRESS & 0x3ffffff) +
          ConfigInfo[3]),
#else
      "r"(CYGHWR_REDBOOT_ARM_LINUX_EXEC_ADDRESS),
#endif
      "r"(CYGARC_PHYSICAL_ADDRESS(CYGHWR_REDBOOT_ARM_TRAMPOLINE_ADDRESS)),
      "r"(CYGARC_PHYSICAL_ADDRESS(CYGHWR_REDBOOT_ARM_LINUX_TAGS_ADDRESS))
      : "r0", "r1"
      );

首先关闭MMU，保证代码跳转位置是绝对的物理地址，然后重置内核（如果需要）到entry处，执行跳转，跳转前保证了：r0置0，r1装载机器类型，r2装载struct tag数组地址。

这样RedBoot结束了其短暂而又伟大的一生，我们进入Linux的世界。

优化代码显示的另一个方法

2008-12-12T11:54:00.002+08:00


int main(void)
{
       printf("Hello, everybody!\n");
}
/* 为啥空出那么多呢？*/

参考：
http://klcintw4.blogspot.com/2006/11/blog-post_03.html

Linux SCSI子系统

2008-12-10T10:16:00.006+08:00

scsi历史

scsi-1::1979年由SHugart Associates创建，它定义了一种具有5MHz数据时钟的8-bit并行接口。

scsi-2::1985年，10MHz，16位总线。

scsi-3::1993年，已经成为了一种标准集，它包含一种命名为Ultra的并行scsi标准和基于串行scsi和基于串行scsi的协议，这些标准通过引入存储网络技术将数据速率拓展到了 1Gb/s。

scsi架构基础

如果你是一位设计师，那么需要从scsi spec下手。而对于软件开发人员来说，你只需要关注scsi的架构。在深入之前，将scsi架构图牢记于心，对于理解代码是非常重要的。linux scsi位于系统的底层 —

linux scsi本身是一种三层架构，upper, mid, lower，upper层最为接近内核，包括一组驱动器（比如块设备SCSI 磁盘和字符设备SCSI generic）；mid实现了common services layer，接受upper的请求并将其转化为scsi请求，scsi lower层则是紧附硬件之上的硬件驱动。

索引

从ibm developerworks大致了解三层架构：

http://www.ibm.com/developerworks/cn/linux/l-scsi-subsystem/

从这里获得scsi标准的细节：

http://www.t10.org/

我们的目标在于linux的实现(pdf, 321KB)：

http://developer.osdl.org/dev/opendrivers/documentation/scsi_design_analysis_2_6_v2.pdf

出发

本着记录和总结的目的，深入求实的精神，我开始在日志上记录scsi的看书笔记。scsi的设备是典型的层次架构，经历过风雨变迁的scsi标准也散发着蓬勃的活力，因此看懂这段代码很有意义。

笔记目标将会从sd_mod.o起步，清晰中间层（mid），上层（upper）和底层（lower）的大致架构，最后深入到公司最近正在移植的sata_sil驱动。

使用muse来发布日志

2008-11-28T16:27:00.005+08:00

使用Emacs是一件实在幸福的事情，它提供了一个又一个强大的拓展，让你的上机活动变的
轻松惬意。很多Linux用户都是以Emacs为中心的。而我现在使用ECB阅读代码，diary-mode
来撰写笔记，org-mode来组织日程规划……这次说到使用muse模式。

muse允许通过简单的样式控制，制作出非常漂亮的网页。

控制基本样式
高亮代码

控制基本样式

很简单的，我先给出几个例子。

#title 第一个Wiki页面
* 一级标题
** 二级标题
*** 三级标题
#anchor
段落需要空行两个（至少）
  居中字前只少空四格
----

这是 *着重* 的文字，这是进一步 **着重** 的文字，这是 ***更进一步的着重*** 的文字

这是 _下划线_ 文字，这是 =等宽verbatim and monospace= 的文字
*** 列表：
- 无序列表需要以空格和“-”开头
1. 有序列表需要以空格和数字序号开头
字典 :: 名词定义需要以“::”分隔名词和所定义文字
- 列表也可以嵌套
1. 列表嵌套深度按照开头空格的多少来控制
2. 可以继续嵌套不同类型的列表
 - 比如这样
*** 表格：
Double bars  || Separate header fields
Single bars   | Separate body fields
Here are more | body fields
Triple bars ||| Separate footer fields

生成的页面：

高亮代码

高亮代码是一个比较头疼的问题，大家给出的方案也不一样。在blogger中，你可以使用
Google的prettyprint方法来实现高亮，但是它支持代码样式很少；同样2maomao也写了一个
高亮语法的工具，相对来说总是麻烦点；其实使用emacs高度的拓展性完全可以做到这点。

这里给出了一个使用muse来实现语法高亮的模式，这个方法非常的cool。它将emacs强大的
高亮特性报留下来，嵌入到了html中。

阅读上面的例子就可以看到，通过很少的字符，就可以实现工整的格式控制，这对于编写繁
杂冗长的标志语言和记住大批的标记来说，是一种极好的替代。muse编写的脚本可以简单的
声称很多种文档发布，包括HTML，Latex，PDF等等，多多使用，也自然可以可以极大提高工
作效率。

参考资料

eCos HAL分析

2008-11-27T17:38:00.001+08:00

HAL架构

HAL在eCos中是一个多层次的架构，层级封装了不同的功能，它包括：

the architecture HAL

架构抽象包含基本的CPU架构，比如interrupt，上下文切换，CPU启动等
the variant HAL

变体抽象层专注某一CPU的特性，比如caches，MMU和FPU等，他通常也处理内存和中断控制器等外设。
the platform HAL

平台抽象层专注于现任的平台特性，比如平台启动，定时器，I/O寄存器访问和中断控制器等等。

HAL接口

这里讲究HAL实现了哪些接口。

architecture characterization

这里包含了CPU基础架构的定义。包括了CPU段文存储格式，上下文切换，bit twiddling，断点，堆栈大小和地址转换。这些定义位于：

cyg/hal/hal_arch.h (arch HAL)
cyg/hal/var_arch.h (var HAL)
cyg/hal/plf_arch.h (plf HAL)

以下为议题细节

register save format
thread context initialization
thread context switching
bit indexing
idle thread activity
reorder barrier
breakpoint support
GDB support
setjmp and longjmp support
stack sizes
address translation
global pointer

interrupt handling

这些接口定义了中断处理相关的定义，包括了异常和中断号，中断允许和屏蔽和实时时钟操作。这些定义可以位于：

cyg/hal/hal_intr.h (arch HAL)

而变体和平台抽象层定义位于：

cyg/hal/var_intr.h (var HAL)
cyg/hal/plf_intr.h (plf HAL)
cyg/hal/hal_platform_ints.h (?)

议题细节：

vector numbers
interrupt state control
ISR and VSR management
interrupt controller management
clock control
microsecond delay

HAL I/O

此接口定义了对设备控制寄存器的访问支持。

cyg/hal/hal_io.h
cyg/hal/var_io.h
cyg/hal/plf_io.h

议题细节有：

cache control

此接口定义了CPU caches的控制支持。

cyg/hal/hal_cache.h
cyg/hal/var_cache.h
cyg/hal/plf_cache.h

详细议题：

cache dimensions
global cache control
cache line control

Linker scripts（连接器脚本，lds）

连接器脚本对于eCos程序来说是必须的，他定义了内存区域，地址和尺寸，代码段和数据段的放置位置，还有分配不同的编译器声称的段。

一般lds位于install/lib/target.ld，它事实上是由其他两类文件声称，一个基本的lds和 ldi文件声称的。

基本lds由arch HAL或者var HAL提供，它由一组lds段组成。ldi由plf HAL提供哦你，它包含目标平台的的内存布局信息，位于

pkgconf/mlt____.ldi

这些ldi文件都是由相应的mlt(memory layout tool)脚本生成的。

诊断支持

略

SMP支持

略

参考资料

Cirrus EP9302: 从RedBoot到Linux

2008-11-25T14:19:00.007+08:00

Cirrus EP9302

Cirrus Logic是美国德州的一家半导体制造商，早在1989年就进入NASDAQ，股票代码是CRUS。
EP93xx是基于ARM920T的主板系列，在官方上你可以看到详尽的EP9302资料。

http://www.cirrus.com/en/products/pro/detail/P1066.html

EP9302和EP9301最大的区别就在于，CPU核心加入了一个浮点运算部件MaverickCrunch。

我在开始的时候曾经说过，eCos支持非常多的架构，包括ARM， CalmRISC, FR-V, H8,
IA32, M68K, Matsushita AM3x, MIPS, NEC V8xx, PowerPC, SPARC, SuperH。这是eCos非
常值得骄傲的一点，也充分发挥了开源的长处。但是毕竟世界上的主板千千万，从汽车到蓝
牙，无线设备等等等等，eCos开发小组也无法支持所有的主板。如果厂商新推出一个主板，
那多半需要自己拓展eCos来支持自己的新板，我所使用的Cirrus Logic就是一个例子。

你可以在官方网站上找到这些工具：

cirrus-arm-linux-2.0.8-full.tar.bz2 (Cirrus Linux套件)
arm-elf-gcc-3.2.1-full.tar.bz2 (arm-elf-gcc)
arm-linux-gcc-3.4.3-1.0.1.tar.bz2 (arm-linux-gcc)

搭建工作环境

(此工作环境是在Red Hat Linux 9.0下配置完成，嵌入式开发普遍需要串口支持。)

解压arm-elf-gcc-3.2.1-full.tar.bz2得到两个目录，按照目录指引放置文件

在/etc/profile或者~/.bashrc中添加系统环境变量。比如 /etc/profile

if [ `id -u` = 0]; then
 pathmunge /sbin
 pathmunge /usr/sbin
 pathmunge /usr/local/sbin
#newly added for arm-3.4
        pathmunge /usr/local/arm/3.4/bin
fi

配置安装redboot

这步会非常简单。Cirrus几乎把一切工作都做好了，解压cirrus-arm-linux-2.0.8.tar.bz2
进入目录 cirrus-arm-linux-2.0.8/edb9302，直接编译

cd /path/to/cirrus-arm-linux-2.0.8/edb9302
make redboot

然后得到cirrus-arm-linux-2.0.8/edb9302/images/redboot.bin，这就是一个redboot内核，
他使用了ecos的redboot模板，创建针对EP9302主板的ecos内核。安装也是比较方便，这使
用到了cirrus给的download工具（如果没有，你还需要编译）：

../download/download -p 1 images/redboot.bin

通常情况下，我们的主板都是不允许FLASH被任意擦写的，这个规定在硬件上被强制实现：
用短路块连接EP9302的JP14的2、3脚。相反接到1、2脚，这个时候Flash会根据写入的协议
向外发布数据，待download侦测到数据时候会进行握手和数据传递。

然后关闭主板，进入EP9302，则可以进入Redboot命令行。

编译烧录linux

# busybox config
cd /path/to/cirrus-arm-linux-2.0.8
tar jxf tarballs/busybox-1.1.3.tar.bz2
cd busybox
make menuconfig

# compile ramdisk.gz
cd /path/to/cirrus-arm-linux-2.0.8/edb9302
make ramdisk

# compile linux zImage
make linuxconfig
make linux

这样就在/path/to/cirrus-arm-linux-2.0.8/edb9302/images中生成两个文件：
ramdisk.gz和zImage。

其中busybox和linux都需要对自己需求的理解来进行配置，在这里不再赘述。这里将一下
linux拷贝方法。将Linux内核传递给EP9302，是使用到了tftp(Trival FTP)，首先需要配置
Red Hat 9.0主机的tftp客户端（/etc/xinetd.d/tftp），tftp常常用于无盘工作站。在这
里作为RH和EP9302的通讯协议。

然后进入EP9302 redboot配置主板（主要是网络）。

# ---- 主板配置部分 ----
# Local IP address是EP9302 IP地址
# Default server IP address是RH9 IP地址
RedBoot> fcon -i
Initialize non-volatile configuration - continue(y/n)
Run script at boot: true
Boot script:
Enter script, terminate with empty line
>> fis load ramdisk
>> fis load zImage
>> exec -r 0x800000 -s 0x800000
>>
Boot script(1000ms resolution): 1
Use BOOTP for network configuration: false
Gateway IP address: 192.168.16.1
Local IP address: 192.168.16.93
Local IP address mask: 255.255.255.0
Default server IP address: 192.168.16.91
DNS server IP address:
Network hardware address[MAC]:0x78:0x56:0x34:0x12:0x64:0x30
GDB connection port: 9000
Force console for special debug messages: false
Network debug at boot time: false
Update RedBoot non-volatile configuration - continue(y/n)? y

# ---- 拷贝文件部分 ----
RedBoot> fis init -f
RedBoot> load -v -r -b 0x800000 ramdisk.gz -h 192.168.16.91
RedBoot> fis create -b 0x800000 -l 0x800000 ramdisk
RedBoot> load -v -r -b 0x80000 zImage -h 192.168.16.91
RedBoot> fis create -b 0x80000 -l 0x120000 zImage

# ---- 重启 ----
RedBoot> re

重启EP9302之后，主板开机加载RedBoot，然后执行默认的启动脚本，加载ramdisk和zImage。
就这样我们进入Linux，第一次进入嵌入式Linux的感觉，是不是很奇妙？

西冲海岸线穿越

2008-11-23T23:34:00.005+08:00

深圳西冲，因为交通不便、偏离市区等天然原因，成为了深圳市最优美的海岸线。仅仅这一
点，就让俺们心里痒痒太多太多了，于是跟随大家一起到西冲鹅公湾穿越海岸线。

到了地方才知道，西贡此行比想象的艰难太多了。活动选取了西贡->鹅公湾这一非常变态的
路线，海岸边的岩石形状大小各异，沟堑无数，深浅不一。在石头间上串下跳，实在是极其
消耗体力的事情，也有部分人受伤。

从下午一点到达海岸开始，接下来的五个小时都要接受如此费力的考验，同时身负重物，真
是让我苦不堪言；更可惜傍晚涨潮，潮水变凉，没能有机会下水。回来时候也已无力气打字，
只能更新照片来看。（PS:不过海景实在是太美了）

回头一看，我也在几个月内到访过梧桐山，老虎涧，塘朗山，排牙山，大小梅沙，西冲海
岸……至此，我也几乎整完深圳所有的著名户外景点，我想可能需要转换一下目标了。当然下
个目标是啥？还没有想过。不过类似户外的活动，我将会愈少的参与。

（以下猛击可查看大图）
---- 登山部分 ----

---- 海岸线部分 ----

---- 结束部分 ----

Thx for you time!

eCos，高度自制性的嵌入式操作系统

2008-11-22T18:50:00.001+08:00

eCos, embedded configuratable os. 这个名字很好的说明了这个操作系统的特性，高度可配置的嵌入式操作系统。他现在是非常流行的嵌入式操作系统，支持很多嵌入式平台（远远不只是ARM平台），而且配置简单。他原先是由Cygnus开发，后来归于Red Hat旗下。

安装

你可以按照官方的方来安装eCos，使用脚本来完成整个下载和安装过程很方便，这个过程安全但是不可靠。其实本质上需要的就是下载两个包，和一套安装方法。

解压后的目录可以放置在任意位置（例如/opt/redboot），然后在此目录下创建以下脚本— (记住设置系统环境变量ECOS_REPOSITORY)

#!/bin/sh
export ECOS_DEST=/opt/redboot
export ECOS_REPOSITORY=$ECOS_DEST/ecos-2.0/packages/
export PATH=$PATH:$ECOS_DEST/gnutools/i386-elf/bin/:$ECOS_DEST/ecos-2.0/tools/bin


rm build -rf
mkdir build
cd build
# ecosconfig new TARGET [template [version]]
# -- create a configuration file: ecos-2.0/packages/ecos.ecc
ecosconfig new pc redboot

# ecosconfig import
# -- import additional config info
ecosconfig import ${ECOS_DEST}/ecos-2.0/packages/hal/i386/pc/v2_0/misc/redboot_FLOPPY.ecm

# ecosconfig tree
# -- create a build tree
ecosconfig tree
make

这样就得到一个裸露的内核redboot.bin，可以制作一个启动软盘，来在虚拟机里测试它。

ecos术语

package

parcket关键字对应一组完成独立功能的代码包，他可以内嵌cdl脚本，来容纳更小的单位，如cdl_option和cdl_component。 option和component是更小的代码元素，在解析之后将会成为C语言的宏。比如：

cdl_option CYGSEM_REDBOOT_DEFAULT_NO_BOOTP {
  user_value 1
};

生成在.h文件，就是 CYGSEM_REDBOOT_DEFAULT_NO_BOOTP 1

target

target指定某种目标架构，关键字下将会定义很多的packet，来设置需要的组建和代码包。

target edb9302 {
 alias       { "Cirrus Logic EDB9302 evaluation board" ep9302 }
 packages    { CYGPKG_HAL_ARM
               CYGPKG_HAL_ARM_ARM9
               CYGPKG_HAL_ARM_ARM9_EP93XX
               CYGPKG_DEVS_FLASH_STRATA
               CYGPKG_DEVS_FLASH_EDB9301
               CYGPKG_DEVS_ETH_ARM_EP93XX
     }
 description "
The EDB9302 target provides the packages needed to run eCos on the Cirrus Logic
EP9302 based development boards."
 set_value CYGHWR_HAL_ARM_EDB93XX_VARIANT "EP9302"
}

此target旨在建立edb9302，他会包含packets中指明的packet，并且设置宏 CYGHWR_HAL_ARM_EDB93XX_VARIANT "EP9302"

template

template是指为某种目的build而建立的相应模板配置，比如选取一些包，配置一些选项等等。在目录 ecos-2.0/package/templates 下面有一些模板的目录。

文件 ecos.db

ecos-2.0/packages/ecos.db是ecos的选项总表，是维系整个ecos代码的数据库。他定义了全部的target和target所需要packets。ecosconfig将从中获取信息，构建ecos.ecc，从而完成代码树的构建。

文件 ecos.ecc

由ecosconfig声称的目标代码的设置文件，他包括了生成目标代码所需的所有选项配置，包括了template, option，component等等等等。ecos.ecc有可能包含有冲突的部分，你需要解决这些冲突，然后ecosconfig tree 声称代码树。

解释刚才的redboot.sh脚本

ecosconfig new pc redboot

此命令来创建一个针对target pc的ecc脚本，他将选取redboot作为模板。根据模板和 ecos.db，ecosconfig会向ecos.ecc脚本放置所有可能的组建，选项和包集合。

ecosconfig import ${ECOS_DEST}/ecos-2.0/packages/hal/i386/pc/v2_0/misc/redboot_FLOPPY.ecm

引入ecm设置，表明我们选择的启动媒体是软盘，你也可以选择其他介质。

ecosconfig tree

根据ecos.ecc来生成代码集合，之后make，完成编译安装。

eCos架构

这是一个ecos的系统框图，框图重点突出了Hardware Abstraction Layer在eCos中的重要作用。如果要领悟这些，还需要参看eCos代码。

这里重点表述了redboot模板的eCos系统架构，redboot相当于是一个bootloader，但是他的作用远远不只是启动内核那么简单。除了提供网络功能，他还包括了硬件初始化，调试，文件系统等等功用。是嵌入式中应用非常广泛的bootloader。

有空下次聊聊eCos的源代码架构。

http://en.wikipedia.org/wiki/ecos
http://ecos.sourceware.org/
http://www.ecoscentric.com/ecos/ecospro.shtml

脚踏排牙山顶

2008-11-17T20:31:00.009+08:00

这次活动去了排牙山，排牙山位于深圳龙岗区的大鹏半岛，这里也是深圳的最东边。大约也
是深圳最后一片未开发的原始森林。这里保持了古森林的特色，大鹏半岛三面环海，景色非
常秀丽，山下是大亚湾，坐落着出名的大亚湾核电站。不过要欣赏美景就要付出代价，排牙
山上没有护栏和石阶，为开发的山路会考验你的脚力，而且排牙山山脉险峻，个别路段陡峭，
给出行带来很大难度。

组织：17爬爬吧
领队：阿文，黄瓜，阿鹏
合作：朗森户外
报名：91人
难度：标准+
地图：点击这里

前面罗嗦了很多，讲的就是此行的意义：能够在艰难的环境中披荆斩棘，会当绝顶，领略到
大鹏美景，这毫无疑问是最有成就感的。排牙山旅途将会经历险要的山路，连绵的山峦，似
乎是在牙齿顶端上下起伏，相信这也是排牙山得名的由来。
（猛击图片查看大图）

经历山顶的起伏，这一路真是险象环生，有部分人中途退出，也有体力透支情况出现。可以
想象排牙山的难度。如果各位朋友要征服排牙山，那定要足够的体力和意志。多人出行需要
作足准备，从登山鞋到活络油不一而足。

下山段也绝对不轻松，很多地方陡峭而且土质疏松。有朋友在这里摔跤和抽筋。

这次旅程在艰险中度过，除了放弃以外，还有中途退出，体力透支，小腿抽筋等意外情况发
生。在后半段过程因为抄近路的原因，领队选择了一段溯溪线路，这段路途很有难度，而且
在六点半钟情况攀爬岩石，大家着实受了苦头。

最后和同行聊天才得知，这次是一次商业性的组织活动，朗森是东莞的一家专门组织户外互
动的公司，本次活动公召集81人参与报名，预计实际参与人数在75人左右。而领队大约只有
6人，而且分布不足，介于人数过多，在旅途中很少得到周围的援助，毕竟认识的人不多，
而且领队都远远的跑在了前面，所以登山之旅实在有些焦躁。如果下次仍旧有此类活动，我
当考虑参与队伍的规模和组织形式。

最后的图片，容易让人产生遐想：

_

正版软件距离我们多远

2008-11-16T00:12:00.004+08:00

最近喧闹的微软黑屏事件影响力可谓波涛汹涌，各方都对此事表达自己的观点。其实形式如
何，大家心知肚明。然而无论是为自己使用盗版谋权力的个人用户，还是正版用户的铁杆支
持者，都对国家的软件产业抱有怀疑态度——正版推广，真的很难。

前些天，深圳第一现场也对此事进行了报道，文中表达了自己对微软黑屏事件的看法：

首先是加大正版软件使用力度，维护软件开发人员和发布厂商权益。

另一方面是减少对单向软件的依赖度。且拿Linux的发布版本Ubuntu为例，推介软件用户除
微软产品以外的更多选择（这里的Ubuntu还打印错了……）。

还有一方面，是加大国有软件的扶植力度，培养有竞争力的自身软件产业。这个例子选取了
最近推出的个人免费版本的WPS国产办公软件。

不过在我看来，国家和媒体对软件权益的认知都建立在软件版权的基础之上，这个出生于微
软之手的概念为微软等软件商带来丰厚的利润。大家可以尝试一下GNU系列软件，他立志于
推广自由软件产业，也尝试保护开发者的权益。Linux就是GNU旗下软件，遵循GPL条例。

山清水秀塘朗山

2008-11-02T22:35:00.007+08:00

这次户外活动选择了塘朗山，塘朗山位于南山北部，是宝安和南山的北部分界线；拥有西丽
水库和梅林水库两个水源，山水秀丽，而且攀爬容易，属于休闲娱乐级别。可谓是居家旅
游，避暑游乐之必选之地……

组织：狼行天涯③(Q群 63191237)
领队：wolf, 小雨
说明：桃源村，螳螂山顶，东部穿越到梅林水库
地图：
http://maps.google.com/maps/ms?ie=UTF&msa=0&msid=102563878911537749872.00045ab3e58dd543dec97

废话不说，启程带你们领略秀丽的山水咯~

这里是桃源村的塘朗山入口。进入正门之后就可以上东边坡路，这条道路开发的非常好！阶
梯让攀爬更加容易。深圳城市这一点让人很是欣慰，梧桐山，大南山等大约所有的景点开发
的非常不错。

桃源村这一段路，难度不高。因为路程短暂，不消一会儿，就可以到达山顶。在这里可以看
到深圳梅林一代的城市景观。早上的雾气和蹩脚的技术，让照片技术打了折扣。

12点后开始东移，沿着塘朗山脉起伏升降，三、四十人的队伍也是够壮观的。我们在一个平
台处开始吃午饭，中途有家伙开始打牌。扑克……平民化的艺术！

梅林段的地势开始恶劣起来……山道变的崎岖，沿着溪流而下，甚至有了溯溪的感觉。大家都
没有任何准备，路途变得缓慢艰难。不少人失身于此。

到达一个小瀑布的时候，路途的艰难程度达到最大，山路陡峭。但这也是后半段景色嘴秀丽
的位置，可谓是RPG的小高潮。好在大家团结一心，没有人受伤。如果各位有打算经历此路
程，一点要有心理准备。

到达山脚，天堑变通途！走起来轻松之极，脚步也轻快多了。短时间之后，立刻看到本次行
动的终点，梅林水库大坝。

这里的景色真是非常美丽，这些天让俺们郁闷的情绪一扫而光。就赖在这里多多拍了几张。

梅林水库的大坝上面，没啥好说的了。

最后是大家的集体照，希望各位读者多多参加户外运动，陶冶情操，多多益善:)

谢谢大家的时间:)

万圣节在世界之窗

2008-10-31T00:15:00.007+08:00

公司加班到六点半，我就找理由逃脱了。周总说了：可以，我也在下棋呢！呵呵。

晚上有洪洪和曾胖组织的世界之窗活动，借助优惠券，我们可以在世界之窗享受廉价的万圣
节。感谢洪洪，感谢曾胖，感谢老外，嘿嘿。

万圣节又名鬼节，在西方是非常活跃的节日。最重要的标志，就是孩子们挨家挨户的要糖果，
这点我们可以在《老友记》中可以感受其气氛（因为被孩子哄的团团转，Rachel把糖果全部
给了一个小女孩）。另外你也可以看到Phoebe的超人服。

今天在世界之窗，你完全感受到另类的中国式万圣节。灰长灰长的热闹！中国人就是多，头
顶上带个犄角，更有各式各样的妖魔鬼怪齐聚这里。

我是第一次进世界之窗，这里你可以看到很多很多的世界之窗。由于在夜间，没有像曾胖同
志那样注意技巧。如果你想学摄影，可以找曾胖。

这里是精简版本的曼哈顿，你也可以看到已经米稀的双子楼。

恐怖活动是主题，到处是南瓜头。在僵尸峡谷还可以看到专业级别的女鬼。

最后是万圣节party，不太专业的乐队，不太哈皮的派对。到最后出现赶鬼行动，用纸团相
互攻击。其实最后被群鬼完全吓跑。

最后是龙套小鬼，祝福大家异类的万圣节快乐。

_

心诚则灵

2008-10-30T00:08:00.000+08:00

经过接近三个月的离职期之后，我最近得以 光荣上岗。

回顾这三个月，似乎经历了松山湖之行，回乡历程，孤单的七夕节，八月北京奥运，经济的
冰冻期;几经周折，我也完成了助学贷款，习惯了泡图书馆的日子，参与17爬爬吧的活动(1，
2，3) 烦躁的求职生活。

这段时间也正是痛苦和快乐并重，有次扁桃体发炎，疼到吞咽困难也坚持不去看医生；多个
公司下遭遇闭门羹，面试题更是折磨的我苦不堪言；我和莹莹经历了最严重的争吵，甚至有
放弃感情的念头……

不过也终究过来了，我觉得生活还就这样，我也还就这样，2008年也就这样过来了。我总是
对这样苦中作乐的日子念念不忘，我还会回头想起高考的日子，踏上深圳的每一步。我甚至
可以一直这样慢悠悠的闲廷信步，一直等到花光手上所有积蓄，需要到必胜客去打钟点工来
找足乐子。尽管这样随性的性格伤害了一些好朋友。

上个星期回家，老妈告诉我家里的情况很乱。一般家里和游子总是处于“报喜不报忧”的状态
之中，假设他们不告诉家中的情形，那你得总怀揣着担忧的心思；而家人支支吾吾甚至直接
告知情况糟糕的时候，家里一定乱成一团糟了。因此找份工作仍旧是重中之重，回家过年也
会挂上日程。

现在的工作是在一家工控公司作嵌入式开发，公司名称保密。他们会为一些厂家作外包，来
实现一些工控，自动化设施的嵌入式主板，他们也有了PCB设计师，调板工，唯独让人郁闷
的是：除了经理以外，没有开发人员。很显然这个公司还处于起步阶段，办公室位于33层
（最高层），主板扔的到处都是，每个房间都有包装盒堆成的小山，室内环境比清华信息港
差上几个档次。最重要的是——在这个公司， 加班时间将成为家常便饭，而且没有加班费。

于是我进入了这样一个阶段：

始终拒绝加班的我，将会把加班作为一种享受
仍旧为成为一个顶级的软件工程师而努力
我将来的一段时间内，必须把工作放在第一位
那个小小的梦想还将被搁置

心诚则灵，收起邋遢随性的性格，为将来努力吧！

得知一大票人口在我和莹莹就职后也开始找到工作，恭喜你们，也祝愿全球金融冰冻期早日
结束。

微软黑屏和盗版权益

2008-10-25T12:31:00.001+08:00

自从微软发布WGA更新以后，中国网民的抗议声音不绝于耳：微软黑屏引发威胁百倍于熊猫烧香，微软黑屏引发国家安全话题，国家版权局将会对此事件表态。真实情况将会怎样呢？是中国一家之言，还是全球群起反对？是网友过激，还是捍卫安全呢？

环顾四周，我们才发现，微软黑屏是一个全球性的政策，然而对其他国家来说远远未像中国那样表现过激，就连香港也对此冷漠。很多普及正版的国家和地区，人民是可以支付正版价格的；而对于大多数发展中国家来说，他们也有更多的选择。

而就技术方面来说，微软只是针对盗版用户投放信息，现在没有任何组织和个人可以拿出证据说微软控制电脑和数据。如果你说强制黑屏可以指明微软控制用户的计算机，我觉得这是捕风捉影。操作系统本身具有利用硬件资源提供服务的功用，而在正常情况下，微软将会根据EULA，在用户同意后才可以使用，更改任何用户数据，并通知处理用户信息的目的。但是因为EULA的争议性，中国大陆还在考虑其是否适用。

如果中国官方现在考虑，那我建议微软黑屏和控制电脑之间需要更多的证据。当然我觉得更值得考虑的事情是：1)盗版用户和软件制作商之间基于什么样的权力关系。2)国家如何扶植操作系统和办公软件，用以改变对Windows和Office过度依赖的现状。3)如何发展本国自由软件技术和提高重要机构的信息安全。

我把事情搞砸了

2008-10-22T09:25:00.000+08:00

事情得回溯到六月底，我一个人在康科办公室里，翻看着APUE的源码，我会很满足的告诉自
己：我在忙碌，我像一个有志向，发奋图强的年轻人一样在学习。但是面对着眼前的烂摊子
我就傻眼了————加拿大随时会发来稀奇古怪的需求，需要你改动一点点小玩意，在晚上下班
之前提交上去。

我讨厌了这样的工作，别人的软件让我在其之上修改一些小的界面，或者使用简单的汇编语
句取得一些硬件信息；完成之后我还要钻到实验室里，花费两天时间来测试效果。想起为了
完成新主板的MAPPING，我要投身两个星期来分析完芯片初期数据，那个经历真是糟糕透了。

我宁愿去看Linux内核，那是一个有创意的，有前途的东西，让我学习了一些硬件知识是如
何应用到操作系统设计之上的。后来我发现手头的工作极其枯燥，而且无法腾出时间来看内
核代码，我义无反顾的提交了辞呈。老板对于我的第二次辞呈没有发表太多意见，在一个月
后（七月底），我在一片静寂之中离开了付出两年汗水的公司。

八月初，我回到家乡，我见到了很多亲人老友，他们对我的经历一无所知，辞职的事情除了
老哥以外，我没有告诉任何人。家里有压在我心头的几块石头，完成这些琐碎之事以后，我
匆忙的回到了深圳，开始了漫长的求职时期。

我得说，我从没想过，求职期如此的漫长和烦躁，这让我生活的周边都显得更加煎熬。

我在八九月发出了超过30条求职信，而回复者寥寥无几。我认为这开始并不是什么稀奇事情，
很多人告诉我八到十月是招聘淡季，我对这些措辞不以为然，我不相信什么淡季，依据我的
能力，找到一个适合的工作没有大问题。现在回想起来，我对自己的自信慢慢感觉到羞愧！

九月份我的回复得到了稍许回应，我接到了几个公司的面试申请。于是我开始一一品尝面试
的滋味，腾讯公司，开源通讯公司，深信服公司，深圳傲天通讯，研祥科技大厦……这其中带
有趣味，然而更多的是苦痛。

在经历过如此多的面试之后，我得说，我根本不了解我工作的这一行是个什么样的状况，甚
至可以说，我根本没有对自己的工作做一个很好的评估————根本不知道自己要作什么。

想起毕业的时候我选择报一本《JAVA编程思想》南下找工作的情景，我觉得从理念上看，现
在和那个时候没有什么本质分别：我依然自信满满的认为我可以作自己要的工作，可对这一
份工作的概念都是模糊的。

我想作Linux程序员，但是来到人才招聘网上，我看到Linux程序员都有什么要求呢：
1) Linux驱动编程
2) Linux嵌入式开发
3) Linux后台开发

在这样的职位需求面前，我傻眼了，如果佯装是一个Linux程序员去面试职位，你几乎必须
面对以下问题之一：
1) Linux内核裁减
2) Linux驱动程序编写和移植
3) 嵌入式CPU架构和编程环境
4) Linux网络编程

如果你没有以上经验，那么你几乎没有和人事部经理谈话的资格，在技术面试官前就会被淘
汰。可是我就没有，全部NO，如我所说，80%的面试官都不会接受我的。

剩下20%是通过面试题来测试的，我得说，我是一个应试型的人才，面对考试不以为然。但
是在答复一些笔试题时候，我仍然深受打击————我的专业功底显得那么的不堪一击！我经历
过的面试题浩如烟海，他们覆盖了计算机知识绝大多数部分：
1. C/C++语言功底，C++庞大的语言特性，Shell高级编程
2. UNIX环境编程，Socket编程，多线程编程
3. UNIX网络编程，tcp/ip，http协议
4. 数据结构和算法设计，一些查找和排序算法
5. CPU架构，x96, Power, MIPS架构知识

要从理论上学习这些，我起码要看完手头的大堆书籍。他们包括：
Thinking in C++
Effective C++
UNIX环境编程 APUE
UNIX网络编程 UNP
编程艺术
算法设计
Linux设备驱动
深入理解Linux内核
... ...

顿时我觉得自己非常渺小，经过的两年工作时间在眼前化为乌有。

如果没有什么奇迹发生的话，我仍将领教上面所说的面试和笔试问题，我将再次面临自己薄
弱的知识和经验积累，我还会在离职的深渊中不断轮回。因此这样一个明显的选择摆在我的
面前：要么尝试其他低阶的工作甚至换行，要么就要费劲心力来补齐自己的不足。更要命的
是，我花费这么长的时间才发觉这个问题，那么离职时我在做什么呢？一年前呢？哦～这让
我实在难受————

天呐！我把事情搞砸了！

[LDD] C3. Character Device driver

2008-10-22T00:34:00.004+08:00

代码阅读 <Linux Device Driver> v3
Chapter 3. Character Device Driver

一、scull介绍 Simple Chracter Utility for Loading Localities
scull是一个操作内存区域的字符设备。

scull源码实现的设备有：
scull0 ~ scull3
这四个设备分别由一个全局且持久的内存区域组成。
scullpipe0 ~ scullpipe3
这四个FIFO与管道类似。一个进程读取由另一个进程写入的数据。如果多个进程读
取同一个设备，它们就会为数据发生竞争。scullpipe的内部实现将说明在不借助
于中断的情况下如何实现阻塞式和非阻塞式读写操作。
scullsingle
scullpriv
sculluid
scullwuid
这些设备与scull0相似，但在何时允许open操作方面有一些限制。
scullsingle，一次只允许一个进程使用该驱动程序。
scullpriv，它对每个虚拟控制台是私有的。因为控制台进程会获取不痛的内存区。
sculluid和scullwuid可以被多次打开，但是每次只能由一个用户打开；如果另一
个用户锁定该设备，sculluid则返回“Device Busy”错误，而scullwuid则实现了阻
塞式open。

二、设备编号
对字符设备的访问是通过文件系统内的设备文件进行的，这些设备文件通常位于/dev。而这
些文件包含两个重要数据，主设备号和次设备号。

主设备号表示对应的驱动程序，现代的Linux允许多个驱动程序共享主设备号，但一般仍旧
遵循“一个主设备号对应一个驱动程序”的原则。

次设备号由内核使用，用于正确确定设备文件指定的设备。


MAJOR(dev_t dev);        /* 返回主设备号 */
MINOR(dev_t dev);        /* 返回次设备号 */
MKDEV(int major, int minor);    /* 由主次设备得到dev_t类型的设备编号 */

关于分配和释放设备编号，系统在linux/fs.h中声明了以下函数：


/* 获得一个或者多个设备编号 */
int register_chrdev_region(dev_t first, unsigned int, char *name);

/* 运行过程中，使用以下函数会为我们恰当分配所需要的设备号 */
int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,
            unsigned int count, char *name);

/* 应该用以下函数释放这些设备编号 */
void unregister_chrdev_region(dev_t first, unsigned int count);

三、重要数据结构


#include <linux/fs.h>
struct inode {
struct hlist_node    i_hash;
struct list_head    i_list;
struct list_head    i_sb_list;
struct list_head    i_dentry;
unsigned long        i_ino;
atomic_t        i_count;
unsigned int        i_nlink;
uid_t            i_uid;
gid_t            i_gid;
dev_t            i_rdev;
u64            i_version;
loff_t            i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t        i_size_seqcount;
#endif
struct timespec        i_atime;
struct timespec        i_mtime;
struct timespec        i_ctime;
unsigned int        i_blkbits;
blkcnt_t        i_blocks;
unsigned short          i_bytes;
umode_t            i_mode;
spinlock_t        i_lock;    /* i_blocks, i_bytes, maybe i_size */
struct mutex        i_mutex;
struct rw_semaphore    i_alloc_sem;
const struct inode_operations    *i_op;
const struct file_operations    *i_fop;    /* former ->i_op->default_file_ops */
struct super_block    *i_sb;
struct file_lock    *i_flock;
struct address_space    *i_mapping;
struct address_space    i_data;
#ifdef CONFIG_QUOTA
struct dquot        *i_dquot[MAXQUOTAS];
#endif
struct list_head    i_devices;
union {
    struct pipe_inode_info    *i_pipe;
    struct block_device    *i_bdev;
    struct cdev        *i_cdev;
};
/* ... */
};

struct file {
/*
 * fu_list becomes invalid after file_free is called and queued via
 * fu_rcuhead for RCU freeing
 */
union {
    struct list_head    fu_list;
    struct rcu_head     fu_rcuhead;
} f_u;
struct path        f_path;
#define f_dentry    f_path.dentry
#define f_vfsmnt    f_path.mnt
const struct file_operations    *f_op;
atomic_t        f_count;
unsigned int         f_flags;
mode_t            f_mode;
loff_t            f_pos;
struct fown_struct    f_owner;
unsigned int        f_uid, f_gid;
struct file_ra_state    f_ra;

u64            f_version;
#ifdef CONFIG_SECURITY
void            *f_security;
#endif
/* needed for tty driver, and maybe others */
void            *private_data;

/* ... */
};

struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*dir_notify)(struct file *filp, unsigned long arg);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};

/* 自定义结构 */
struct scull_qset {
void **data;
struct scull_qset *next;
};

struct scull_dev {
struct scull_qset *data;
int quantum;
int qset;
unsigned long size;
unsigned int access_key;
struct semaphore sem;
struct cdev cdev;
};

struct inode ————
内核使用inode结构在内部表示文件，因此它和file结构不同，后者表示打开的文件描述符。
对单个文件，可能会有许多个表示打开的文件描述符的file结构，但他们都指向单个inode
结构。

inode包含大量节点文件信息。而此驱动只是用到了以下两个字段：
dev_t i_rdev; // 对于表示设备的inode结构，该字段包含真正的设备编号
struct cdev *i_cdev; // 对于表示字符设备的inode结构，此字段包含struct cdev指针

另外，开发者可以通过两个宏来获取主次设备编号：
unsigned int iminor(struct inode *inode);
unsigned int imajor(struct inode *inode);

struct file ————
file结构代表一个打开的文件，系统中任何一个打开的文件都有一个对应的file结构，他由
内核在open时候创建，并传递给在文件上的所有函数，知道最后的close函数。在文件实例
关闭之后，内核会释放这个结构。用到的字段有：


struct path        f_path;
#define f_dentry    f_path.dentry        // 目录项结构
const struct file_operations    *f_op;
unsigned int         f_flags;    // 标志，是否阻塞
mode_t            f_mode;        // 权限检查
loff_t            f_pos;        // 当前读写位置
/* needed for tty driver, and maybe others */
void            *private_data;    // 跨系统调用时候保存状态信息

struct file_operations ————
file_operations用来建立驱动程序操作和驱动设备编号之间的连接，他包含了一组函数指
针，这些函数和某些系统调用相关联。程序员可以视此结构为面向对象的C编程的一个例证。

file_operations的函数指针必须指向驱动程序实现特定操作的函数，对于不支持的操作，
对应的字段被赋值NULL，这种情况下，内核的处理行为是不尽相同的。
在本例中，我们实现了以下操作：


struct file_operations scull_fops = {
.owner =    THIS_MODULE,
.llseek =   scull_llseek,
.read =     scull_read,
.write =    scull_write,
.ioctl =    scull_ioctl,
.open =     scull_open,
.release =  scull_release,
};

四、scull内存使用
两个函数 ————
void *kmalloc(size_t size, gfp_t flags);
void kfree(void *ptr);
这个两个函数定义在linux/stab.h中，是内核中非常重要的两个内存操作函数。用kmalloc
函数分配，然后用kfree释放，同时也注意不应该把非kmalloc返回的指针传递给kfree。
（但是将NULL传递给kfree是合法的）

scull驱动中，每一个scull设备（scull_dev）都是一个链表头，他的指针指向scull_qset
结构的链表。而每一个scull_qset则是典型的链表结构，包含了一个4000bytes * 1000的内
存区域，这里的每一个区域就被称为是一个量子（quantum）。
4000和1000的尺寸，由宏SCULL_QUANTUM和SCULL_QSET定义。当然，你也可以设置为模块参
数，也可以在运行时使用ioctl来更改。

由于scull设备是虚拟的内存区域，所以我们的read/write操作也将是对内存的操作，顶多
的麻烦是跨越内核空间和用户空间的拷贝而已。这让实现变的非常容易。

五、实现
初始化和清理函数


int scull_init_module(void)
{
int result, i;
dev_t dev = 0;

if (scull_major) {
    dev = MKDEV(scull_major, scull_minor);
    result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
    result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,
                     "scull");
    scull_major = MAJOR(dev);
}

if (result < 0) {
    printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
    return result;
}

/* allocate the devices -- we can't have them static, as the number
 * can be specified at load time.
 */
scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
if (!scull_devices) {
    result = -ENOMEM;
    goto fail;
}
memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));

/* initialize each device */
for (i = 0; i < scull_nr_devs; i++) {
    scull_devices[i].quantum = scull_quantum;
    scull_devices[i].qset = scull_qset;
    init_MUTEX(&scull_devices[i].sem);
    scull_setup_cdev(&scull_devices[i], i);
}

    /* At this point call the init function for any friend device */
dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
//    dev += scull_p_init(dev);
//    dev += scull_access_init(dev);

#ifdef SCULL_DEBUG /* only when debugging */
//    scull_create_proc();
#endif
printk(KERN_INFO "init scull successful\n");
return 0; /* succeed */

fail:
scull_cleanup_module();
return result;
}

void scull_cleanup_module(void)
{
int i;
dev_t devno = MKDEV(scull_major, scull_minor);

/* Get rid of our char dev entries */
if (scull_devices) {
    for (i = 0; i < scull_nr_devs; i++) {
        scull_trim(scull_devices + i);
        cdev_del(&scull_devices[i].cdev);
    }
    kfree(scull_devices);
}

#ifdef SCULL_DEBUG /* use proc only if debugging */
scull_remove_proc();
#endif

/* cleanup_module is never called if registering failed */
unregister_chrdev_region(devno, scull_nr_devs);

/* and call the cleanup functions for friend devices */
//    scull_p_cleanup();
//    scull_access_cleanup();
printk(KERN_INFO "cleanup scull successful\n");
}

init_module过程包括 ————
1) 注册设备
2) 初始化scull_dev设备
3) 初始化其他设备
为了简化设计，此章节没有引入pipe等设备，所以注销了某些方法。

cleanup_module过程 ————
1）释放scull_dev结构，注销字符设备
2) 注销设备号

然后是在file_operations指明的函数，这里重点讲解read和write的实现 ————


ssize_t scull_read(struct file *filp, char __user *buf,
       size_t count, loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = 0;

if (down_interruptible(&dev->sem))
    return -ERESTARTSYS;
if(*f_pos >= dev->size)
    goto out;
if(*f_pos + count > dev->size)
    count = dev->size - *f_pos;

item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;

dptr = scull_follow(dev, item);

if (dptr == NULL || !dptr->data || !dptr->data[s_pos])
    goto out;

if (count > quantum - q_pos)
    count = quantum - q_pos;

if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {
    retval = -EFAULT;
    goto out;
}
*f_pos += count;
retval = count;
out:
up(&dev->sem);
return(retval);
}


ssize_t scull_write(struct file *filp, const char __user *buf,
        size_t count, loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = 0;

if (down_interruptible(&dev->sem))
    return -ERESTARTSYS;
if(*f_pos >= dev->size)
    goto out;
if(*f_pos + count > dev->size)
    count = dev->size - *f_pos;

item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;

dptr = scull_follow(dev, item);

if (dptr == NULL)
    goto out;
if (!dptr->data) {
    dptr->data = kmalloc(qset *sizeof(char *), GFP_KERNEL);
    if (!dptr->data)
        goto out;
    memset(dptr->data, 0, qset * sizeof(char *));
}
if (!dptr->data[s_pos]) {
    dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
    if (!dptr->data[s_pos])
        goto out;
}

if (count > quantum - q_pos)
    count = quantum - q_pos;

if (copy_from_user(dptr->data[s_pos] + q_pos, buf, count)) {
    retval = -EFAULT;
    goto out;
}
*f_pos += count;
retval = count;

/* 更新文件大小 */
if (dev->size < *f_pos)
    dev->size = *f_pos;
out:
up(&dev->sem);
return(retval);
}

scull_read从filp的f_pos处读取count个字节，写到buf中。
首先要作的是，确定f_pos的位置，根据f_pos，我们要确定写的位置，位于第几个item的
第s_pos数组的第q_pos个量子处，然后根据item返回我们要的scull_qset结构体。最后使用
copy_to_user完成读操作。

写操作和读操作很相似，使用了逆向的copy_from_user函数。

这两个重要的系统调用实现，都使用了跨越内核和用户空间的写操作：
copy_to_user(void *to, void *from, int count);
copy_from_user(void *to, void *from, int count);

六、总结
scull_init_module
* alloc_chrdev_region
* scull_setup_cdev
** cdev_init, cdev_add
** scull_fops(llseek, read, write, ioctl, open, release)
* scull_create_proc
* scull_p_init
* scull_access_init

_

[TIC++] C13. Dynamic Object Creation

2008-10-14T11:40:00.002+08:00

代码阅读<Thinking In C++>
Chapter 13. Dynamic Object Creation

一、在堆区创建内存


// c13: malloc_class.cpp
// malloc with class objects
#include <cstdlib>
#include <cstring>
#include <cstring>
#include <iostream>
using namespace std;

class obj {
   int i, j, k;
   enum { sz = 100 };
   char buf[sz];
public:
   void initialization() {  // can't use constructors
       cout << "initialization obj" << endl;
       i = j = k = 0;
       memset(buf, 0, sz);
   }
   void destroy() {
       cout << "destroy obj" << endl;
   }
};

int main()
{
   obj *o = (obj*)malloc(sizeof(obj));
   if (o == 0)
       return -1;
   o->initialization();
   //sometimes later...
   o->destroy();
   free(o);
}
/* result:
initialization obj
destroy obj
*/

当C++对象创建的时候，将会发生两件事情：
1) 为空间分配内存
2) 调用构造方法来初始化这块内存

而空间创建问题（1），可以有以下选择：
1) 在程序开始前创建静态空间，位于静态内存区，拥有文件生命期
2) 在执行点处创建堆栈空间，他将在执行跳出方法的时候释放。堆栈的处理是处理器完成
的，自然非常高效
3) 在执行点处创建堆空间(heap)，这被成为动态内存分配(!)。方法必须在运行调用的时候
创建堆空间，这意味着你可以决定任何时候创建，当然也要为释放负全权责任————生命期完
全由程序员掌控。

上面的例子展示了C处理堆区空间的方法：
这里的obj o对象的创建，没有使用到构造方法！这是非常糟糕的情况，因为你有可能选择
是否初始化，甚至可能忘记，初始化的丢失极为可能带来bug。

于是C++引入了一种新方法：


// c13: new_and_delete.cpp
#include <iostream>
using namespace std;

class tree {
   int height;
public:
   tree(int tree_height): height(tree_height) {}
   ~tree() { cout << "*"; }
   friend ostream& operator <<(ostream &os, const tree* t) {
       return os << "tree height is: "
             << t->height << std::endl;
   }
};

int main(void)
{
   tree *t = new tree(40);
   cout << t;
   delete t;
}
/* result
tree height is: 40
*/

new和delete保证了构造方法的正常调用，甚至还会检查内存申请是否调用成功。
这一切显得像堆栈内存分配一样简单。

二、delete void*


// c13: bad_void_pointer_deletion.cpp
#include <iostream>
using namespace std;

class object {
   void *data;
   const int size;
   const char id;
public:
   object(int sz, char c): size(sz), id(c) {
       data = new char[size];
       cout << "constructing object" << id
            << ", size = " << size << endl;
   }
   ~object() {
       cout << "desctructing object " << id << endl;
       delete []data; // OK, just release storage;
       // no desctructor calls are necessary;
   }
};

int main() {
   object *a = new object(40, 'a');
   delete a;
   void *b = new object(40, 'b');
   delete b;
}
/* result:
constructing objecta, size = 40
desctructing object a
constructing objectb, size = 40
*/

object是一个包含 void *data的一个类，在这个类的析构方法中，我们看到使用了delete
来析构data，这没什么问题，因为这里要作的只是释放内存。

但是在main()中，对于delete来说，对象类型信息就非常必要了。由于delete a知道a是一
个class object，所以他使用到了~object()析构方法，data也被释放了。可是void *b就遇
到麻烦，他无法得知void*的类型信息，就无法调用析构方法，因此data将会永远的丢失，
这是一个静静的内存泄露。

如果你在C++工程中有内存泄露问题，那就要好好检查你的delete了。

三、介绍new handler


// c13: new_handler.cpp
#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;

int count = 0;

void out_of_memory()
{
   cerr << "memory exhausted after " << count << " allocations" << endl;
   exit(1);
}

int main()
{
   set_new_handler(out_of_memory);
   while(1) {
       count++;
       new int[1000];
   }
}

当new无法找到一个足够大的堆空间来存放对象，会出现何种情况呢？
这样的情况下，就会调用new-handler。默认的new-handler会抛出异常，当然可以定义新的
new-handler，打印出信息告诉你发生了什么。

这里就是用<new>的set_new_handler设置了方法，他会打印在经历多少次存储之后耗尽内存。

_

[TIC++] C11. References & the Copy-Constructor

2008-10-14T11:37:00.001+08:00

代码阅读<Thinking In C++>
Chapter 11. References & the Copy-Constructor

一、再次介绍引用


// reference.cpp
int *f(int *x)
{
    (*x)++;
    return x;
}

int &g(int &x)
{
    x++;
    return x;
}

int &h()
{
    int q;
//!    return q;    // error
    static int x;
    return x;
}

int main()
{
    int a = 0;
    f(&a);
    g(a);
}

reference可以被简单视作一个常量指针，而这个指针会在预编译期间自动被解释掉。
ref最常用到的地方，就是作为参数和返回值使用了。对参数而言，任何形参的改变会作用
到实参；针对返回值，要注意的是返回的东西只是引用，必须保证要返回的内存在返回地可
见。
* 因此，你不能在h()中返回局部变量。

在介绍copy constructor之前，让我们来看常引用情况 ————


// const_ref.cpp
void f(int&) {}
void g(const int&) {}

int main() {
//!    f(1);    //invalid initialization of non-const reference
    g(1);
}

当传递1这个实参的时候，编译器会为1分配内存，然后创造一个引用(int&)绑定到这个内存
地址。如果1没有被声明为const，那将是毫无意义的。f(1)将得到一个编译时错误。

最后是复合化的引用，指向指针的引用 ————


// c11: ref_to_pointer.cpp
#include <iostream>
using namespace std;

void increment(int* &i) { i++; }

int main()
{
    int *i = 0;
   
    cout << "i = " << i << endl;
    increment(i);
    cout << "i = " << i << endl;
}

这里阵阵改变的是指针(int*)i，而不是指针指向的值，但是这里传递的i。
在C中要做到这点，那就要使用二级指针了。

二、copy-constructor


// c11: howmany.cpp
#include <fstream>
#include <string>

using namespace std;
ofstream out("howmany.out");

class howmany {
    static int object_cnt;
public:
    howmany() { object_cnt++; }
    static void print(const string& msg = "") {
        if (msg.size() != 0)
            out << msg << ": ";
        out << "object_cnt = " << object_cnt << endl;
    }
    ~howmany() {
        object_cnt--;
        print("~howmany()");
    }
};

int howmany::object_cnt = 0;

// pass and return by value:
howmany f(howmany x)
{
    x.print("x argument inside f()");
    return x;
}

int main()
{
    howmany h;
    howmany::print("after construction of h");
    howmany h2 = f(h);
    howmany::print("after call to f()");
}
/* result:
after construction of h: object_cnt = 1
x argument inside f(): object_cnt = 1
~howmany(): object_cnt = 0
after call to f(): object_cnt = 0
~howmany(): object_cnt = -1
~howmany(): object_cnt = -2
*/

首先我们构建howmany h，调用构造函数，会得到object_cnt = 1;
然后我们使用f()来构建第二个对象h2 = f(h)，编译器传递h拷贝，并没有使用构造函数来
创建h2。但是意想不到的是，离开f()的时候发生了析构，导致object_cnt = 0。
而最后的两个析构，使得object_cnt得到负数。

这是为什么呢？
因为在f()内，函数使用了C形式的bitcopy，我们得到的只是一份h的拷贝，他没有调用构造
方法，所以我们没有看到f()中objecgt_cnt = 2。而在后来，C++特性去保证了最后一步析
构，因此出现了object_cnt不升反降的结果。

C++中为了保证构造的完整性，因此提出了copy-constructor————


// c11: howmany.cpp
#include <fstream>
#include <string>
using namespace std;

ofstream out("howmany2.out");

class howmany2 {
    string name;
    static int object_cnt;
public:
    howmany2(const string &id = ""): name(id) {
        ++object_cnt;
        print("howmany2()");
    }
    ~howmany2() {
        --object_cnt;
        print("~howmany()");
    }
    howmany2(const howmany2 &h): name(h.name) {
        name += " copy";
        ++object_cnt;
        print("howmany2(const howmany2&)");
    }
    void print(const string& msg = "") const {
        if (msg.size() != 0)
            out << msg << endl;
        out << '\t' << name << ": "
            << "object_cnt = " << object_cnt << endl;
    }
};

int howmany2::object_cnt = 0;

// pass and return by value:
howmany2 f(howmany2 x)
{
    x.print("x argument inside f()");
    return x;
}

int main()
{
    howmany2 h("h");
    out << "entering f()" << endl;
    howmany2 h2 = f(h);
    h2.print("h2 after call to f()");
    out << "call f(), no return value" << endl;
    f(h);
    out << "after call to f()" << endl;
}
/*
howmany2()
    h: object_cnt = 1
entering f()
howmany2(const howmany2&)
    h copy: object_cnt = 2
x argument inside f()
    h copy: object_cnt = 2
howmany2(const howmany2&)
    h copy copy: object_cnt = 3
~howmany()
    h copy: object_cnt = 2
h2 after call to f()
    h copy copy: object_cnt = 2
call f(), no return value
howmany2(const howmany2&)
    h copy: object_cnt = 3
x argument inside f()
    h copy: object_cnt = 3
howmany2(const howmany2&)
    h copy copy: object_cnt = 4
~howmany()
    h copy copy: object_cnt = 3
~howmany()
    h copy: object_cnt = 2
after call to f()
~howmany()
    h copy copy: object_cnt = 1
~howmany()
    h: object_cnt = 0
*/

我们可以看到，f()传递参数的时候，编译器将会把拷贝传值的过程交给copy-constructor，
同样return返回值，也需要这样的拷贝。
entering f()
howmany2(const howmany2&)
h copy: object_cnt = 2
x argument inside f()
h copy: object_cnt = 2
howmany2(const howmany2&)
h copy copy: object_cnt = 3

而后离开f()，这需要析构刚才创建的临时变量，保留return的值。

第二次f()没有返回值，因此情况稍微发生改变。此种调用忽略了返回值，编译器也会聪明
的直接在调用点析构此临时对象。

三、选择copy-construction
我们来看如何迫使系统自建拷贝构造方法


// c11: default_cc.cpp
// automatic creation of the copy-constructor
#include <iostream>
#include <string>
using namespace std;

class withcc {
public:
    withcc() {}
    withcc(const withcc &) {
        cout << "withcc(withcc &)" << endl;
    }
};

class wocc {
    string id;
public:
    wocc(const string &ident = ""): id(ident) {}
    void print(const string &msg = "") const {
        if (msg.size() != 0)
            cout << msg << ": ";
        cout << id << endl;
    }
};

class composite {
    withcc tc;
    wocc oc;
public:
    composite(): oc("composite()") {}
    void print(const string &msg = "") const {
        oc.print(msg);
    }
};

int main() {
    composite c;
    c.print("content of c");
    cout << "calling composite copy-constructor" << endl;
    composite c2 = c;
    c2.print("content of c2");
}
/* reuslt
content of c: composite()
calling composite copy-constructor
withcc(withcc &)
content of c2: composite()
*/

我们在这里看到两个案例：
1) class withcc拥有构造方法和拷贝构造方法。一旦包含拷贝构造函数，这就是在告诉编
译器：永远不要再自作主张，自动创建默认构造函数。因此，如果class withcc没有定义
withcc()，编译器会报错——composite中的tc没有办法创建。

2) class composite拥有构造方法，而没有拷贝构造方法。一旦需要拷贝构造方法，编译器
会为所有的成员对象调用他们的拷贝构造方法。（这通过组合或者继承可以实现composite）
在这里，c2 = c，就强迫调用了withcc和wocc的拷贝构造方法。而wocc没有拷贝构造方法，
因此系统为其自动定义一个，完成bitcopy。

接下来，通过小技巧来避免赋值拷贝


// c10: no_cc.cpp
class nocc {
    int i;
    nocc(const nocc &);
public:
    nocc(int ii = 0): i(ii) {}
};

void f(nocc);

int main(void)
{
    nocc n;
// copy-constructor is private!
//!    f(n);
//!    nocc n2 = n;
//!    nocc n3(n);
}

通过将拷贝构造方法设置为私有，来避免赋值拷贝，这是一个非常简单的方法。
在此不用赘述。
_

[TIC++] C10. Name Control

2008-10-11T01:20:00.003+08:00

代码阅读<Thinking In C++>
Chapter 10. Name Control

一、局部变量作为static


// c10: static_objects_inside_funcs.cpp
#include <iostream>
using namespace std;

class X {
   int i;
public:
   X(int ii = 0):i(ii) {}
   ~X() { cout << "X::~X()" << endl; }
};

void f()
{
   static X x1(47);
   static X x2;
}

int main()
{
   f();
} ///:~
/* result:
X::~X()
X::~X()
*/

当局部变量声明为static的时候，此变量将不会放置在堆栈区内，而是放置在程序的静态内
存区。这就意味着static变量：
* 具有全局生命期
* 初始化只进行一次
* 此变量在声明函数外部不可见

来解析一下静态对象的析构方法：


// c10: static_destructors.cpp
// static object destructors

#include <fstream>
using namespace std;

ofstream out("statdest.out");

class obj {
   char c;
public:
   obj(char cc): c(cc) {
       out << "obj::obj() for " << c << endl;
   }
   ~obj() {
       out << "obj::~obj() for " << c << endl;
   }
};

obj a('a');

void f()
{
   static obj b('b');
}

void g()
{
   static obj c('c');
}

int main()
{
   out << "inside main()" << endl;
   f();
   //g() not called
   out << "leaving main()" << endl;
}
/* statdest.out:
obj::obj() for a
inside main()
obj::obj() for b
leaving main()
obj::~obj() for b
obj::~obj() for a
*/

静态变量具有全局生命期，这样静态对象会在main()函数退出时候，或者调用C标准函数
exit()的时候被自动调用析构方法。这意味着：如果你在静态对象的析构方法内exit，就会
造成一个死循环。这是很危险的。另外，调用abort()函数结束程序，将不会自动调用静态
对象的析构方法。

这个例子解释了一些基本概况，a是全局对象，b是f()内部的静态对象，他们的构造和析构
顺序正好相反:
cons a -> cons b -> des b --> des a
（在C++中，全局静态对象的构造函数是在main()之前被调用的）

二、全局变量为static
local_extern.cpp -- 第一个模块（main）


// c10: local_extern.cpp

#include <iostream>

int main()
{
   extern int i;
   std::cout << i << endl;;
}
/* result:
5
*/

local_extern2.cpp -- 第二个模块


// c10: local_extern2.cpp
int i = 5;

static 和 extern在 C++中是一对反义词。
* 默认全局变量是extern的，extern关键词标明次变量包含外部链接，可以在其他模块中引
用。而static则约束此变量为内部链接，不可外部引用。这对于“非成员”函数也同样适用。
file scope:
1) 全局变量声明默认为extern，而声明为static只会更改可视范围，这样变量只包含内部
链接————它仍旧会位于静态数据区域，无论static还是extern。

2) 局部变量声明默认为auto，若声明为static则会更改可视范围，并且更改存储区域（从
堆栈区更改到静态数据区）；若声明为extern，则显示此变量位于别的模块。

3) 方法定义为static/extern，只会改变可视范围。

三、名字空间 namespaces


// c10: continuation.cpp
namespace mylib {
   extern int x;
   void f();
}

namespace mylib {
   extern int y;
   void g();
}

int main() {}

* 名字空间的定义必须在全局区内，或者被嵌套在其他名字空间内。
* 定义的末尾没有";"
* 可以在多个头文件里添加名字空间定义（原本看起来像重复定义）
* 名字空间可以被引用为其他名字，比如
namespace bob = bobs_super_duper_library;
* 对名字空间内部数据的引用类似于成员操作
* 你不能使用名字空间建立实例，他根本不是一个类型

四、using 指令
namespace_int.h -- 定义名字空间Int


// c10: namespace_int.h
#ifndef __NAMESPACEINT_H
#define __NAMESPACEINT_H

namespace Int {
   enum sign { positive, negative };
   class Integer {
       int i;
       sign s;
   public:
       Integer(int ii = 0): i(ii),
                    s(i >= 0 ? positive : negative)
           {}
       sign get_sign() const { return s; }
       void set_sign(sign sgn) { s = sgn; }
   }
}

#endif /// __NAMESPACEINT_H

namespace_math.h -- 定义名字空间Math


// c10: namespace_math.h
#ifndef __NAMESPACEMATH_H
#define __NAMESPACEMATH_H

#include "namespace_int.h"

namespace Math {
   using namespace int;
   Integer a, b;
   Integer divide(Integer, Integer);
}

#endif  /// __NAMESPACEMATH_H

arithmetic.cpp


// c10: arithmetic.cpp
#include "namespace_math.h"
void arithmetic()
{
   using namespace Int;
   Integer x;
   x.set_sign(positive);
}

int main() {}

在arithmetic()的方法中，我们看到了using指令，如果没有他，任何命名空间的内容都需
要全名提供。

五、C++中的static数据成员


// c10: static_init.cpp
#include <iostream>
using namespace std;

int x = 100;

class with_static {
   static int x;
   static int y;
public:
   void print() const {
       cout << "with_static::x = " << x << endl;
       cout << "with_static::y = " << y << endl;
   }
};

int with_static::x = 1;
int with_static::y = x + 1;
// with_static::x not ::x

int main()
{
   with_static ws;
   ws.print();
}
/*
with_static::x = 1
with_static::y = 2
*/

类的static成员存在于一个独立的空间中，无论建立多少个对象，他们的static成员都是共
享的。更重要的是static成员只有在类对象中可见，它也可以受成员访问符约束。

在此例子中，在没有创建实例的时候，我们就对with_static::x进行初始化，这对于静态成
员是可行的。


// c10: static_array.cpp
class values {
   static const int scsize;// = 100;
   static const long sclong = 100;

   static const int scints[];
   static const long sclongs[];
   static const float sctable[];
   static const char scletters[];
   static int size;
   static const float scfloat; // differ from tic++
   static float table[];
   static char letters[];
};
int values::scsize = 100;
int values::size = 100;
const float values::scfloat = 1.1;
const int values::scints[] = { 99, 47, 33, 11, 7 };
const long values::sclongs[] = { 99, 47, 33, 11, 7 };
const float values::sctable[] = { 1.1, 2.2, 3.3, 4.4 };
const char values::scletters[] = { 'a','b','c','d','e','f','g','h','i','j',};
float values::table[4] = { 1.1, 2.2, 3.3, 4.4 };
char values::letters[10] = { 'a','b','c','d','e','f','g','h','i','j',};

int main() { values v; }

这里揭示了static初始化的可行性分析：
1) static 不可以在类中初始化，必须要求const。
2) static const 非原子类型，不可以在类中初始化。
3) static const 原子类型，可以而且必须在类中初始化。

下面来看嵌套类定义和局部类定义中的static情况————


// c10: local.cpp
// static member & local classes
#include <iostream>
using namespace std;

// Nested classes CAN have static data members;
class outer {
   class inner {
       static int i;
   };
};

int outer::inner::i = 47;

//local class can not have static data members;
void f()
{
   class local {
   public:
//!        static int i; // error
// (how could you define i?)
   } x;
}

int main()
{
   outer x;
   f();
}

你可以发现嵌套类定义中的static完全可行，但是在局部类定义中却被禁止了。
我们怎么办呢？实际上，局部类定义是很少使用的。

六、static成员方法


// c10: static_member_funcs.cpp
class X {
   int i;
   static int j;
public:
   X(int ii = 0): i(ii) {
       // non-static member function can
       // access static member function or data
       j = i;
   }
   int val() const { return i; }
   static int incr() {
       //! i++; // Error: static member function
       // cannot access non-static member data
       return ++j;
   }
   static int f() {
       //! val(); // Error: static member function
       // cannot access non-static member function
       return incr();
   }
};

int X::j = 0;

int main()
{
   X x;
   X *xp = &x;

   x.f();
   xp->f();
   X::f(); // only works with static members
} ///:~

同样，我们在C++中可以像定义成员数据那样定义一个static成员方法，在我们需要创建一
个仅仅作用于类或者对象的方法的时候，我们不希望他在全局区域内造成命名污染，因此，
这个念头就诞生了。

static方法可以直接被引用调用，不需要建立类实例（就像数据成员初始化一样）。有一点
要注意的是：static成员方法，他并不包含this指针，这注定了它：

* 不能够访问数据成员，也不能调用成员方法。


// c10: singleton.cpp
#include <iostream>
using namespace std;

class egg {
   static egg e;
   int i;

   egg(int ii): i(ii) {}
   egg(const egg&); // prevent copy-construction
public:
   static egg* instance() { return &e; }
   int val() const { return i; }
};

egg egg::e(47);

int main()
{
//!    egg x(1); // private constructor
   cout << egg::instance()->val() << endl;
}

这个例子非常有趣，除了egg::e，你将永远无法创造第二个egg对象。

1) 因为egg的构造函数设置为私有，你无法直接创建私有对象。
2) 使用static成员方法egg::instance()，你可以创建一个实例，这个实例是
static egg e;
3) 由于egg e本身也是e，那么所有的 instance()调用，都会返回这一个对象。其他对象创
建不能。
4) 此例还禁用了拷贝构造方法 egg(const egg&)，这意味着，你甚至无法赋值对象，最后
一条路也被封锁了。

七、static 初始化依赖 static initialization dependency
initializer.h


// c10: initializer.h
#ifndef __INITIALIZER_H
#define __INITIALIZER_H

#include <iostream>

extern int x;
extern int y;

class initializer {
   static int init_count;
public:
   initializer() {
       std::cout << "initializer()" << std::endl;
       //initialize first time only
       if (init_count++ == 0) {
           std::cout << "performing initialization"
                 << std::endl;
           x = 100;
           y = 200;
       }
   }
   ~initializer() {
       std::cout << "initializer()" << std::endl;
       //cleanup last time only
       if (--init_count == 0) {
           std::cout << "performing cleanup"
                 << std::endl;
           // any necessary cleanup here
       }
   }
};

static initializer init;

#endif//__INITIALIZER_H

initializer_defs.cpp -- 已知模块


// c10: initializer_defs.cpp
#include "initializer.h"

int x;
int y;
int initializer::init_count;

initializer.cpp -- 测试模块(main)


// c10: initializer.cpp
#include "initializer.h"
using namespace std;

int main()
{
   cout << "inside main()" << endl;
   cout << "leaving main()" << endl;
}
/* result:
initializer()
performing initialization
initializer()
inside main()
leaving main()
initializer()
initializer()
performing cleanup
*/

在extern的初始化过程中，我们会遇到这样的问题：


   extern std::ofstream out;
   class Oof {
   public:
       Oof() { std::out << "ouch"; }
   } Oof;

这段代码引用到了其他文件的一个对象ofstream out，如果两个文件位于不同的模块，那么
这意味着out的定义和使用位于两个模块。在编译器编译的时候，往往不能完全决定哪一个
模块先编译，操作系统也没有提供确保初始化顺序的绝对方法。如果是此段代码先编译，那
么面对的问题就是，out还未构造就使用了，这会带来混乱。
这个问题针对的对象是（它们会在main()之前执行初始化）：
1) 全局对象
2) 局部static对象

为了解决此问题的发生，我们给出三种方法：
1) 永远别这样做，避免此类问题发生是最好的选择
2) 如果必须这样做，把静态对象定义放在一个文件里，这样你可以安排预想的编译次序。
3) 如果不可避免的要把静态对象放在不同模块中，可以采用两种技巧来解决此问题。

本段例子就是技巧1，它是Jerry Schwarz在创建iostream库的时候提出的。
initializer.h *设计目标
initializer_defs.cpp *已知模块
initializer.cpp *已知模块
我们要求的目标是，无论initializer_defs.cpp和initializer.cpp哪一个先初始化，都可
以保证x,y的安全使用。
实现方法：首先在initializer.h中，extern引用x,y，然后定义为x,y专门的初始化类
initializer，根据static成员int_count是否为0，判断x,y是否已经被初始化，如果未初始
化，则实现初始化；否则不要动。以同样的方法定义析构方法。接着在文件末尾添加static
对象initializer init。
最后一步，在x,y对象定义的模块初始化 initializer::init_count = 0;

由于已知模块都已经包含了initializer.h头文件，那么他们将共同拥有init对象，init对
象保证了对象x,y的初始化；由于class initializer的处理，也将屏蔽x,y的重复初始化。

下面介绍技巧2————
dependency1.h


// c10: dependency1.h
#ifndef __DEPENDENCY1_H
#define __DEPENDENCY1_H

#include <iostream>

class dependency1 {
   bool init;
public:
   dependency1(): init(true) {
       std::cout << "dependency1 construction"
             << std::endl;
   }
   void print() const {
       std::cout << "dependency1 init:"
             << init << std::endl;
   }
};

#endif//__DEPENDENCY1_H

dependency2.h


// c10: dependency2.h
#ifndef __DEPENDENCY2_H
#define __DEPENDENCY2_H

#include "dependency1.h"

class dependency2 {
   dependency1 d1;
public:
   dependency2(const dependency1 &dep1): d1(dep1) {
       std::cout << "dependency2 construction ";
       print();
   }
   void print() const { d1.print(); }
};

#endif//__DEPENDENCY2_H

dependency1statfun.h


// c10: dependency1statfun.h
#ifndef __DEPENDENCY1STATFUN_H
#define __DEPENDENCY1STATFUN_H

#include "dependency1.h"
extern dependency1 &d1();

#endif//__DEPENDENCY1STATFUN_H

dependency2statfun.h


// c10: dependency2statfun.h
#ifndef __DEPENDENCY2STATFUN_H
#define __DEPENDENCY2STATFUN_H

#include "dependency2.h"
extern dependency2 &d2();

#endif//__DEPENDENCY2STATFUN_H

dependency1statfun.cpp


// c10: dependency1statfun.cpp
#include "dependency1statfun.h"

dependency1 &d1()
{
   static dependency1 dep1;
   return(dep1);
}///:~

dependency2statfun.cpp


// c10: dependency2statfun.cpp
#include "dependency1statfun.h"
#include "dependency2statfun.h"

dependency2 &d2()
{
   static dependency2 dep2(d1());
   return(dep2);
}

technique2b.cpp


// c10: technique2b.cpp
// (L) dependency1statfun dependency2statfun

#include "dependency2statfun.h"

int main()
{
   d2();
}///:~
/* result:
dependency1 construction
dependency2 construction dependency1 init:1
*/

这个方法显然更加干净清爽:)
dependency1.h * 已知头文件
dependency2.h * 已知头文件
dependency1statfun.h * 设计头文件
dependency2statfun.h * 设计头文件2
dependency1statfun.cpp * 设计模块
dependency2statfun.cpp * 设计模块2
technique2b.cpp *main函数，用来测试
我们发现class dependency2的对象实例必须通过拷贝构造函数来初始化，而且他需要借助
class dependency1的对象。因此以下的初始化总是可能存在的:
dependency2 dep2((dependency1)dep1);
如果dep1和此定义不再同一模块中，我们显然要面对静态对象的依赖问题。

技巧2是这样作的。他通过定义两个模块提供了两个函数d1()和d2()，他们分别包含一个静
态对象dep1和dep2(d1)，如果要创建dependency2对象，只有通过d2()返回得到。实际上，
技巧2正是封锁了初始化方法，迫使初始化按照即定的顺序进行。
dependency2& -> d2() -> dep2(d1()) -> d1() -> dep1 -> dependency1: dependency1()

总结

我们看到static带来功能性的同时，也带来了困惑，因为在某些情况下，它用来控制存储位
置，有些时候控制可视范围或者名字的链接属性。
* static存储在静态数据内存区，拥有全局生命域
* 作用在局部变量上，static使得变量局部可见却拥有全局生命期。
* 作用在全局变量上，static控制可视范围，仅仅在本模块内可见。
* 作用在类的数据成员上，static既控制生命期，又限制该标识符仅仅在类中可见。
* 作用在类的成员方法上，static方法除了保留数据成员特性以外，还去除了指针。这意味
着，静态成员不能访问非static数据成员，也不能调用非static成员方法。

namespace 同样给予更加灵活的方法，让您在大工程内部控制代码的增加和繁衍。

class 内部的class是在程序中控制名字的另外一种方法，他不会和全局名字冲突，而在程
序内部享用独立的可视范围和访问控制。这会大大增强你代码的维护性能。

We Are On The Cruise! -- OnePiece 十周年纪念

2008-10-10T16:01:00.012+08:00

财富、名声、力量——曾经拥有这世界上一切男人，海贼王 Gol D. Roger，他在临刑前的一
句话，让全世界的人们趋之若鹜奔向大海：“想要我的财宝吗？想要的话可以全部给你！伟
大航路！我把所有财宝都放在了那里。”于是男子汉们启程前往伟大航路————
大海贼的时代来临了！
----

这是每次星期天晚上都会听到的话，这一天的早上九点，隔海相望的日本将会定期推出日本
漫画《One Piece》。因此这一天来说，对我总是轻松的一天，可以享受周末的轻松，同样
观看《One Piece》——我从来未曾想过自己会爱上一部动画。

而最新的373集openning再次更改，启用了10周年版本主题曲，我们在openning动
画中看到了从第一章节至今出现过的主要人物，从Buggy，Arlong，Smoker到Red Foot Zeff，
巨鲸Laboon，Vivi，Mr.2，还有冰山先生，七武海Sir Crocodile，最新的CP9。这才发现
《One Piece》已经度过漫长的10周年～

One Piece是啥玩意儿呢？对于一些大叔大婶，从来认为动画是小儿科的人们，咱们还是来
普及一下————

One Piece介绍
One Piece是由日本漫画家尾田荣一郎创作的少年漫画，自1997年8月4日起开始在《周刊少
年JUMP》中连载，而漫画每一章节都由株式会社集英社以单行本的方式发行，至今仍在连载。
（OnePiece漫画创刊号）

其名字“One Piece”在故事中为“一个大秘宝”之意。One Piece讲述的是一个17岁的男孩，
Monkey D. Luffy，从误食恶魔果实获得超自然力，而后伙同一群勇敢的海贼的冒险故事，
他们的海贼团体叫做“草帽海贼团”。Luffy以获得世界的终极秘宝——One Piece为目标，从而
成为新一代的海贼王。

我们所听到的译名“海贼王”为台湾中文版发行权转移之后的新代理商“东立出版社”因版权关
系另取的译名。你可以在内地看到以下译名，他都说的是一个动画————One Piece：
海贼王（台湾大然文化）
航海王（台湾东立出版社）
海贼王（香港天下出版社）

借由1亿4千万的漫画销量，One Piece是《周刊少年JUMP》史上销量第三的漫画作品，同样
One Piece也被认为是最受好评的三大漫画作品之一。

情节
听到上面的解说，你还是对One Piece没有概念，因为描述实在乏味，这和打败BOSS拿钥匙
开宝箱的经典剧情没有啥大分别。那我没的办法，因为我无法用三言两语把十年长篇的漫画
说个清楚透彻。

One Piece中描述的海贼，显然和大家想象中的不一样，“独木腿、铁钩手、黑眼罩、三角帽
子、提着酒瓶劫掠四方的人”，这种《加勒比海盗》中的海贼形象在One Piece的世界里显得
更加简单但是多元化，我们的几个主角将会是各自背景不同，使命非凡，勇于追逐梦想，极
富自由精神的，乐于向上，将朋友视为生命的海贼，这将传统意义上作恶多端的海贼形象完
全颠覆。

主线似乎很明了，少年时代的Luffy，被他心目中的英雄“红发Shanks”鼓舞，而起身寻找传
说的大秘宝，这个宝藏可谓是世界财富的集合与象征，更重要的是，它是“海贼王”称号的标
志。为了成为“海贼之王”，Luffy面临的将是世界上最危险，最诡异的海域：伟大航路
（The Grand Line）。

Luffy在东海位置起步，他面临的首要任务是组织一个草帽海贼团；沿着上一代海贼王，
Gold Roger的足迹，他们将一步步的逼近One Piece秘宝。

我喜欢的OP
我在这里说说这部动画的杰出之处。他和其他漫画有啥分别。

1) OP的故事构架太出色了。
在二十几集的时候和三百多集的时候，我依然抱有同样感觉：海贼王的故事写的太好了！
从四海到伟大航路，再到新世界，这样故事的轮廓非常清晰，而四皇，海军，七武海三大势
力的均衡也很直白，尾田没有在这里隐瞒什么。相反观众和读者的想法都很简单：Luffy是
要朝着新世界去的，在三大势力并存的新世界，草帽海贼团显然不是个旁观者。他将会与这
些恶势力搏斗，最终取得One Piece。

传统动画上呢？你几乎永远摸索不到故事的主题，当然如果“主角变强变强再变强”也算主题。
（中将Monkey D. Garp介绍四皇）

2) OP启用了多元化的叙述方式，让故事显得更加具有立体感。
大体轮廓确定之后，尾田先生在漫画的主干上面耗费了太多太多的精力，为我们呈现出来极
其精彩的故事。

我们开始的时候都会知道，Shanks是Luffy的启蒙英雄，由他激励鼓舞，Luffy踏上了海贼王
的征程。那么依据观众的理解，Shanks将来肯定会在伟大航路和Luffy碰面，还会向Luffy提
供帮助和指引。对，没错，不过Shanks后来展现在大家面前的时候还是吓了一跳：他就是在
新世界里君临海上的四皇之一“红发Shanks”。这种落差感，让我们对他们的相遇期待度大增。

尾田的这种起承的手法用了非常非常的多，包括巨鲸Laboon的约定，Zoro对Mihawk的誓言等
等等等。

再来说说，第24集动画的时候，Luffy遭遇Sanji，努力想纳入麾下。但是面对的主要矛盾则
是，摆脱红脚Zeff的干扰和努力说服Sanji，但是红脚Zeff可是穿越伟大航路的大海贼，所
以我们开始把视线聚焦到Luffy vs. Zeff的问题上来。但是后来东海霸主Kreig来袭，我们
又确定他才是本场的强敌。不过更恐怖的才来到我们面前，世界第一剑客，同时是七武海之
一的鹰眼Mihawk紧随Kreig来到东海，而又发生Zoro单挑鹰眼的事件。这让观众才和Zoro一
样惊叹：这才是世界第一的力量！这种层层迭加的紧张感觉，更加白热化的场景，实在让海
贼王更加趋近于电影化。

这样的情节在海贼王屡见不鲜，空岛被迫牵连到本地人的纠纷，司法岛引出Nico Robin离奇
的身世，处处显示出尾田先生的高明。

3) 尾田创作的是一部笑着流泪的漫画。
环顾当今《周年少年JUMP》的三大漫画，OP一定是最为轻松的一个了。Luffy，Usopp和
Chopper本身就是一个超级无敌高效组合……尾田先生在剧情中添加了非常非常多夸张的肢体
语言，可以让猥琐的敌人更加幽默，让恐怖的局势稍显放松。

然而OP努力在人格刻画上费劲心思，Shanks为拯救Luffy而断臂，Zeff为Sanji忍受饥饿，
Laboon厮守和Brook的约定，Vivi和草帽海贼团的惜别之情。这些OP迷们耳熟能详的场面，
每每重复的时候，仍旧能让大家泪流满面。

想到动画开始的时候真的是非常痛苦，不明白是制作成本，还是知名度不高的原因，OP动画
的前几十集真的是朴实到“粗糙”，长时间以来人们都称之为“一流漫画，二流动画”。即便是
到后来，OP仍旧没有引用广泛的3d技术，没有神乎其神的PK情景，绚烂的招式噼里啪啦打上
天昏地暗，我才明白，这才是OP，用真情信义感动大家的海贼王。
（草帽一伙与Vivi惜别）

4) OP的场景和角色非常多元化。
能坚持从头看到今天，我真是对画家佩服的五体投地。十年动画里涌现出来的各式新鲜玩意
儿，实在让人目瞪口呆。

那么那么多的建筑风格，那么那么多的恶魔果实，那么那么多的珍禽异类，那么那么奇怪的
大叔大婶，那么那么搞笑的敌人。。。尾田脑子里天天在想些什么呢？

5) OP自始自终保留了故事的神秘美感，这是能够在十年以来保持长久不衰的重要原因。
当然我在这里就不再讨论七武海是啥能力，四皇最后一位是谁了，那是些论坛上永久不会停
歇的话题（除了尾田直接说出来）。我只说一些重头戏：

历史文本之谜。空岛的老头曾经说过：“20年前也有一个家伙来到空岛，那家伙真是豪爽阿！
”紧接着，在空岛的历史正文旁边，草帽们发现了海贼王Roger的签名。在之后的水之都章节
里，我们已经发现Nico Robin隐藏着巨大的秘密，这显然印证了青稚所言：那个女人身后的
黑暗不是你们可以理解的。司法岛一战才告诉我们，恶魔之子Nico Robin正是可以读懂历史
正文的最后一人。由此即将揭示的空白历史到底描述了什么呢？

还有一些热度非常高的未解之谜：Luffy的父亲Dragon到底在进行什么样的事业，海贼王
Roger投降的原因呢？恶魔果实的来源？

漫画达到10年历程，我们还是被这样的迷题折腾的死去活来，这无疑让One Piece保持着神
秘的美感，延续着它的青春和生命力。
（革命家Dragon一切都是个迷）

6) 最后，轻松搞笑的海贼王，仍旧具有深度和前瞻性。
世界政府掩盖历史，无论如何，这都会让人联想到日本政府掩盖真相的事实。这个隐喻不言
而喻，真正的历史是属于人类的，它们一定不会被抹杀。

在尾田的笔下，人物焕发出来的精神和气质值得当代青年人学习：
这里有Sanji表现出来的骑士精神，Zoro为梦想坚持不懈，永不言放弃，Usopp唯唯诺诺，需
要不断超越自我，Brook作死守誓约的男人，Luffy重视朋友轻易，这一群爱理想的少年焕发
出来的自由注意精神，永远值得我们称道！

对海贼王的问候

最后在十周年之际，向他们致以问候！

Monkey D. Luffy，船长。没啥可说的。

三刀流 Roronoa Zoro，Zoro在OP世界里以传统职业——剑士的身份，通过苦行不断磨练自己，
最终达到终极目标————打败世界第一剑客 Dracule Mihawk！

航海士 Nami，在地理位置复杂，气候恶劣的Grand Line，一位杰出的航海士将会是顺利航
行的关键。清纯可爱的Nami对宝箱可是有着天生的直觉。

狙击手 Usopp，他用来完成远程狙击人物，在尾田的笔下，Usopp性格幽默，但身材柔弱，
胆小怕事，这使得Usopp更加趋近于常人，形象具有警世的价值！
值得一提的是，Usopp的声优是非常出名的山口胜平，你可以想象金田一，犬夜叉，怪盗基
德，乱马……实乃声优界的超级大腕。

厨师 Sanji，在Sanji看来，没有什么比荒岛上饿肚子更加恶劣的体验了。平日里的Sanji，
形象俊朗，见女士腿软，极富“骑士精神”。

医师 Tony Tony Chopper，队中唯一的一位动物角色，Chopper极富仁义的天性和羞怯可爱
的性情，使得他胜任医生重要一职。为其献声的因为皮卡秋誉满全球的大谷育江。

恶魔之子 Nico Robin，通晓古文字的她可以破解“冥王”之谜，而她黑暗离奇的身世将会在
司法岛章节揭开。从Miss All Sunday到草帽海贼团一员，尾田对于Robin花费了太多的手笔，
Nico Robin 也是我个人最喜欢的动漫女性角色。

造船师 Franky，在水之都对草帽海贼团建造新船——万里阳光号，这无疑是给海贼团们进行
了大换血。

音乐家 Brook，拥有88岁的年纪，他将是One Piece的第八个队员。Brook是一个借助恶魔果
实保持生命的骷髅，他有着儒雅的风度，却保留了很龌龊的个性（喜欢问女孩子：可以看一
下内裤吗……）。Brook的目标是绕行伟大航路一周，最后回到双子岬完成50年的约定。

第一只船，黄金梅利号（Going Merry），这是来自Usopp相知相识的朋友Kaya赠送给草帽们
的珍贵礼物。

第二之船，万里阳光号（Thousand Sunny），在司法岛事件之后，Franky送给草帽海贼团一
件大礼，借助自己无以伦比的造船工艺，新船具有更出色的性能，舒适的船舱和强大的功能。

最后是大神尾田荣一郎，现年33岁。他的画风深受著名画家鸟山明的影响。

OP十周年纪念！

-----------------
引用：
1. 少年JUMP官方网站：
2. wiki -- onepiece
3. The Rise and Fall of Weekly Shonen Jump:
4. OnePiece官方网站

[TIC++] C9. Inline Functions

2008-10-06T11:46:00.001+08:00

代码阅读 <Thinking in C++>
Chapter 9. Inline Functions

一、什么是Inline


// c09: macro_side_effects.cpp
#include <fstream>
using namespace std;

#define BAND(x) (((x) > 5 && (x) < 10) ? (x) : 0)

int main()
{
    ofstream out("macro.out");
//    assure(out, "macro.out");
    for (int i = 4; i < 11; i++) {
        int a = i;
        out << "a = " << a << endl << "\t";
        out << "BAND(++a)" << BAND(++a) << endl;
        out << "\t a = " << a << endl;
    }

}
/* macro.out:
a = 4
    BAND(++a)0
     a = 5
a = 5
    BAND(++a)8
     a = 8
a = 6
    BAND(++a)9
     a = 9
a = 7
    BAND(++a)10
     a = 10
a = 8
    BAND(++a)0
     a = 10
a = 9
    BAND(++a)0
     a = 11
a = 10
    BAND(++a)0
     a = 12
*/

第一个例子，介绍了宏(macro)带来的负面效应。BAND(x)定义了一个三元运算符，C/C++中
会对选择语句中的与运算和或运算进行优化，(x)>5为false之后，将不会考虑(x)<10，而自
增运算符结合macro会产生预料之外的效果。

为了消除奇异，避免此类情况发生，我们引入了内联方法——


// c09: inline.cpp
#include <iostream>
#include <string>
using namespace std;

class Point {
    int i, j, k;
public:
    Point(): i(0), j(0), k(0) {}
    Point(int ii, int jj, int kk)
        : i(ii), j(jj), k(kk) {}
    void print(const string &msg = "") const
        {
            if (msg.size() != 0)
                cout << msg << endl;
            cout << "i = " << i << ","
                 << "j = " << j << ","
                 << "k = " << k << endl;
        }
};

int main()
{
    Point p, q(1,2,3);
    p.print("value of p");
    q.print("value of q");
}

这里和以前并没有什么异常，这证明人的习惯是很可怕的……我们要说的是，以前在类中定义
的所有函数，都是内联函数(inline functions)。内联函数也只是存在于编译期内，编译的
时候，编译器会打开内联函数的代码，直接迭代到调用处。他起到了宏的作用，而且避免了
负面效用。

考虑一下print(const string&)方法，如果没有内联，那么print代码本身就要将this指针
放入堆栈，并且使用一次汇编语句CALL，大多数机器中，这段代码的长度会比内联展开的代
码量要大，而且花费时间也会更长。

二、使用内联
这个例子包含了三个代码段stash4.h，stash4.cpp，stash4test.cpp。

stash4.h


// c09: stash4.h
// inline functions

#ifndef __STASH4_H
#define __STASH4_H

class stash {
    int size;
    int quantity;
    int next;
    unsigned char *storage;
    void inflate(int increase);
public:
    stash(int sz): size(sz), quantity(0), next(0), storage(0) {}
    stash(int sz, int init_quantity): size(sz), quantity(0), next(0), storage(0)
    {
        inflate(init_quantity);
    }

    ~stash()
    {
        if (storage != 0)
            delete []storage;
    }

    void *fetch(int index) const
    {
        if (index >= next)
            return 0;
        return &(storage[index * size]);
    }

    // declarations of non-inline functions
    int add(void *element);
    int count() const { return next; }
};


#endif // __STASH4_H

stash4.cpp


// c09: stash4.cpp
#include "stash4.h"
#include <iostream>
#include <cassert>
using namespace std;

const int increment = 100;

int stash::add(void *element)
{
    if (next >= quantity)
        inflate(increment);
    int start_bytes = next * size;
    unsigned char *e = (unsigned char*)element;

    for (int i = 0; i < size; i++)
        storage[start_bytes + i] = e[i];
    next ++;
    return(next -1);
}


void stash::inflate(int increase)
{
    assert(increase >= 0);
    if (increase == 0)
        return;
    int new_quantity = quantity + increase;
    int new_bytes = new_quantity * size;
    int old_bytes = quantity * size;
    unsigned char *b = new unsigned char[new_bytes];

    for (int i = 0; i < old_bytes; i++)
        b[i] = storage[i];
    delete [](storage);
    storage = b;
    quantity = new_quantity;
}
///:~

stash4test.cpp


// c09: stash4test.cpp
#include "stash4.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main()
{
    stash int_stash(sizeof(int));

    for (int i = 0; i < 100; i++)
        int_stash.add(&i);
    for (int j = 0; j < int_stash.count(); j++)
        cout << "int_stash.fetch(" << j << ") = "
             << *(int*)int_stash.fetch(j)
             << endl;

    const int bufsize = 80;
    stash string_stash(sizeof(char) * bufsize, 100);
    ifstream in("stash4test.cpp");
    string line;
    while(getline(in, line))
        string_stash.add((char*)line.c_str());

    int k = 0;
    char *cp;
    while ((cp = (char*)string_stash.fetch(k++)) != 0)
        cout << "string_stash.fetch(" << k << ") = "
             << cp << endl;
}
/* result: 结果中途省略
int_stash.fetch(0) = 0
int_stash.fetch(1) = 1
int_stash.fetch(2) = 2
int_stash.fetch(3) = 3
...
int_stash.fetch(98) = 98
int_stash.fetch(99) = 99
string_stash.fetch(1) = // c09: stash4test.cpp
string_stash.fetch(2) = #include "stash4.h"
string_stash.fetch(3) = #include <fstream>
string_stash.fetch(4) = #include <iostream>
string_stash.fetch(5) = #include <string>
string_stash.fetch(6) = using namespace std;
string_stash.fetch(7) =
string_stash.fetch(8) = int main()
string_stash.fetch(9) = {
...
string_stash.fetch(31) = }
*/

stash中的简单方法在这里用到了inline，他们更加的高效和简洁。但也要留意两个最大的
方法在外部被定义，这样他们就不是inline方法，因为这样作不会带来任何效益。

三、向前引用特性


// c09: evaluation_order.cpp
// inline evaluation order

class forward {
    int i;
public:
    forward(): i(0) {}
    // call undeclared function
    int f() const { return g() + 1; }
    int g() const { return 1; }
};

int main()
{
    forward fwd;
    fwd.f();
}

注意到，f()在g()声明或者定义之前调用了g()，这在inline函数世界里变得可能了。
_

[TIC++] C8. Constants

2008-10-05T10:30:00.003+08:00

代码阅读<Thinking in C++>
Chapter 8. constants

一、介绍常量


//safecons.cpp
#include <iostream>
using namespace std;

const int i = 100;
const int j = i + 10;
long address = (long)&j;
char buf[j + 10];

int main(void)
{
   cout << "type a character & CR: ";
   const char c  = cin.get();
   const char c2 = c + 'a';
   cout << c2 << endl;
}

1. 宏，它只存在于预编译期(preprocessing)，不占据内存空间，不包含类型信息。
2. 常量，也在编译期被翻译。通常情况下默认为内部链接，并且不会为const分配内存。这
被称为const folding原则。但是这个原则在很多情况下会被打破。
特例有很多，主要一点就是常量的外部引用。比如extern声明会强制建立外部链接，这
要求修饰的const也要提供地址（内存空间所在位置）。

二、常量遭遇指针


// c08: const_pointer.cpp
const int *u;               // pointer to const int, init not required
int const *v;               // still pointer to const int!
int d = 1;
int * const w = &d;         // const pointer
const int * const x  = &d;  // const pointer to const object
int const * const x2 = &d;

int main(void){}

指针也可以被声明常量，这里带来两个歧义：一个是指针指向的东西被声明常量(pointer
to const)；另一个是指针包含的地址本身被定义为常量(const pointer)。
上面的例子就列举了两种定义，还有另外指向常量的常量指针。
1) 指向常量的指针(`const*')
可以不被初始化
2) 常量型指针(`*const')
必须初始化
3) 指向常量的常量指针(`const * const')
必须初始化


// c08: pointer_assignment.cpp
int d = 1;
const int e = 2;
int *u = &d;
//! int *v = &e;   // illegal -- a const
int *w = (int*)&e; // legal but bad practice

int main(){}

这里举例说明了指针赋值。
1. 常量不可以再被非常量直接引用(指针和引用均不可以)。
2. 但是他可以被强制转换，转换的安全性需要程序员负责。
3. 不可以在文件域内部对指向常量指针赋值（p2c，cp都不行）

三、常量返回值 return consts by value


// c08: constval.cpp
// return consts by value
// has no meaning for built-in type
int f3() { return 1;}
const int f4() { return 1;}

int main(void)
{
   const int j = f3(); // Works fine
   int k = f4();       // But this works fine too!
}

原子类型之间的赋值，只是拷贝，勿需考虑常量情况。


// c08: const_return_values.cpp
// const return by value
// result cannot be used as an lvalue

class X {
   int i;
public:
   X(int ii = 0);
   void modify();
};

X::X(int ii)
{
   i = ii;
}

void X::modify()
{
   i++;
}

X f5()
{
   return X();
}

const X f6()
{
   return X();
}

void f7(const X& x) // pass non-const reference
{
   x.modify();
}

int main()
{
   f5() = X(1);
   f5().modify();
   // compile-time error
//!    f6() = X(1);
//!    f6().modify();
//!    f7(f5());
//!    f7(f6());        // 29
}

将返回值定义为常量，这对于原子类型来说没有意义。而在自定义类型中，却有很大不同。
NOTE!
如果函数返回一个常量类型的类对象，那么返回的值将不能成为左值（不可被定义和修改）。
而原子类型本身就不能成为左值，所以返回常量原子类型是无意义的。
f5()返回了非常量型，而f6()返回的是常量型的类对象，因此f6()的赋值和修改都是非法的
（f6不可以作为左值）。

四、传递和返回地址 passing and returning addresses


// c08: const_pointer2.cpp

void t(int*) {}

void u(const int *cip)
{
//!    *cip = 2; // illegal -- modifies value
   int i = *cip; // OK -- copies value
//!    int *ip2 = cip; // illegal: non-const
}

const char *v()
{
   // return address of a static array
   return "result of function v()";
}

const int * const w()
{
   static int i;
   return &i;
}

int main()
{
   int x = 0;
   int *ip = &x;
   const int *cip = &x;

   // passing addresses
   t(ip);  // non-const* to non-const*
//!    t(cip); // const*     to non-const*
   u(ip);  // non-const* to const*
   u(cip); // const*     to const*

   // returning addresses
//!    char *cp = v();         // const* to non-const*, not OK
   const char * ccp = v(); // const* to const*
//!    int *ip2 = w();         // const* to non-const*, not OK!
   const int * const ccip = w(); // const* to const*
   const int * cip2 = w();
//!    *w() = 1; // modify consts, not OK
}

无论是传递地址，还是返回地址。从const*到non-const*的传递（或赋值）都是被禁止的，
而如果选择将const转换为non-const，则需要确保转换的安全性。

五、常量成员的初始化


// c08: const_init.cpp
#include <iostream>
using namespace std;

class Fred {
   const int size;
public:
   Fred(int sz);
   void print();
};

Fred::Fred(int sz) : size(sz) {}
void Fred::print() { cout << size << endl; }

int main()
{
   Fred a(1), b(2), c(3);

   a.print(), b.print(), c.print();
}

这里展示了构造方法的初始化列表的用法。形如：
Fred::Fred(int sz) : size(sz) {}
函数列表括弧后的单位就是，常量初始化的地方。唯有这里可以将类中定义的常量成员初始
化，实际上，他们是在进入函数体之前就进行了初始化。

六、const 成员遭遇 static


// c08: string_stack.cpp
// using static const to create a compile-time constant
// inside a class
#include <cstring>
#include <string>
#include <iostream>
using namespace std;

class string_stack {
   static const int size = 100; // a static constant
   const string *stack[size];
   int index;
public:
   string_stack();
   void push(const string *s);
   const string *pop();
};

string_stack::string_stack():index(0)
{
   memset(stack, 0, size * sizeof(string*));
}

void string_stack::push(const string *s)
{
   if (index < size)
       stack[index++] = s;
}

const string *string_stack::pop()
{
   if (index > 0) {
       const string *rv = stack[--index];
       stack[index] = 0;
       return rv;
   }
   return 0;
}

const string icecream[] = {
   "pralines & cream",
   "fudge ripple",
   "jamocha almond fudge",
   "wild mountain blackberry",
   "raspberry sortbet",
   "lemon swirl",
   "rocky road",
   "deep chocolate fudge"
};

const int icsz = sizeof(icecream) / sizeof(*icecream);

int main()
{
   string_stack ss;
   for(int i = 0; i < icsz; i++)
       ss.push(&icecream[i]);
   const string *cp;
   while((cp = ss.pop()) != 0)
       cout << *cp << endl;
}

这里展示了C++ string的强大与方便。但是更重要的是，解释了compile-time constants的
用法。
static类成员意味着，无论用此类建立多少个对象，static成员实例都只会存在一个。
另外static const的特性要求，static const常量(原子型)必须在定义位置初始化。

从例子中可以看到，push持有const string*参数，pop()则返回const string*，还有
string_stack包含了一个const string*成员。这看来像一个锁链一样，一环套一环。
stack_stack包含const string *stack[]，这要求在pop():
* 中间赋值必须用const传递, const string *rv;
* 返回值类型必须是const.

const string *icecream也要求push():
* 持有const参数

三个const约定了字符串以const形式亚栈，而除了push和pop以外，你再也无法更改
成员*stack[]。

七、const 成员方法


// c08: const_member.cpp
class X {
   int i;
public:
   X(int ii);
   int f() const; // const member func
   int g();
};


X::X(int ii): i(ii) {}
int X::f() const { return i;}
int X::g() {}

int main()
{
   X x1(10);
   const X x2(20);

   x1.f();
   x2.f();
//!    x2.g(); // discards qualifiers
}

const成员方法，将会告诉编译器，他可以被常量对象调用。而没有被申明常量的方法，将
不可以被常量对象调用！

const成员方法和const函数(const func)有本质不同：
* const func 是返回一个常量值。
* func const 则是表明此成员方法可以被常量对象调用。他的使用方法是：

为了强调const方法，编译器强迫在const成员方法的声明和定义处都要加上const。

接下来细细观察const成员方法和普通成员方法的不同——


// c08: quoter.cpp
// random quote selection

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

class quoter {
   int lastquote;
public:
   quoter();
   int get_lastquote() const; // const member func
   const char *quote(); // member func which returns a const pointer
};

quoter::quoter()
{
   lastquote = -1;
   srand(time(0));
}

int quoter::get_lastquote() const
{
   return lastquote;
}

const char *quoter::quote()
{
   static const char *quotes[] = {
       "Are we having fun yet?",
       "Doctors always know best",
       "Is it ... Atomic?",
       "Fear is obscene",
       "There is scientific evidence "
       "to support the idea "
       "that life is serious",
       "Things that make us happy, make us wise",
   };
   const int qsize = sizeof quotes / sizeof *quotes;
   int qnum = rand() % qsize;

   while (lastquote >=0 && qnum == lastquote)
       qnum = rand() % qsize;
   return quotes[lastquote = qnum];
}

int main()
{
   quoter q;
   const quoter cq;

   cq.get_lastquote();
//!    cq.quote(); // 常量型对象无法调用非常量型成员方法
   for (int i = 0; i < 20; i++)
       cout  << q.quote() << endl;
}

这里比较了const对象和普通对象处理的区别，另外揭示了const成员方法的条件：
如果成员方法体内更改了数据成员，那么它就不能声明为const。

比如const char *quoter::quote()更改了成员 lastquote（return语句），它将不能声明
为const；而int quoter::get_lastquote()则没有动，他就可以成为const成员方法，而且
可以被常量对象cq安全调用。

如果我确实声明了const成员方法，我又确实想更改类成员，我该如何是好？

八、bitwise vs. logical const


// c08: castaway.cpp
class Y {
   int i;
public:
   Y();
   void f() const;
};

Y::Y(): i(0) {}

void Y::f() const
{
   //! i++;
   ((Y*)this)->i++;
   // Better: use C++ explicit cast syntax:
   (const_cast<Y*>(this))->i++;
}

int main()
{
   const Y yy;
   yy.f();
}

bitwise const意思是说，此对象的每一数据比特都是永久不可变的，这样它的任何一部分
都不可改变；而logical const意思是，虽然从概念上说整个对象不可改变，但是可以从成
员基础上更改它本身。
这其实是编译器给const定义的两面性，一方面编译器小心翼翼地确保const对象是bitwise
的，另一方面，它又提供两个路径来通过_const成员函数_来更改数据成员。

以上就是第一个：转换掉const属性。无论是C还是C++语法，都一样可行。
这样带来的一个问题就是，你无法确认你的更改是否有效。。。

于是提供了第二个方法：


// c08: mutable.cpp
class Z {
private:
   int i;
   mutable int j;
public:
   Z();
   void f() const;
};

Z::Z(): i(0), j(0) {}

void Z::f() const
{
   //! i++; // error - const mem func
   j++;
}

int main()
{
   const Z zz;
   zz.f();
}

mutable 关键词告诉编译器，被定义为mutable的数据成员，在const成员方法内仍旧可以更
改。相对转型，显然mutable更加优雅一点。

TIC++也提到了只读属性（ROMability），如何指导编译器把const对象放到只读内存中呢？
这个条件比较复杂，任何可以改写数据成员的可能都会阻止只读化：
1) 不包含logical const特性（不能有mutable关键词，也不能有const转型）
2) class或者struct不可以包含任何自定义构造和析构方法
3) 也不可以包含有自定义构造和析构方法的超类和成员对象（子类没有限制）

九、volatile和类


// c08: volatile.cpp

class comm {
   const volatile unsigned char byte;
   volatile unsigned char flag;
   enum { bufsize = 100 };
   unsigned char buf[bufsize];
   int index;
public:
   comm();
   void isr() volatile;
   char read(int index) const;
};

comm::comm(): index(0), byte(0), flag(0) {}

// only a demo; won't actually work as an interrupt service routine:
void comm::isr() volatile
{
   flag = 0;
   buf[index++] = byte;
   if (index >= bufsize)
       index = 0;
}

char comm::read(int index) const
{
   if (index < 0 || index >= bufsize)
       return 0;
   return buf[index];
}

int main()
{
   volatile comm port;
   port.isr(); // OK
//!    port.read(0); // Error, read() not volatile
}

volatile关键字和const是极其相似的修饰词，只不过他们的意义不同。
通常情况下，编译器会告诉我们：我把此数据读入到了寄存器，但我保证不会再去碰它。下
次需要读取此变量，直接从寄存器中读取即可（而不需要到内存中寻找）。
而volatile告诉编译器：这个数据成员的活动，将会超过编译器的理解范围。如果需要读取
此数据，不要尝试从寄存器中取值，因为内存和寄存器可能已经出现了不同步。

同const一样，volatile对象也只能调用volatile成员方法。

十、总结
const一章的例子比其他章节要多，原因是const类型在C++中遇到了多种繁杂的情况，而且
他们也表现出来各自的特性。总结来说，我们探讨了以下情况：

* 原子类型申明为const（这里也讨论了const*和*const）
const声明意味着，这意味着该内存为只读属性。const存在于编译期，通常情况下默认为
内部链接，并且不会为const分配内存，这被称为const folding原则。const类型的局部
标识符必须在定义时候初始化。
const指针包括了指向常量的指针(const*)和常指针(*const)，const*可以选择是否初始
化，但是他不可以显性修改指针指向的内存(*x = y illegal)；*const不可以修改指针
本身((int*)a = (int*)b illegal)。

* 返回值为const
const返回值将不可作为左值，赋值修改都是非法的。而作为右值时候，const返回值的左
值必须为const，const到non-const的传递和赋值都是非法的。

* 传递参数为const
const到non-const的传递仍旧是非法的。要切记这一规则。

* 成员数据为const
const成员数据不可以在普通成员方法中更改。这里也给出了特例（const_init.cpp）：
使用构造方法的初始化列表来完成常量数据成员的初始化。

* 成员数据为static const
static说明所有的成员实例都会共享一个static数据成员。static const额外要求必须在
定义位置实现初始化。

* 成员方法为const
首先，一个const成员方法将永远不会更改类的数据成员。
再次，声明为const的成员方法允许被const对象调用，而普通成员方法是不允许调用的。

* 对象为const
const对象表现出两个特性，一个是表面上他的整体不可改变（bitwise const）,另一个
则是通过某些特殊方法实现更改（logical const）。
logical const的实现有两种方法，一个在const成员方法使用强制类型转换
（castaway.cpp），另一个是在类定义中给想要修改的值添加mutable修饰词
（mutable.cpp）。
_

[TIC++] C7. Function Overloading and Default Arguments

2008-10-04T10:35:00.005+08:00

代码阅读<Thinking in C++>
Chapter 7. Function Overloading and Default Arguments

一、C++中的union


//unionclass.cpp
#include 
using namespace std;

union u {
private:
   int i;
   float f;
public:
   u(int a);
   u(float b);
   ~u();
   int read_int();
   float read_float();
};

u::u(int a)
{
   i = a;
}

u::u(float b)
{
   f = b;
}

u::~u(void)
{
   cout << "u::~u()\n"; }  int u::read_int(void) {     return i; }  float u::read_float(void) {     return f; }  int main(void) {     u X(12), Y(1.9F);     cout <<>

这个例子展示了union的用法。union仍就是C++的关键词，union也和class一样，他也可以
有constructor，destructor，成员方法甚至访问控制。
union和class的不同之处在于：
1. union含有独特的数据存储方式。
2. union不能被继承，这也是由特性1决定的。这使得它在C++里无法大展身手。

二、匿名union


//supervar.cpp
#include 
using namespace std;

class supervar {
   enum {
       character,
       integer,
       floating_point,
   } vartype;
   union {            // anonymous union
       char c;
       int i;
       float f;
   };
public:
   supervar(char ch);
   supervar(int ii);
   supervar(float ff);
   void print();
};

supervar::supervar(char ch)
{
   vartype = character;
   c = ch;
}

supervar::supervar(int ii)
{
   vartype = integer;
   i = ii;
}

supervar::supervar(float ff)
{
   vartype = floating_point;
   f = ff;
}

void supervar::print(void)
{
   switch (vartype) {
   case character:
       cout << "character: " <<>

1. class supervar定义了一个enum类型，但是没有给此类型标注类型名。因为他只是用此
enum定义了一个变量实例vartype.
2. class supervar定义了一个union类型成员，这是一个匿名union(anonymous union)，这
样在此类的成员中应用union成员，将不必使用成员操作符`.'。
如果匿名union定义在文件类型，_一定_要声明为static，这样他就有了内部链接。
_

国庆第二天-疯狂的南山巡游

2008-10-02T22:09:00.006+08:00

国庆到达第二天了，没有能出去爬山，也没有太多能力腐败了。想起酝酿许久的自行车旅
行，觉得今天真是个好日子。曾胖花费￥1400的自行车，多好的条件，于是立刻出发！

地图路线：
http://maps.google.com/maps/ms?ie=UTF&msa=0&msid=102563878911537749872.0004584479d8054cb6ac0
（注意卫星地图和交通图是不一致的，选择卫星地图）

首先从大新居委会出发，西转到深圳西车站，然后顺着月亮湾大道南下。沿途大部分交通工
具都是货车，在港湾和机场之间来回。不过一会，就来到南山区的西南角——妈湾。

接着从妈湾东转到赤湾，这一带是集装箱盛集的地方。

然后来到赤湾岛部分，伸出的小岛部分被集装箱覆盖。

然后进入到赤湾村，我在深圳不知道曾经坐过多少次226和204，这次就来到他们的终点站——
赤湾。赤湾的景点，最出名的就是宋少帝陵。
引自百度百科：宋少帝陵位于蛇口赤湾，是广东省境内仅有的黄陵。1278年蒙古入侵，南宋
王朝败退至广东新会，爆发"崖海大战"．南宋政权军队被歼始尽，危急关头，宰相陆秀夫背
负仅８岁的少帝跳海殉国．少帝陵处还有陆秀夫背帝的石像．

经过兴海大道，蛇口港，终于来到海上世界。
曾经在07年的时候，我曾经赴海上世界参加百度贴吧深圳吧的聚会，认识了大熊，老男人，
大黄等人。跟着一帮人混达了很长时间，现在大家都是常聚的好友了。因此海上世界是一个
非常有意义的地方，让我想起了一年前的那个时侯。

傍晚时候沿着南海大道狂奔。由于夜色降临，路途急忙，没能拍到照片，敬请见谅。今日行
程也告一段落。

最后给第二主角露一小脸。祝愿大家开心！~

_

从内存对齐到结构对齐

2008-09-30T10:24:00.012+08:00

对于直接操控内存的程序员来说，数据对齐不该是个陌生的术语。它和程序如何良好运行，
甚至和程序是否能正常运转都有很大关系。

在这里我将先简要说明一下内存对齐的基础知识。这些内容来自于IBM developerworks。

内存访问粒度 memory access granularity

程序员可以先将内存简单的认为是一个一维数组。在C和衍生语言里，char*代表着这样一块
内存，而在Java中甚至会用到byte[]来表示内存块。

程序员眼中的内存

我们可以看到内存从0到最大值顺序排列，每一个内存单元都被一个数字索引，这就是内存
地址。

但是现代的处理器却往往不是以一个比特为单位来访问内存的，而是以2，4，8，16，甚至
32个字节为单位。我们把这个尺寸称之为内存访问粒度，用来表示处理器一次存取的内存大
小。

处理器眼中的内存

内存对齐基础知识

我们用固定比特读取这样一个例子，来分析内存对齐。

首先是访问粒度为1比特的处理器

这和程序员脑子中的内存模型是一致的，每次读取一个比特。那么从地址0读取和地址1读
取4个字节，情形完全相同。

来看看访问粒度为2的情况

从0读取的时候，粒度为2的处理器将会花费1/2的时间来读取同样大小的内存（与粒度1相
比）。读取4个字节，将只需要2次存取。

然而，地址1的读取则大不相同，因为地址1没有落在处理器的内存边界上，处理器的活儿就
多了。这样的地址被成为“不对齐地址”。由于地址1没有对齐，那么粒度为2的处理器将会多
花费1个存取次数，显然降低了访问速度。

最后我们来查看粒度为4的处理器

从边界地址上读取4个字节，这里只访问了一次内存。但是从“不对齐地址”处读取，依然会使
读取次数加倍。

懒惰的处理器

回想到我们上面所陈述的3种情况，我们来总结一下非对齐地址的读取。

首先处理器需要从非对齐地址读取第一个内存块，然后将不需要的内存位移出内存块，然后
再从非对齐地址读到第二个内存块，同样移除不需要的内存地带。最后将两者合并到一起，
放置到寄存器里。OH，这真是一个麻烦的任务～

而且……有些处理器不愿意为你作这样的工作。

原先的68000就是粒度为2的处理器，他却缺乏处理非对齐地址的相应电路，因此当遇到此类
访问的时候，处理器会抛出异常。早期的Mac OS对待这种异常非常不友好，很可能会要求用
户重启计算机。听起来实在无奈～

现在所有的处理器都会使用有限数量的晶体管来完成此类任务，在这类问题上会更上一层楼。
但无论怎样，非对齐地址的内存访问始终大大落后于对齐地址，这里处理器必须面对的一个
现实。

编译器中的数据对齐


struct P{
 char a;
 long b;
 char c;
};

struct P的尺寸会是多少？很多程序员会不假思索的回答：6(1+4+1)。他们假想的元素布局
可能会是这样：

Field Type	Field Name	Field Offset	Field End	Field Size
char	a	0	0	1
long	b	1	4	4
char	c	5	5	1
Total Size in Bytes:				6

然而，问问你的编译器就很知道，sizeof(struct P)是12 (GCC4)。真实的结构体布局是：

Field Type	Field Name	Field Offset	Field End	Field Size
char	a	0	0	1
long	b	4	7	4
char	c	8	8	1
Total Size in Bytes:				12

这和我们刚才所说的内存对齐紧密相连。为了保持较高的内存访问效率，编译器也会在数据
结构存储上应用到数据对齐。对齐原则针对平台，编译器，可能会有较大不同，这也是这篇
文章的重点。

首先引入对齐模数概念，编译器会要求数据结构的成员地址是某个数k的倍数，这个常数k则
被称为该数据类型的对齐模数 (alignment modulus，余下简称modulus)。它是成员地址的
公约数，也是成员偏移量的公倍数。

结构体对齐原则

（下面的对齐原则，仅仅针对于GCC）


struct A {
 char a;
 char b;
};
//sizeof(struct A) = 2;

struct B {
 short a;
 short b;
 short c;
};
//sizeof(struct B) = 6;

struct C {
 int a;
 int b;
 int c;
};
//sizeof(struct C) = 12;

这样看很简单。sizeof似乎没有什么问题。char,short,int的长度分别是1,2,4，这样可以
轻而易举的加到结果。


struct D {
 short a;
 int b;
 unsigned c;
};
//sizeof(struct D) = 12;

这里先确定对齐模数，针对VC和GCC编译器，他们各有不同。
cl.exe:
选取成员中的最宽类型的字长为modulus(对齐模数)
GCC:
同样选取成员中字长最大值，但是对齐模数只在三个值间选择，他们是1，2，4。
这意味着GCC结构体的最大modulus只能是4。

struct D中最长类型为int，那么它在GCC中的对齐modulus是sizeof(int) = 4；

同样，这里阐述结构体对齐的三条原则：
1) 结构体变量的首地址必须能够被modulus所整除
2)* 结构体每个成员相对于首地址的偏移量(Offset)必须能被modulus整除，如有需要，在
成员间填充空白字节（这被称为internal padding）

struct D的成员 a 使用到了internal padding。

3) 结构体总大小必须是modulus的整数倍，如有需要，在最末元素填充字节(trailing
padding)

成员C就用到了 trailing padding。

根据以上原则我们可以列出struct D内存布局图:

Field Type	Field Name	Field Offset	Field End	Field Size
short	a	0	1	2
/	(padding)	2	3	2
int	b	4	7	4
char	c	8	8	1
/	(padding)	9	11	3
Total Size in Bytes:				12


struct E {         // offset/data size
 short a;   // 0/2，空位填充
 int b;     // 4/4
 char c;    // 8/1，邻接元素填充
 short d;   // 10/2
};
//sizeof(struct E) = 12;

内存布局：

Field Type	Field Name	Field Offset	Field End	Field Size
short	a	0	1	2
/	(padding)	2	3	2
int	b	4	7	4
char	c	8	8	1
/	(padding)	9	9	1
short	d	10	11	2
Total Size in Bytes:				12

这里引用到了GCC的压缩存储。压缩存储要求，结构体的成员会紧凑的将成员压缩到一个
modulus里。GCC的强压缩方式，又可以忽略元素类型，将不同类型的成员压缩到一个
modulus里。

然后阐述的原则将会对对齐原则2重新定义：
4) 考虑到GCC的压缩存储方式，邻近成员会合并到一个modulus里，合并过程直到可能超出
modulus大小时停止
5) 合并在一个modulus里的数个成员，将会按照“子结构体”的方式来存储。比如拥有更小的
mini modulus，按照mini modulus排列数据成员

struct E 中的元素c，d就使用到了压缩存储。那么c和d将会按照“子结构体”方式存储，
他们拥有的modulus是2 (sizeof(short))。


/* modulus只能考虑基本数据类型，因此结构体成员还需追溯其成员类型 */
struct F {
 char a;
 struct A b;  //
};
//sizeof(struct F) = 3;

对齐模数只能考虑原子数据类型，因此：
6) 成员结构体需要打破结构体边界，追溯成员类型。数组也是一样，modulus将和数组大小
无关

union和class对齐

除了struct以外，C中包含有union，而在C++中更是包含了人见人爱的class支持。他们同
struct一样，是属于符合类型，允许定义多个不同类型的成员。

我们来看看union的特性：


union G {
 char a;
 int b;
 char c[10];
};

通过实验，我们看到结果：sizeof(union F) = 12;
* union仍旧选用最宽数据类型作为modulus（和struct一样）

union G 的modulus是4 (int)。

* 而union采用完全完全压缩方式，它占有的总内存大小，将和最大成员字长一样。

union G的最大成员是char c[10]，再考虑modulus=4，因此取总字长为12。

然后我们写出union G的内存布局。

Field Type	Field Name	Field Offset	Field End	Field Size
char	a	0	0	1
int	b	0	3	4
char	c	0	11	12
Total Size in Bytes:				12



class H {
private:
 int a;
 static char b;           // static 不占空间
 short c;
 unsigned short d;
 void func0();            // public func不占空间
public:
 int e;                   // 公私有对sizeof无影响
 virtual void func1();    // 一个类的virtual只能占据一个指针
 void func2();
 virtual void func3();    //
 virtual void func4();
 virtual void func5();    //
};
//sizeof(H) = 16;

class概念是C++的根基，作为C的超集，C++在class定义中添加了非常多的特性。我们简单
说一下class对齐和内存占用原则:

1) modulus大小和原子类型排列的原则和struct相同
class H将仍旧选取4（int）为对齐modulus。

2) 内存占用和访问控制修饰符无关（比如private，class，protected）
成员a, e各自享用4个字节。

3) static 变量和成员函数，在class结构中不占用空间
static char b将不占内存空间。

4) 如果类包含虚函数，那么要算上一个指针的空间（虚指针）
所有的虚函数（virtual）都共享一个虚指针，原class字长+4

5) 子类将使用基类的modulus。由于继承了成员，子类也将会包含基类的所有字节大小，在
此基础上定义的新成员则按照上述3个法则计算

引用：
1. wikipedia wiki: sizeof
2. Rentzsch, Jonathan. "Data alignment: Straighten up and fly right."
3. king. "sizeof(结构体)和内存对齐"

[TIC++] C5. Hiding the implementation

2008-09-26T11:48:00.003+08:00

代码阅读<Thinking in C++>
Chapter 5. Hiding the implementation

一、友元


//friend.cpp

// public, private, protected
// friends

struct X;
struct Y {
   void f(X*);
};


struct X {
private:
   int i;
public:
   void initialize();
   friend void Y::f(X*);     // struct member friend
   friend struct Z;          // Entire struct is a friend
   friend void g(X*, int);   // Global friend
   friend void h();
};

void X::initialize()
{
   i = 0;
}

void Y::f(X *x)
{
   x->i = 47;
}

struct Z {
private:
   int j;
public:
   void initialize();
   void g(X *x);
};

void Z::initialize()
{
   j = 99;
}

void Z::g(X *x)
{
   x->i += j;
}


void g(X *x, int i)
{
   x->i = i;
}

void h()
{
   X x;
   x.i = 100;
}

int main()
{
   X x;
   Z z;
   z.g(&x);
}

此代码示范了friend友元的用途，声明友元的类在告诉大家，此友元可以访问我的私有成员。
* 从struct X的定义可以看出，在public区域定义了四种友元，他们都可以试图访问修改私
有成员i，当然也包括自己的成员函数。

全局友元函数 global friend
在函数体内，可以任意修改struct X类对象的成员i。
类成员作为友元 struct member friend
可以更改传递的X*参数。
整个类作为友元 entire struct
这样此类的所有成员函数，都拥有友元性质。

二、嵌套的友元


//nested_friend.cpp

#include <iostream>
#include <cstring>
using namespace std;

const int sz = 20;

struct Holder {
private:
   int a[sz];
public:
   void initialize();
   struct Pointer;
   friend struct Pointer;
   struct Pointer {        // nested struct friend
   private:
       Holder *h;
       int *p;
   public:
       void initialize(Holder *h);
       void next();
       void previous();
       void top();
       void end();
       int  read();
       void set(int i);
   };
};

// type class::nested_class::variable;
void Holder::initialize()
{
   memset(a, 0, sz * sizeof(int));
}

void Holder::Pointer::initialize(Holder *rv)
{
   h = rv;
   p = rv->a; // access private member of super class
}

void Holder::Pointer::next()
{
   if (p < &(h->a[sz - 1]))
       p++;
}

void Holder::Pointer::previous()
{
   if (p > &(h->a[0]))
       p--;
}

void Holder::Pointer::top()
{
   p = &(h->a[0]);
}

void Holder::Pointer::end()
{
   p = &(h->a[sz-1]);
}

int Holder::Pointer::read()
{
   return *p;
}

void Holder::Pointer::set(int i)
{
   *p = i;
}

int main()
{
   Holder h;
   Holder::Pointer hp, hp2;
   int i;

   h.initialize();
   hp.initialize(&h);
   hp2.initialize(&h);
   for (i = 0; i < sz; i++) {
       hp.set(i);
       hp.next();
   }
   hp.top();
   hp2.end();
   for (i = 0; i < sz; i++) {
       cout << "hp = " << hp.read()
            << ", hp2 = " << hp2.read() << endl;
       hp.next();
       hp2.previous();
   }
}
/* result:
hp = 0, hp2 = 19
hp = 1, hp2 = 18
hp = 2, hp2 = 17
hp = 3, hp2 = 16
hp = 4, hp2 = 15
hp = 5, hp2 = 14
hp = 6, hp2 = 13
hp = 7, hp2 = 12
hp = 8, hp2 = 11
hp = 9, hp2 = 10
hp = 10, hp2 = 9
hp = 11, hp2 = 8
hp = 12, hp2 = 7
hp = 13, hp2 = 6
hp = 14, hp2 = 5
hp = 15, hp2 = 4
hp = 16, hp2 = 3
hp = 17, hp2 = 2
hp = 18, hp2 = 1
hp = 19, hp2 = 0
*/

这里的Holder类中又包含Pointer类定义，这是个嵌套类。例子在展示子类作为友元时的用
途。
在这里定义了Holder类对象h，和子类Pointer对象hp,hp2，他们包含有h的指针，和父类私
有成员a的位置。作为友元类，hp和hp2可以访问、修改父类对象h的私有成员int a[];

三、初识构造函数和析构函数


//constructor.cpp
#include <iostream>
using namespace std;

class Tree {
   int height;
public:
   Tree(int initialHeight);
   ~Tree();
   void grow(int years);
   void printsize();
};

Tree::Tree(int initialHeight)
{
   height = initialHeight;
}

Tree::~Tree()
{
   cout << "inside tree destructor " << endl;
   printsize();
}

void Tree::grow(int years)
{
   height += years;
}

void Tree::printsize()
{
   cout << "Tree height is " << height << endl;
}

int main()
{
   cout << "before opening brace " << endl;
   {
       Tree t(12);  //constructor called
       cout << "after Tree creation" << endl;
       t.printsize();
       t.grow(4);
       cout << "before closing brace" << endl;

       //destructor called(endline of t)
   }
   cout << "after closing brace  " << endl;
}
/* result:
before opening brace
after Tree creation
Tree height is 12
before closing brace
inside tree destructor
Tree height is 16
after closing brace
*/

例子展示了constructor和destructor的性能。
* constructor在建立对象的时候，由编译器插入语句，完成初始化行为，在对象生命期内
只执行一次。
* destructor相反，在注销对象的时候执行。
* 代码中使用了{}圈定对象Tree T的生命域，它在`}'之后被注销。
下面讲述constructor一个特性。


//nojump.cpp
#include <iostream>
using namespace std;

class X {
public:
   X();
};

X::X() {}

void f(int i)
{
   if (i < 10) {
       // crosses initialization of `X x1'
//        goto jump1;
   }
   X x1;  

jump1:
   switch (i) {
   case 1:
       X x2;
       // crosses initialization of `X x3'
       break;
//    case 2:
       X x3;
       break;
   }
}

int main()
{
   f(9);
   f(11);
}

这是一个诡异的例子，首字符注释段取消注释之后，编译器将报错: `cross
initialization'。GCC将不允许goto，case语句等，来跳过任何对象的定义（初始化）阶段。

四、定义stack


//stack.h
#ifndef _STACK_H
#define _STACK_H

class stack {
   struct linklist {
       void *data;
       linklist *next;
       linklist(void *dat, linklist* nxt);
       ~linklist();
   }* head;
public:
   stack();
   ~stack();
   void push(void *data);
   void *peek();
   void *pop();
};

#endif // STACK_H


//stack.cpp
#include "stack.h"

stack::linklist::linklist(void *dat, linklist *nxt)
{
   data = dat;
   next = nxt;
}

stack::linklist::~linklist() {}

stack::stack()
{
   head = 0;
}

void * stack::peek()
{
   if (head != 0)
       return head->data;
   else
       return 0;
}

void stack::push(void *dat)
{
   head = new linklist(dat, head);
}

void * stack::pop()
{
   if (head == 0)
       return 0;
   void *result = head->data;
   linklist *oldHead = head;
   head = head->next;
   delete oldHead;
   return result;
}

stack::~stack()
{
   if (head != 0)
       return;
}


//stacktest.cpp
#include "stack.h"

#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
//    requireArgs(argc, 1);
   ifstream in(argv[1]);
   if(in == 0)
       return -1;
//    assure(in, argv[1]);

   stack textlines;
   string line;
   while (getline(in, line))
       textlines.push(new string(line));
   string *s;
   while ((s = (string *)textlines.pop()) != 0) {
       cout << *s << endl;
       delete s;
   }
}
/* 执行命令 ./a.out Makefile
* 将按行逆序打印Makefile内容。
*/

stack.h，stack.cpp，stacktest.cpp是链表式堆栈的实现。
* linklist是节点数据结构的实现，他是stack数据结构的成员。
* 无论对于父子类对象，他们都会有自己的构造函数和析构函数。
* push函数非常漂亮！
* 使用new 和 delete，来分配堆区空间，这会使得C++代码更加优雅。

Gentoo配置无限网卡ipw2100

2008-09-25T16:43:00.004+08:00

无限网卡的配置让我倍受折腾，在一两个月内，我不知道翻阅了多少资料，问了多少人，尝
试了多少遍，和放弃了多少遍。昨天我转换一下思维，直接从命令行里敲iwconfig命令，居
然连接上了。因此赶快留下记录，供以后查阅。

硬件环境
IBM Thinkpad R50
- Intel PRO/Wireless LAN 2100 无线网卡
- ATI Radeon Mobility 7500

软件环境
linux-2.6.26-gentoo, i686
Gentoo profile: default/linux/x86/2008.0/desktop
gcc-4.3.1
glibc-2.8_p20080602-r0

配置方案
内核驱动 + ipw2100固件 + iwconfig

下面简述安装配置过程;

一、安装内核驱动

ipw2100作为应用广泛的网卡，已经在内核里加入支持，而且你在gentoo的portage tree中
也找不到ipw2100的驱动了。因此，你只需要在内核里编译即可（建议编译成模块），编译
后的模块名称为ipw2100。

编译选项为：


Symbol: IPW2100 [=m]
│ Prompt: Intel PRO/Wireless 2100 Network Connection
│   Defined at drivers/net/wireless/Kconfig:126
│   Depends on: NETDEVICES && !S390 && PCI && WLAN_80211
│   Location:
│     -> Device Drivers
│       -> Network device support (NETDEVICES [=y])
│         -> Wireless LAN
│           -> Wireless LAN (IEEE 802.11) (WLAN_80211 [=y])
│   Selects: WIRELESS_EXT && FW_LOADER && IEEE80211

二、安装firmware

firmware是不公开的驱动程序需要的数据。ipw2100的固件在gentoo里可以直接安装，安装
后的固件在 /lib/firmware 中。


wickyl@ ~: eix ipw2100
[I] net-wireless/ipw2100-firmware
   Available versions:  (1.3)  1.3
   Installed versions:  1.3(1.3)(04:50:13 PM 08/31/2008)
   Homepage:            http://ipw2100.sourceforge.net/
   Description:         Firmware for the Intel PRO/Wireless 2100 3B miniPCI adapter
wickyl@ ~: sudo emerge ipw2100

至此ipw2100的驱动已经安装完毕了，加载模块ipw2100正确之后，可以用ifconfig查找到新
增的网卡借口（我的是eth1），也可以在dmesg中发现模块打印的信息。


wickyl@ ~: sudo ifconfig
eth1      Link encap:Ethernet  HWaddr 00:0c:f1:0c:87:17
        inet addr:172.1.2.191  Bcast:172.1.255.255  Mask:255.255.0.0
        UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
        RX packets:13955 errors:28 dropped:0 overruns:0 frame:0
        TX packets:2493 errors:0 dropped:0 overruns:0 carrier:0
        collisions:0 txqueuelen:1000
        RX bytes:2311035 (2.2 MiB)  TX bytes:507580 (495.6 KiB)
        Interrupt:11 Base address:0x2000 Memory:c0204000-c0204fff

lo        Link encap:Local Loopback
        inet addr:127.0.0.1  Mask:255.0.0.0
        UP LOOPBACK RUNNING  MTU:16436  Metric:1
        RX packets:265 errors:0 dropped:0 overruns:0 frame:0
        TX packets:265 errors:0 dropped:0 overruns:0 carrier:0
        collisions:0 txqueuelen:0
        RX bytes:20472 (19.9 KiB)  TX bytes:20472 (19.9 KiB)


wickyl@ ~: dmesg | grep ipw2100
ipw2100: Intel(R) PRO/Wireless 2100 Network Driver, git-1.2.2
ipw2100: Copyright(c) 2003-2006 Intel Corporation
ipw2100: Detected Intel PRO/Wireless 2100 Network Connection
firmware: requesting ipw2100-1.3.fw

三、安装必备软件支持

必备的软件包括wireless-tools, dhcpcd，gentoo的官方文档中提醒你，无线的配置工具可
以使用 wpa_supplicant 和 iwconfig(wireless-tools)，但是我始终无法使用
wpa_supplicant 成功配置无线网卡，如果你成功了，请告诉我，让我也惊讶一下。


wickyl@ ~: sudo emerge wireless-tools dhcpcd

These are the packages that would be merged, in order:

Calculating dependencies... done!
[ebuild   R   ] net-wireless/wireless-tools-29  USE="nls -multicall" 0 kB
[ebuild   R   ] net-misc/dhcpcd-4.0.1  USE="compat zeroconf" 0 kB
...

四、配置网络接口 (eth1)

网络接口的配置，在 gentoo 里显得规范而且有特色，它的主配置文件在 /etc/conf.d/net
里，在官方文档中详细的介绍了无线网络服务的配置。

配置步骤分两步，首先建立 /etc/init.d/net.eth1 链接。


wickyl@ ~: ln -s /etc/init.d/net.lo /etc/init.d/net.eth1

然后是配置 /etc/conf.d/net，以下是我的配置（eth1）：


#### wireless networking configuration
#### ipw2100 + wpa_supplicant
config_eth1=("dhcp");
modules=("iwconfig");
key_<essid1>="[1] <passwd> key [1] enc open"
key_<essid2>="off"

preferred_aps=("<essid1>" "<essid2>")

简单说明一下，我的eth1是使用dhcp来配置网络和路由器地址的，这需要你安装dhcpcd。我
从没有使用静态地址配置无线网络，那样显得很不实际。

modules=("iwconfig");
指定无线配置接口，可选项是：iwconfig/wpa_supplicant。

key_<essid1>="[1] <passwd> key [1] enc open"
key_<essid2>="off"
指定AP接入点和加密方式。这里的<essid1>使用了开放方式，需要用<passwd>指定密码。
而<essid2>则没有设立密码，一般的公网就是不设定密码的。

preferred_aps=("<essid1>" "<essid2>")
preferred_aps指定AP的优先顺序。你也可以添加接入点APs的更多选项，包括屏蔽接入点等
等。这在手册中都有介绍。

五、启动 net.eth1 服务来完成配置


wickyl@ ~: sudo rc-config start net.eth1

配置完成之后，可以用iwconfig来查询信息。这是南山图书馆一个AP的配置信息。


wickyl@ ~: sudo iwconfig eth1
Password:
eth1      IEEE 802.11b  ESSID:"nslib"  Nickname:"ipw2100"
        Mode:Managed  Frequency:2.412 GHz  Access Point: 00:02:6F:05:CF:7A
        Bit Rate=11 Mb/s   Tx-Power:16 dBm
        Retry short limit:7   RTS thr:off   Fragment thr:off
        Encryption key:off
        Power Management:off
        Link Quality=98/100  Signal level=-49 dBm
        Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
        Tx excessive retries:0  Invalid misc:4   Missed beacon:4

为什么我消耗老长的时间？

长久以来，我都没有爱好选择习惯，如果一个事物有更多的好处，那我偏向于倾注经历在此
事物上。
在gentoo的手册上，明确写着：“wpa_supplicant is the best choice”。我听之任之，一
直都在使用 wpa_supplicant 来坚持配置无限网卡。

在szlug上，我张贴询问了配置问题，上面列举了我怎么在这个问题上消磨生命的。


ieee80211_crypt: registered algorithm 'NULL'

这东西我不知道所言何物，按照rae老兄的指示，我用Ubuntu LiveCD测试了一下，乖乖！
Gnome下的NetworkManager工具直接提示我输入无限网接入密码。实在是太自卑了！
我查看了一下dmesg info。


ieee80211_crypt: registered algorithm 'WEP'

这显然是ieee80211加密算法的问题。我重新编译内核，加入了ieee80211_crypt_wep模块。

然后又是启动服务的时候报错，我使用的是wpa_supplicant。


ipw2100: Fatal interrupt. Scheduling firmware restart.
ipw2100: exit - failed to send CARD_DISABLE command

我始终没有尝试过转换角度，如果早些时候可以退一步，来使用iwconfig配置，如果我像昨
天一样轻轻的敲入一个iwconfig命令，我就可以发现世界是多么的美好。

事情很奇妙，不是么？有选择，就有出路。这就是Linux。

9月21日移步老虎涧

2008-09-23T12:45:00.010+08:00

17爬爬吧在最近有了突飞的进步：它的QQ群成为高级群，开始过多容纳更多的驴友；爬爬吧
也有了自己的队旗；他也有了自己的贴吧。

活动组织：http://tieba.baidu.com/f?kz=478862495
GoogleMaps:
http://maps.google.com/maps/ms?ie=UTF&msa=0&msid=102563878911537749872.000456f0206e6b722a6c2

这次的活动，选取了梧桐山的老虎涧。这是非常适合溯溪登山，前往梧桐山的一条捷径。但
是这次的活动人数过多（35人），因此没有选择达到大梧桐峰作为目的地。行程将要选择经
历三个瀑布，然后环山路到恩上村，午饭后搭乘饭馆老板的车，沿着新开的盐田高速下山。

这就是“17爬爬吧”的队旗，上面清楚的写上Q群的号码，和群的性质：深圳户外。

这次的人非常之多，也有了明细的分工。包括领队黄瓜，中间Wick（我），结尾老狼，还有
队医米卡飞飞。装备完善，可谓作足了准备阿！

马上临近十一了，黄金周的气氛洋溢在每个人的脸上。
除了我们以外，仍旧有别的户外组织和我们一起同行。达到第一个瀑布，已经有小伙子们按
捺不住，跳入清泉。

第二个瀑布最热闹，大堆的小伙子前赴后继跳入瀑布中，有如下饺子一样。

老虎涧坡度要比马峦山陡峭，水流更多，岩石更滑，因此难度也更大。如果要选择溯溪，一
定要有防滑鞋。还有不爱穿袜子的女孩子，一定要注意了，这对爬山都相当不利。

梧桐山也是一个出色的绿色生态系统，有着繁多的动植物品种。但是沿途只发现蚂蚁和蜘蛛
……

第三个瀑布，很是漂亮。从这里分道，一队直奔大梧桐峰，而大部队则环山绕道恩上村。

恩上村一路平坦，会经过梧桐山的爬坡。小队推进速度很快。

面朝沙头角的一面，可以看到盐田港，对面就是香港。很多联通的朋友可以收到香港的信号。
还可以看到Minsk航母。

登山路途艰辛，到达恩上村时开始一路平坦。沿途汗水和足迹，印证老虎涧的历程。

恩上大坝，风景优美。这里奉上集体照。

到达恩上村时候已经下午两点，我们开始坐下。村庄里的景色非常优美，和马峦山不相上下。
这里还保持着田园耕作的方式，很多作物可以自给自足，无公害的绿色蔬菜也是美味。
在等菜的当儿，大家伙儿按捺不住，开始搓起麻将。广东麻将有如内地的扑克一样普及啊～

饭馆老板送我们下山，下山路将经过新修的盐田高速公路，环山绕道而下，有种GT赛车的感
觉。（这是沿途汽车抗议我们的偷拍）

这是山脚下的盐田区法院，旁边是盐田区文化馆。从外表来看，宏伟的难以想象啊……

谢谢观赏～

[TIC++] C3. C in C++

2008-09-20T16:32:00.013+08:00

代码阅读<Thinking in C++>
Chapter 3. C in C++

一、指针运算


//ptr_math.c
#include <iostream>
using namespace std;

#define P(EX) cout << #EX << ": " << EX << endl;

int main(void)
{
    int a[10];

    for (int i = 0; i < 10; i++)
        a[i] = i;

    int *ip = a;
    P(*ip);
    P(*++ip);
    P(*(ip + 5));

    int *ip2 = ip + 5;
    P(*ip2);
    P(*(ip2 - 4));
    P(*--ip2);
    P(ip2 - ip);
}
/* result:
*ip: 0
*++ip: 1
*(ip + 5): 6
*ip2: 6
*(ip2 - 4): 2
*--ip2: 5
ip2 - ip: 4
*/

C中强大的指针在C++里得到很好的保留，指针的灵活也给初学者带来困惑
1. `#EX'宏定义，此宏定义，将直接迭代打印变量名称（而不是变量值）
2. 指针是带有其类型信息的，根据信息，编译器理解指针运算的单位。
int *pi;
char *pc = (char*)pi;
pi++; //int型指针跳转4个字节
pc++; //char指针增加1个字节

二、介绍引用


//pass_reference.cpp
#include <iostream>
using namespace std;

void f(int& r)  //reference
{
    cout << "r  = " << r << endl;
    cout << "&r = " << &r << endl;
    r = 5;
    cout << "r  = " << r << endl;
}

int main(void)
{
    int x = 47;

    cout << "x  = " << x << endl;
    cout << "&x = " << &x << endl;
    f(x);
    cout << "x  = " << x << endl;
}
/* result:
x  = 47
&x = 0xbfbb29ac
r  = 47
&r = 0xbfbb29ac
r  = 5
x  = 5
*/

引用是C++中的新概念，相当于给变量起了一个新名字。通常用于参数传递。
* C中允许传值，和传址两中方式，在C++又包含了传递引用。
* 传递引用和传址不一样的是，调用方只是传递变量，而非该变量的指针，被调用函数则心
领神会，隐性得到参数地址(&r = &x)。

三、C++中的类型转换


//dynamic_cast.cpp
class Base
{
public:
    int m_iNum;
    virtual void foo() {};  //缺少虚函数会报错
};

class Derived: public Base
{
public:
    char *m_szName[100];
};

int main(void)
{
    Base *pb;
    Derived *pd1 = static_cast<Derived *>(pb);
    Derived *pd2 = dynamic_cast<Derived *>(pb);
}

(非TIC++代码)
dynamic_cast 是C++引入的类型转换方法，其他另外还有三个标准方法，这里将举例介绍
dynamic_cast和const_cast。
static_cast是静态类型转换，他仅要求：不可以在无关类型间转换。在基类和子类的指针
和引用转换过程中，其下行转换是危险的（即便可能通过），因为static_cast不会进行类
型转换。
dynamic_cast则弥补了这个缺陷，上下行转换都会进行类型检查，不符合的时候会返回NULL
指针，表明转换失败（而不是报错）。值得注意的是，下行转换的时候dynamic_cast要求基
类保留纯虚函数，否则会报错（因为纯虚函数拥有包含运行时类型信息的虚函数表，无虚函
数是没有虚函数表的）。


//const_cast.cpp
int main(void)
{
    const int i = 0;

    int *j = (int*)&i;                // deprecated form
    j = const_cast<int*>(&i);         // preferred, only int* to int*
//    long *l = const_cast<long*>(&i);  // int* to long*? invalid!
    volatile int k = 0;
    int *u = const_cast<int*>(&k);
}

const_cast<TYPE>(expression)仍然是C++的标准类型转换方法。他用来转换const和
volatile（比如常量指针转换为非常量指针）。有一个要求，那就是要求TYPE和express类
型必须一致。

[TIC++] C2. Making objects

2008-09-20T16:23:00.007+08:00

代码阅读 <Thinking in C++>
Chapter 2. Making Objects

一、第一个C++程序


//hello.cpp---------------------
#include <iostream>
using namespace std;

// cout is an object
// `<<' is an overloaded operator
// `namespace' is used to prevent name collisionx
int main(void)
{
 cout << "Hello world! "
      << "I am "  << 8
      << " today!"<< endl;
}

这是C++的第一个代码程序。和大多其他语言的教材一样，Bruce Eckel也选择了`Hello
world!'这样一个程序来开启C++之门。这个程序的框架和C极其相似，有头文件包含，main
函数等等。

1. <iostream>是C++的标准头文件，这些头文件包含了标准数据结构定义和函数的索引。他
们位于: /usr/lib/gcc/i686-pc-linux-gnu/4.3.1/include
(在`gcc -v'中可以查询configure项：includedir)
2. namespace是C++引入的概念，为了避免命名污染，C++用namespace来指定一些变量的可
视范围(scope)，`using namespace std'是使用std标准命名空间。
3. cout是iostream中定义的一系列标准对象，`<<'则实现了cout对象的运算符重载，作用
是将字符等对象输出到标准输出对象cout。

iostream定义标准对象有：
* cout
一个ostream类的对象，用来打印数据到标准输出设备(STDOUT)
* cerr
也是ostream类的对象，将非缓冲输出数据写入到标准错误设备(STDERR)
* clog
和cerr相似，但是使用缓冲方式输出
* cin
istream，用来从标准输入设备中读取数据(STDIN)

二、numconv.cpp


//numconv.cpp---------------------
#include <iostream>
using namespace std;

int main(void)
{
 int number;

 cout << "please input the number : ";
 cin  >> number;
 cout << "value in octal =  0" << oct << number << endl;
 cout << "value in hex   = 0x" << hex << number << endl;
}

程序从终端读取一个整数，以八进制和十六进制将其打印，展现的是重载运算符的灵活用法。
输出说明：
1. 如果输入起始字符不是整数，则打印无规则数据。（？）
2. 如果输入起始字符是整数，则一直读取到不是字符或者换行符，然后打印。

三、文件流介绍


//scopy.cpp---------------------
#include <fstream>
#include <iostream>
using namespace std;

int main(void)
{
 ifstream in("Makefile");
 ofstream out("output");
 string s;

 // don't worry about how much storage to allocate for a string
 // just add things to it!
 while (getline(in, s))
  out << s << "\n";
}

读取文件Makefile，按行打印到文件output（一次输出一行）。
* ifstream和ostream是来自<fstream>的类，负责建立文件流对象（读和写）。
* string是C++的内建类，这里不必再去担心如何为string对象分配空间。
* getline来源于<string>。
istream& getline( istream& is, string& s, char delimiter = '\n' );
* out如同标准对象cout一样，可以使用重载运算符`<<'。

四、介绍vector


//getwords.cpp---------------------
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;

int main(void)
{
 vector<string> v;
 ifstream in("Makefile");

// string line;
// while (getline(in, line)) // (1)
//  v.push_back(line);
 string word;
 while (in >> word)        // (2)
  v.push_back(word);

 for (int i = 0; i < v.size(); i++)
  cout << i << ": " << v[i] << endl;
}

使用C++标准模板类vector。
1. vector是C++的标准模板类，作为C++代码可重用性的体现，STL一直是C++中变动频繁的
地方。
2. vector<string>将临近元素像数组一样存储。
vector成员赋值和添加元素都可以在O(k)中完成，查找和插入则在O(k*n)中完成。
vector支持一系列操作（cppreference.com）：

  
 /* vector<TYPE>:
  * void assign( size_type num, const TYPE& val );
  * void assign( input_iterator start, input_iterator end );
  * void   insert( iterator loc, size_type num, const TYPE& val );
  * void push_back( const TYPE& val );
  */

代码阅读TIC++：序章

2008-09-20T16:04:00.005+08:00

一、硬件环境


IBM Thinkpad R50
Intel Pentium M 1400MHz

二、软件环境


Gentoo Linux 2008.0
linux-2.6.26-gentoo
GCC 4.3.1
GNU binutils 2.1.8

GCC编译器，其具体信息可以通过`gcc -v'来查询：


  Using built-in specs.
  Target: i686-pc-linux-gnu
  Configured with:
  /var/tmp/portage/sys-devel/gcc-4.3.1/work/gcc-4.3.1/configure
  --prefix=/usr
  --bindir=/usr/i686-pc-linux-gnu/gcc-bin/4.3.1
  --includedir=/usr/lib/gcc/i686-pc-linux-gnu/4.3.1/include
  --datadir=/usr/share/gcc-data/i686-pc-linux-gnu/4.3.1
  --mandir=/usr/share/gcc-data/i686-pc-linux-gnu/4.3.1/man
  --infodir=/usr/share/gcc-data/i686-pc-linux-gnu/4.3.1/info
  --with-gxx-include-dir=/usr/lib/gcc/i686-pc-linux-gnu/4.3.1/include/g++-v4
  --host=i686-pc-linux-gnu
  --build=i686-pc-linux-gnu
  --disable-altivec
  --enable-nls
  --without-included-gettext
  --with-system-zlib
  --disable-checking
  --disable-werror
  --enable-secureplt
  --disable-multilib
  --enable-libmudflap
  --disable-libssp
  --enable-cld
  --disable-libgcj
  --with-arch=i686
  --enable-languages=c,c++,treelang,fortran
  --enable-shared
  --enable-threads=posix
  --enable-__cxa_atexit
  --enable-clocale=gnu
  --with-bugurl=http://bugs.gentoo.org/
  --with-pkgversion='Gentoo 4.3.1 p1.0'
Thread model: posix
gcc version 4.3.1 (Gentoo 4.3.1 p1.0)

三、关于《Thinking in C++》
《Thinking in C++》是C++非常出色的教材类书籍，作者是Bruce Eckel
（同时也是《Thinking in Java》的作者）。
你可以在这里查看到他的全面信息，同样在这里可以下载电子版图书。

四、代码编译
在下载的文件里，一般都包含有书籍里的代码。
编译他们是很简单的，通常情况下，执行一下命令，就可以得到可执行文件 a.out.


g++ filename.cpp

线程的例子需要在加上另外的POSIX thread支持的gcc选项`-pthread'。


g++ filename.cpp -pthread

多文件项目可以自己简单的写出Makefile，在此不再赘述。

中秋佳节，马峦山溯溪

2008-09-14T23:30:00.009+08:00

深圳的秋老虎气候接近尾声了，对于一个属于盛夏的城市，我们目送深圳夏天离去，一个最
好的方式，就是爬山、流汗。9月14日又是中秋节，因此对马峦山的聚会倍加期待。

那先说一下啥是溯溪，溯溪并非爬山，而是沿着溪流顺山而上。这说明活动围绕水而展开，
而不是徒步登山。

这次登山的目的地，选择了深圳的马峦山，在深圳小梅沙的北部。海拔300～590米，在盛夏
山上气温比深圳市区要低3摄氏度。马峦山没有工业污染，空气清新，没有城市噪音，环境
质量相当之高。

活动：马峦山溯溪
人数：26人
官方Q群：4565678
贴吧：http://tieba.baidu.com/f?kz=477382839

公交线路：103（上下沙），360（银湖），364（深航大厦），387（火车站），833（龙岗）
GoogleEarth地址：
http://maps.google.com/maps/ms?ie=UTF&msa=0&msid=102563878911537749872.000456ae6390c1a543d9d

活动开始……

这是深圳海洋世界正门，这是小梅沙旁边极其出名的水上游乐园，大家在里面可以看到的东
东，从南极企鹅，北极熊，到海豚表演等等。门票100元/人，咱们只是沿途看看，咱们都不
说话。

领队：黄瓜，看这装备可谓具备专业驴友素质，头巾，登山包，还有刚买的Canon EOS
1000D，那是相当的骚包。

大部队跟上，我来垫后。

途径叠翠湖，风景不算精致，倒是没有污染，感觉很好。

溯溪自然是顺溪流直上，因此攀岩必不可少，也具备一定的危险性。如果选择溯溪，定要具
备足够的水源和登山鞋。

沿途的细沙，给了一特写。

除了体验大自然的意趣，团队协作也是有意思的部分。需要大家向朋友伸出双手，感受彼此
的关怀。当然关怀之外有啥大事儿发生，当然需要当事人负责的。。。

非常喜欢的瀑布！我们还跳入水里游泳，打闹。让几天来的郁闷一扫而光。

披荆斩棘之后迎来山顶前的冲刺部分，黄瓜告诉咱们，到山顶就可以吃饭了。有美味的土家
烧鸡等着我们。

到达山顶的农家，店家开始现杀现做，准备咱们的午饭。这里风光无限。

今天是中秋节活动，避不了的是中秋月饼，还有主角土家烧鸡。当然这里可以看到是二十六
个人，分五个月饼，囧rz

待到四点钟下山，沿途疾步如飞。

我们在夕阳下结束一天旅程。

谢谢观赏，而后会更新几张更加别致的照片……

照片更新一张吧。

小鑫光临深圳

2008-09-12T20:01:00.004+08:00

前天小鑫发短信问我：深圳西站到深圳主站有多远？二十块钱打的行不？
我回答：恩，二十块钱，我可以带你过去。
小鑫：你现在买车了？
我：架车，楼下房东的。

我不明白为什么远在南京的小鑫会问我这样的问题，怎么突然对深圳感兴趣起来了？直到昨
天下午吓了我一跳。小鑫打电话说：我下午五点会到深圳西站。我才明白这家伙是有预谋的。

南头距离深圳西站非常的近，因此我选择徒步过去。四点半出门后我发现头上乌云，走到半
路的时候，深圳吓起瓢泼大雨。眼前就是深圳西站，这让我很是郁闷。小鑫回话说：深圳的
第一印象是雷声响、雨点大、来势猛、铺天盖地的大暴雨。哎，囧阿！

（这位老哥正准备进站，可是突降大雨又遇堵车）

咱们在一家湘菜馆里坐下，小鑫感觉非常痛苦，一盘拆骨肉辣的是浑身冒汗。这才向我道来
原由：由于小鑫在南京通过了华为的面试，这就到坂田的华为基地来面试呢。这华为效率还
是冈冈地呢～

吃饭的时候聊了很多，说说两年来干的活，一直都是又苦又累。且说上个工作以来，几乎是
夜夜都要在十二点之后下班。这也不是公司的规定，氛围如此，倘若有人十点早退，也不会
有人拦你。但当老班十一点开车夜巡的时候，发现你仍旧挑灯夜战，他也会夸你两句。对于
深圳人来说，这样苦的差事也不是未听过，但是总不至于像南京那样普遍。如若在南京的你
不喜，那你也可以走人，门槛外求职的人比比皆是。南京的工作压力能到这种地步？让我不
解了……

只道是终须一别，在送走小鑫之后，也唯有祝愿他工作蒸蒸日上，注意身体。

（小鑫以奉献精神向大家问好，祝愿大家中秋快乐。此照片翻录必究）

记录腾讯面试

2008-09-02T11:29:00.005+08:00

今天去了腾讯公司的老巢，坐落在飞亚达大楼的7层。

第一次去的时候还是有点发蒙，因为飞亚达那里长时间施工，一时间晕头转向的绕道沙河立
交后面。这样一折腾之后，浑身汗透了，和出道深圳的时候极其类似。

在上电梯的时候，我就琢磨着，腾讯的势力有多大。因为4，5，6层电梯开门总是能看到正
对面的腾讯前台，到了7层一问：小伙子，3楼到10楼都是腾讯地盘。一切简洁代过。

技术型的面试就是简单，递给两张试题，圆珠笔，草稿纸，支个地方就可以了。我在作题目
的时候还能看到后面的人在用source insight写代码，偶尔也会回头和我打招呼，对眼色。

面试题目是核心，大家一定想知道很多。我应聘的是Linux后台开发（看到QQ大批的业务，
他的后台却是Linux，你们大家如何想呢？），题目自然是关注Linux编程环境。面试的师傅
问我作C还是C++，我答曰C。于是他给我抽出试卷B。

题目总共两张，总共9道题，大致划分：

编程环境，2道，execl调用，TCP select问题
数据结构，3道，sizeof，数据存储，查找算法
编程语言，1道，C++类存储
算法，2道，算法分析和设计
编程工具，1道，Makefile

我基本都有答，不过有两个是彻底瞎蒙的。
1. 问题输出结果


#include "unistd.h"
#include "stdio.h"
int main(void)
{
 printf("call execl");
 sleep(1);
 execl("/bin/sh", "", NULL);
 printf("error!\n");
}

正解-->
这个东西只会输出ls结果，两个printf都是不输出的。
首先，Linux IO是行缓冲形式，未遇到换行和强制输出是不数出的，待到execl执行后，创
建新的进程映像，后面的printf也不会去执行。

2. TCP通讯中，select到读事件，但是读到的数据量是0，为什么，如何解决。
同步传输控制？我根本没使用过:(

其他的基本通过，有一个问题很有意思。

3. 假设电信每分钟登录次数是60w次，现在要提醒5分钟内重复登录的用户，如何设计程序
缓存和查找算法？
我说，数据库查询得到5分钟内拨号号码，然后根据号码建立位图数组。他反问我：你知道
数组要有多大么？我答曰，假设足够大……
我又说，为建立的号码列表排序，方便以后二分检索，他又反问：那如果我说这个程序是动
态的呢？要知道随时都会有其他用户登录。我没法回答了。
你咋不早说妮！！……

----------

这么多天来，我一直都在琢磨一个事情，为何自己的能力在一个阶段上，迟迟不能进步。老
是想着作大项目，得到项目经验，却在一些大工程上不知道如何下手。我才发现一个严重的
问题，我往往忽略了很多关键性和基础性的能力培养。数据结构和算法设计是两个核心的概
念，除此之外，那些应付性的代码和蹩脚的设计根本无法谈上经验，似乎这两年都在无止境
的乏味折腾。

所以还是，千里之行，始于足下。如果极限概念模糊，也不要吝惜自己“宝贵”的时间，咬牙
抱起高等数学吧。

Edwick

2011年5月17日 SZLUG 月度聚会

主题

SZLUG 历史、发展与现状, by Wick

介绍 Ubuntu Natty, by Wick

Ubuntu installfest

自由讨论阶段

Kernel Module Loading Order

五一节假日汕头之行 Shantou Tour on May Day Holiday

HOWTO disable failsafe mode in Openwrt

intersection and union： find the difference between two directories

SZLUG April monthly meeting

IOWAIT - 测试IO性能的标尺

物理简史 之 爱因斯坦相对论

2011 磨房深圳百公里体验

SZLUG 月度聚会，一月讨论张乐的谷歌Offer

SZLUG 年底小聚，迎接jserv先生

Syntax Highlighter Test

Ifconfig 如何获得流量统计信息

Ifconfig

net-tools/ifconfig.c

linux/net/core/dev.c

linux/drivers/net/8139too.c

总结

SCSI和SATA

SCSI

概念

SCSI历史

ATA/ATAPI

概念

ATA/ATAPI历史

SCSI和SATA

索引

翻阅 C99 标准

EP93xx GPIO interface

名词

GPIO

GPIO 初始化

GPIO端口和针脚映射

GPIO 寄存器映射

寄存器索引

引用

新章： 试用LXDE Desktop Environment

闲聊

新手接触 LXDE

希望

截图

游历深圳博物馆 (Shenzhen Museum)

初学sed

ARM Linux 启动过程 (1)

RedBoot (bootloader)

概述

RedBoot做的工作

启动内核

优化代码显示的另一个方法

Linux SCSI子系统

scsi历史

scsi架构基础

出发

使用muse来发布日志

控制基本样式

高亮代码

eCos HAL分析

HAL架构

HAL接口

architecture characterization

interrupt handling

HAL I/O

cache control

Linker scripts（连接器脚本，lds）

诊断支持

SMP支持

Cirrus EP9302: 从RedBoot到Linux

Cirrus EP9302

搭建工作环境

配置安装redboot

编译烧录linux

西冲海岸线穿越

eCos，高度自制性的嵌入式操作系统

安装

物理简史之爱因斯坦相对论

新章：试用LXDE Desktop Environment