Jesse's Blog

languages

2011-11-30T18:47:00.001+08:00

(按：写完后，发现此文甚水，而且处处强词夺理。不过有几个地方应该还有点道理，而且我这种人写出文章来就不舍得扔了，所以依然发表。权当博君一笑吧。)

用汉语，英语和法语表达“我是歌手”：

可以看到汉语和英语的语法都相对简单，而汉语更简单一点。上面的汉语例句中，系动词“是”和表语“歌手“没有任何变化，而英语还是保留了一些时态和语态的规则，虽然英语也在变得越来越简单 (趋向于所谓分析语)。

所以说，在语法和语音层面上 (暂且抛开文字不谈)，汉语是一门很简单的语言。那些操着半吊子汉语，还在泡中国姑娘的老外，实在是懒 (抑或是幸运?)。

法国人一向以自己的语言自豪，而法语确实有一种独特的韵味。即使一句普通的话，比如 à la prochaine fois，意思明确，又不失美感。作为对比，英语怎样呢？Till the next time? 意思接近，但是显得别扭，做作；Goodbye, 又偏离原意了。汉语呢，“拜拜”估计是英语中来的，意思同样不准确，放在这也不应景；“再见”，倒正是这个意思，但是在大量使用下，已经丢掉了字面上的本意；不过汉语中确实有个好的，“回见”，虽然略显北京腔。

再看这个例子，传说路易十五曾经这样预言，“在我之后，洪水将至”。法语原文是 Après nous, le déluge。英语翻译是 After me, the flood。

法语依然韵味十足，而我们也能发现英语的一个特点，就是直接，practical。汉语呢，对一个事情往往能有多种表述。语法的简单意味着更少的拘束，更加灵活。

比如这句话 (来自亦舒的一句诗)，彼之熊掌，我之砒霜；或者“彼之琼瑶，我之砒霜”；“彼之蜜糖，我之砒霜”；每一种表述，虽然含义相同，但都带有独特的风味。同样的意思，英语中的经典表述是 One man's food is another's poison. 好直接... 而且即使把 food/poison 换成别的组合，也不会给人不一样的感觉。那法语呢，有伏尔泰的一句话，Le malheur des uns fait le bonheur des autres. 还是法语的特点，表意明确，没有二义，韵味也不失。

汉语中，字词本身不会有语态时态的变化，而且字词的数量比较小 (相对拼音文字的单词)，一句话的意思全靠句子结构、遣词造句来表达 (所谓分析语)，所以句子往往很灵活，说一件事有很多说法，可以高贵，可以卑微，可以直接，可以含蓄。与之相对，英语中单词的意思一般比较单一，句子很少有附加或曲折的含义。

所以说汉语既简单，又灵活，是一种与法语不一样的博大精深。英语则完全是一种实用派的语言，有事说事，直截了当。这些语言都有自己的特点，很难说是优点，也很难说是缺点。

说起法语和法国人的自豪，有一个很重要的原因是法兰西学院，几百年来一直是法语的权威机构，主导法语的发展方向，保持着法语的纯正性。汉语和英语都没有类似的机构，所以两种语言发展的更自由，变化也更大。这一点同样无法评判是好是坏。

当然，很难想象如果有一个“中华学术院”会是个什么样子。极有可能，就沦为作协一样的傀儡了。

而且抛开文化不谈，单从语言特点上看，汉语更容易被操控。乌托邦文学中描述的极权政府经常会有对语言的控制，无论是一九八四中的“新话”，还是电影 V for Vendetta 中的 “I remember how the meaning of words began to change. ... I remember how "different" became dangerous.” 但是对拼音文字来说，这并不是那么的致命。因为他们有大量的词汇可以使用，更可以创造新词。但是汉语就不同，汉字和词语的数量都不大，很难造出新字或新词。如果一个字或词被操纵了，对整个语言的影响会很大。或者说，我们要想挤掉语言中的狼奶，会更难。

英语国家的女权运动中，对语言的修改是一种很重要的表现形式。而汉语中很难做类似的语言游戏。不只是女权运动，汉语就像这个国家一样，转身总是很艰难。

conary dir

2011-11-29T18:44:00.000+08:00

Some conary recipe methods (including addArchive, Make, etc.) accept a "dir" parameter. It allows you to specify a custom directory within which to execute the action. What's confusing is that, its behavior is not so consistent (when dir is a relative directory).

addArchive() by default works inside the "builddir", usually ~/conary/builds/foobar/ (that is the buildPath; check your buildPath with `conary config | grep buildPath`). So an explicit "dir" argument for addArchive is relative to the builddir.

For Make(), MakeInstall(), etc., they work inside the "maindir", usually ~/conary/builds/foobar/foobar-1.0/. So "dir" for them is relative to maindir.

Here is an example.

Some time ago I needed to add an additional tarball to the conary package. This is what it takes.

r.addArchive('https://some/url/conary-bash-completion-0.2.tar.bz2', dir='%(maindir)s')
r.Make(dir='conary-bash-completion-0.2')
r.MakeInstall(dir='conary-bash-completion-0.2')

The tarball has such a structure,

$ tar tf conary-bash-completion-0.2.tar.bz2
conary-bash-completion-0.2/
conary-bash-completion-0.2/generate.py
conary-bash-completion-0.2/README
conary-bash-completion-0.2/Makefile

So, the addArchive() call will extract the tarball at the maindir, ~/conary/builds/conary/conary-2.3/. The files will be available under ~/conary/builds/conary/conary-2.3/conary-bash-completion-0.2. And Make and MakeInstall will work inside that directory.

whitespaces

2011-11-23T18:26:00.000+08:00

两个 shell 小技巧，处理带有空格的文件名。

bash 里，用 for .. in (比如 for f in `cat some/file`; do ...) 或者其它方式 (比如 xargs, cat some/file | xargs ls -l) 处理文件的时候，如果文件名有空格，经常会遇到问题，因为本来是一行一行的文件会被当成一个长字符串，而 bash 和 xargs 在处理的时候，把空格和换行都当成分割符 ($IFS, internal field separator)。

这时候可以改 $IFS。但是它的用法好像比较微妙。所以如果需求很简单，也有一些很简单的应对办法。以下举两例。

1. for f in `cmd`; do ... 可以换成 cmd | while read f; do ...。比如，

cat some/file | while read f; do echo $f; done

2. xargs 可以利用 --delimiter=delim 参数，比如，

xargs -a some/file -d '\n' du -shc

indefinite adjective

2011-11-10T15:45:00.001+08:00

什么叫 indefinite adjective？

An indefinite adjective is an adjective formed from an indefinite pronoun.

The most common indefinite pronouns are: all, any, anyone, anything, each, everybody, everyone, everything, few, many, nobody, none, one, several, some, somebody, and someone.

When used as adjectives, these are known as "indefinite adjectives". (ref)

嗯，非限定性形容词。用作代词时是非限定性代词 / indefinite pronoun，用作形容词就是非限定性形容词。

非限定性，也就是表示泛指。注意，“所有”，“任何”也是泛指。

法语中与英语类似，常见的 indefinite adjective (adjectif indéfini) 包括 autre, aucun, certain, chaque, divers, différents, maint, même, n'importe, plusieurs, quelque, quelconque, tout, 等等。

tout 貌似是个很麻烦的东西，以后再整理。

agile

