printf 从用户层到OS层之间的调用关系

了解printf函数的调用机制，我将以PowerPC为例子介绍它到OS的调用过程，首先我们先来看看printf的函数的具体的实现，如下：

static char sprint_buf[1024];            //定义一个buf存储空间来存放参数；

int printf(const char *fmt, ...)

{

 va_list args;

 int n;

 va_start(args, fmt);

 n = vsprintf(sprint_buf, fmt, args);           //主要用于输出格式的匹配工作；

 va_end(args);

 if (console_ops.write)

     console_ops.write(sprint_buf, n);        //终端的操作，注册和初始化串口；

 return n;

}

        从上面的函数来看，printf函数主要做的就是两件事情，首先确定内容如何输出，以何种格式输出，然后初始化串口，通过串口将数据输出到硬件层。

下面我们将来介绍它的调用过程，以帮助我们对printf函数的理解。

int vsprintf(char *buf, const char *fmt, va_list args)

{

 int len;

 unsigned long long num;

 int i, base;

 char * str;

 const char *s;

 int flags;                            /* flags to number() */

 int field_width;                  /* width of output field */

 int precision;                     /* min. # of digits for integers; max  number of chars for from string */

 int qualifier;                      /* 'h', 'l', or 'L' for integer fields */

                                           /* 'z' support added 23/7/1999 S.H.    */

/* 'z' changed to 'Z' --davidm 1/25/99 */

for (str=buf ; *fmt ; ++fmt) {

  if (*fmt != '%') {

   *str++ = *fmt;

   continue;

  }

   

  /* process flags */

  flags = 0;

  repeat:

   ++fmt; /* this also skips first '%' */

   switch (*fmt) {

    case '-': flags |= LEFT; goto repeat;

    case '+': flags |= PLUS; goto repeat;

    case ' ': flags |= SPACE; goto repeat;

    case '#': flags |= SPECIAL; goto repeat;

    case '0': flags |= ZEROPAD; goto repeat;

    }

 

  /* get field width */

  field_width = -1;

  if ('0' <= *fmt && *fmt <= '9')

   field_width = skip_atoi(&fmt);

  else if (*fmt == '*') {

   ++fmt;

   /* it's the next argument */

   field_width = va_arg(args, int);

   if (field_width < 0) {

    field_width = -field_width;

    flags |= LEFT;

   }

  }

  /* get the precision */

  precision = -1;

  if (*fmt == '.') {

   ++fmt;

   if ('0' <= *fmt && *fmt <= '9')

    precision = skip_atoi(&fmt);

   else if (*fmt == '*') {

    ++fmt;

    /* it's the next argument */

    precision = va_arg(args, int);

   }

   if (precision < 0)

    precision = 0;

  }

  /* get the conversion qualifier */

  qualifier = -1;

  if (*fmt == 'l' && *(fmt + 1) == 'l') {

   qualifier = 'q';

   fmt += 2;

  } else if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L'

   || *fmt == 'Z') {

   qualifier = *fmt;

   ++fmt;

  }

  /* default base */

  base = 10;

  switch (*fmt) {

  case 'c':

   if (!(flags & LEFT))

    while (--field_width > 0)

     *str++ = ' ';

   *str++ = (unsigned char) va_arg(args, int);

   while (--field_width > 0)

    *str++ = ' ';

   continue;

  case 's':

   s = va_arg(args, char *);

   if (!s)

    s = "<NULL>";

   len = strnlen(s, precision);

   if (!(flags & LEFT))

    while (len < field_width--)

     *str++ = ' ';

   for (i = 0; i < len; ++i)

    *str++ = *s++;

   while (len < field_width--)

    *str++ = ' ';

   continue;

  case 'p':

   if (field_width == -1) {

    field_width = 2*sizeof(void *);

    flags |= ZEROPAD;

   }

   str = number(str,

    (unsigned long) va_arg(args, void *), 16,

    field_width, precision, flags);

   continue;

  case 'n':

   if (qualifier == 'l') {

    long * ip = va_arg(args, long *);

    *ip = (str - buf);

   } else if (qualifier == 'Z') {

    size_t * ip = va_arg(args, size_t *);

    *ip = (str - buf);

   } else {

    int * ip = va_arg(args, int *);

    *ip = (str - buf);

   }

   continue;

  case '%':

   *str++ = '%';

   continue;

  /* integer number formats - set up the flags and "break" */

  case 'o':

   base = 8;

   break;

  case 'X':

   flags |= LARGE;

  case 'x':

   base = 16;

   break;

  case 'd':

  case 'i':

   flags |= SIGN;

  case 'u':

   break;

  default:

   *str++ = '%';

   if (*fmt)

    *str++ = *fmt;

   else

    --fmt;

   continue;

  }

  if (qualifier == 'l') {

   num = va_arg(args, unsigned long);

   if (flags & SIGN)

    num = (signed long) num;

  } else if (qualifier == 'q') {

   num = va_arg(args, unsigned long long);

   if (flags & SIGN)

    num = (signed long long) num;

  } else if (qualifier == 'Z') {

   num = va_arg(args, size_t);

  } else if (qualifier == 'h') {

   num = (unsigned short) va_arg(args, int);

   if (flags & SIGN)

    num = (signed short) num;

  } else {

   num = va_arg(args, unsigned int);

   if (flags & SIGN)

    num = (signed int) num;

  }

  str = number(str, num, base, field_width, precision, flags);

 }

 *str = '\0';

 return str-buf;

}

