合抱之木，生于毫末。 《老子·道德经》 在智能手机平台中，为了保证多媒体业务在平台上的流畅运行，多采用专用的处理器来处理多媒体业务。如在Qucalcomm MSM 7K 平台上，就包含了4 个处理器内核，Qucalcomm MSM 7K 平台采用ARM 9（mARM，modemARM）处理基带业务；采用mDSP（Modem DSP）来处理协议栈业务；采用ARM 11（aARM，application ARM）来负责Linux 操作系统的运行；采用aDSP（Application DSP）来处理多媒体业务方面的编/解码加速工作。 在2010 年末，智能终端的CPU 得到了快速发展，高端的智能终端已经采用了Cortex-A8 的双核处理器。而在平板电脑上，Nvidia 开发的基于Cortex-A9 的双核处理器Tegra 2 则成了市场的宠儿。 通信离不开内存的操作，在Qucalcomm平台上，内存一般分为3种：基带内存（Modem Memory）、应用内存（Application Memory）和共享内存，其中系统MPU保护基带内存不被aARM接入，ARM MMU保护应用内存不被mARM接入。在本章中，将主要介绍基于共享内存的多核通信。 3.1 共享内存 在Linux 中，实现进程通信的机制有很多种，如信号、管道、信号量、消息队列、共享内存和套接字等，但共享内存的方式效率最高。 在Aurora 中，共享内存是多核通信的物理基础，其实现主要包括3 个部分：共享内存驱动（SMD，Shared Memory Driver）、共享内存状态机（SMSM，Shared Memory State Machine）和共享内存管理器（SMEM，Shared Memory Manager）。其中SMD 用于多核之间的数据通信；SMSM用于多核之间的状态通信；SMEM是一个底层的协议，是物理RAM共享内存的管理接口，是SMD和SMSM的基础。 SMEM 具有两种分配模式：动态SMEM 和静态SMEM，动态SMEM 根据需要实时分配，静态SMEM则会预先分配。SMEM的主要接口为：smem_alloc()、smem_find()、smem_init()等。 SMEM、SMD、SMSM的实现都需要硬件平台厂商提供支持 3.1.1 同步与互斥 在Aurora 中，共享内存用到了自旋锁和互斥锁的概念。 自旋锁是Linux 内核的同步机制之一，与互斥锁类似，但自旋锁使用者一般保持锁的时间非常短。自旋锁的效率远高于互斥锁。自旋锁的定义位于auroramsm工程msmincludelinuxspinlock_*.h文件中。在Aurora 中，并未引入在Kernel 2.6.25 中才引入的排队自旋锁（FIFO Ticket Spinlock）概念。排队自旋锁（FIFO Ticket Spinlock）通过保存执行线程申请锁的顺序信息，可以解决传统自旋锁的“不公平”问题，在设计之初仅支持X86 架构。 自旋锁的定义如下：

1. typedef struct {  
2. volatile unsigned int lock; //无符号整数  
3. } raw_spinlock_t; 

lock虽然被定义为无符号整数，但是实际上被当做有符号整数使用。slock值为1 代表锁未被占用，值为0 或负数代表锁被占用。初始化时slock被置为1。 与信号量和读写信号量导致调用者睡眠不同，自旋锁不会引起调用者睡眠。如果自旋锁已被别的执行单元保持，调用者就一直循环以确定是否该自旋锁的保持者已经释放了锁。 由于自旋锁适用的访问共享资源的时间非常短， 导致自旋锁通常应用于中断上下文访问和对共享资源访问文件非常短的场景中，如果被保护的共享资源在进程上下文访问，则应使用信号量。 与信号量和读写信号量在保持期间可以被抢占的情况不同，自旋锁在保持期间是抢占失效的，自旋锁只有在内核可抢占或SMP（Symmetrical Multi-Processing）的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。 由于智能终端平台上通常存在多个CPU 或DSP，自旋锁的运用就显得非常重要。在Aurora 的SMD 和SMSM的实现上，自旋锁主要运用于中断处理、信道列表和信道状态的变更过程中，自旋锁的定义如下：

1. static DEFINE_SPINLOCK(smd_lock);  
2. static DEFINE_SPINLOCK(smem_lock); 

