chenrui

tcpip stack(2) -- L3 send and receve

2011-08-07T17:58:00.000+08:00

数据传输的数据结构

在BSD Socket层使用struct msghdr保存数据。在INET Socket层以下使用struct sk_buff保存数据，这个结构被整个网络协议栈使用，如MAC或其他L2链路协议，三层IP，四层TCP或UDP等。并且其中的成员变量在结构从一层向另一层传递时解析本层的数据头。

网络层数据收发
a.发送数据

raw_sendmsg
     |
     |- ip_router_output_flow 根据saddr和daddr在rt_hash_table中查找路由表。
     |                        如果没有找到则查找fib，并__mkroute_output创建struct rtable。将rtable加入rt_hash_table
     |                        neigh_create:根据rtable->dst_entry创建struct neigh邻居,设置定时操作neigh_timer_handler,
     |                        arp_constructor设置arp处理函数
   |
   |- ip_append_data   将大数据分片,创建struct sk_buffer,并将其加入struct sk->sk_write_queue
   |
   |- ip_push_pending_frames
           |
           |- ip_finish_skb 构造ip头
           |
           |- ip_send_skb
                 |
                 |- ip_local_output--> dst_output-->ip_output (__mkroute_output中指定rth->dst.output=ip_output)
                      |
                      |- ip_finish_output      如果在hh_cache中找到daddr信息则将数据传到driver
               |                                   否则调用struct dst_entry->neighbour->output (neigh_resolve_output)
                     |- neigh_resolve_output
                           |
               |- neigh_event_send 更改邻居状态为NUD_INCOMPLETE,neigh_timer_handler将发送arp请求(arp_solicit)
              |     ......
              |- apr_rev -> neigh_update      接收arp报文,更新邻居系统
                                |
              |- neigh_resolve_output
                 |
             |- neigh_hh_init     更新hh_cache
                                     |
                   |- dev_hard_header   初始化以太网报文头
                                     |
                   |- dev_queue_xmit 数据发送至硬件抽象层(neigh->ops->queue_xmit)
                                           |
                           |- dev->netdev_ops->ndo_start_xmit 驱动数据发送函数

        b.发送数据
|- netif_rx              驱动创建skb后调用此函数，函数skb加入struct softnet_data->input_pkt_queue中，之后出发软中断
| ......
|- net_rx_action         数据接收软中断
     |
   |- process_backlog
   |- __skb_dequeue 从softnet_data->input_pkt_queue接收数据
         |
     |- __netif_receive_skb 调用struct packet_type->func(inet_init是注册ip_packet_type)
         |
           |- ip_rcv   解析ip头
         |
           |- ip_rcv_finish
               |
         |- ip_route_input_common    查找路由表，如果没有则加入fib和rt_hash_table
               |
               |- ip_local_deliver                 (struct dst_entry->input)
                   |
                   |- ip_local_deliver_finish
                   |    |
                   |    |- raw_v4_input     将skb加入struct sock->sk_receive_queue
                   |
                   |- 如果数据不是raw类型，则进入L4处理函数struct net_protocol->handler

tcpip stack(1) -- init

2011-07-31T17:52:00.001+08:00

1. socket_init()建立vfsmount文件系统
static struct vfsmount *sock_mnt __read_mostly;
static int __init sock_init(void)
{
    skb_init(); //为socket buffer创建高速缓存
    init_inodecache(); //为struct sock_alloc创建高速缓存

    //创建已安装文件系统
    register_filesystem(&sock_fs_type);
    sock_mnt = kern_mount(&sock_fs_type);
}

static struct file_system_type sock_fs_type = {
    .name = "sockfs",
    .mount = sockfs_mount,
    .kill_sb = kill_anon_super,
};

static struct file_system_type *file_systems;
int register_filesystem(struct file_system_type * fs)
{
    struct file_system_type ** p;
    /*将sock_fs_type注册到全局的file_systems中*/
    p = find_filesystem(fs->name, strlen(fs->name));
    if(p)
        return error;
    else
        *p = fs;
}

函数kern_mount()将调用vfs_kern_mount()创建vfsmount
struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct vfsmount *mnt;
    struct dentry *root;

    mnt = alloc_vfsmnt(name); //从高速缓存中获取vsfmount结构
    root = mount_fs(type, flags, name, data);

    //建立vfsmount与dentry的对应关系
    mnt->mnt_root = root;
    mnt->mnt_sb = root->d_sb;
    mnt->mnt_mountpoint = mnt->mnt_root;
    mnt->mnt_parent = mnt;
    return mnt;
}

创建dentry对象
struct dentry *
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
{
    struct dentry *root;
    struct super_block *sb;

    root = type->mount(type, flags, name, data); //调用sock_fs_type中的sockfs_mount()
    sb = root->d_sb;

    return root;
}
sockfs_mount()将调用mount_pseudo()
static const struct super_operations sockfs_ops = {
    .alloc_inode = sock_alloc_inode,
    .destroy_inode = sock_destroy_inode,
    .statfs = simple_statfs,
};
static const struct dentry_operations sockfs_dentry_operations = {
    .d_dname = sockfs_dname,
};
struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
const struct super_operations *ops,
const struct dentry_operations *dops, unsigned long magic)
{
    struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
    //创建super block并注册到全局super_blocks中
    struct dentry *dentry;
    struct inode *root;

    root = new_inode(s); //创建inode对象
    dentry = d_alloc(NULL, &d_name); //创建dentry对象

    //将创建的3个对象建立联系
    ……
    return dentry;
}
初始化完成后：sock_mnt->vfsmount->dentry->inode->superblock
2. inet_init()网络网络层初始化
static int __init inet_init(void)
{
    proto_register(/*tcp, udp, raw*/); //将inet socket结构proto注册到proto_list中

    sock_register(&inet_family_ops); //将协议族net_proto_family注册到net_families中

    inet_add_protocol(/*tcp, udp, icmp*/);
    //将协议处理接口结构net_protocol注册到inet_protos中

    //建立inetsw链表与inetsw_array数组的对应关系
    for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
        INIT_LIST_HEAD(r);
    for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
        inet_register_protosw(q);
    ……
}
Socket基本结构：

3. socket()
SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
    struct socket *sock;
    /*调用sock_alloc创建struct socket_alloc，其中包含struct socket和struct inode;
     调用sock->create()-------->inet_create()创建struct sock
    */
    retval = sock_create(family, type, protocol, &sock);
    //创建文件描述符struct file，将file指针放入fd数组中
    retval = sock_map_fd(sock,flags&(O_CLOEXEC|O_NONBLOCK));
    return retval;
}
结构如图：
                                             struct socket_alloc
                                                    |-------------|
                                                    | socket    |------>sock
                                                    |-------------|
                                 |----dentry->|   inode    |------------>
    Struct file->path-|    |-------------|    Super_block
                                 |----fsmount->dentry->inode------>

用户进程通过文件描述符就可以找到INET socket。BSD socket层从已注册的INET proto_ops结构中调用INET层socket支持例程来执行工作。例如，一个ipv4的BSD socket建立请求，将用到下层的INET socket的建立函数。为了不把BSD socket与tcpip的特定信息搞混，INET socket层使用它自己的数据结构struct sock，它与BSD socket结构相连。Sock结构的协议操作指针也在初始化时建立，它依赖于被请求的协议。如果请求时TCP，那么sock结构的协议操作指针将指向TCP连接所必须的TCP协议操作集。
4. net_dev_ini ()网络设备抽象层初始化
static int __init net_dev_init(void)
{
    //Initialise the packet receive queues.
    for (i = 0; i < NR_CPUS; i++) {
        struct softnet_data *queue; queue = &per_cpu(softnet_data, i);
        skb_queue_head_init(&queue->input_pkt_queue);

        queue->throttle = 0;
        queue->cng_level = 0;
        queue->avg_blog = 10; /* arbitrary non-zero */
        queue->completion_queue = NULL;
        INIT_LIST_HEAD(&queue->poll_list);
        set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
        queue->backlog_dev.weight = weight_p;
        queue->backlog_dev.poll = process_backlog;
        atomic_set(&queue->backlog_dev.refcnt, 1);
    }

    open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
    open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
}
为每个CPU创建一个struct softnet_data的队列，表示要交给此CPU处理的数据包。并注册网络相关的软中断。
网络设备抽象层通过struct net_device调用指定的device driver与设备通信。
5. device driver initialize
用insmod加载驱动模块时，内核会默认执行模块中的module_init()函数
static int __init xxx_init_module (void)
{
    return pci_register_driver(&xxx_pci_driver);
}
module_init(xxx_init_module);

pci_register_driver()注册设备驱动程序(struct pci_driver)
int __pci_register_driver(struct pci_driver *drv, struct module *owner,
const char *mod_name)
{
    /*将strcut pci_driver加到总线链表中，并执行.probe()初始化设备驱动 */
    driver_register(&drv->driver);

    /* 为驱动创建sysfs文件 */
    pci_create_newid_file(drv);
    pci_create_removeid_file(drv);
}
strcut pci_driver->probe()调用驱动初始化函数初始化struct net_device
static int __devinit xxx_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
    struct net_device *dev = NULL;
    xxx_init_board (pdev, &dev);
    /* 设备抽象层提供驱动操作函数 */
    dev->open = xxx_open;
    dev->hard_start_xmit =xxx_start_xmit;
    dev->poll = xxx_poll;
    dev->stop = xxx_close;
    dev->do_ioctl = netdev_ioctl;
}

study kernel(3) -- memory,vfs

2011-07-31T17:32:00.000+08:00

