lwIP 操作系统模拟层

注1：除非特别说明，以下内容针对 lwIP 2.0.0 及以上版本。
注2：操作系统使用 FreeRTOS

contrib 2.1.0 给出了一个 lwIP 的操作系统模拟层，使用的操作系统为 FreeRTOS。模拟层位于：\contrib-2_1_0\ports\freertos 。

宏 LWIP_TCPIP_CORE_LOCKING 定义在 opt.h 中：

/**
 * LWIP_TCPIP_CORE_LOCKING
 * Creates a global mutex that is held during TCPIP thread operations.
 * Can be locked by client code to perform lwIP operations without changing
 * into TCPIP thread using callbacks. See LOCK_TCPIP_CORE() and
 * UNLOCK_TCPIP_CORE().
 * Your system should provide mutexes supporting priority inversion to use this.
 */
#if !defined LWIP_TCPIP_CORE_LOCKING || defined __DOXYGEN__
#define LWIP_TCPIP_CORE_LOCKING         1
#endif
1
2
3
4
5
6
7
8
9
10
11

这个宏用于启用协议栈锁定功能，是通过互斥量实现的，要求互斥量具备优先级继承机制。使能后，在 tcpip.c 中定义全局变量:

#if LWIP_TCPIP_CORE_LOCKING
/** The global semaphore to lock the stack. */
sys_mutex_t lock_tcpip_core;
#endif /* LWIP_TCPIP_CORE_LOCKING */
1
2
3
4

在函数 tcpip_init 中会申请互斥量：

/**
 * @ingroup lwip_os
 * Initialize this module:
 * - initialize all sub modules
 * - start the tcpip_thread
 *
 * @param initfunc a function to call when tcpip_thread is running and finished initializing
 * @param arg argument to pass to initfunc
 */
void
tcpip_init(tcpip_init_done_fn initfunc, void *arg)
{
  lwip_init();

  tcpip_init_done = initfunc;
  tcpip_init_done_arg = arg;
  if (sys_mbox_new(&tcpip_mbox, TCPIP_MBOX_SIZE) != ERR_OK) {
    LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
  }
#if LWIP_TCPIP_CORE_LOCKING
  if (sys_mutex_new(&lock_tcpip_core) != ERR_OK) {		// <--- 这里
    LWIP_ASSERT("failed to create lock_tcpip_core", 0);
  }
#endif /* LWIP_TCPIP_CORE_LOCKING */

  sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

使用宏做了一层包装

#if LWIP_TCPIP_CORE_LOCKING
/** The global semaphore to lock the stack. */
extern sys_mutex_t lock_tcpip_core;
#if !defined LOCK_TCPIP_CORE || defined __DOXYGEN__
/** Lock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */
#define LOCK_TCPIP_CORE()     sys_mutex_lock(&lock_tcpip_core)		// <-- 这里
/** Unlock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */
#define UNLOCK_TCPIP_CORE()   sys_mutex_unlock(&lock_tcpip_core)	// <-- 这里
#endif /* LOCK_TCPIP_CORE */
#else /* LWIP_TCPIP_CORE_LOCKING */
#define LOCK_TCPIP_CORE()
#define UNLOCK_TCPIP_CORE()
#endif /* LWIP_TCPIP_CORE_LOCKING */
1
2
3
4
5
6
7
8
9
10
11
12
13

函数或宏

互斥量

struct _sys_mut {
  void *mut;
};
typedef struct _sys_mut sys_mutex_t;
1
2
3
4

信号量

struct _sys_sem {
  void *sem;
};
typedef struct _sys_sem sys_sem_t;
1
2
3
4

邮箱

FreeRTOS 并没有邮箱机制，模拟层使用 队列 来模拟邮箱。

struct _sys_mbox {
  void *mbx;
};
typedef struct _sys_mbox sys_mbox_t;
1
2
3
4

lwIP 进程
在操作系统中，lwIP 被封装到一个名为 tcpip_thread 的进程中。在函数 tcpip_init 中，会创建这个进程：

sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);
1

宏 TCPIP_THREAD_STACKSIZE 和 TCPIP_THREAD_PRIO 分别表示进程的堆栈空间和优先级，需要在 lwipopts.h 中定义。

tcpip_thread 进程会阻塞在一个邮箱上，等待消息，处理消息。这个邮箱内的消息可能来自于底层硬件驱动接收到的数据包，也可能来自上层应用程序的 API 调用。

/**
 * The main lwIP thread. This thread has exclusive access to lwIP core functions
 * (unless access to them is not locked). Other threads communicate with this
 * thread using message boxes.
 *
 * It also starts all the timers to make sure they are running in the right
 * thread context.
 *
 * @param arg unused argument
 */
static void
tcpip_thread(void *arg)
{
  struct tcpip_msg *msg;
  LWIP_MARK_TCPIP_THREAD();
  LOCK_TCPIP_CORE();
  if (tcpip_init_done != NULL) {
    tcpip_init_done(tcpip_init_done_arg);
  }
  while (1) {                          /* MAIN Loop */
    LWIP_TCPIP_THREAD_ALIVE();
    /* wait for a message, timeouts are processed while waiting */
    TCPIP_MBOX_FETCH(&tcpip_mbox, (void **)&msg);
    if (msg == NULL) {
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      continue;
    }
    tcpip_thread_handle_msg(msg);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30