互斥锁主要用于实现Linux 内核中的互斥访问功能，在Aurora 的SMD 的实现上，互斥锁主要用于SMD 信道的打开或关闭过程。定义如下：

1. static DEFINE_MUTEX(smd_creation_mutex); 

关于自旋锁和互斥锁的更多内容请参考文献。 3.1.2 SMD 数据通信（1） 在Linux 中，基于SMD 的数据通信是以信道的形式作为一个设备存在的，作为一种双向信道，其接口的实现遵循Linux 设备驱动规范。在Qucalcomm 平台上，SMD 的缓冲大小为8192bit，最大信道数为64，SMD的头大小为20bit。 SMD 的相关代码实现主要位于auroramsmmsmarcharmmach-msm目录下。主要文件包括： smd.c、smd_nmea.c、smd_qmi.c、smd_rpcrouter.c、smd_rpcrouter_clients.c、smd_rpcrouter_device.c、smd_rpcrouter_servers.c、smd_tty.c等。 SMD 信道需要同时维护接收信道、发送信道的状态和数据信息，SMD 的信道定义如下：

1. struct smd_channel {  
2. volatile struct smd_half_channel *send; //发送握手信道  
3. volatile struct smd_half_channel *recv; //接收握手信道  
4. unsigned char *send_buf; //发送信道数据  
5. unsigned char *recv_buf; //接收信道数据  
6. unsigned buf_size;  
7. struct list_head ch_list; //信道列表  
8. unsigned current_packet;  
9. unsigned n;  
10. void *priv;  
11. void (*notify)(void *priv, unsigned flags);  
12. int (*read)(smd_channel_t *ch, void *data, int len); //读数据  
13. int (*write)(smd_channel_t *ch, const void *data, int len); //写数据  
14. int (*read_avail)(smd_channel_t *ch); //是否可读  
15. int (*write_avail)(smd_channel_t *ch); //是否可写  
16. int (*read_from_cb)(smd_channel_t *ch, void *data, int len);  
17. void (*update_state)(smd_channel_t *ch);  
18. unsigned last_state;  
19. char name[20];  
20. struct platform_device pdev;  
21. unsigned type;  
22. }; 

共享信道的信道状态在其握手信道中记录，握手信道的定义如下：

1. struct smd_half_channel {  
2. unsigned state;  
3. unsigned char fDSR;  
4. unsigned char fCTS;  
5. unsigned char fCD;  
6. unsigned char fRI;  
7. unsigned char fHEAD; //头部  
8. unsigned char fTAIL; //尾部  
9. unsigned char fSTATE; //状态  
10. unsigned char fUNUSED;  
11. unsigned tail;  
12. unsigned head;  
13. }; 

在实际实现中，SMD信道分配被封装在SMEM（Shared Memory Manager）模块中，系统提供了smem_init()、smem_alloc()、smem_get_entry()等内存操作函数供SMD和SMSM操作。 SMD 的状态共有SMD_SS_CLOSED、SMD_SS_OPENING、SMD_SS_OPENED、SMD_SS_FLUSHING、SMD_SS_CLOSING、SMD_SS_RESET、SMD_SS_RESET_OPENING等。其变化过程如图3-1所示。   图3-1 SMD的状态机 下面结合SMD信道的实现简要介绍SMD 信道的分配、打开、读取、写入、关闭等操作。 1．分配信道 SMD 信道根据数据的类型可以分为流信道和包信道，其中包信道具有比流信道更强的流控制能力，包含头信息。在创建SMD 信道时，会根据信道类型的不同，确定创建的是FIFO信道还是普通信道，是流信道还是包信道，然后为SMD 进行设备注册。SMD 分配信道的实现如下： 代码3-1 SMD分配信道的过程