一、内存及内存管理
1. 内存地址
三种不同的地址：
1．逻辑地址：每个逻辑地址都有一个段和偏移量组成，偏移量指明从段开始的地方到实际地址之间的距离。Linux中逻辑地址总是与线性地址一致。
2．线性地址：虚拟地址。32位系统有4G的线性地址，64位系统有8G线性地址。
3．物理地址：物理内存的实际地址。
地址转换关系：
逻辑地址通过分段单元转换为线性地址，之后再通过分页单元转换为物理地址。
2. 页
页：线性地址被分成固定长度为单位的组。页内部连续的线性地址被映射到连续的物理地址中。页既指一组线性地址，又指这组地址中的数据。Linux每一页有4KB容量。
页框：或物理页。一个页框包含一个页，因此页框长度与页长度一致。页可存放在任何一个物理页中。页框就是物理内存。
页表：保存线性地址和物理地址之间映射的页。
内核中用页述符struct page描述每一个页框的状态信息，所有的页描述符都保存在mem_map数组中。
struct page {
unsigned long flags; //描述页框状态
atomic_t _count; //页框的引用计数
atomic_t _mapcount; //页框中页表数目
void *virtual;; //页框的虚拟地址
……
}
转换关系如图：

3. 内存管理区

内核物理内存划分为不同的区，并用struct zone描述每个区。每个管理区的分配器可以在他的物理内存区域添加删除页框。

4. slab分配器
slab层把不同对象划分为高速缓存组，每个高速缓存被划分为多个slab，每个slabe由一个或多个连续的页框组成，页框中包含对象的数据结构。
如struct inode由inode_cachep高速缓存进行分配。这个高速缓存有一个或多个slab组成。每个slab包含尽可能多的struct indoe对象。当内核请求分配新的inode结构时，内核从部分满或空的slab返回一个指向已分配但未使用的结构的指针。当内核用完后，slab分配器把该对象标记为空闲。

Slab的使用：(struct task_struct)
a. 创建高速缓存
static struct kmem_cache *task_struct_cachep; //全局变量
void __init fork_init(unsigned long mempages) //内核初始化调用
{
    task_struct_cachep =
    kmem_cache_create("task_struct", sizeof(struct task_struct),
    ARCH_MIN_TASKALIGN,SLAB_PANIC|SLAB_NOTRACK, NULL);
}
b. 申请进程描述符
当创建子进程会有如下过程
fork()->sys_fork()->do_fork()->copy_process()->dup_task_struct()
static struct task_struct *dup_task_struct(struct task_struct *orig)
{
    struct task_struct *tsk;
    tsk = kmem_cache_alloc (task_struct_cachep, GFP_KERNEL);
                                            //从高速缓存中返回一个进程描述符的指针
    ……
}
c. 释放进程描述符
当进程被销毁时会有如下过程：
free_task()->free_task_struct()
即执行kmem_cache_free(task_struct_cachep, (tsk))，将tsk所指的进程描述符标记为空闲。
二、进程地址空间
1. 进程虚拟内存的使用
Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。进程的可用32 位地址系统支持的全部4G 线性空间。进程的线性地址空间分成两部分：1. 从0x00000000 到 0xbfffffff 的线性地址，无论用户态还是内核态的进程都可以寻址。2. 从0xc0000000 到 0xffffffff 的线性地址，只有内核态的进程才能寻址。
对普通进程来讲，它都会涉及到5种不同的数据段。
1．代码段：代码段是用来存放可执行文件的操作指令，也就是说是它是可执行程序在内存种的镜像。代码段需要防止在运行时被非法修改，所以只准许读取操作，而不允许写入操作。
2．数据段：数据段用来存放可执行文件中已初始化全局变量，就是存放程序静态分配的变量和全局变量。可读可写。
3．BSS段：包含了程序中未初始化全局变量，在内存中 bss段全部置零。
4．堆：堆是用于存放进程运行中被动态分配的内存段，它大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上；当利用free等函数释放内存时，被释放的内存从堆中被剔除。
5. 栈：栈是用户存放程序临时创建的局部变量。除此以外在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也回被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上将我们可以把堆栈看成一个临时数据寄存、交换的内存区。
2. 创建进程的地址空间
内核使用内存描述符struct mm_struct表示进程的地址空间。当创建新的进程时内核调用copy_mm()函数建立新进程的所有页表和内存描述符来创建进程的地址空间：
static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
{
    struct mm_struct * mm, *oldmm;
    oldmm = current->mm;

    if (clone_flags & CLONE_VM) { //线程使用父进程地址空间
        atomic_inc(&oldmm->mm_users);
        mm = oldmm;
        goto good_mm;
    }

    mm = dup_mm(tsk); //创建子进程地址空间
}

struct mm_struct *dup_mm(struct task_struct *tsk)
{
    struct mm_struct *mm, *oldmm = current->mm;

    mm = allocate_mm(); //从slab中分配一个mm_struct
    memcpy(mm, oldmm, sizeof(*mm));

    mm_init(mm, tsk); //初始化结构体并为进程创建pgd和pte

    init_new_context(tsk, mm);

    dup_mm_exe_file(oldmm, mm);

    dup_mmap(mm, oldmm); //创建VMA
}
VMA指定地址空间内连续区间上的一个独立内存范围来代表多种类型的内存区域。VMA用struct vm_area_struct描述。
static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
{
    struct vm_area_struct *mpnt, tmp；
    struct rb_node **rb_link, rb_parent；

    //扫描父进程的VMA链表
    for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
        tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
        *tmp = *mpnt; //复制父进程VMA

        //将复制的VMA插入到子进程的VMA链表和红黑树中
        _vma_link_rb(mm, tmp, rb_link, rb_parent);
        rb_link = &tmp->vm_rb.rb_right;
        rb_parent = &tmp->vm_rb;
}

        /*拷贝父进程所有vm_area_struct对应的页目录、页表。将父子进程中私
         有的、可写的页标记为只读的，以便这种页面能用写时复制机制进行处理
        */
        copy_page_range(mm, oldmm, mpnt);
}
虚拟地址、虚拟地址区域、内存描述符之间关系如图：

3. 缺页异常处理
内核中的函数直接获得动态内存，内核是操作系统中优先级最高的成分,可采用kmalloc/vmalloc分配连续和非连续线性区得到内存。
用户态进程调用malloc分配内存时，请求被认为是不紧迫的，因此，当用户态进程请求动态内存时，并没有立即获得实际的物理页框，而仅仅获得对一个新的VMA。这样，当用户进程真正向这些线性区写的时候，就会产生缺页异常，在缺页异常处理程序do_page_fault()中获得真正的物理内存。

三、虚拟文件系统
虚拟文件系统(VFS)是一个内核软件层，用来处理与Unix标准文件系统相关的所有系统调用。它与驱动程序联系的更加紧密。其分层结构如图：

1. 主要数据结构
a. 超级块对象结构struct super_block
该结构保存了一个被安装在linux系统上的文件系统的信息。对于基于磁盘的文件系统，该结构一般和保存在磁盘上的"文件系统控制块"对应。也就是说如果是磁盘文件系统，该结构保存的磁盘文件系统的控制信息。
b. 索引节点对象结构struct inode
该结构中存储的是一个特定文件的一般信息，对于一个基于磁盘的文件系统，该结构对应磁盘上的文件数据控制块。每一个inode结构都对应一个inode节点号，这个节点号是唯一的，它也唯一标识一个文件系统中的文件。
c. 文件对象结构struct file
该结构中存储的是一个打开的文件和打开这个文件的进程间的交互信息。该结构保存在内核的内存区，在打开文件时被创建，关闭文件时被释放。
d. 目录项对象结构struct dentry
该结构存储的是目录实体和对应的文件的关联信息。
2. 各数据结构之间的关系
内核创建文件对象并返回文件描述符索引号给用户空间。文件对象引用目录项对象，后者引用索引节点对象。这两个对象都引用超级块对象。多个文件对象可以引用同一个目录项对象。一个目录项对象还可能引用另一个目录项对象。如图：

study kernel(2) -- sync, interrupt

2011-07-24T14:33:00.001+08:00

