本文转自http://netwalker.blog.chinaunix.net,作者写了一系列名为linux模式设计,这里将他整理放到一起

     1-数据大小:

#define USHORT_MAX ((u16)(~0U))
#define SHORT_MAX ((s16)(USHORT_MAX>>1))
#define SHORT_MIN (-SHORT_MAX- 1)
#define INT_MAX ((int)(~0U>>1))
#define INT_MIN (-INT_MAX- 1)
#define UINT_MAX (~0U)
#define LONG_MAX ((long)(~0UL>>1))
#define LONG_MIN (-LONG_MAX- 1)
#define ULONG_MAX (~0UL)
#define LLONG_MAX ((long long)(~0ULL>>1))
#define LLONG_MIN (-LLONG_MAX- 1)
#define ULLONG_MAX (~0ULL)

#include <stdio.h>
#define UCHAR_MAX ((unsigned char)(~0U))
#define CHAR_MAX ((char)(UCHAR_MAX>> 1))
#define CHAR_MIN (-CHAR_MAX- 1)
int main()
{
    printf("UCHAR_MAX:\t%u\n", UCHAR_MAX);
    printf("CHAR_MAX:\t%d\n", CHAR_MAX);
    printf("CHAR_MIN:\t%d\n", CHAR_MIN);
    return 0;
}

定义数据大小的方法有很多种，比如通过接下来数据对齐小节中的偏移位机制，但是这会在生成第一个数值时产生移位运算，并且在生成宽度大于32位的类型时要分别考虑，没有上面方法的效率高。一个完成相同功能的示例如下，它的思想参考数据对齐小节。

#define CHAR_SHIFT (sizeof(char)<< 3 + 1)
#define UUCHAR_MAX ((unsigned char)((1<< CHAR_SHIFT)- 1))
......

上例中符合表达式中声明了局部变量_a，而返回值为++_a的结果，所以a的值为1。基于这种扩展，内核可以通过在复合语句中定义局部变量而表面自加自减运算符的副作用问题。内核中的min_t和max_t宏就是这样实现的。

include/linux/kernel.h

#define min_t(type, x, y)({            \
        type __min1 =(x);            \
        type __min2 =(y);            \
        __min1 < __min2? __min1: __min2;})
#define max_t(type, x, y)({            \
        type __max1 =(x);            \
        type __max2 =(y);            \
        __max1 > __max2? __max1: __max2;})

#define min(a, b)((a)> (b)?(b) : (a))
#define max(a, b)((a)> (b)?(a) : (b))

#define min(x, y)({                \
    typeof(x) _min1= (x);            \
    typeof(y) _min2= (y);            \
    (void)(&_min1 == &_min2);        \
    _min1 < _min2? _min1 : _min2;})
#define max(x, y)({                \
    typeof(x) _max1= (x);            \
    typeof(y) _max2= (y);            \
    (void)(&_max1 == &_max2);        \
    _max1 > _max2? _max1 : _max2;})

xxx.c:35: warning: comparison of distinct pointer types lacks a cast

    3-数据圆整

对于x = βy + δ来说，β>=0，y>0，并且0<=δ<y。因为y>0且为整数，那么0<=δ<y等价于0<=δ&lt;=y-1。对于圆整运算来说，可以将x中可以整除y的部分βy提取出来，只对剩下的δ部分做圆整运算然后加上βy。同理这里对δ+y-1部分进行圆整，由于0<=δ<=y-1，得到y-1 <= δ + y-1 <= 2y-2。考虑两种情况：当可以整除时，δ=0，也即取y-1，显然圆整值为0，也即不用向上圆整；而不可整除时，δ>0，所以y-1 < δ + y-1 <= 2y-2，又因为y为整数，所以y <= δ + y-1 <= 2y-2成立，由于y=1时符合第一种情况，所以只需考虑y>=2的情况。y==y并且2y-2在y>=2时>=y且<2y，所以保证δ + y-1的圆整值为1，也即不整除则要始终向上圆整。

一种更易被人理解的定义方式如下，它根据取余的结果计算圆整，由于整除的概率很低，所以这种算法每次都要多计算一次取余，而不能完全避免对除法的运算以消减取余算法的影响，它的效率要低。