2011-10-24T22:35:00.002+08:00

M同学问我，“那美国是资本主义吗?”

这个问题本身就是错误的。分类不是这样分的。就好比现在我提出个理论，把所有的水果分成红色主义和绿色主义，那香蕉是哪个主义的？假设现在香蕉卖的特别好，那是因为它采取了红色主义，还是因为它采取了绿色主义？

所以改革开放最大的成就之一就是放弃了以意识形态作为判断标准。以事实作为评判依据，意味着鼓励尝试。(当然，此党的本质决定了这种鼓励不会深入。)

从脑子里想出来的“主义”几乎不可能是完美的，所以选了一个以某一主义为纲的政党上台，从一开始就决定了我们悲惨的结局。

开发软件，尚且无法完全按照计划来实行，更何况治国呢？最伟大的开国者不在于能提出完美的方案，而在于能制定完美的规则。

django simple pager

2011-09-23T18:30:00.000+08:00

Here is a short piece of code to help write a simple pager (or paginator) in django.

Its main function is to insert ellipses at the right places. (Of course! What's hard about a pager anyway). The result is like the one you see on stackoverflow.com.

Examples:

The code (See the original post for the code, if you are using a feed reader such as Google Reader):

python get relative time

2011-09-07T18:26:00.000+08:00

Here is a little piece of python code to get the "age" of a timestamp (in other words, how much time has elapsed since then). Like what you see on Hacker News or reddit, "8 hours ago", "1 day ago", etc.

The job of this code is to figure out the "8 hours" and "1 day" part.

Here is the code (hosted as a gist on github).

I think I got some inspiration from someone's blog on the internet, but I can't find it now. Anyway the codes don't look alike IIRC and it's short, and I put it in the public domain. Do whatever you want.

The function is simple and it's not very robust, e.g. it doesn't handle the case when you pass in a date in the future. But it should be easy to extend.

And it only works for English. For something that can do i18n, you may need gettext.

git notes

2011-08-20T12:23:00.000+08:00

Now git looks even more powerful in my eyes. git-notes gives you the ability to attach some information to the commits. When I came upon this when searching blindly on Google, I thought, "Wow, this is damn cool. Exactly what I'm looking for!"

For the details of this command, see here on Pro Git or in the git manual. This post is about how I used it.

As it always does, git gives the command lots of flexibility. See it for yourself. But what I needed is simple. I don't care about all those feature. I just want "git notes add" and "git notes show", which will help me attach information to the HEAD and later retrieve it.

This is my use case. I'm converting conary repositories (which stores the conary source packages) into git repositories. And I want incremental conversion, i.e. when the conary repo gets new commits, I want to add them on top of the existing git repo, without generating it all once again.

The problem is, there is no way to tell the revisions of the conary packages from the git revisions (neither the other way around). The history in the git repo is identical with that in the conary repo. The commit messages are the same and the commit body are the same. But there is no way to tell which conary revision is which git revision.

Which means, I don't know the progress of the conversion, so I don't know where to resume when new commits come into the conary repo.

I thought about storing the progress in an external file, but that's fragile. What would the git repo was changed by someone else than my script? I thought about storing the conary revision in each of the git commit messages. But that would break my goal of keeping the history untouched.

Then blindly and without much hope, I searched for "git store extra info in commit" on google. The first result is some mailing list discussion. And someone mentioned "git notes". Voilà!

How I used it is actually simple. When one pass of conversion is done, I store the revision of each package that's been converted in a git note. And the next time, I just fetch the note and retrieve the revisions :-)

And I'm grateful that git doesn't complain when I store a 52KB note :)

The code of my script is available at github.

web.py: get auto-increment value after db.insert

2011-07-27T17:09:00.001+08:00