三、内核同步
1. 原子操作
linux提供了一系列C语言函数来实现内核中的原子操作，这些函数又分为两类，分别针对bit变量和整数变量进行原子操作。它们的共同点是在任何情况下都是原子的，内核代码可以安全的调用它们而不被中断，而且它们都依赖底层CPU的原子操作来实现-所有这些函数都是CPU架构相关的。其实现在atomic.h和bitops.h中
2. 禁止中断
CPU具备屏蔽中断和打开中断的功能，这项功能可以保证正在执行的内核控制路径不被中断处理程序所抢占，防止某些竞争条件的发生。Linux提供了local_irq_disable()/local_irq_enable()，local_irq_save()/local_irq_restone()来实现屏蔽/开启中断的功能。
另外，内核提供的另外一些函数隐含的调用了屏蔽中断的功能，如spin_lock_irq()。中断机制对于内核的正常运行是非常重要的，因为异步I/O，进程调度等很多重要操作都依赖于中断，而在屏蔽中断期间所有的中断都无法得到处理，而必须延迟到解除屏蔽以后。所以长时间的屏蔽中断是很危险的，有可能造成数据丢失乃至系统崩溃等后果。这就要求在屏蔽了中断之后，当前的内核控制路径应当尽快的执行完临界区的代码，然后解除对中断的屏蔽。尤其需要注意的是，屏蔽中断后的内核控制路径不能调用有可能引起阻塞的函数，因为这些函数会使进程睡眠，然后主动调用schedule()来放弃CPU。
3. 自旋锁
自旋锁在试图加锁的时候，如果当前锁已经处于锁定状态，加锁进程就进行"旋转"，用一个死循环测试锁的状态，直到成功的取得锁。自旋锁的这种特性避免了调用进程的挂起，用"旋转"来取代进程切换。而上下文切换需要一定时间，并且会使高速缓冲失效，对系统性能影响是很大的，所以自旋锁在多处理器环境中非常方便。当然，被自旋锁所保护的"临界代码"一般都比较短，否则就会浪费过多的CPU资源。
当一个内核控制路径与中断处理程序之间存在竞争条件时，需要使用中断安全版本的自旋锁spin_lock_irq()/spin_lock_irqsave()，这个函数首先禁止本地CPU上的中断，然后试图获得自旋锁，这样在执行临界区代码的时候，本地CPU不会被中断处理程序所抢占。同时，由于禁止的只是本地CPU上的中断，系统中其它CPU仍然可以对外部中断进程处理。
自旋锁是互斥的，同一时刻只能有一个内核控制路径拥有自旋锁。
4. 信号量
信号量为了解决多个内核控制路径竞争资源的问题，这些内核控制路径可能是单处理器系统中分时执行的控制路径，也可能是多处理器系统中的并行执行的控制路径。在试图获得信号量的时候，如果信号量繁忙，相应的内核控制路径会挂起，直到信号量被释放的时候控制路径才恢复运行。使用信号量的时候，先声明一个semaphore类型的对象，然后调用函数sema_init()来初始化它。要想获得信号量的掌握权，需要调用函数down_interruptible()/down()，此时如果信号量忙，调用进程被挂起，加入到信号量的等待队列中去；释放信号量的时候则调用up()函数，系统同时会唤醒正在等待信号量的进程，唤醒的顺序与等待的顺序是一致的。
注：中断上下文只能用自旋锁，而任务睡眠时只能使用信号量。
四、中断
中断由硬件设备生成，再由中断控制器向处理器发送相应信号。处理器检测到此信号，便中断自己的当前工作转而处理中断。此后处理器会通知系统已经产生中断，操作系统就可以对这个中断进行适当的处理。
IRQs(Interrupt ReQuests)：外设引起的中断应该被称为中断请求。中断请求号和中断号中间有一定的映射关系。这个映射关系和平台有关。
1. 中断处理的层次
中断的嵌套会带来很多问题，在中断处理函数重屏蔽其他中断源可以解决防止中断嵌套，但是长时间地屏蔽中断会导致内核遗漏掉一些重要的中断。因此，中断处理函数重中断的屏蔽时间应该越短越好。
中断处理函数应满足下面两个要求：
a. 代码量应越少越好，以便中断函数的快速执行。
b. 如果中断处理函数也可以并发，那么他们之间不得互相影响。
上述两个条件中，后者可以通过优化中断处理函数的设计和编码来实现，但想实现前者，则不那么容易。但实际上，并非中断处理程序的所有工作的重要性都是相同的，通常来讲，一个中断服务程序可根据其是否需要马上处理而分为三个部分：
Critical actions:
这个部分必须要在中断发上后马上执行，否则将无法保证系统的稳定性或者数据操作的正确性。例如，当网卡上有数据包到达后，内核必须马上将数据从网卡挪到内存中，如果这个动作没有在中断发生后马上执行，该数据可能会被后续接收到的数据覆盖。在进行这个 critical actions 的时候，其他的中断必须被关掉。
Noncritical actions:
这些actions相比前面的critical actions重要性稍低，但是也应该尽快完成。不同的是，它可以在打开其他中断的前提下进行，因此可能会被其他的中断所"中断"(受其他的中断影响)。
Deferrable actions:
Deferrable actions 的重要性比前两者都低，可以不用放在中断处理函数中进行。内核可以等到没什么事情的时候再处理它。
对中断处理函数的划分，并根据各个部分的不同的重要性，可以将中断函数拆成若干不同的片段，放在不同的上下文中执行，很大程度上，在保证了系统事件完整性的前提下，防止了中断的嵌套。
2. 中断上半部
a) 中断的处理
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
[0 ... NR_IRQS-1] = {
.handle_irq = handle_bad_irq,
.depth = 1,
.lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
}
};
中断处理函数do_IRQ()根据中断号被存放到irq_desc数组中；从irq_desc中，可以依据中断号，找到相应的中断处理程序。
struct irq_desc用于描述一个IRQ，其中：
handler_data: 指向一些与IRQ处理函数相关的数据。当中断发生时，handle_irq被调用。
action: 这个数据结构提供了当中断发生后需要执行的中断处理程序。
b) 中断处理程序的注册
static inline int __must_checkrequest_irq (unsigned int irq, irq_handler_t handler,
unsigned long flags, const char *name, void *dev)
{
return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}

request_threaded_irq首先从内核中获取了这个irq对应的irq_desc，然后创建结构体irqaction，设置action的handler, flags, name, dev_id。然后调用__setup_irq完成后续工作。
Flags标志：
SA_INTERRUPT：执行中断处理程序时屏蔽所有中断线。而默认没有这个标志时，除了正在运行的中断处理程序对应的中断线被屏蔽外，其他所有中断都是激活的。
SA_SAMPLE_RANDOM: 内核通过一系列的事件的相关信息来生成随机数,如果有这个标志，则调用rand_initialize_irq将IRQ添加到熵池所需的相关数据结构中。
SA_SHIRQ：可以在多个中断处理程序之间共享中断线。
3. 中断下半部
下半部的任务就是执行于中断处理密切相关但中断处理程序本身不执行的工作。提供如下几种机制：
c) 软中断
i. 注册软中断处理程序
软中断项：
struct softirq_action{
void (*action) (struct softirq_action *); //软中断处理程序
void *data;
}
软中断向量表：
static struct softirq_action softirq_vec[NR_SOFTIRQS];
函数open_softirq()通过软中断索引号注册软中断处理函数

ii. 触发/禁止软中断
函数raise_softirq()/raise_softirq_irqoff()通过软中断索引号修改软中断状态寄存器irq_stat

iii. 软中断守护线程函数do_softirq()核心部分代码：
void do_softirq(void){
struct softirq_action *h;
__u32 pending;

if (in_interrupt()) //处于中断上下文则返回
return;

pending = local_softirq_pending(); //查询软中断状态寄存器irq_stat判断事件是否发生
set_softirq_pending(0);
h = softirq_vec; //软中断向量表
do{
if (pending & 1) //事件发生则执行软中断处理程序
h->action(h);
h++;
pending >>= 1;
}while (pending);
}
d) tasklet
Tasklet为一个软中断，考虑到优先级问题，分别占用了软中断向量表中的0号和5号软中断。
i. 创建tasklet
struct tasklet_struct
{
struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
};
调用DELCARE_TASKLET创建struct tasklet_struct结构体并注册tasklet处理程序。
调用tasklet_schedule()/tasklet_hi_schedule()将struct tasklet_struct加入tasklet向量表tasklet_vec/tasklet_hi_vec。
ii. tasklet注册软中断处理程序
在softirq_init()中调用注册tasklet软中断处理函数tasklet_action()/tasklet_hi_action()
static void tasklet_action(struct softirq_action *a){
struct tasklet_struct *list;

list = __this_cpu_read(tasklet_vec.head); //读取tasklet向量表

while (list) {
struct tasklet_struct *t = list;
list = list->next;
if (!atomic_read(&t->count))
t->func(t->data); //如果count为0则执行tasklet处理程序。
}
}
e) 软中断与tasklet的区别
软中断必须确保共享数据的安全，因为两个甚至更多相同类别的软中断有可能在不同的处理器上同步执行。而两个同类型的tasklet不能同时执行。

study kernel(1) -- process, schedule

2011-07-24T14:33:00.000+08:00

一、进程
1. 进程描述符
内核用进程描述符task_struct表示用户空间中进程的所有信息。
task_struct 定义如下：
struct task_struct {
volatile long state; //进程运行状态
struct thread_info; //线程描述符
struct mm_struct; //描述内存存储信息
struct tty_struct; //与进程相关的tty
struct fs_struct; //当前目录
struct signal_struct; //所接收的信号
......
};
其中，state用于表示进程当前的运行状态进程状态：
1． TASK_RUNNING：进程正在执行或是可执行的，调度器可将其加入运行队列(runqueue)。
2． TASK_INTERRUPTIBLE/TASK_UNINTERRUPTIBLE：进程由于某些原因（通常是状态不满足）而被阻塞，当条件满足后，则会重新变成TASK_RUNNING。不同的是， TASK_INTERRUPTIBLE，可以响应内核发出的信号；而TASK_UNITERRUPTIBLE不响应内核发出的信号。
3． EXIT_ZOMBIE：进程已经结束，但此时任占用内核栈、thread_info、task_struct，为了向父进程提供信息。当父进程调用了wait4()后，信息会被释放。
4． __TASK_STOPPED：进程停止运行。
2. 创建进程
fork()系统调用的功能是为当前进程创建一子进程。调用此函数时，系统将调用宏指令_syscall0，并做最终调用内核接口sys_fork()。
asmlinkage int sys_fork(struct pt_regs regs)
{
return do_fork(SIGCHLD, regs.esp, ®s, 0, NULL, NULL);
}
SIGCHLD是在定义的一个宏，它告诉do_fork()函数应创建一个子进程，即创建并初始化进程描述符task_struct以及他包含的其他结构。
3. 创建内核线程
Linux内核可以看作一个服务进程。内核需要多个执行流并行，为了防止可能的阻塞，多线程化是必要的。内核线程的调度由内核负责，一个内核线程处于阻塞状态时不影响其他的内核线程，因为其是调度的基本单位。
内核线程是由kernel_thread()函数在内核态下创建的:
int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
struct pt_regs regs;
memset(®s, 0, sizeof(regs));
......
/* Ok, create the new process.. */
return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, ®s, 0, NULL, NULL);
}
内核线程的创建本质上也是建立了一个task_struct。其中CLONE_VM标志表示，避免复制进程的页表。内核线程和调用的进程(current)具备相同的进程空间，因为调用者运行在进程的内核态，所以进程在内核态时共享内核空间。