#define roundup(x, y)((x)%(y)? ((x)/(y)+ 1) * (y): x)

  int divisor= 0;
  printf("divisor\troundup\trounddown\n");
  for(; divisor< 5; divisor++)
       printf("%d:\t%d\t%d\n", divisor, roundup(divisor, 2), roundown(divisor, 2));

    4-数据对齐

#define ALIGN(x, a) __ALIGN_MASK(x,(typeof(x))(a)- 1)
#define __ALIGN_MASK(x, mask)(((x)+ (mask))&~(mask))
#define PTR_ALIGN(p, a)((typeof(p))ALIGN((unsigned long)(p),(a)))
#define IS_ALIGNED(x, a)(((x)& ((typeof(x))(a)- 1))== 0)

/*to align the pointer to the (next) page boundary*/
#define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)

#include <stdio.h>
......
int main()
{
    int a = 0 ,i = 0;
    int *p = &a;
    for(; i< 6; i++)
         printf("ALIGN(%d, 4): %x\n", i, ALIGN(i, 4));
        
    printf("p:%p, PTR_ALIGN(p, 8): %p\n", p, PTR_ALIGN(p, 8));
    printf("IS_ALIGNED(7, 8): %d, IS_ALIGNED(16, 8): %d\n", IS_ALIGNED(7, 8), IS_ALIGNED(16, 8));
      
    return 0;
}

#define DECLARE_BITMAP(name,bits)\
    unsigned long name[BITS_TO_LONGS(bits)]

#define BITS_PER_BYTE        8
#define BITS_TO_LONGS(nr)    DIV_ROUND_UP(nr, BITS_PER_BYTE* sizeof(long))

内核定义了一系列的宏和函数来对DECLARE_BITMAP定义的位图进行操作，它们分别位于bitmap.h和bitmap.c中。这些宏和函数的操作思想是一致的。

static inline void bitmap_zero(unsigned long*dst, int nbits)
{
    if (nbits <= BITS_PER_LONG)
        *dst = 0UL;
    else {
        int len = BITS_TO_LONGS(nbits)* sizeof(unsigned long);
        memset(dst, 0,len);
    }
}

/**
 * container_of- cast a member of a structure out to the containing structure
 * @ptr: the pointerto the member.
 * @type: the type of the container struct thisis embedded in.
 * @member: the name of the member within the struct.
 *
 */
#define container_of(ptr, type, member)({ \
        const typeof(((type *)0)->member) *__mptr = (ptr);\
        (type*)((char *)__mptr- offsetof(type,member));})

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
#else
#define offsetof(TYPE, MEMBER)((size_t)&((TYPE*)0)->MEMBER)
#endif

#include <stdio.h>
......
typedef struct man
{
    char name[32];
    unsigned int id;    
    unsigned char age;
    char address[64];
}man_t;
int main()
{
    man_t tom ={"Tom", 0, 24,"ShangHai China"};
    man_t *man= NULL;
       
    printf("tom:%p, tom.age:%p, offsetof(man_t, age): %d\n",
                     &tom,&tom.age, offsetof(man_t, age));
                        
    man = container_of(&tom.age, man_t, age);
    printf("tom.name:%s, tom.id:%d, tom.age:%u, tom.address:%s\n",
                    man->name, man->id, man->age, man->address);
        
    return 0;
}

它通过对0指针灵活运用，是对sizeof的一种变相扩展。

2.ARRAY_SIZE获取数组维数

ARRAY_SIZE用来获取一维或者多维数组的第一维大小，并对非数组指针进行合法性检查。

#define __must_be_array(a)\
  BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))

/* Force a compilationerror if conditionis true */
#define BUILD_BUG_ON(condition)((void)sizeof(char[1- 2*!!(condition)]))
/* Force a compilationerror if conditionis true, but also produce a
   result (of value 0and type size_t), so the expression can be used
   e.g.in a structure initializer (or where-everelse comma expressions
   aren't permitted).*/
#define BUILD_BUG_ON_ZERO(e)(sizeof(char[1- 2 * !!(e)])- 1)

struct map
{
    int used[2];        /* 8 */
    int empty[5];        /* 20*/    
       
    char pad[32- 28];
} men = {{1, 2},{0, 3, 4, 5, 6}};
int main()
{
    BUILD_BUG_ON(sizeof(men)!= 32);
    printf("BUILD_BUG_ON_ZERO(0):%d, %d\n", BUILD_BUG_ON_ZERO(0), sizeof(men));
       
    return 0;
}