从这个函数我们可以看出printf的格式符的重要性，以及它所支持的所有输出格式，在这个函数中调用了两个重要的函数，下面我们来介绍这俩个重要的函数函数的功能;

static char * number(char * str, unsigned long long num, int base, int size, int precision, int type)

{

 char c,sign,tmp[66];

 const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";

 int i;

 if (type & LARGE)

  digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

 if (type & LEFT)

  type &= ~ZEROPAD;

 if (base < 2 || base > 36)

  return 0;

 c = (type & ZEROPAD) ? '0' : ' ';

 sign = 0;

 if (type & SIGN) {

  if ((signed long long)num < 0) {

   sign = '-';

   num = - (signed long long)num;

   size--;

  } else if (type & PLUS) {

   sign = '+';

   size--;

  } else if (type & SPACE) {

   sign = ' ';

   size--;

  }

 }

 if (type & SPECIAL) {

  if (base == 16)

   size -= 2;

  else if (base == 8)

   size--;

 }

 i = 0;

 if (num == 0)

  tmp[i++]='0';

 else while (num != 0) {

  tmp[i++] = digits[do_div(num, base)];

 }

 if (i > precision)

  precision = i;

 size -= precision;

 if (!(type&(ZEROPAD+LEFT)))

  while(size-->0)

   *str++ = ' ';

 if (sign)

  *str++ = sign;

 if (type & SPECIAL) {

  if (base==8)

   *str++ = '0';

  else if (base==16) {

   *str++ = '0';

   *str++ = digits[33];

  }

 }

 if (!(type & LEFT))

  while (size-- > 0)

   *str++ = c;

 while (i < precision--)

  *str++ = '0';

 while (i-- > 0)

  *str++ = tmp[i];

 while (size-- > 0)

  *str++ = ' ';

 return str;

}

        

        这个函数的功能主要是将数字字符串按2,8，16进制的形式输出结果的处理，以及对输出的结果正负的处理和空格的处理。同时也解决了数据的输出对齐问题，从而让数据根据我们想要的形式输出结果，下面我们来介绍下该函数所用到的一些宏的定义，以便于帮助我们来理解该函数的功能。

#define ZEROPAD 1                             /* pad with zero */

#define SIGN         2                             /* unsigned/signed long */

#define PLUS         4                             /* show plus */

#define SPACE      8                             /* space if plus */

#define LEFT        16                            /* left justified */

#define SPECIAL  32                            /* 0x */