二、进程调度
4. 进程调度类型
Linux进程按照下面调度类型被调度：
SCHED_FIFO：先进先出的实时进程。如果没有其他可运行的更高优先级实时进程，该进程将一直占用CPU。
SCHED_RR：时间片轮转的实时进程。所有具有相同优先级的SCHED_RR实时进程公平分配CPU时间。
SCHED_NORMAL：普通的分时进程。
5. 普通进程调度
普通进程通过静态优先级nice值决定进程的基本时间片，nice值越小，静态优先级越高，进程获得的CPU时间更长。同时以nice值为基础并通过检查进程过去的情况设置优先级，既动态优先级。调度程序总是选择动态优先级高的进程投入运行。
Linux基于以动态优先级为基础的调度算法。内核为每个进程设置一个基本的优先级，但它允许调度程序根据需要来加减优先级，然后挑选优先级最高的进程投入运行。当进程时间片用完重新分配时间时，也会根据优先级值动态分配时间。
6. 实时进程调度
实时算法实现都是静态优先级，而不会设置动态优先级。这能保证优先级高的实时进程总能抢占优先级低的进程。
7. 更新时间片scheduler_tick()
void scheduler_tick(void)
{
struct task_struct *p = current;

if (p->array != rq->active) { //如果current->array没有指向runqueue，说
set_tsk_need_resched(p); 明进程已经过期但未被替换，则设置
goto out; need_resched字段以进行重新调度
}

/* current为SCHED_FIFO，进程不会被低优先级进程抢占，因此不更新时间片。
current为SCHED_RR，时间片将递减。若时间片用完，则重新计算时间片，设置need_resched字段，将进程加入runqueue尾部。
*/
if (rt_task(p)) {
if ((p->policy == SCHED_RR) && !--p->time_slice) {
p->time_slice = task_timeslice(p); //根据静态优先级计算时间片
set_tsk_need_resched(p);
requeue_task(p, rq->active);
}
goto out_unlock;
}
/* 更新普通进程时间片。若时间片用完，设置need_resched字段，根据动态优先级设置进程优先级，根据静态优先级设置时间片。若时间片未用完，则检查进程是否可继续占用CPU。
*/
if (!--p->time_slice) {
set_tsk_need_resched(p);
p->prio = effective_prio(p);
p->time_slice = task_timeslice(p);
} else {
......
}
}
8. 调度程序schedule()
调用schedule()函数分为直接调用和延迟调用。如果current进程因不能获得必要的资源要立即被阻塞，就直接调用schedule()；也可通过设置current的need_resched字段被设置，以延迟方式调用schedule()。由于总是在恢复用户态进程的执行前检查这个标志，所有schedule()将在不久之后的某个时间被调用。
asmlinkage void __sched schedule(void)
{
struct task_struct *prev, *next;
struct list_head *queue;
struct prio_array *array;
int idx;
struct rq *rq;
……
……
prev = current;
array = rq->active; //获取活动优先级队列
idx = sched_find_first_bit(array->bitmap); //通过优先级位图快速查找进程
queue = array->queue + idx;
next = list_entry(queue->next, struct task_struct, run_list); //返回进程描述符
if(prev != next)
context_switch(); //如果选中的进程不是当前进程则进行上下文切换
}
9. 用户抢占
内核即将返回用户空间时，如果need_resched标志被设置，会导致schedule()被调用，发生用户抢占。
10. 内核抢占
thread_info引入了preempt_count计数器。该计数器初始值为0，每当使用锁的时候数值加1，释放锁的时候数值减1。当数值为0的时候，内核就可执行抢占。从中断返回内核空间的时候，内核会检查need_resched和preempt_count的值。如果need_resched被设置，并且preempt_count为0的话，这说明有一个更为重要的任务需要执行并且可以安全地抢占，此时调度程序就会调度(抢占当前进程)。如果preempt_count不为0，说明当前任务持有锁，所以抢占是不安全的。这时，就会像通常那样直接从中断返回当前执行进程。如果当前进程所持有的所有的锁都被释放了。那么preempt_count就会重新为0。此时，释放锁的代码会检查need_resched是否被设置。如果是的话，就会调用调度程序。

container_of()

2011-05-19T22:29:00.000+08:00

#include <stdio.h>

/*
    #define container_of(ptr, type, member) ({             \
                 const typeof( ((type *)0)->member ) *__mptr = (ptr);     \
                 (type *)( (char *)__mptr - offsetof(type,member) );})


    #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
*/



struct test {
    int a;
    char *b;
};

int main(int argc, char *argv[])
{

    //通过struct test成员b返回struct的入口地址    //container_of(&tmp.b, (struct test), b);

    struct test tmp;
    struct test *ptmp;
    int offset;
    tmp.a = 10;

    printf("&tmp.a = %02x, &tmp.b = %02x\n", &tmp.a, &tmp.b);

    //定义一个 _mptr指针， 类型为struct test结构体中b成员的类型
    //typeof 为获取（（（struct test＊）0）->b)的类型，此处此类型为char*
    const typeof(((struct test *)0)->b) *_mptr = &tmp.b;
    printf("_mptr = %02x\n", _mptr);


    //#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
    //TYPE是某struct的类型 0是一个假想TYPE类型struct,MEMBER是该struct中的一个成员.

    //由于该struct的基地址为0, MEMBER的地址就是该成员相对与struct头地址的偏移量.
    offset = (int)(&((struct test *)0)->b);
    printf("offset = %d\n", offset);

    //_mptr的地址减去MEMBER在该struct中的偏移量得到的地址, 再转换成type型指针. 该指针就是struct的入口地址了.
    ptmp = (struct test *)((char *)_mptr - offset);
    
    printf("tmp = %02x, ptmp = %02x\n", &tmp, ptmp);
    printf("ptmp->a = %d\n", ptmp->a);
    return 0;
}

输出结果：

$ ./a.out

&tmp.a = bfffe6a0, &tmp.b = bfffe6a4
_mptr = bfffe6a4
offset = 4
tmp = bfffe6a0, ptmp = bfffe6a0
ptmp->a = 10

iptables command and rules

2011-05-14T20:21:00.000+08:00

$ iptables [-t table] command [match] [target]

iptables有5个链：PREROUTING，INPUT，FORWARD，OUTPUT，POSTROUTING；4个表：filter,nat,magle,raw.

4个表的优先级由高到低为：raw->mangle->nat->filter.

[-t table] 选项允许使用标准表之外的任何表。表是包含仅处理特定类型信息包的规则和链的信息包过滤表。该选项不是必需的，如果未指定，则 filter 用作缺省表。
filter：表用于一般的信息包过滤。包括链表：
INPUT：主要与想要进入本机的封包有关；
OUTPUT：主要与本机所要送出的封包有关；
FORWARD：用于转发，与nat table 相关性较高。
nat：主要在进行来源与目的之 IP 或 port 的转换，与 Linux 本机较无关，主要与 Linux 主机后的区域网路内电脑较有相关。包括链表：
PREROUTING：在进行路由判断之前所要进行的规则(DNAT/REDIRECT)
POSTROUTING：在进行路由判断之后所要进行的规则(SNAT/MASQUERADE)
OUTPUT：与发送出去的封包有关。
mangle：该表包含一些规则来标记用于高级路由的信息包，该表包含 PREROUTING 和 OUTPUT 链。

RAW表只使用在PREROUTING链和OUTPUT链上,因为优先级最高，从而可以对收到的数据包在连接跟踪前进行处理。一但用户使用了RAW 表,在某个链上,RAW表处理完后,将跳过NAT表和 ip_conntrack处理,即不再做地址转换和数据包的链接跟踪处理了.RAW表可以应用在那些不需要做nat的情况下，以提高性能。如大量访问的web服务器，可以让80端口不再让iptables做数据包的链接跟踪处理，以提高用户的访问速度。

各链表关系如下：

hash list

2011-05-14T18:27:00.000+08:00

拉链法实现HASH链表

 #include <stdio.h>
 #include <string.h>
 
 #define N 14
 #define M 14
 
  typedef struct struct_node{
      int key;
      struct struct_node *next;
  }node;
 
  int get_hash_key(int key)
  {
      return key % 11;
  }
 
  node **hash_init(node **hash_table,int m)
  {
      int i = 0;
 
      for ( ; i < m ; i++ )
          hash_table[i] = NULL;
 
      return hash_table;
  }
 
  node **create_hash_table(node **hash_table,int *a)
  {
      node *m;
      int i = 0,key;
 
      for ( ; i < N ; i++ ) {
          key = get_hash_key(a[i]);
          m = (node *)malloc(sizeof(node));
          if ( !m ) {
              printf("malloc failed.\n");
              exit(0);
          }
          m->key = a[i];
 
          if ( hash_table[key] == NULL ) {
              hash_table[key] = m;
              m->next = NULL;
              continue;
          }
 
          m->next = hash_table[key];
          hash_table[key] = m;
      }
 
      return hash_table;
  }
 
  node *search_node(node **hash_table,int key)
  {
      node *p;
      int i = 0,hash_key;
 
      hash_key = get_hash_key(key);
      p = hash_table[hash_key];
 
      if ( !p )
          return NULL;
 
      while ( p ) {
          if ( p->key == key )
              return p;
          p = p->next;
      }
 
      return NULL;
  }
 
  node **delete_node(node **hash_table,int key)
  {
      node *p,*q,*head;
 
      p = hash_table[get_hash_key(key)];
      if ( !p ) {
          printf("[-] no key in hash_table .\n");
          return hash_table;
      }
 
      if ( p->next == NULL ) {
          hash_table[get_hash_key(key)] = NULL;
          return hash_table;
      }
 
      while ( p != NULL ) {
          if ( p->key == key ) {
              if ( p == hash_table[get_hash_key(key)] ) {
                  hash_table[get_hash_key(key)] = p->next;
                  return hash_table;
              }
              else{
                  q->next = p->next;
                  return hash_table;
              }
          }
          q = p;
          p = p->next;
      }
 
      return NULL;
  }
 
  void print_node(node *head)
  {
      if ( !head )
          return ;
 
      while ( head != NULL ) {
          printf("%d,",head->key);
          head = head->next;
      }
  }
 
  void print_hash_table(node **hash_table)
  {
      int i = 0;
 
      for ( ; i < M ; i++ ) {
          print_node(hash_table[i]);
          printf("\n");
      }
  }
 
  void destroy_node(node *head)
  {
      node *p;
 
      while ( head != NULL ) {
          p = head->next;
          free(head);
          head = p;
      }
  }
 
  void destroy_hash_table(node **hash_table)
  {
      int i = 0;
 
      for ( ; i < N ; i++ )
          destroy_node(hash_table[i]);
  }
 
  int main(void)
  {
      node *hash_table[M],*p,**s;
      int a[N] = {47,7,29,11,16,92,22,8,3,50,37,89,94,21};
 
      hash_init(hash_table,M);
      printf("[+] hash init ok.\n");
      create_hash_table(hash_table,a);
      printf("[+] hash table create ok.\n");
      print_hash_table(hash_table);
 
      printf("..................................\n");
 
      p = search_node(hash_table,29);
      printf("%d\n",p->key);
      printf("..................................\n");
 
      s = delete_node(hash_table,8);
      if ( !s )
          printf("[-] hash_table NULL.\n");
      print_hash_table(s);
 
      destroy_hash_table(hash_table);
      printf("[+] destroy hash_table ok.\n");
 
      return 0;
  }