1. static void smd_alloc_channel(struct smd_alloc_elm *alloc_elm)  
2. {  
3. struct smd_channel *ch;  
4. uint32_t *smd_ver;  
5. //分配SMEM 内存  
6. smd_ver=smem_alloc(SMEM_VERSION_SMD, 32 * sizeof(uint32_t));  
7. if (smd_ver && ((smd_ver[VERSION_MODEM]>>16)>=1))  
8. ch=smd_alloc_channel_v2(alloc_elm->cid); //FIFO信道  
9. else  
10. ch=smd_alloc_channel_v1(alloc_elm->cid); //普通信道  
11. if (ch==0)  
12. return;  
13. ch->type=SMD_CHANNEL_TYPE(alloc_elm->type);  
14. memcpy(ch->name, alloc_elm->name, 20);  
15. ch->name[19]=0;  
16. if (smd_is_packet(alloc_elm)) { //包信道  
17. ch->read=smd_packet_read;  
18. ch->write=smd_packet_write;  
19. ch->read_avail=smd_packet_read_avail;  
20. ch->write_avail=smd_packet_write_avail;  
21. ch->update_state=update_packet_state;  
22. ch->read_from_cb=smd_packet_read_from_cb;  
23. } else { //流信道  
24. ch->read=smd_stream_read;  
25. ch->write=smd_stream_write;  
26. ch->read_avail=smd_stream_read_avail;  
27. ch->write_avail=smd_stream_write_avail;  
28. ch->update_state=update_stream_state;  
29. ch->read_from_cb=smd_stream_read;  
30. }  
31. ch->pdev.name=ch->name;  
32. ch->pdev.id=ch->type;  
33. pr_info("smd_alloc_channel() '%s' cid=%d ",  
34. ch->name, ch->n);  
35. mutex_lock(&smd_creation_mutex); //互斥锁  
36. //将信道添加到“smd_ch_closed_list”列表中  
37. list_add(&ch->ch_list, &smd_ch_closed_list); 
    mutex_unlock(&smd_creation_mutex);  
38. platform_device_register(&ch->pdev); //注册设备  
39. } 
40. 3.1.2 SMD 数据通信（2） 2．打开信道 为了打开一个信道，首先要判断SMD 信道是否已经初始化。如果SMD 信道已经初始化，就根据信道名获得信道，将信道加入到“smd_ch_list”信道列表中并设置该信道的状态为SMD_SS_OPENING，然后调用notify_other_smd()函数通知其他的信道该信道已经激活。在默认情况下，其信道类型为SMD_APPS_MODEM，打开一个SMD信道的实现如下： 代码3-2 SMD打开信道的过程
    1. int smd_named_open_on_edge(const char *name, uint32_t edge,  
    2. smd_channel_t **_ch,  
    3. void *priv, void (*notify)(void *, unsigned))  
    4. {  
    5. struct smd_channel *ch;  
    6. unsigned long flags;  
    7. if (smd_initialized==0) { //判断SMD 信道是否已初始化  
    8. printk(KERN_INFO "smd_open() before smd_init() ");  
    9. return -ENODEV;  
    10. }  
    11. D("smd_open('%s', %p, %p) ", name, priv, notify);  
    12. ch=smd_get_channel(name, edge); //获取信道  
    13. if (!ch)  
    14. return -ENODEV;  
    15. if (notify==0)  
    16. notify=do_nothing_notify;  
    17. ch->notifynotify=notify;  
    18. ch->current_packet=0;  
    19. ch->last_state=SMD_SS_CLOSED;  
    20. ch->privpriv=priv;  
    21. *_ch=ch;  
    22. D("smd_open: opening '%s' ", ch->name);  
    23. spin_lock_irqsave(&smd_lock, flags); //自旋锁  
    24. list_add(&ch->ch_list, &smd_ch_list); 
        //将信道添加到“smd_ch_list”列表中  
    25. D("%s: opening ch %d ", __func__, ch->n);  
    26. smd_state_change(ch, ch->last_state, 
        SMD_SS_OPENING); //信道状态变更  
    27. spin_unlock_irqrestore(&smd_lock, flags);  
    28. return 0;  
    29. } 
    3．关闭信道 关闭信道的操作相对简单，首先将信道从“smd_ch_list”信道列表中删除，然后将信道状态设置为SMD_SS_CLOSED，并将信道添加到“smd_ch_closed_list”信道列表中即可。关闭SMD 信道的实现如下： 代码3-3 SMD关闭信道的过程
    1. int smd_close(smd_channel_t *ch)  
    2. {  
    3. unsigned long flags;  
    4. printk(KERN_INFO "smd_close(%p) ", ch);  
    5. if (ch==0)