#define LARGE     64                            /* use 'ABCDEF' instead of 'abcdef' */

          对于这些宏我就不做过多的解释了，只要将它们代入具体的宏的位置去就可以了，它们只是基本的宏替换的功能而已，没有其它过多的用法了，看到这个宏定义，让我想到了枚举，其实我可以用枚举的方法来定义这些宏定义，只是在初始化的时候有点区别，枚举的第一个成员默认被分配为0，之后每个成员要是没有赋值它将会在前一个成员的基础上加一，当让枚举和宏定义还是有区别的，宏定义是在编译器编译时对宏进行宏展开的工作，所以它不分配内存空间，而枚举就有些不一样了，他是结构类型，所以在为它初始化后它会占用内存空间，所以它会分配内存；还是继续来说说另外一个重要的函数的功能吧！

static int skip_atoi(const char **s)

{

 int i, c;

 for (i = 0; '0' <= (c = **s) && c <= '9'; ++*s)

        i = i*10 + c - '0';

 return i;

}

看到这个函数我相信我们大家都很熟悉了，这个函数和我们之前调用的atoi的功能差不多，本函数主要是主要是将字符型数字转化为十进制数字的功能，它是通过一位一位的返回模式转化的。

下面我们再来看看printf函数的另外的一个函数的功能，首先来看看 console_ops 结构体；

struct console_ops console_ops;

/* Console operations */

struct console_ops {

 int (*open)(void);

 void (*write)(const char *buf, int len);

 void (*edit_cmdline)(char *buf, int len);

 void (*close)(void);

 void *data;

};

另外一个函数就是这个结构的write成员函数，下面我们来看看它的功能。

int serial_console_init(void)

{

 void *devp;

 int rc = -1;

 devp = serial_get_stdout_devp();

 if (devp == NULL)

  goto err_out;

 if (dt_is_compatible(devp, "ns16550") ||

     dt_is_compatible(devp, "pnpPNP,501"))

  rc = ns16550_console_init(devp, &serial_cd);

 else if (dt_is_compatible(devp, "marvell,mv64360-mpsc"))

  rc = mpsc_console_init(devp, &serial_cd);

 else if (dt_is_compatible(devp, "fsl,cpm1-scc-uart") ||

          dt_is_compatible(devp, "fsl,cpm1-smc-uart") ||

          dt_is_compatible(devp, "fsl,cpm2-scc-uart") ||

          dt_is_compatible(devp, "fsl,cpm2-smc-uart"))

  rc = cpm_console_init(devp, &serial_cd);

 else if (dt_is_compatible(devp, "fsl,mpc5200-psc-uart"))

  rc = mpc5200_psc_console_init(devp, &serial_cd);

 else if (dt_is_compatible(devp, "xlnx,opb-uartlite-1.00.b") ||

   dt_is_compatible(devp, "xlnx,xps-uartlite-1.00.a"))

  rc = uartlite_console_init(devp, &serial_cd);

 /* Add other serial console driver calls here */

 if (!rc) {

  console_ops.open = serial_open;

   console_ops.write = serial_write;

  console_ops.close = serial_close;

  console_ops.data = &serial_cd;

  if (serial_cd.getc)

   console_ops.edit_cmdline = serial_edit_cmdline;

  return 0;

 }

err_out:

 return -1;

}

当函数执行时，console_ops.write函数就相当于执行serial_write函数，我们来看看它又做了些什么事情;

static void serial_write(const char *buf, int len)

{

 struct serial_console_data *scdp = console_ops.data;

 while (*buf != '\0')

     scdp->putc(*buf++);

}

由上面的console_ops结构体我们已经知道了它有一个data成员，下面我们来具体看看serial_console_data结构的具体内容；

struct serial_console_data {

 int (*open)(void);

 void (*putc)(unsigned char c);

 unsigned char (*getc)(void);

 u8 (*tstc)(void);

 void (*close)(void);

};

看到这个结构体就是一个操作串口的操作集合，我们只要调用它就可以操作串口了，serial_write函数主要是操作它的putc函数来输出内容到串口，下面看看putc函数，通过查找得知它又调用其它函数；

int cpm_console_init(void *devp, struct serial_console_data *scdp)