MeeGo挺不住了

2011-02-11T23:55:00.002+08:00

2月11日，NOKIA宣布，与微软达成广泛战略合作关系，并将Windows Phone作为其主要的智能手机操作系统。并且MeeGo和移动解决方案业务主管阿尔伯托·托雷斯(Alberto Torres)已经于2月10日离职。
同时有消息，首款MeeGo系统手机Nokia N9-00也不幸夭折。传说中的MeeGo，被视为诺基亚在高端智能手机市场上对抗苹果和谷歌的利器，看来大势已去。不知Intel有何感想，怀胎10月，流产了。

Tieto，跟在Nokia后的小弟，你又何去何从？！。。。命运掌握在自己手中睡觉才踏实，觉醒吧。

Gstreamer Pad

2011-01-30T12:40:00.000+08:00

The relationship between pad and caps

                       |-name_template(eg:wavparse_src, wavparse_sink)
                       |
                       |-direction(src or sink)
  GstStaticPadTemplate-|
          |            |-presence(Sometimes, Always, request)
          |            |
          |            |                  |-GstCaps(String is stored in GstStruct)
          |            |-GstStaticCaps----|
          |                               |-String(support caps)
   gst_static_pad_template_get()
          |
          |           |-GstObject
          V           |
  GstPadTemplate------|-direction
          |           |
          |           |-presence
          |           |
          |           |-GstCaps
          |
   gst_pad_new_from_static_template()
          |
          |
          V    |-GstObject
  GstPad-------|-GstPadTemplate
               |...

Add pad into element and set relation

gst_element_add_pad(element, pad)
  {
      _set_parent(element, pad) {
          pad->parent = element
      }
  
      if(pad->direction == src)
          element->srcpads = pad
      else if(pad->direction == sink)
          element->sinkpads = pad
  
      element->pads = pad
  }
  
  +---------+         +------------+         +---------+
  |      parent------>|  element   |<------parent      |
  | Gstpad  |<-----sinkpad      srcpad------>|  GstPad |
  +---------+         +------------+         +---------+

Set pad active from srcpad to sinkpad

element state change from READY to PAUSE, set pad active

gst_element_pads_activate(element, TRUE)
  {
      //set srcpad
      activate_pads(element->srcpads, TRUE);
      //set sinkpad
      activate_pads(element->sinkpads, TRUE);
  }

check pad current mode and call pad->activefunc

gst_pad_set_active(pad)
  {
      mode = GST_PAD_ACTIVATE_MODE(pad);
      if(mode == GST_ACTIVATE_PUSH || mode == GST_ACTIVATE_PULL) {
          //pad already activation
          return TRUE;
      }
      else if (mode == GST_ACTIVATE_NONE)
          GST_PAD_ACTIVATEFUNC(pad) (pad);
  }

call pad->activepushfunc or pad->activepullfunc, default is pushfunc

gst_pad_activate_push(pad)
  {
      GST_PAD_ACTIVATE_MODE(pad) = GST_ACTIVATE_PUSH;
  
      GST_PAD_ACTIVATEPUSHFUNC(pad) (pad);
  }
  gst_pad_activate_pull(pad)
  {
      GST_PAD_ACTIVATE_MODE(pad) = GST_ACTIVATE_PULL;
  
      GST_PAD_ACTIVATEPULLFUNC(pad) (pad);
  }

Gstreamer State Change

2011-01-14T14:05:00.000+08:00

Some concepts of States
1. States defined in gstreamer
  - GST_STATE_VOID_PENDING: the state of an element is not set.
  - GST_STATE_NULL: initial state of an element.
  - GST_STATE_READY: all sources are ready and can go to pause.
  - GST_STATE_PAUSE: ready to accept and process data.
  - GST_STATE_PLAYING: the GstClock is running and the data is flowing.
2. Variables in GstElement
  - current_state: the current state of an element.
  - next_state: the next state of an element.
  - pending_state: the final state the element should go to.
  - target_state: last state the element we set.
  - last_return: the last return value of an element state change.
3. The states switch

Create a simple pipe to understand what are states

$ gst-launch-0.10 alsasrc ! audiorate ! filesink location=test.wav

At the beginning, gstreamer core how to initialize each element

Use funtion gst_element_factory_make("alsasrc", "sound") to create alsasrc element

When create instance of alsasrc(sound), gst_element_init() will initial state of the element.

GST_STATE_TARGET (element) = GST_STATE_NULL;            //target_state

GST_STATE_NEXT (element) = GST_STATE_VOID_PENDING;      //next_state

GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;   //pending_state

GST_STATE_RETURN (element) = GST_STATE_CHANGE_SUCCESS;  //last_return

GST_STATE (element) = GST_STATE_NULL;                   //current_state

Use function gst_bin_add_many to add elements to pipeline. Just add each element to GstBin->children, didn't change state of element
After link success I want to change state of pipeline from GST_STATE_NULL to GST_STATE_PLAYING
1. Now the state of element is GST_STATE_NULL, first change the state to GST_STATE_READY. All elements are added in GstBin->cheldren, when we change the state of pipeline to GST_STATE_READY, pipeline will call gst_bin_change_state_func to find child elemnt to change state to GST_STATE_READY. each child element will call plugin->change_state which defined by ourselves.
2. If state change to GST_STATE_READY successfully, update state of element, then try to change state of pipeline from GST_STATE_READY to GST_STATE_PAUSE. Alsa call gst_bin_change_state_func, the same as step 1.
3. If state change to GST_STATE_PAUSE successfully, update state of element, then try to change state of pipeline from GST_STATE_PAUSE to GST_STATE_READY. Alsa call gst_bin_change_state_func, the same as step 1.
When accept message GST_MESSAGE_EOS, try to change the state of pipeline from GST_STATE_PLAYING to GST_STATE_NULL

ubuntu samba server

2011-01-07T14:19:00.000+08:00

Installl samba

$ sudo apt-get install samba4

(install samba, server can not start, i don't know why)

$ sudo apt-get install smbclient

Configure /etc/samba/smb.conf

[global]
      security = share

[share]
      comment = chenorui
      path = /home/chenorui/share
      public = yes
      guest ok = yes
      browsable = yes
      writable = no

Restart samba server
```
$ sudo /etc/init.d/samba4 restart
```

Look at what services are available on a server

$ smbclient -L //yourIP
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.5.4]
  
  Sharename       Type      Comment
  ---------       ----      -------
  IPC$            IPC       IPC Service (chenorui server (Samba, Ubuntu))
  share           Disk      chenorui
  HP-LaserJet-M1522 Printer   HP LaserJet M1522
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.5.4]
  
  Server               Comment
  ---------            -------
  
  Workgroup            Master
  ---------            -------

mount share profile

$ sudo smbmount //yourIP/share /tmp/test

gstreamer caps negotiation

2011-01-05T17:03:00.000+08:00

协商过程中主要函数:
gst_pad_get_caps/gst_pad_set_getcaps_function, gst_pad_set_caps/gst_pad_set_setcaps_function。

gst_pad_get_caps 函数用来返回该pad能接受的caps。首先检查getcaps函数指针是否为NULL，如果不是则调用getcaps函数，这是一个函数指针，我们可以通过gst_pad_set_getcaps_function来给这个函数指针赋值，从而实现自定义的get_caps函数的逻辑。完成后函数返回；如果getcaps函数指针为NULL，则gst_pad_get_caps函数从该pad的pad template中列出所有的caps，返回；如果该pad没有pad template，则gst_pad_get_caps函数检查该GstPad的caps成员是否为NULL，如果不为NULL，则返回这个 member；最后，如果前面的都不成立，则gst_pad_get_caps创建一个empty的GstCaps并返回，表示该pad目前没有caps。

get_pad_set_caps 函数用来设置指定pad的caps。该函数首先检查参数中给出的caps是否已经和目前该pad中的caps相同，如果是，则直接返回。如果不相同，则检查setcaps函数指针是否为NULL，如果不为NULL则调用setcaps函数。我们可以通过 gst_pad_set_setcaps_function函数来给setcaps这个函数指针赋值，这样就在gst_pad_set_caps函数中实现了自定义的逻辑。注意，gst_pad_set_caps函数会判断setcaps函数的返回值，如果是FALSE，则会直接报错return FALSE，这样的结果就是gst_pad_set_caps函数执行失败，caps negotiation失败。当setcaps函数执行完毕后，gst_pad_set_caps函数执行gst_caps_replace，将保存在该pad中的caps member替换成参数中指定的caps，然后函数结束。