This is probably too simple, so no one ever bothered to write about it. (Or I couldn't come up with the proper keywords for Google).

The situation is simple. I have a table where the primary key is some auto-incrementing ID number (in the case of postgresql, with the primary key called nid, the definition is nid serial primary key). After inserting a record into the table, I want to know what ID it has got.

Turns out it's very simple. I need only to pass a custom seqname to db.insert().



nid = db.insert("tablename", seqname="tablename_nid_seq",...)

For the serial column, postgresql creates a sequence automatically and assigns it a particularly constructed name. More details at FAQ: Using Sequences in PostgreSQL.

This is probably not the best style (I'm hard-coding the seqname in the source code), and I'm not even sure if it's the right way. But at least I can proceed with my prototyping and hacking now :)

Resize partition

2011-07-21T16:53:00.000+08:00

第一次成功地调整分区的大小，所以写篇文章记录一下。

我依稀记起了刚用 Linux 的时候，大概是在 06 或者 07 年吧，当时也是要调整分区大小，结果一番操作下来，启动系统，发现硬盘上啥都没有了。所以最后只能重装系统。现在再来做这件事，虽然不是轻车熟路，但也是不慌不忙了 :P

我要给一个 qemu 虚拟机调整分区，所以下文第一部分是关于 qemu 的。第二部分应该能适用于一般的在真正的硬件上的系统。

1. 调整 qemu 虚拟磁盘的大小

我现在用了一个 12G 的虚拟磁盘给虚拟机用，里边装了个 Linux，根分区大约 10G。我想把根分区扩大 4G。

所以首先要扩大虚拟磁盘的大小。Google 一下可以找到很多办法，我采取的是这里提到的，先创建一个 4G 的文件，然后把它 cat 到原磁盘文件的末尾。这个看起来比较安全 (我一直比较惧怕 dd)。



$ dd if=/dev/zero of=zeros.raw bs=1024k count=4096



$ cat foresight.img zeros.raw > new-foresight.img

用 cat zeros.raw >> foresight.img 估计也可以。

(如果磁盘文件不是 raw 格式的，可能需要先把磁盘文件从 qcow 等格式转换为 raw 格式；可用 qemu-img info foresight.img 查看)。

到这儿，我的虚拟磁盘文件 (foresight.img) 就从 12G 变成 16G 了。以上都是在 host 机器上做的，下一步就是在虚拟机里调整分区大小。

2. 调整分区大小

为了能够在不挂载的条件下进行操作 (以免出问题，fdisk 实际上好像也要求分区不能挂载)，需要用另一个系统来启动机器。用 liveCD 光盘或者 liveUSB 都可以，我是直接用的 Foresight Linux 的安装盘，因为它支持一个 rescue 模式 (跟 liveCD 差不多，但是命令行的，速度快一点)。

普通安装的话，把光盘放光驱就可以了。用 qemu 的话，传一个 -cdrom 选项。(同时也把启动时的菜单打开，以便能选择从光驱启动。)



-cdrom /path/to/foresight/iso -boot menu=on

进入后，不用挂载机器上原来的分区。

先来点小知识。对 Linux 来说，分区 (partition) 和文件系统 (filesystem) 是分开的，前者指的是硬件，后者指的是软件。文件系统创建在分区上，它的大小可以比分区更小。我的最终目的是调整文件系统的大小，因为操作系统是安装在文件系统中的。

所以要为操作系统提供更多的可用空间，需要分两步：1，扩大硬盘分区；2，扩大文件系统。前者用 fdisk 完成，后者用 resize2fs。(有的工具比如 parted 和 gparted 把两步合在一块了)。

2.1 扩大分区

# fdisk /dev/sda

执行 fdisk。把原来的分区删掉，然后创建一个新的分区。新分区的开头要跟旧分区一样，长度要比旧分区大。

由于我当初分区的时候把根分区放在了 swap 之前，所以我要先把 swap 分区删掉，最后再创建一个新的 swap。

fdisk 不会修改分区里面的东西，所以这样就把分区扩大了。其上的文件系统没有变，还是原来的大小。

2.2 扩大文件系统

# resize2fs -f /dev/sda2

resize2fs 把 sda2 上的文件系统扩大到跟分区一样大。

至此就搞定了。执行下 sync 重启即可。

2.3 其他

由于我上边重建了 swap 分区，所以要重新格式化 swap。

$ sudo mkswap /dev/sda3

我系统中原来的 fstab 是用 label 来引用分区。由于 label 没有了，所以把它改成直接使用 /dev/sda3：

LABEL=SWAP-sda3         swap                    swap    defaults        0 0

/dev/sda3                          swap                    swap    defaults        0 0

应该也可以重新创建 label 的，但是由于我不知道怎么做，就只好这样了。

我是在系统启动之后执行这两步的，也可以在 rescue 系统中做。

如果用的是 lvm，就更省事儿了，不过我一直不会用...

Supybot JIRA plugin

2011-07-08T20:04:00.000+08:00

I have been working on a small project recently, a JIRA plugin for supybot. Today I feel it's feature complete (at least for its use in the Foresight Linux IRC channels). So time for a blog post :-)

Firstly the code is available at GitHub. It's easy to setup (hopefully). See JIRA/README.txt for details. I won't repeat it here in order to minimize duplication.

The main (and only) function is to monitor the chatting in the channels and detect when people mention an issue number. Then the bot queries the JIRA and posts a summary of the issue to the channel.

It supports multiple JIRA installations. For example in #foresight our bot knows about the Foresight JIRA, as well as the rPath JIRA, so that we can get information about conary issues (which is maintained outside Foresight Linux at rPath).

There are a few configuration options too. The format of the issue summary can be customized. There is also a timeout option (default to 5 minutes); the bot won't report the same issue again and again, and spam the channel.

If you want to play with it, stop by #foresight and find the bot there (it may be called foresight, flbot, fleabot or other names). Then /query the bot and give it some commands (e.g. FL-12, KDE-34, etc.)

Birthday of THE PARTY

2011-07-01T10:40:00.002+08:00

此文没啥新意，但是党的生日来了，我觉得我们都应该写篇文章，抒发一下自己对这个事物的看法。

写这篇文章的冲动来自于：听俞正声上党课——“执政者的声音”。

显然这就是很多人内心真实的想法了，抛去冠冕堂皇，这不止是他们做的秀，也是他们内心真正相信的东西。

> 怎么样在复杂的社会环境中间保持一种政治上的坚定性，“是一件不容易的事情”。

“政治上的坚定”，这种说法可真奇怪。为什么要坚定？党自身的想法都不是固定的。跟所有的党一样 (且看美国当今两党的变化历程，民主党|共和党)，党的理念在不停的变化。一个人，作为一个个体，有着自己的大脑，为什么要“坚定”在一个不停变化的组织旁边？

而且现实世界中的决策从来不是非黑即白，事情的两面很难说出孰优孰劣。申纪兰确实是够坚定的。

只能说这是一种愚昧的坚定。

> 中共诞生，就是要为劳苦大众打天下，就是不能让社会、官僚们熟视无睹群众死活的状况在中国继续下去，所以才产生了共产党。

“社会、官僚们熟视无睹群众死活”。这是教科书上向来的说法。当时的生活确实不好，但也不至于这么概括吧 (其实应用于当下更合适)。从建国大业和建党伟业来看，当时的政治气氛比现在可是好多了。

至于党的目的，这么概括就更是洗脑了。毫无疑问当时一些纯洁的大学生确实是这么想的，但是要说“党”的目的是“为劳苦大众打天下”，也太没脑子了。对权力的争夺才是最根本的目的。从本质上讲，中共跟历代的农民起义没有区别，不过是提出了更新的口号而已。从陈胜吴广，到宋江，到李自成，到义和团，造反的农民们提出的口号代代在刷新。毛泽东也就配跟这些人相提并论。

而且这句口号在今天看来，就是十足的讽刺了。再过一阵，建党大业都会成为禁片。

> 解放战争的胜利...根本上是人民群众的拥护和支持。

刘邦的胜利，根本上是人民群众的拥护和支持。

> 我对毛主席是非常尊敬的，虽然他犯了这么大的错误。

40后和50后这代人很是奇怪，他们在童年一方面接受着党的教化 (洗脑)，一方面眼睁睁看着党在行凶，看着自己的家人受迫害。结果他们就形成了上边这种畸形的心理。这不就是斯德哥尔摩综合征吗？与斯德哥尔摩综合征的特征和四大历程如此符合。

毛泽东既然知道自己做错了，造成了很大的破坏，为什么不引咎辞职？毫无疑问，太祖作为太祖，一个独裁者，认为天下是自己的。就跟皇帝一样，做错点事，让一些草民丢掉性命，事后自责一下就够了，他们绝对不会想到自己应该下台，受人唾弃。

当时的最高权力机构，既然认定毛泽东做错了，为什么不把他判罪？当然，原因还是跟封建王朝一样。

如今六七十岁那些人是精神上最分裂的一代。

> 党也不回避自己的问题和失误。

这。。。只能说是赤裸裸的撒谎了。

> 中国大陆要是多党，可能就会把中国大陆变成了政客权谋的竞技场。

中国大陆现在难道不是政客权谋的竞技场？而且把活跃的政治活动说成是混乱，像 CCTV-4 这种党媒整天刷黑台湾，其实只能说明党的内心虚弱到了何种程度。

> 如果党本身是软弱无力的，这个党不会有希望。

党很害怕。

> 要敢于讲真话，你敢不敢于在领导面前发表你的看法？

这一代人眼里，“领导”就是主宰一切的神。

仔细想想，什么是“党”？党不是千万党员，不是总书记，不是这个职位或那个职位。党不是一个或几个人。党是一种理念，党是一种非物质。党是人性中最邪恶的一面，是所有党员最邪恶的一面的合集。

How to understand recursion

2011-06-28T14:01:00.000+08:00

这是从 ANSI Common Lisp 里看到的一段。本来想在豆瓣上写个读书笔记的，但是我觉得这个太重要了，应该写篇文章来记录一下。

很多人（包括我）觉得递归难以理解，因为我们大脑里对“函数”的模型不对。基于这种模型去思考，整个递归过程很容易变成一团浆糊。

那我们潜意识中是怎样对待“函数”的呢？书里一般会说函数是一种抽象，所以我们就把函数当作一个黑盒子，或者按照 Paul 的说法，当作一个机器。参数是这个机器的原材料；机器有时候会把部分工作外包给别的机器；最后的产品被组装起来，也就是函数的返回值。这就是我们大脑里的模型。

遇到递归函数的时候我们还是这样思考的，但是现在，这种抽象反而让事情更难以理解。一个机器已经在运转了，怎么还能把一部分活儿外包给自己？它们生成的产品又是怎么组装到一块的？

比如这样一个简单的递归函数，判断一个对象是否在一个列表中：


def member(obj, lst):
    if not lst:
        return False
    if lst[0] == obj:
        return lst
    return member(obj, lst[1:])

按照以前的习惯，我的大脑会尝试着展开每次递归调用。结果不必说，一团乱麻。

Paul 讲了一个更好的方法，也就是把函数当作一个处理过程 (process)。上边的函数可以转换成这样一个用自然语言描述的过程：

1. 首先检查 lst 是否为空，如果是空的，obj 当然不是这个列表的元素。处理完毕。

2. 否则，检查 obj 是否是 lst 的第一个元素。如果是的话，obj 是 lst 的元素。

3. 否则，当且只当 obj 是 lst 剩余部分的一个元素的时候，它是 lst 的一个元素。

这样是不是很直白？使用自然语言能帮助我们理解一个递归函数。

再举个现实世界中的例子。假设现在有个党史学家，他想研究一下党员数量的变化。他研究的过程可能是这样的：

1. 找一份资料。

2. 寻找跟党员数量相关的信息

3. 如果这份资料提到了其他可能有用的资料，研究这些资料。

显然这是个递归的过程。对一个过程来说，递归是很自然的。现实世界中有各种各样的递归过程。所以把函数想成一个过程，而不是一个机器，会帮我们更好的理解递归。

再回到上边的 member 函数，不要把它想成一个用于判断对象是否在列表中的机器。把它当作一组进行判断的规则，顺着这组规则走下来，我们就能做出正确的判断。

(当然第二个例子是本文作者虚拟的。在现实世界中，党说党员数量是怎么变化的，党员数量就是怎么变化的。)

Working with Different Coding Styles

2011-03-17T22:27:00.004+08:00

问题最近看代码看得相当的 high，有时候也写上几行，再没有了那种不能写代码的郁闷。工作中当然还是没有多少 coding 的机会，不过我现在能挤出时间，尽量增加跟代码的接触 (感谢开明的老板)，所以工作心情好多了。这里记录此过程中一个非技术的小问题。

因为接触了好几个开源项目 (Expand Your Bandwidth)，而每个都有不同的代码风格，导致我写代码的时候有点不方便。如何缩进 (或者说 tab 键的处理) 是主要的问题，有的用 4 个空格缩进 (比如多数的 python 代码), 有的用 8 个空格 (比如 systemd), 有的用真正的 tab (比如 Linux kernel, packagekit)。但是对于 vim 来说，配置只能有一个，没法照顾到所有的情况。

我能想到的解决办法有这么几个：

在文件头部指定代码风格，比如 "Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8"。这叫 mode line，vim 和 emacs 都支持，但是两者的格式却不一样，上边那个是 emacs 的，要是 vim 的话，得再添一行，"vim: set ts=8 sw=4 tw=0:"。鉴于此，不能指望每个项目在每个文件里为每种编辑器写一行 mode line。systemd 就只考虑了 emacs，因为 Lennart Poettering 用的是 emacs。
上面的问题有两个办法，1) 学习 emacs, 2) 用这个 vim 插件，让 vim 识别 emacs 的 mode line。1) 就算了... 但是 2) 基本上也行不通，因为有相当多的项目根本就没有任何的 mode line。
vim 在读取配置的时候，能够识别当前目录下的配置文件。这样就可以为每个工程加一个 .vimrc，在里边指定本工程的代码风格。