{

 void *vreg[2];

 u32 reg[2];

 int is_smc = 0, is_cpm2 = 0;

 void *parent, *muram;

 void *muram_addr;

 unsigned long muram_offset, muram_size;

 if (dt_is_compatible(devp, "fsl,cpm1-smc-uart")) {

  is_smc = 1;

 } else if (dt_is_compatible(devp, "fsl,cpm2-scc-uart")) {

  is_cpm2 = 1;

 } else if (dt_is_compatible(devp, "fsl,cpm2-smc-uart")) {

  is_cpm2 = 1;

  is_smc = 1;

 }

 if (is_smc) {

  enable_port = smc_enable_port;

  disable_port = smc_disable_port;

 } else {

  enable_port = scc_enable_port;

  disable_port = scc_disable_port;

 }

 if (is_cpm2)

  do_cmd = cpm2_cmd;

 else

  do_cmd = cpm1_cmd;

 if (getprop(devp, "fsl,cpm-command", &cpm_cmd, 4) < 4)

  return -1;

 if (dt_get_virtual_reg(devp, vreg, 2) < 2)

  return -1;

 if (is_smc)

  smc = vreg[0];

 else

  scc = vreg[0];

 param = vreg[1];

 parent = get_parent(devp);

 if (!parent)

  return -1;

 if (dt_get_virtual_reg(parent, &cpcr, 1) < 1)

  return -1;

 muram = finddevice("/soc/cpm/muram/data");

 if (!muram)

  return -1;

 /* For bootwrapper-compatible device trees, we assume that the first

  * entry has at least 128 bytes, and that #address-cells/#data-cells

  * is one for both parent and child.

  */

 if (dt_get_virtual_reg(muram, &muram_addr, 1) < 1)

  return -1;

 if (getprop(muram, "reg", reg, 8) < 8)

  return -1;

 muram_offset = reg[0];

 muram_size = reg[1];

 /* Store the buffer descriptors at the end of the first muram chunk.

  * For SMC ports on CPM2-based platforms, relocate the parameter RAM

  * just before the buffer descriptors.

  */

 cbd_offset = muram_offset + muram_size - 2 * sizeof(struct cpm_bd);

 if (is_cpm2 && is_smc) {

  u16 *smc_base = (u16 *)param;

  u16 pram_offset;

  pram_offset = cbd_offset - 64;

  pram_offset = _ALIGN_DOWN(pram_offset, 64);

  disable_port();

  out_be16(smc_base, pram_offset);

  param = muram_addr - muram_offset + pram_offset;

 }

 cbd_addr = muram_addr - muram_offset + cbd_offset;

 scdp->open = cpm_serial_open;

 scdp->putc = cpm_serial_putc;

 scdp->getc = cpm_serial_getc;

 scdp->tstc = cpm_serial_tstc;

 return 0;

}

这个函数的具体内容就不看了，就去看看cpm_serial_putc函数的具体实现，来看看它实现什么功能；

static void cpm_serial_putc(unsigned char c)

{

 while (tbdf->sc & 0x8000)

 barrier();      //执行空操作；

 sync();

 tbdf->addr[0] = c; 

 eieio();         //上下文同步；

 tbdf->sc |= 0x8000;

}

针对barrier函数和eieio函数的具体实现做一些说明：

static inline void barrier(void)

{

     asm volatile("" : : : "memory");     //执行空指令，但是消耗没存空间；      

}

static inline void eieio(void)

{

     __asm__ __volatile__ ("eieio" : : : "memory");     //同上

}

        eieio 是上下文同步指令。“上下文同步”指的是：处理器内核包含着多个独立的执行单元，所以它能够并行的执行多个指令并且是乱序的。上下文同步指令用于需要严格秩序的地方，进行强制严格的指令顺序。eieio代表“强制按顺序执行IO”。在执行过程中，加载/存储单元等待前一个访问结束之后再开始运行加载/存储指令。eieio的目的就是为了防止执行过程中的随意加载和存储。

我们再来看看tbdf具体是什么结构，看看的结构体的具体作用；

static struct cpm_bd *tbdf, *rbdf;

struct cpm_bd {

 u16 sc;                    /* Status and Control */

 u16 len;                  /* Data length in buffer */

 u8 *addr;                /* Buffer address in host memory */

};

        

        从该结构体的可以看出，putc最后存储的内容其实是存在了buff空间里了，但是疑问也同时产生了tbdf结构体是在什么时候被初始化的，初始化值是什么，带着疑问我们继续来往下看看；