PUSH MODE:

              src              sink
              |                 |
              |  accepts?       |
  type A      |---------------->|
              |      yes        |
              |<----------------|
              |                 |
 get buffer   |  alloc_buf      |
 from pool    |---------------->| 
 with type A  |                 | Create buffer of type A.
              |                 |
 check type   |<----------------|
 and use A    |                 |
              |  push           |
 push buffer  |---------------->| Receive type A, reconfigure to
 with new type|                 | process type A.
              |                 |

PUSH MODE下，总是由src pad发起negotiation，为了让src pad和peer sink pad都能接受的caps来，src pad会将自己的caps和peer sink pad的caps做intersect，这时就会调用函数gst_pad_get_caps，参数就是peer sink pad（一般直接使用gst_pad_peer_get_caps函数一步完成）。如果 peer sink pad没有设置getcaps函数指针的话，那就会直接返回peer sink pad template中的所有caps。接下去就是src pad调用gst_pad_set_caps，把自己的caps确定下来，再然后就是申请并分配buffer

PULL MODE

src              sink
              |                 |
              |  accepts?       |
              |<----------------| type B
              |      yes        |
              |---------------->|
              |                 |
 get buffer   |  alloc_buf      |
 from pool    |---------------->| 
 with type A  |                 | Create buffer of new type B.
              |                 |
 check type   |<----------------|
 and          |                 |
 reconfigure  |                 |
              | pull            |

              |<----------------| Pull buffer from the peer src pad

              |                 |

PULL MODE下，由于是sink element的sink pad来drive pipeline，所以，caps negotiation要在pull thread启动之前就完成。首先，sink pad将自己的caps和peer src pad的caps做intersect（需调用peer src pad上的gst_pad_get_caps），之后调用gst_pad_set_caps将sink pad caps确定下来。调用gst_pad_set_caps，设置peer src pad，如果成功，那么表示src pad和自己一样，都具备了相同的caps，这样negotiation就成功了。最后，可以使用gst_pad_pull_range来获取数据，这个函数会为我们检查buffer中的caps和当前sink pad中的caps是否一致，如果不一致，就会return GST_FLOW_NOT_NEGOTIATED。

gst_pad_set_caps 被调用的时机。当在_chain函数中收到一个buffer之后，一般需要检查该buffer中的caps是否和当前pad中的caps相同，以防止数据在运行过程中改变caps。如果这两个caps不相同，那么，_chain函数应该返回GST_FLOW_NOT_NEGOTIATED，这样，gstreamer core就会用buffer中这个新的caps，去调用gst_pad_set_caps，这样做的目的是gstreamer要知道pad能否接受这个 caps，如果函数返回TRUE，表示接受该caps，而且pad已经更新了自己的caps为目前这个，如果函数返回FALSE，表示caps negotiation failed，pipeline就无法正常运行了。

在 PUSH模式下，_chain函数返回GST_FLOW_NOT_NEGOTIATED，gstreamer core就会自动为我们调用gst_pad_set_caps；但是在PULL模式下，虽然gst_pad_pull_range也会返回 GST_FLOW_NOT_NEGOTIATED，但是gst_pad_set_caps并不会自动被调用，gstramer不支持在pull thread中做set caps的动作。所以，在PULL模式下，我们需要自己处理这种GST_FLOW_NOT_NEGOTIATED的情况。回想pull thread没有启动之前，为什么我们需要设置setcaps函数呢？这是因为我们需要在这个函数中，使用gst_pad_set_caps来给peer src pad设置caps来完成caps negotiation，而这个动作在PUSH模式下，只要peer element的_chain函数返回GST_FLOW_NOT_NEGOTIATED，gstreamer core就会自动为我们调用peer src pad上的gst_pad_set_caps，所以，PUSH模式下，我们不需要去设置setcaps函数指针。

不能上网了！！！！

2011-01-05T12:20:00.000+08:00