方案

第一跟第二条属于自己控制不了的，最后一个还比较靠谱。不过 vim 默认不会读取当前目录下的配置文件。因此首先要在 ~/.vimrc 里添加这么两行 (引用)：

set exrc   " enable per-directory .vimrc files
set secure   " disable unsafe commands in local .vimrc files

第二行是为安全起见 (因为 vimrc 里的东西是被 vim _执行_ 的，所以可以被用作特洛伊木马)。

然后写各工程的 .vimrc，这些都不会太长，因为只需要指定少数几个选项，比如 expandtab 和 shiftwidth。

$ cat .vimrc 
autocmd FileType c set noexpandtab shiftwidth=8

这个配置适合 packagekit，用真正的 tab 进行缩进 (只针对 C 文件；工程里还有 python 文件，仍然使用 vim 的全局配置)。

剩下的一个问题是，git status 的时候说有 untracked file，看起来实在不够清爽 :-) 本来可以让 git 忽略掉 .vimrc，但是项目里的 .gitignore 不是我能掌控的。不过，记住我们用的是 git :-) 用户可以指定全局的 gitignore 文件 (引用)。

$ git config --global core.excludesfile '~/.gitignore'

再写好 gitignore，

$ cat ~/.gitignore 
.vimrc

这样，就 OK 了!

Git remote add

2011-03-10T21:43:00.002+08:00

今天打算下载 DRM 的源代码，但是公司的网络访问 git.kernel.org 特别慢。而内核的源码树，加上所有的修改历史，大概有 1GB 吧，就算 git 能够先压缩再下载，也得几百兆。可怜下载速度只有十几 KB 每秒。再联想到 git 不能续传...

公司倒是有自己的内核源码树，就在北京本地的服务器上。从那儿下载能有十几 MB 每秒，所以花几十秒钟就可以了。怎么办呢？毕竟两个源码树肯定是大同小异的。

这，就是 git 的强大之处了。且看命令:



$ git clone git://internal/kernel-tree

$ cd kernel-tree



$ git remote add airlied-drm git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6.git



$ git fetch airlied-drm drm-next:drm-next

remote: Counting objects: 284642, done.

remote: Compressing objects: 100% (55324/55324), done.

remote: Total 261757 (delta 210979), reused 253047 (delta 203096)

Receiving objects: 100% (261757/261757), 75.90 MiB | 10 KiB/s, done.

Resolving deltas: 100% (210979/210979), completed with 8754 local objects.

From git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6

 * [new branch]      drm-next   -> drm-next

这样就在本地得到了一个 drm-next 分支，用来追踪 airlied 的 DRM 源码树。同时 master 分支仍然是追踪公司自己的源码树。两者互不干扰，用 git checkout 来切换就行了。

也就是说，一个 git 仓库可以有多个 remote，而各个 remote 既相互独立，又可以共享数据。用上面的办法只需要下载 75 兆的数据，从输出中可以看到 git 确实 "reuse" 了一些东西。

再跟直接的 git clone 比较一下，objects 的数量有相当大的区别 (当然，我不确定这跟实际的下载量是不是一回事)：



$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6.git

Cloning into drm-2.6...

remote: Counting objects: 1908681, done.

remote: Compressing objects: 100% (309630/309630), done.

^Cceiving objects:   0% (1198/1908681), 500.00 KiB | 11 KiB/s

git，真是无比强大...

What does the Mc in McDonald mean?

2011-03-05T17:08:00.002+08:00

今天又遇到一个加拿大人，姓是以 Mc 开头 (McMaster)。于是请教了一下这是为什么，终于明白了这种分两段的姓的意思。