static int cpm_serial_open(void)

{

 disable_port();

 out_8(&param->rfcr, 0x10);

 out_8(&param->tfcr, 0x10);

 out_be16(&param->mrblr, 1);

 out_be16(&param->maxidl, 0);

 out_be16(&param->brkec, 0);

 out_be16(&param->brkln, 0);

 out_be16(&param->brkcr, 0);

 

 rbdf = cbd_addr;

 rbdf->addr = (u8 *)rbdf - 1;

 rbdf->sc = 0xa000;

 rbdf->len = 1;

 tbdf = rbdf + 1;

 tbdf->addr = (u8 *)rbdf - 2;

 tbdf->sc = 0x2000;

 tbdf->len = 1;

 

 sync();

 out_be16(&param->rbase, cbd_offset);

 out_be16(&param->tbase, cbd_offset + sizeof(struct cpm_bd));

 do_cmd(CPM_CMD_INIT_RX_TX);

 enable_port();

 return 0;

}

         从这个函数我们可以看出它对tbdf的初始化工作，我们可以根据它的初始化内容结合putc函数来理解数据的输出功能，do_cmd函数出现过多次，我们来看看这个函数，再看这个函数之前我先来看看几个宏定义；

#define CPM_CMD_STOP_TX     4

#define CPM_CMD_RESTART_TX  6

#define CPM_CMD_INIT_RX_TX  0

下面来看看do_cmd函数的实现，根据函数的查找我们可以看到do_cmd函数其实是在cpm_console_init函数里面被初始化的，实际上它是调用cpm2_cmd（do_cmd = cpm2_cmd）函数；

static void cpm2_cmd(int op)

{

 while (in_be32(cpcr) & 0x10000)

  ;

 out_be32(cpcr, op | cpm_cmd | 0x10000);

 while (in_be32(cpcr) & 0x10000)

  ;

}

         针对这个函数我们来看看它调用的函数的功能，由于它内嵌汇编，所以我们要看看它的汇编指令的意思，结合它一起来理解该函数的功能，先来看看函数本身吧；

static inline unsigned in_be32(const volatile unsigned *addr)

{

 unsigned ret;

 __asm__ __volatile__("lwz%U1%X1 %0,%1; twi 0,%0,0; isync"

        : "=r" (ret) : "m" (*addr));

 return ret;

}

static inline unsigned in_be32(const volatile unsigned *addr)

{

 unsigned ret;

 __asm__ __volatile__("lwz%U1%X1 %0,%1; twi 0,%0,0; isync"

        : "=r" (ret) : "m" (*addr));

 return ret;

}

         我们可以看到其实这两个函数本身都是在调用汇编指令，由于我们分析的PowerPC架构的代码，所以我们只能去找它的指令集看看，看是否有lwz指令，看它是什么意思了；

            lwz rD，d（rA） ；EA＝（rA|0）＋d，从EA处读取4个字节的数，并加载到rD。

         从上面的汇编指令我们可以看出，其实就是加载字节的指令，将EA的字节存放到rD中去。针对上面的汇编部分我们做一些简单的解释，

 lwz%U1%X1 %0,%1;   将%1的内容加载到%0中去；

 twi 0,%0,0;                这是内核的寄存器的配置，具体执行什么就需要根据具体的芯片指令手册进行查找了，这里不作具体介绍；

 isync                        这个是同步数据的指令；

 : "=r" (ret)             “=r”表示以寄存器变量的形式输出数据，然后将数据给ret变量，它对应上面指令的%0；

 : "m" (*addr)        “m” 表示输入的是内存中的变量，它对应的是%1，也就是将*addr替换%1；

        我们就先介绍到这里，就不分析细节方面的函数了，如果要深入的理解它可以从细节方面的着手，本文主要是分析printf函数的OS的基本的调用过程，是为让初学者对它有个大概的认识，以便于后续的学习，当然本文跟多的是我个人的理解，所以中间肯定存在理解错误的地方；在后续工作中我将会深入的去了解它的具体的过程，并且会写成文档收集起来以供有需要的人学习。