adsl modern坏了，上不了网，狂晕:(
周末逛电脑城。。。

Command -- trap

2010-12-30T10:45:00.001+08:00

man trap, trap --help都没有，网上搜到格式如下：
trap "command" signal
于是有

#!/bin/bash

trap "echo \"hello world\"; echo $1" SIGKILL

while : ; do

sleep 1

done

$ ./test abc&

$ kill 11219

额。。。没反应！
原来kill 命令发出信号SIGTERM，如果想用SIGKILL需要执行kill -9。
再次运行后结果为：

$ ./test abc&

$ kill -9 112424

$ hello world

abc

trap为信号捕捉器，当接收到指定信号后执行""中的命令。

Command -- find

2010-12-28T21:21:00.001+08:00

1. 想查看当前文件夹及子文件夹里有没有文件名为“abc”的文件

# find . -name abc
. ：表示当前目录
-name：表示要根据名称查找

2. 想查看当前文件夹及子文件夹里有没有”xyz”目录

# find . -type d -name xyz
-type：表示设定类型，d表示文件夹类型，可以替换为f(普通文件)、l(链接文件)

3. 想找出当前文件夹及子文件夹里所有后缀是”.txt”的文件

# find . -name “*.txt”

4. 想查找当前目录及其子文件夹中“roc”用户自己的文件有哪些

# find . -user roc
-user：用于设定所属用户的名称，此处可替换为-group，即所属用户组的名称

5. 想查找当前文件夹及子文件夹里权限设定为755的所有文件

# find . -perm 755
-perm：用于设定权限

6. 想查找当前文件夹及子文件夹里的同时含有b字符和3字符的文件：用到正则表达式技术

# find . -regex ‘.*b.*3′
-regex：表示使用正则表达式进行匹配。请注意，此命令会和“全路径”进行匹配，也就是说前面要加.*，因为输出结果中会有“./”符号。

7. 如果想全部输出用find命令查找出的”*.abc”文件的内容

# find . -type f -name “*.abc” -exec cat {} \;
输出/tmp/code中所有.h，.c文件长度的总和
# find /tmp/code -name '*.[ch]' -exec wc -l {} \; | awk '{n+=$1} END{print n}'
-exec 表示由find找到的匹配项会作为“-exec后面设定的命令”的参数
可以使用-ok代替-exec，这样对每个匹配项进行操作，都会要求用户确认（y/n）.
命令最后的{} \; 别忘了写，其中{}代表用find查找到的结果中的每一个查找项。

8. 查找当前目录下在5分钟内被访问过的文件

# find . -amin -5
访问过用amin，修改过用mmin，文件状态改变过用cmin
精确到分钟的用amin,mmin,cmin，精确到天的用atime,mtime,ctime
在5分钟之内的用-5，在5分钟以上的用＋5

9. 想查找当前目录及子目录下文件大小大于10M的所有文件

# find . -size +10000000c
-size：表示文件大小，＋表示大于某个数，－表示小于某个数。c表示单位是字节，你可以将c换成k,M,G。

10. 上述所有的find命令都是查找当前目录及其子目录。如果不想深入到子目录中，而是只查找当前一层目录，则可以：

# find . -maxdepth 1 -name “*.c”

Linux system admin command(basic)

2010-12-28T21:20:00.000+08:00

Linux Command
1. output files
cat -- concatenate files and print on the standard output
tac -- concatenate and print file in reverse
nl -- number lines of file
head -- output the first part of file
tail -- output the last part of file

2. summarizing files
wc -- print newline, word, and byte counts for each file
eg. $wc -l -c test 30(line) 557(byte) test

3. sort files
sort -- sort lines of text files

eg.

sort缺省默认空格和tab键为分隔符。其他方式分隔，使用-t选项。缺省以第1列来排序，即-k1

-n 指定分类是域上的数字分类。

如编辑文件1111.txt

sdsad 311 315 asd3f

wdasd 551 133 adsff

sdsad 606 44 fgfdgdf

wdwew 77 599 gghgf

eeese 23 22 fgdf

eeese 23 22 fgdf

dfdff 78 55 fdgd

   -k 使用k做分类排序,如按第2列来分类排序

$ sort -k2 1111.txt 

eeese 23 22 fgdf

eeese 23 22 fgdf

sdsad 311 315 asd3f

wdasd 551 133 adsff

sdsad 606 44 fgfdgdf

wdwew 77 599 gghgf

dfdff 78 55 fdgd

    -n 指定分类列上按数值来分类排序，如第按第2列数值大小来分类

$ sort

 -k2n 1111.txt

eeese 23 22 fgdf

eeese 23 22 fgdf

wdwew 77 599 gghgf

dfdff 78 55 fdgd

sdsad 311 315 asd3f

wdasd 551 133 adsff

sdsad 606 44 fgfdgdf

    -u 去除重复的行，即完全一样的行，只保留一行

$ sort

 -k2n -u 1111.txt 

eeese 23 22 fgdf 只有1行了

wdwew 77 599 gghgf

dfdff 78 55 fdgd

sdsad 311 315 asd3f

wdasd 551 133 adsff

sdsad 606 44 fgfdgdf

4. unique filesuniq -- report or omit repeated lines
        -d: only print duplicate lines
       -u: only print unique lines
5. compare filesdiff -- compare files line by line
     -y: output in two colums
      -c: output lines of copied context (上下文输出格式)
      -u: output lines of unified context

eg.

a.txt

    abc

    hello

b.txt

    cba

    hello

$ diff -y a.txt b.txt -W 50

abc              |    cba

hello            hello

$ diff -c a.txt b.txt

*** a.txt   2010-12-13 22:15:13.000000000 +0800
--- b.txt   2010-12-13 22:15:21.000000000 +0800
***************
*** 1,2 ****
! abc
hello
--- 1,2 ----
! cba
hello

$ diff -u a.txt b.txt
--- a.txt    2010-12-13 22:15:13.000000000 +0800
+++ b.txt    2010-12-13 22:15:21.000000000 +0800
@@ -1,2 +1,2 @@
-abc
+cba
test

6. operating on characters
tr -- translate or delete characters
      -c: 取SET1的反义，所有不在SET1中的字符
      -d: delete characters in SET1
      -s: 浓缩重复的字符。如果标准输入中连续重复出现SET1里所列的字符，则将其浓缩成一个。或者将其浓缩成SET1中的字符
ps:

$echo "chennnrui123" | tr -d "cr123"

hennnui

$echo "chennnrui123" | tr -s "[a-z]"

chenrui123

$echo "abc123def" | tr -cs "[a-z]" " "

abc

def

$echo "abc123def" | tr -cs "[a-z]" " "

abc

def

Others
alias -- redefine command
eg. alias ls='ls -lh'

bash学习笔记（五）—— awk

2010-12-28T21:17:00.000+08:00

awk简介

awk命令行的程序模型

awk [-F field-separator] 'commands' input-file(s)-F 指定域分隔符，可选，默认为空格。

commands的命令格式为：/pattern/{actions}

condition{actions}pattern是正则表达式，actions是一系列操作。

awk程序一行一行读出待处理文件，如果某一行与pattern匹配，或者满足condition条件，

则执行相应的actions，如果一条awk命令只有actions部分，则actions作用于待处理文件的每一行。
例：
testfile文件内容为
ProductA  30  aaa
ProductB  76  bbb
ProductC  55  ccc

打印每一行的第二列:

$ awk '{print $2;}' testfile

30

76

55

自动变量$1、$2分别表示第一列、第二列等，类似于Shell脚本的位置参数，而$0表示整个当前行。

$ awk '$2<75 {printf "%s\t%s\n", $0, "REORDER";} $2>=75 {print $0;}' testfile

ProductA  30    aaa REORDER

ProductB  76 bbb

ProductC  55    ccc REORDER

awk命令的condition部分还可以是两个特殊的condition－BEGIN和END，对于每个待处理文件，BEGIN后面的actions在处理整个文件之前执行一次，END后面的actions在整个文件处理完之后执行一次。

awk 'BEGIN {print "name belt -----"}{print $1" "$3} END {print "end"}' testfile

name belt -----

ProductA aaa

ProductB bbb

ProductC ccc

end

ps: 注print与printf的区别

初次awk时，可能会经常出现错误，在碰到错误时，可以按以下方式查找：
!确保整个awk命令用单引号括起来
!确保命令内所有引号成对出现
!确保用花括号括起动作语句，用圆括号括起条件语句
!确保文件路径正确
awk有许多内置变量设置环境信息。这些变量可以被改变。下面是一些常用的内置变量。

ARGC              命令行参数个数

ARGV              命令行参数排列

EVVIRON        支持队列中系统环境变量的使用

FILENAME      awk浏览的文件名

FNR                浏览文件的记录数

FS                 设置输入域分隔符，等价于命令行-F选项

NF                 浏览记录的域个数

NR                  已读的记录数

OFS                输出域分隔符

ORS                输出记录分隔符

RS                  控制记录分隔符

例：
$ awk 'END {print NR}' testfile3
$ awk '{print NF} END {print FILENAME}' testfile
3
3
3
testfile

bash学习笔记（四）—— cut

2010-12-28T21:15:00.001+08:00

cut简介
cut是以每一行为一个处理对象的，这种机制和sed是一样的。
cut命令主要是接受三个定位方法：
第一，字节（bytes），用选项-b
第二，字符（characters），用选项-c
第三，域（fields），用选项-f

以“字节”定位标志，例

$who
rocrocket :0 2009-01-08 11:07
rocrocket pts/0 2009-01-08 11:23 (:0.0)
rocrocket pts/1 2009-01-08 14:15 (:0.0)
如果我们想提取每一行的第3个字节，就这样：
$ who|cut -b 3
c
c
c
如果“字节”定位中，提取第3，第4、第5和第8个字节，则：
$ who|cut -b 3-5,8
croe
croe
croe
注意，cut命令如果使用了-b选项，那么执行此命令时，cut会先把-b后面所有的定位进行从小到大排序，然后再提取。

以“字符”为定位标志，例：

$ who|cut -c 3-5,8
croe
croe
croe
不过，看着怎么和-b没有什么区别啊？莫非-b和-c作用一样? 其实不然，看似相同，只是因为这个例子举的不好，who输出的都是单字节字符，所以用-b和-c没有区别，如果你提取中文，区别就看出来了，来，看看中文提取的情况：
$ cat cut_ch.txt
星期一
星期二
星期三
星期四
[rocrocket@rocrocket programming]$ cut -b 3 cut_ch.txt
�
�
�
�
[rocrocket@rocrocket programming]$ cut -c 3 cut_ch.txt
一
二
三
四
看到了吧，用-c则会以字符为单位，输出正常；而-b只会傻傻的以字节（8位二进制位）来计算，输出就是乱码。

以“域”为定位标志：

为什么会有“域”的提取呢，因为刚才提到的-b和-c只能在固定格式的文档中提取信息，而对于非固定格式的信息则束手无策。这时候“域”就派上用场了。
以/etc/passwd的前五行内容为例：
$ cat /etc/passwd|head -n 5
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
$ cat /etc/passwd|head -n 5|cut -d : -f 1
root
bin
daemon
adm
lp
用-d来设置间隔符为冒号，然后用-f来设置我要取的是第一个域。
当然，在设定-f时，也可以使用例如3-5或者4-类似的格式：
$ cat /etc/passwd|head -n 5|cut -d : -f 1,3-5,7
root:0:0:root:/bin/bash
bin:1:1:bin:/sbin/nologin
daemon:2:2:daemon:/sbin/nologin
adm:3:4:adm:/sbin/nologin
lp:4:7:lp:/sbin/nologin

bash学习笔记（三）—— 基本语法

2010-12-28T21:12:00.000+08:00

变量，判断，重复动作

参数展开是shell提供变量值在程序中使用的过程。如：
aa="hello word"
sleep 10
echo $aa 或 "$aa"
变量展开需用"",如果改为'',则不会展开。echo '$aa',输出为'$aa'

替换运算符

${varname:-word}



如果varname存在且非null,则返回其值；否则，返回word。例，如果count未定义，则${count:-0}返回0。

${varname:=word}



如果varname存在且非null,则返回其值；否则，varname=word。

${varname:?message}

如果varname存在且不是null,则返回它的值；否则，显示varname:message后退出脚本。

${varname:+word}

如果varname存在且非null,则返回word;否则，返回null。例，如果count已定义，则${count:+1}返回1。

ps:上述运算符内的冒号都是可选的。如果去掉则将定义中的存在且非null改为存在，即运算符仅用于测试变量是否存在。

模式匹配运算符

${var#pattern}

如果模式匹配于变量值的开头处，则删除匹配的最短部分，并返回剩下部分。



${var##pattern}

如果模式匹配于变量值的开头处，则删除匹配的最长部分，并返回剩下部分。

${var%pattern}

如果模式匹配于变量值的结尾处，则删除匹配的最短部分，并返回剩下部分。



${var%%pattern}

如果模式匹配于变量值的结尾处，则删除匹配的最长部分，并返回剩下部分。

例：

path=/home/tolstoy/mem/long.file.name

${path#/*/} 结果： tolstoy/mem/long.file.name

${path##/*/} 结果：long.file.name

${path%.*} 结果：/home/tolstoy/mem/long.file

${path%％.*} 结果：/home/tolstoy/mem/long

字符串操作：

${#path} : 返回变量的字符串长度, 为32

${string:position:length},例{path:6:11} : 返回6－11字符串：tolstoy/mem

${string/substring/replacement}

Replace first match of $substring with $replacement

${string//substring/replacement}

Replace all matches of $substring with $replacement

特殊变量：例

$ set -- hello "hi there" greetings                设置新的位置参数

$ echo there are $# total arguments                显示计数值

there are 3 total arguments

$ for i in $* (or $@)                               $*,$@一次表示所有的命令行参数 

  do echo i is $i

  done

i is hello

i is hi

i is there

i is greetings

$ for i in "$@"                 "$@"将所有命令行参数视为单个字符串，即"$1 $2"

  do echo i is $i

  done

i is hello

i is hi there

i is greetings

$ shift                                                                      去除第一个参数

$ echo there are $# total arguments

there are 2 total arguments

if-elif-else-fi基本语法：例

#! /bin/bash

echo "Is it morning? Please answer yes or no."
read YES_OR_NO                   #输入value
if [ "$YES_OR_NO" = "yes" ]; then
  echo "Good morning!"
elif [ "$YES_OR_NO" = "no" ]; then
  echo "Good afternoon!"
else
  echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."
  exit 1
fi
exit 0

ps: "［］"为判断语句，返回1或0。if [pipeline] 等价于 if test pipeline。

因此可在［］中加入test的各种参数。
如：
if [ -f "$file" ] && [ ! -x "$file" ]; then
    echo $file is a file but cannot execute
elif [ -d "$file" ]; then
    echo $file is a directory
fi

case/esac基本语法： case命令可类比C语言的switch/case语句，esac表示case语句块的结束。C语言的case只能匹配整型或字符型常量表达式，而Shell脚本的case可以匹配字符串和Wildcard，每个匹配分支可以有若干条命令，末尾必须以;;结束，执行时找到第一个匹配的分支并执行相应的命令，然后直接跳到esac之后，不需要像C语言一样用break跳出。

#! /bin/bash



echo "Is it morning? Please answer yes or no."

read YES_OR_NO

case "$YES_OR_NO" in

yes|y|Yes|YES)

  echo "Good Morning!";;

[nN][oO])

  echo "Good Afternoon!";;

*)

  echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."

  exit 1;;

esac

for/in/do/done基本语法：例

#! /bin/bash



for FRUIT (in apple banana pear); do

  echo "I like $FRUIT"

done

ps: 如果未写()中内容，则默认执行 for FRUIT in "$#"

while/do/done基本语法：例

#! /bin/sh



echo "Enter password:"

read TRY

while [ "$TRY" != "secret" ]; do

  echo "Sorry, try again"

  read TRY

done

bash学习笔记（二）—— grep, sed

2010-12-28T21:08:00.000+08:00

文本过滤工具grep

传统的 grep 程序, 在没有参数的情况下, 只输出符合 RE 字符串之句子. 常见参数如下:

-v: 逆反模示, 只输出"不含" RE 字符串之句子.

-r: 递归模式, 可同时处理所有层级子目录里的文件.

-q: 静默模式, 不输出任何结果(stderr 除外. 常用以获取 return value, 符合为 true, 否则为 false .)

-i: 忽略大小写.

-w: 整词比对, 类似 \<word\> .

-n: 同时输出行号.

-c: 只输出符合比对的行数.

-l: 只输出符合比对的文件名称.

-o: 只输出符合 RE 的字符串. (gnu 新版独有, 不见得所有版本都支持.)

-E: 切换为 egrep .



* egrep:

为 grep 的扩充版本, 改良了许多传统 grep 不能或不便的操作. 比方说:

- grep 之下不支持 ? 与 + 这两种 modifier, 但 egrep 则可.

- grep 不支持 a|b 或 (abc|xyz) 这类"或一"比对, 但 egrep 则可.

- grep 在处理 {n,m} 时, 需用 \{ 与 \} 处理, 但 egrep 则不需.

诸如此类的... 我个人会建议能用 egrep 就不用 grep 啦

grep的一般格式为：
   grep [选项]基本正则表达式[文件]。
     在grep命令中输入字符串参数时，最好将其用双引号括起来。在调用模式匹配时，应使用单引号。
   例如："mystring"。这样做有两个原因，一是以防被误解为shell命令，二是可以用来查找多个单词组成的字符串。在调用变量时，也应该使用双引号，诸如:grep "$myvar" file，如果不这样，将没有返回结果。
模式匹配:grep 'ab\{1,5\}' file。这样可以防止grep中使用的专有模式与一些shell命令的特殊方式相混淆。

在文本文件里进行替换
1. Sed简介
sed是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。

2. 定址
可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定。

3. Sed命令
调用sed命令有两种形式：

sed [options] 'command' file(s)
sed [options] -f scriptfile file(s)

<
a\
在当前行后面加入一行文本。
b lable
分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
c\
用新的文本改变本行的文本。
d
从模板块（Pattern space）位置删除行。
D
删除模板块的第一行。
i\
在当前行上面插入文本。
h
拷贝模板块的内容到内存中的缓冲区。
H
追加模板块的内容到内存中的缓冲区
g
获得内存缓冲区的内容，并替代当前模板块中的文本。
G
获得内存缓冲区的内容，并追加到当前模板块文本的后面。
l
列表不能打印字符的清单。
n
读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
N
追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
p
打印模板块的行。
P（大写）
打印模板块的第一行。
q
退出Sed。
r file
从file中读行。
t label
if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
T label
错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
w file
写并追加模板块到file末尾。
W file
写并追加模板块的第一行到file末尾。
!
表示后面的命令对所有没有被选定的行发生作用。
s/re/string
用string替换正则表达式re。
=
打印当前行号码。
#
把注释扩展到下一个换行符以前。
以下的是替换标记
g表示行内全面替换。
p表示打印行。
w表示把行写入一个文件。
x表示互换模板块中的文本和缓冲区中的文本。
y表示把一个字符翻译为另外的字符（但是不用于正则表达式）

4. 选项
<
-e command, --expression=command
允许多台编辑。
-h, --help
打印帮助，并显示bug列表的地址。
-n, --quiet, --silent
取消默认输出。
-f, --filer=script-file
引导sed脚本文件名。
-V, --version
打印版本和版权信息。

5. 元字符集
<
^
锚定行的开始如：/^sed/匹配所有以sed开头的行。
$
锚定行的结束如：/sed$/匹配所有以sed结尾的行。
.
匹配一个非换行符的字符如：/s.d/匹配s后接一个任意字符，然后是d。
*
匹配零或多个字符如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[]
匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^]
匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
$..$
保存匹配的字符，如s/$love$able/\1rs，loveable被替换成lovers。
&
保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
\<
锚定单词的开始，如:/\
\>
锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
x\{m\}
重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
x\{m,\}
重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
x\{m,n\}
重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
6. 实例
删除：d命令
$ sed '2d' example-----删除example文件的第二行。
$ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
$ sed '$d' example-----删除example文件的最后一行。
$ sed '/test/'d example-----删除example文件所有包含test的行。
替换：s命令
$ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
$ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
$ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加 localhost，变成192.168.0.1localhost。
$ sed 's/hello/& chen/' example-----hello rui替换为hello chen rui。＆被标记为查找内容hello。
$ sed -n 's/$love$able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
$ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
选定行的范围：逗号
$ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
$ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
$ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
多点编辑：e命令
$ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
$ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
从文件读入：r命令
$ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
写入文件：w命令
$ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。

追加命令：a命令
$ sed '/^test/a\\--->this is a example' example<-----'this is a example'被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
插入：i命令
$ sed '/test/i\\
new line
-------------------------' example
如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
下一个：n命令
$ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
变形：y命令
$ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
退出：q命令
$ sed '10q' example-----打印完第10行后，退出sed。
保持和获取：h命令和G命令
$ sed -e '/test/h' -e '$G example-----在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
保持和互换：h命令和x命令
$ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
7. 脚本
Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。

比如，如果要打印出含有字串”1024”的行，我就可能会用：
cat filename | sed –n ‘/1024/p’sed命令详解!!(要学习shell的朋友要好好看看)
sed /^$/d filename
可以删除文件中的空行。
sed /^[[:space:]]*$/d filename
可以删除内容为多个空格/tab组成的行。

bash学习笔记（一）——正则表达式

2010-12-28T21:06:00.000+08:00

脚本第一行的#!
由于系统拥有好几个shell，因此需要通过一种方式告知UNIX内核应该以哪个shell来执行指定的shell脚本。指定方法是，通过脚本文件中特殊的第一行来设置，如：#!/bin/bash。

重定向
<：改变标准输入 >：改变标准输出，如果存在同名文件则覆盖，不存在则创建

tr -d 'a' < tmp1.txt > tmp2.txt，此命令表示用ｔｍｐ１作为输入执行tr -d命令并将结果输出到ｔｍｐ２中。

>>:　作用同>,但其不会覆盖同名文件而是追加。

｜：管道连接符，可将不同的命令连接起来。

Ｓｈｅｌｌ脚本参数
shell脚本的命令行参数都是由整数命名，当它超过9，就应该用大括号把数字框起来。例:

#!/bin/bash
echo first arg is $1
echo tenth arg is ${10}
如需要调试脚本，可在#!/bin/bash后加上 -ｘ/+ｘ来打开/关闭跟踪功能。

正则表达式
metacharacter:
\
将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "$" 则匹配 "("。

^
匹配输入字符串的开始位置。

$
匹配输入字符串的结束位置。

*
匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。

+
匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

?
匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。

[]
匹配括号中的一个字符。例，[abc]表示匹配a,b或c

\($
将$与$间的模式存储在保留空间。最多可将9个独立的子模式存储在单个模式中。匹配于子模式的文本，可通过转义序列\1至\9被重复使用在相同模式里。例如，$ab$$cd$*\2\1,表示abcd*cdab。 $["']$.*\1,表示""和''。

\{n,m\}

区间表达式，匹配在它前面的单个字符重现的次数区间。\{ｎ\}指重现ｎ次；\{ｎ,\}指至少重现ｎ次；\{ｎ,ｍ\}指重现ｎ至ｍ次。ｎ,ｍ的值必须介于0－255。

POSIX 字符类. [:class:]

这是另外一个可选的用于指定匹配字符范围的方法。

*

[:alnum:] 匹配字母和数字.等同于A-Za-z0-9.
*

[:alpha:] 匹配字母. 等同于A-Za-z.
*

[:blank:] 匹配一个空格或是一个制表符(tab).
*

[:cntrl:] 匹配控制字符.
*

[:digit:] 匹配(十进制)数字. 等同于0-9.
*

[:graph:] (可打印的图形字符). 匹配 ASCII 码值的33 - 126之间的字符. 这和下面提到的 [:print:]一样,但是不包括空格字符.
*

[:lower:] 匹配小写字母. 等同于a-z.
*

[:print:] (可打印字符). 匹配 ASCII码值 32 - 126之间的字符. 这和上面提到的一样[:graph:], 但是增多一个空格字符。
*

[:space:] 匹配空白字符 (空格符和水平制表符).
*

[:upper:] 匹配大写字母. 等同于A-Z.
*

[:xdigit:] 匹配十六进制数字. 等同于0-9A-Fa-f.

POSIX字符类一般都要求用[[ ]]引起来, 如： grep [[:digit:]] test.txt

使用GAE翻墙

2010-12-28T12:47:00.001+08:00

1. Sign in with your account in appspot.com
2. Install Google App Engine SDK for Python
http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Python
http://googleappengine.googlecode.com/files/google_appengine_1.4.0.zip
download and extract uncompress google_appengine_1.4.0.zip.
modify PATH variable in ~/.bashrc for GAE.
3. checkout GAppProxy
svn checkout http://gappproxy.googlecode.com/svn/trunk/ gappproxy
4. deploy GAppProxy
modify fetchserver/app.yaml, application:
appcfg.py update fetchserver
login appspot.com, My Applications-> -> Versions, choose the lastest and make default.
5. edit localproxy/proxy.conf
6. testing
localproxy/proxy.py