Mac, Mc, (甚至简写成 M'), 还有 O', 都是 son of 某某人的意思 (O' 其实是 grandson of )。McDonald 这个姓就类似于英语中的 Smithson, Johnson，从某个角度表示了这个家族的发展历史。

我遇到过的例子有 McMaster, MacDonald, MacLeod, O'Brien。搜索一下，有更深入的解释。这几个姓貌似来源于苏格兰语或者爱尔兰语。

where are the functions defined?

2011-03-04T21:55:00.000+08:00

0. Token Concatenation

在 C 代码中，宏定义中可以进行"文本"层面上的变换，比如在 systemd 的链表实现 (类似 Linux kernel 的链表) 中有这样的用法,

#define LIST_FIELDS(t,name)                                             \
        t *name##_next, *name##_prev

"##" 能完成所谓的 Token Concatenation, 具体解释看 gnu.org 的手册, 和维基百科，简单的说，## 能把前后两个 token 连为一个。上边定义的 LIST_FIELDS 可以这样使用，

struct Job {
        LIST_FIELDS(Job, transaction);
        LIST_FIELDS(Job, run_queue);
}

编译的时候就能扩展为

struct Job {
        Job *transaction_next, *transaction_prev;
        Job *run_queue_next, *run_queue_prev;
}

这样确实很聪明，也很省事。但是如果你不熟悉这种用法，初读代码会一头雾水，因为遇到下边这样的代码时，根本找不到这些 _next 和 _prev 变量的定义，无论是用 cscope 还是 grep。

assert(!j->transaction_next);
assert(!j->transaction_prev);

1. 没有定义的 to_string 和 from_string 函数

最近看 systemd 代码，遇到了一个叫 log_target_from_string 的函数。某个头文件有它的声明，

LogTarget log_target_from_string(const char *s);

但是却找不到它的定义。最后发现是这样的，

/* src/log.c */

static const char *const log_target_table[] = {
        [LOG_TARGET_CONSOLE] = "console",
        [LOG_TARGET_SYSLOG] = "syslog",
        [LOG_TARGET_KMSG] = "kmsg",
        [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
        [LOG_TARGET_NULL] = "null",
        [LOG_TARGET_AUTO] = "auto"
};

DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);

/* src/util.h */

#define DEFINE_STRING_TABLE_LOOKUP(name,type)                           \
        const char *name##_to_string(type i) {                          \
                if (i < 0 || i >= (type) ELEMENTSOF(name##_table))      \
                        return NULL;                                    \
                return name##_table[i];                                 \
        }                                                               \
        type name##_from_string(const char *s) {                        \
                type i;                                                 \
                unsigned u = 0;                                         \
                assert(s);                                              \
                for (i = 0; i < (type)ELEMENTSOF(name##_table); i++)    \
                        if (name##_table[i] &&                          \
                            streq(name##_table[i], s))                  \
                                return i;                               \
                if (safe_atou(s, &u) >= 0 &&                            \
                    u < ELEMENTSOF(name##_table))                       \
                        return (type) u;                                \
                return (type) -1;                                       \
        }                                                               \
        struct __useless_struct_to_allow_trailing_semicolon__

也就是说有一个通用的宏 DEFINE_STRING_TABLE_LOOKUP，它提供了 to_string 和 from_string 这两个函数的“模板”。

systemd 需要进行很多的 enum 数值和对应的字符串之间的转换，这些对应关系都是定义在一个个的字符串数组中，比如上面的 log_target_table。转换操作其实很简单，无非就是在数组中进行查找，但是代码树里有很多这样的数组，也有很多的 enum 类型。如果要给每个数组都定义自己的 to_string 和 from_string 函数，那肯定是一大坨重复代码。

使用 token concatenation 显然是一个很聪明的办法，达到的效果跟 C++ 的模板机制是类似的，能够大幅度地减少代码的重复。DRY! (C vs. C++... 不敢妄下评论，you be the judge)。

(定义一个通用的查找函数也许是另一种办法)。

how gnome starts

2011-03-02T20:47:00.002+08:00

关于 Linux 的启动过程，网上有不少资料。比如这个，从按下开机键到创建 TTY 登录界面这个过程讲的很清楚。但是没有讲到这之后发生的故事。gdm 是怎么启动的？X server 又是怎么启动的？

运行下 pstree，会发现这样一个进程树结构。

init-
     |-gdm-binary-+-gdm-simple-slav-+-Xorg
     |            |                 |-gdm-session-wor-+-gnome-session-+-applet.py
     |            |                 |                 |               |-gdu-notificatio
     |            |                 |                 |               |-gnome-panel---{gnome-panel}
     |            |                 |                 |               |-gnome-power-man---{gnome-power-man}
     |            |                 |                 |               |-gnome-volume-co
     |            |                 |                 |               |-kerneloops-appl
     |            |                 |                 |               |-metacity---{metacity}
     |            |                 |                 |               |-nautilus---2*[{nautilus}]
     |            |                 |                 |               |-nm-applet---{nm-applet}
     |            |                 |                 |               |-polkit-gnome-au---2*[{polkit-gnome-au}]
     |            |                 |                 |               |-stardict---4*[{stardict}]
     |            |                 |                 |               `-2*[{gnome-session}]
     |            |                 |                 `-{gdm-session-wor}
     |            |                 `-{gdm-simple-slav}
     |            `-{gdm-binary}

这些是如何发生的？

下边是一个基于 Foresight Linux 的很简单的讲解。但是应该也适用于所有建立在传统的 sysvinit 之上的 Linux 发行版。而至于 upstart 和 systemd 等等就不适用了。

1. init -> /etc/X11/prefdm

我们都知道 kernel 在启动之后，会执行 init 程序。而 init 的行为是由 /etc/inittab 定义的。

我的系统上 inittab 有这样一行:

$ tail -1 /etc/inittab 
x:5:respawn:/etc/X11/prefdm -nodaemon

也就是说在进入 runlevel 5 的时候，init 会调用 /etc/X11/prefdm。这是 X11 目录下的一个文件，我们应该能大体猜出它的用处。

小插曲: 这个文件其实是 initscripts 提供的，

$ conary q --path /etc/X11/prefdm
initscripts:runtime=foresight.rpath.org@fl:2-qa/9.12.1-0.3-1

2. /etc/X11/prefdm -> gdm

/etc/X11/prefdm 是个很短的 shell 脚本。作用很简单，它会依次尝试运行 gdm, kdm 等等。对 GNOME 来说就是相当于 exec gdm。这样 gdm 进程就取代了 prefdm。

3. gdm -> Xorg

你可能发现了，直到现在 X server 还没有启动呢。上边的进程树中也体现出来了，gdm 是 init 的子进程，而 Xorg 是 gdm 的子进程。

gdm 的全称是 GNOME Display Manager，是 X display manager 的一种。维基百科说了，gdm 是对默认的 xdm 的一个更加易用的替换。

那么什么是 X display manager？还看维基百科，

When the display manager runs on the user's computer, it starts the X server before presenting the user the login screen

也就是说，gdm 会首先启动 X server (比如在 tty7 上)，然后把登录界面显示出来。这样用户就可以登录了。

其实就是这么简单。再输入密码，gnome-session, gnome-panel 等等就会启动，你就能进入到你的桌面了。

package testing made easy by conary rollback

2011-02-08T22:02:00.004+08:00

Some time ago I came into a bug of foresight, FL-2639 - fails to boot due to libata-migrate. Then our lead developer António committed an updated recipe. But before new packages are made, I was asked to build the recipe and test it locally.

So I checked out the recipe, and 'cooked' it on my system.

cvc cook mkinitrd.recipe

The package was built and I installed it.

sudo conary update mkinitrd-6.0.93.ccs

But something seemed wrong, as you might guess from the libata-migrate warnings in the above screenshot.

So I asked António and confirmed the problem.

I didn't panic. As António said, I ran a single command and brought my system back to safety :)

sudo conary rollback 1

That's a typical scenario during foresight development, and part of what makes it a fun to work with conary.

foresight 2.5.0 ALPHA 2 released

2011-02-02T23:30:00.003+08:00

Og Maciel 刚刚发布了 Foresight Linux 2.5.0 ALPHA 2.

Foresight 经过了一段很艰难的岁月，但是我们撑过来了 :) ALPHA1 发布之后，还是吸引了相当多的关注。根据 DistroWatch, Foresight 的关注度从 185 位, 升到 147, 又升到 115, 然后又升到了 47。

ALPHA2 下载链接，

* Foresight Linux GNOME Edition 2.5.0 x86:
    URL: https://www.rpath.org/images/foresight/27224/foresight-2.4.99+alpha2+2011.01.31-x86-dvd1.iso
    Size: 1.60 GB
    SHA1: 9068e94a0c6552409ae46893e2d32bbfedc0b442

* Foresight Linux GNOME Edition 2.5.0 x86_64:

    URL: https://www.rpath.org/images/foresight/27223/foresight-2.4.99+alpha2+2011.01.31-x86_64-dvd1.iso
    Size: 1.78 GB
    SHA1: f8fe9c020f97b114d9f543f427caa498c0f407ac

using conary api

2011-02-02T15:03:00.003+08:00

Conary has a public API, through which you can have access to the packages on your system. Here is some quick examples.

1. Query packages installed locally, (equivalent of 'conary query')


1 # test1.py
2 import pprint
3 
4 from conary.conaryclient import ConaryClient
5 from conary.conarycfg import ConaryConfiguration
6 
7 c = ConaryClient(ConaryConfiguration())
8 troves = c.db.findTroves(None, [('dbus', None, None)])
9 pprint.pprint(troves)


$ python test1.py 
{('dbus', None, None): [('dbus',
                         VFS('/foresight.rpath.org@fl:devel//2-qa/1.4.0-0.3-1'),
                         Flavor('is: x86')),
                        ('dbus',
                         VFS('/foresight.rpath.org@fl:devel//2-qa/1.4.0-0.3-1'),
                         Flavor('is: x86_64'))]}
$ conary q dbus
dbus=foresight.rpath.org@fl:2-qa/1.4.0-0.3-1[is: x86]
dbus=foresight.rpath.org@fl:2-qa/1.4.0-0.3-1[is: x86_64]

2. Query packages in the repository, (equivalent of 'conary repoquery')


 1 # test2.py
 2 import pprint
 3 
 4 from conary.conaryclient import ConaryClient
 5 from conary.conarycfg import ConaryConfiguration
 6 
 7 cfg = ConaryConfiguration(readConfigFiles=True)
 8 c = ConaryClient(cfg)
 9 troves = c.repos.findTroves(cfg.installLabelPath, [('dbus', None, None)])
10 pprint.pprint(troves)


$ python test2.py
{('dbus', None, None): [('dbus',
                         VFS('/foresight.rpath.org@fl:devel//2-qa/1.4.0-0.3-1'),
                         Flavor('is: x86')),
                        ('dbus',
                         VFS('/foresight.rpath.org@fl:devel//2-qa/1.4.0-0.3-1'),
                         Flavor('is: x86_64'))]}

3. List files of a package, (equivalent of 'conary q --ls')


 1 # test3.py
 2 
 3 from conary.conaryclient import ConaryClient
 4 from conary.conarycfg import ConaryConfiguration
 5 
 6 c = ConaryClient(ConaryConfiguration())
 7 n, v, f = c.db.findTrove(None, ('m4:doc', None, None))[0]
 8 trove = c.db.getTrove(n, v, f, withFiles=True)
 9 for (pathId, path, fileId, version) in trove.iterFileList():
10     print path


$ python test3.py 
/usr/share/info/m4.info.gz
/usr/share/man/man1/m4.1.gz

Note that the trove you use for iterFileList() "will have to be a trove that has files -- a component or fileset, but not a package or a group". ('Trove' is a general name for package/component/group).

And there is also a second approach,


1 from conary.conaryclient import ConaryClient
2 from conary.conarycfg import ConaryConfiguration
3 
4 c = ConaryClient(ConaryConfiguration())
5 n, v, f = c.db.findTrove(None, ('m4:doc', None, None))[0]
6 iter = c.db.iterFilesInTrove(n, v, f, withFiles=True, capsules=False)
7 for (pathId, path, fileId, version, filename) in iter:
8     print path

4. List components of a package, (equivalent of 'conary q --troves' or 'conary q --all-troves'):


 1 # test4.py
 2 
 3 from conary.conaryclient import ConaryClient
 4 from conary.conarycfg import ConaryConfiguration
 5 
 6 c = ConaryClient(ConaryConfiguration())
 7 n, v, f = c.db.findTrove(None, ('kernel', None, None))[0]
 8 trove = c.db.getTrove(n, v, f)
 9 components = trove.iterTroveList(strongRefs=True)
10 for (n, v, f) in components:
11     print "%s %s %s - %s" % (n, v, f,
12             "Installed" if c.db.hasTrove(n, v, f) else "Not Installed")


$ python test4.py 
kernel:runtime /foresight.rpath.org@fl:2-qa-kernel/2.6.35.10-5-1 ~kernel.debugdata,~!xen is: x86_64 - Installed
kernel:vmware /foresight.rpath.org@fl:2-qa-kernel/2.6.35.10-5-1 ~kernel.debugdata,~!xen is: x86_64 - Installed
kernel:debuginfo /foresight.rpath.org@fl:2-qa-kernel/2.6.35.10-5-1 ~kernel.debugdata,~!xen is: x86_64 - Not Installed
kernel:build-tree /foresight.rpath.org@fl:2-qa-kernel/2.6.35.10-5-1 ~kernel.debugdata,~!xen is: x86_64 - Not Installed
kernel:configs /foresight.rpath.org@fl:2-qa-kernel/2.6.35.10-5-1 ~kernel.debugdata,~!xen is: x86_64 - Installed

That's it, some dirty examples and I don't know if it's the recommended way of doing things. And not all functions used above are official public APIs (now I'm using conary-2.2.9 and python-2.6.6). So take care, and better to install pycscope and poke around the source code yourself:)

explanation of a systemd.recipe

2010-12-23T19:54:00.001+08:00

I have been wanting to write something about packaging for conary. So here is an line-by-line explanation of the systemd recipe that I made for Foresight Linux.

systemd is still under heavy development and my package is far from perfection, so this article is just to show you a typical conary recipe. It's not meant to be a packaging guide for systemd and the recipe is subject to change.

------------------

First let's see how it looks like.

  1 class Systemd(AutoPackageRecipe):
  2     name = 'systemd'
  3     version = '15'
  4  
  5     buildRequires = [
  6         # for autoreconf
  7         'autoconf:runtime',
  8         'automake:runtime',
  9 
 10         'audit:devel',
 11         'dbus:devel',
 12         'libcap:devel',
 13         'libxslt:runtime',
 14         'm4:runtime',
 15         'pam:devel',
 16         'pkgconfig:devel',
 17         'tcp_wrappers:devel',
 18         'udev:devel',
 19         'vala:runtime',
 20 
 21         # for gtk support
 22         'dbus-glib:devel',
 23         'gtk:devel',
 24         'libnotify:devel',
 25         ]
 26 
 27     # XXX our cryptsetup may be too old and doesn't provide libcryptsetup.pc
 28  
 29     extraConfig = (
 30         '--with-distro=foresight '
 31         '--with-rootdir= '
 32         )
 33 
 34     patches = [
 35         # backported from upstream, for vala and libnotify version check
 36         '0001-gnome-ask-password-agent-also-support-libnotify-0.7-.patch',
 37         '0002-Ensure-LIBNOTIFY07-conditional-is-always-set.patch',
 38         # patches for porting to foresight
 39         'foresight-linux-port.patch',
 40         'foresight-units.patch',
 41         # need to update util-linux (>2.18) to have 'fsck -l'
 42         'foresight-workaround-old-fsck.patch',
 43         ]
 44 
 45     extraSources = [
 46         'console.conf',
 47         ]
 48 
 49     def unpack(r):
 50         r.addArchive('http://www.freedesktop.org/software/systemd/')
 51         for patch in r.patches:
 52             r.addPatch(patch)
 53 
 54         for source in r.extraSources:
 55             r.addSource(source)
 56 
 57     def configure(r):
 58         r.Run('autoreconf') # XXX is autoreconf right?
 59         r.Configure(r.extraConfig)
 60 
 61     def policy(r):
 62         r.Install('console.conf', '%(sysconfdir)s/tmpfiles.d/console.conf')
 63 
 64         # /etc/xdg/systemd/user points to /etc/systemd/user
 65         r.ExcludeDirectories(exceptions='%(sysconfdir)s/systemd/user')
 66 
 67         # The unit files (plain-text) are in /lib/systemd/system, so no need to fix
 68         r.FixupMultilibPaths(exceptions='/lib/systemd/system/')
 69 
 70         # warning: DanglingSymlinks: symlink /usr/share/systemd/user/bluetooth.target
 71         # points from package systemd:data to systemd:lib
 72         r.ComponentSpec('lib', '%(datadir)s/systemd/user/.*.target')
 73 
 74         # Create SysV compatibility symlinks. systemctl/systemd are smart
 75         # enough to detect in which way they are called.
 76         r.Symlink('../bin/systemd', '/sbin/init')
 77         r.Symlink('../bin/systemctl', '/sbin/reboot')
 78         r.Symlink('../bin/systemctl', '/sbin/halt')
 79         r.Symlink('../bin/systemctl', '/sbin/poweroff')
 80         r.Symlink('../bin/systemctl', '/sbin/shutdown')
 81         r.Symlink('../bin/systemctl', '/sbin/telinit')
 82         r.Symlink('../bin/systemctl', '/sbin/runlevel')
 83 
 84         # Use graphical.target unconditionaly as default for now
 85         r.Symlink('/lib/systemd/system/graphical.target', '/etc/systemd/system/default.target')
 86 
 87         cmds = (
 88             '/sbin/halt',
 89             '/sbin/init',
 90             '/sbin/poweroff',
 91             '/sbin/reboot',
 92             '/sbin/runlevel',
 93             '/sbin/shutdown',
 94             '/sbin/telinit',
 95             )
 96 
 97         mans = (
 98             '%(datadir)s/man/man1/init.1.*',
 99             '%(datadir)s/man/man8/halt.8.*',
100             '%(datadir)s/man/man8/poweroff.8.*',
101             '%(datadir)s/man/man8/reboot.8.*',
102             '%(datadir)s/man/man8/runlevel.8.*',
103             '%(datadir)s/man/man8/shutdown.8.*',
104             '%(datadir)s/man/man8/telinit.8.*',
105             )
106 
107         for f in cmds:
108             r.DanglingSymlinks(exceptions=f)
109 
110         for f in cmds + mans:
111             r.PackageSpec('systemd-sysvinit', f)

------------------

Now let's break the recipe down into pieces.

1. First of all, the recipe is called systemd.recipe and named after the package.

2. Line 1

class Systemd(AutoPackageRecipe):

Most recipes get started like this. Remember that conary recipes are pure Python code. So here it's a Python "class" that's being defined. Its name is "Systemd" and it is inheriting from one super-class called "AutoPackageRecipe".

The class name is in CamelCase and derived from the package name. Conary will do the transformation for you if the recipe is created using a template:

cvc newpkg systemd --template foresight

The "foresight" template (/etc/conary/recipeTemplates/foresight) is defined as:

class %(className)s(AutoPackageRecipe):

"className" will become "Systemd" for the systemd package.

As for the "%()s" surrounding className, it's (the first argument to) Python's "string interpolation operator". Read the official documentation (http://docs.python.org/library/stdtypes.html#string-formatting-operations) for details.

But there is something strange. The % operator is defined as "format % values" and requires two operands. We have got the format "%()s", but where is the values?

Values will be provided by conary automatically. That's how "macros" work in recipes. As in C, macros will come in handy sometimes. See http://docs.rpath.com/conary/Conaryopedia/sect-macros.html for details.

3. Line 2 to 25.

name = 'systemd'
version = '15'
buildRequires = ['autoconf:runtime', 'automake:runtime', 'audit:devel', ...]

These are the variables that will appear in most recipes and they are built into conary (for example conary has commands to query a package's name, version and buildRequires). Their meanings are obvious: package name, package version, and what you need to build this package. It's almost the same as in RPM .spec files.

4. Line 29 to 47.

extraConfig = ()
patches = []
extraSources = []

These are the variables that I define for my own convenience. Later part of the recipe will make use of them.

For now I only want to point out one thing. extraConfig seems to be a tuple, but it's actually a string. Not sure what's Python's official description but I use it as a trick to make the code look better.

5. methods

def unpack(r):
def configure(r):
def policy(r):

Now we get to some Python functions. Each of them controls a part of the packaging process (extract the tarball, call "./configure", call "make", call "make install", etc).

But where is the function that controls the whole process? It would be the job of setup() and it's being defined in the super-class AutoPackageRecipe. The class Systemd got it through inheritance.

The class AutoPackageRecipe (defined in the package "autopackage") has such methods:

 7     def setup(r):
 8         r.unpack()
 9         r.configure()
10         r.make()
11         r.makeinstall()
12         r.policy()
13 
14     def unpack(r):
15         pass
16     def configure(r):
17         r.Configure()
18     def make(r):
19         r.Make()
20     def makeinstall(r):
21         r.MakeInstall()
22     def policy(r):
23         pass

setup() is the only function that's required by conary to be defined in a recipe and determines how the packaging is done. But thanks for the recipe being Python code, you don't actually have to do it. It's sufficient to just override a few portions of setup(), where special processing is truly required. The other subroutines, namely make() and makeinstall(), can be used as is.

6. "r"

You might have noticed, the first parameter of all methods is an "r". And when methods are invoked, they have "r." before them. Suffice it to say, "r" in conary recipes is what "self" is in usual Python code. Refer to Python documentation for details.

7. unpack(r)

This is the first of our three methods. Here the source code of systemd is prepared for later compiling. A tarball, some patches and one extra configuration file are added to the project using built-in functions,addArchive(), addPatch() and addSource().

The tarball will be extracted to the building directory (e.g. ~/conary/builds/systemd/). The patches will be applied on the source code. Then the extra sources will be copied into the building directory.

The "patches" and "extraSources" defined above are used here, in a for-loop. It's only a engineering habit of me to list patches in the beginning of recipes. You could of course put them one by one in the for-loop, though I prefer otherwise.

Again, "patches" is referenced as 'r.patches' and "r" is just like "self" here.

8. configure()

AutoPackageRecipe provides a straitforward configure() method which is just a thin wrapper of r.Configure() (which is simply "./configure" under the hood, with some default options such as "--prefix=/usr").

But systemd needs more. So I override it with my own configure(), which invokes "autoreconf" and passes some additional options. autoreconf is needed since I have patches against configure.ac and must get configure regenerated.

9. policy()

Now we come to the last part of systemd.recipe. In my recipes policy() is usually used to finalize and clean up the packaging process.

For every package, conary will run a bunch of "policies" against it, checking buildRequires, correcting obvious errors, normalizing against established customs, etc. For example, conary checks for non-executable files in directories that are "usually" for binary files (e.g. /usr/bin). But if you explicitly want such files, now is a good time to set "exceptions" to the policies.

Most of the actions in systemd.recipe's policy() are conary policies, such as FixupMultilibPaths (

Fix up and warn about files installed in directories that do not allow side-by-side installation of multilib-capable libraries

) and DanglingSymlinks (Disallow dangling symbolic links).

But Install() and Symlink() are not; they are build time functions just like Make() (Runs make with system defaults) and MakeInstall (Runs make utility with install target). In vim, build funtions and policy funtions will have different colors, thanks to the syntax file conaryrecipe.vim.

For details of these conary API, reference to the manuals using "cvc explain <funtion name>".

------------------

That's the overview of systemd.recipe. I hope you get a taste of conary recipes (at least in my style :) Though it's not without its own shortcomings, conary recipes are the most elegant packaging scripts, compared to rpm, deb, bitbake and all the others that I've ever seen (most of them seem to be shell-based).

2010 yearly summary

2010-12-22T21:54:00.000+08:00

It's already the last month of this year. Time to summarize and look forward into the future.

2010 is surely an important period of time during my life. This year I graduated from university and got a job and finally have a life of my own. Looking back, there is actually more that has happened than I realized.

So what happened during my 2010:

1. I graduated from Beihang University. It's 2006 that I came to Beijing and now four years have passed, it's surely a great tour.

2. Beginning in the later part of 2009, I have an 8-months internship at Sun Microsystems. Even though it's also the last few months of the Sun company, I've a great time there and I always missed the colleagues from the first company that I worked for. Thank you, Lingbo, Aaron, Edward, Edgar, Miao, Emily. And there are many more whom I can't all list here, but I always feel grateful for them when I think of the help that they gave me.

3. Then I got a job at Wind River. It began in May, so it's already seven months! In this position I have been learning more and more about Linux, and although I don't much coding, there are plenty of chances to get knowledge about what I want.

4. I managed to keep up with our Open Source Club. In the first half of the year, it became quite silent since people are busy graduating. But we got over it and things are much better now.

5. About my participation in open source projects, Foresight Linux is the only one in which I'm still active. I gradually dropped out of the others and stopped appearing in local open source meetings. That's kind of sad, which I hope will be changed in the future. On the other hand, I'm happy that we are keep sticking together around Foresight Linux, even it's still so small. 2009 was such a hard year for many people, but we are seeing better in 2010 and hopefully even better in 2011.

6. Until now I wrote 17 blogs during 2010 (20 in 2009 and 31 in 2008). You can't judge everything simply through numbers, but it still means something. I may still post one or two more articles, so the final number will be 20 and on average, it's 18 days per post.

7. The books I read in this year include Lord of the Rings, 1984, Lincoln the Unknown, More Joel on Software (in Chinese), 程序员羊皮卷 (a book on programmer career), Linux Application Development (not quite finished), Linux Programming by Example (in Chinese; not quite finished), Brain Rules (in progress), 程序员的自我修养 (similar topic as in Linkers and Loaders; in progress) and Apprenticeship Patterns (in progress). There might be some that I didn't write down but yeah, I should read more.

8. I have been memorizing English words for about two months, and it feels very good.

That's it. Year 2010.

What do I have in mine about the new year?

1. Write more blogs. I don't have goals but 20 to 30 should be good.

2. Read more books. Again I don't have goals, but I will read more on various topics. And since no one is giving me homework now, I will have more liberty as for what to read.

3. Participation in open source projects and meetings. I'll go to meetings and try to get into some projects. For now I have Foresight Linux and systemd in mind.

4. Keep active in Beihang Open Source Club. It feels great to be among students. Though I was a student not long ago, I'm not now. I'll help get our club going forward with my friends in the university.

Let's see how it goes.

get serial port output from qemu

2010-12-18T21:39:00.000+08:00

So I was testing systemd in qemu, and wanted to see its debug output. Here is how I managed to do it.

1. Start qemu with the serial port redirected somewhere. I chose to redirect to a file since that would be searchable.

qemu-kvm FL-devel-dev.img -serial file:/tmp/systemd-console

-serial will redirect the serial port output to the file.

(The other options I use are "-vga vmware -m 512M -redir tcp:5555::22", but it's irrelevant here.)

2. Tell the kernel that the console is on the serial port.

Edit the bootloader config and add console=ttyS0 to the kernel arguments.

You may also need to remove "splashy", "quiet" or others.

Now you can inspect the log file on the host.

per-process mount namespace

2010-11-03T17:24:00.005+08:00

systemd 用到了这么一段代码，用来读取系统上的挂载信息：

m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")

奇怪之处在于 mountinfo 这个文件是在 self 目录下，而不是 /proc 的最上层。也就是说，它是进程相关的，而不是整个系统范围的。

所以... 原来有 per-process mount namespace 这么个东西。

$ man proc
    /proc/[pid]/mountinfo (since Linux 2.6.26)
        This file contains information about mount points.

   /proc/mounts
        Before kernel 2.4.19, this file was a list of all the file systems currently
        mounted on the system.  With the introduction  of  per-process  mount
        namespaces  in  Linux  2.4.19,  this  file  became  a link to
        /proc/self/mounts, which lists the mount points of the process's own mount
        namespace.

$ man 2 mount
    Per-process Namespaces
        Starting with kernel 2.4.19, Linux provides per-process mount namespaces.  A
        mount namespace is the set of file system mounts that are visible to a process.
        Mount-point namespaces can be (and usually are) shared between multiple
        processes, and changes to the namespace (i.e., mounts and unmounts) by one
        process are visible to all other processes sharing the same namespace.  (The
        pre-2.4.19 Linux situation can  be considered as one in which a single
        namespace was shared by every process on the system.)

        A child process created by fork(2) shares its parent's mount namespace; the
        mount namespace is preserved across an execve(2).

        A  process  can  obtain a private mount namespace if: it was created using the
        clone() CLONE_NEWNS flag, in which case its new namespace is initialized to be
        a copy of the namespace of the process that called clone(); or it calls
        unshare(2)  with  the  CLONE_NEWNS  flag,  which causes  the caller's mount
        namespace to obtain a private copy of the namespace that it was previously
        sharing with other processes, so that future mounts and unmounts by the caller
        are invisible to other processes (except child processes that the caller
        subsequently creates) and vice versa.