kernel源码（十六）vsprintf.c和printk.c和panic.c

最新推荐文章于 2024-07-14 14:55:20 发布
最新推荐文章于 2024-07-14 14:55:20 发布
阅读量51 收藏 1
点赞数
文章标签： c语言 算法 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhenjingcool/article/details/133074785
版权

这两个源码用于对参数产生格式化输出，和内核关系不大，主要是调用C语言进行一些格式化操作。了解一下。

1 vsprintf.c源码

/*
 *  linux/kernel/vsprintf.c
 *
 *  (C) 1991  Linus Torvalds
 */

/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
/*
 * Wirzenius wrote this portably, Torvalds fucked it up :-)
 */

#include <stdarg.h>
#include <string.h>

/* we use this so that we can do without the ctype library */
#define is_digit(c)    ((c) >= '0' && (c) <= '9')

static int skip_atoi(const char **s)
{
    int i=0;

    while (is_digit(**s))
        i = i*10 + *((*s)++) - '0';
    return i;
}

#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 SMALL    64        /* use 'abcdef' instead of 'ABCDEF' */

#define do_div(n,base) ({ \
int __res; \
__asm__("divl %4":"=a" (n),"=d" (__res):"0" (n),"1" (0),"r" (base)); \
__res; })

static char * number(char * str, int num, int base, int size, int precision
    ,int type)
{
    char c,sign,tmp[36];
    const char *digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int i;

    if (type&SMALL) digits="0123456789abcdefghijklmnopqrstuvwxyz";
    if (type&LEFT) type &= ~ZEROPAD;
    if (base<2 || base>36)
        return 0;
    c = (type & ZEROPAD) ? '0' : ' ' ;
    if (type&SIGN && num<0) {
        sign='-';
        num = -num;
    } else
        sign=(type&PLUS) ? '+' : ((type&SPACE) ? ' ' : 0);
    if (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;
}

int vsprintf(char *buf, const char *fmt, va_list args)
{
    int len;
    int i;
    char * str;
    char *s;
    int *ip;

    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 */

    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 (is_digit(*fmt))
            field_width = skip_atoi(&fmt);
        else if (*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 (is_digit(*fmt))
                precision = skip_atoi(&fmt);
            else if (*fmt == '*') {
                /* it's the next argument */
                precision = va_arg(args, int);
            }
            if (precision < 0)
                precision = 0;
        }

        /* get the conversion qualifier */
        qualifier = -1;
        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
            qualifier = *fmt;
            ++fmt;
        }

        switch (*fmt) {
        case 'c':
            if (!(flags & LEFT))
                while (--field_width > 0)
                    *str++ = ' ';
            *str++ = (unsigned char) va_arg(args, int);
            while (--field_width > 0)
                *str++ = ' ';
            break;

        case 's':
            s = va_arg(args, char *);
            len = strlen(s);
            if (precision < 0)
                precision = len;
            else if (len > precision)
                len = precision;

            if (!(flags & LEFT))
                while (len < field_width--)
                    *str++ = ' ';
            for (i = 0; i < len; ++i)
                *str++ = *s++;
            while (len < field_width--)
                *str++ = ' ';
            break;

        case 'o':
            str = number(str, va_arg(args, unsigned long), 8,
                field_width, precision, flags);
            break;

        case 'p':
            if (field_width == -1) {
                field_width = 8;
                flags |= ZEROPAD;
            }
            str = number(str,
                (unsigned long) va_arg(args, void *), 16,
                field_width, precision, flags);
            break;

        case 'x':
            flags |= SMALL;
        case 'X':
            str = number(str, va_arg(args, unsigned long), 16,
                field_width, precision, flags);
            break;

        case 'd':
        case 'i':
            flags |= SIGN;
        case 'u':
            str = number(str, va_arg(args, unsigned long), 10,
                field_width, precision, flags);
            break;

        case 'n':
            ip = va_arg(args, int *);
            *ip = (str - buf);
            break;

        default:
            if (*fmt != '%')
                *str++ = '%';
            if (*fmt)
                *str++ = *fmt;
            else
                --fmt;
            break;
        }
    }
    *str = '\0';
    return str-buf;
}
View Code

把数字串转成整数

static int skip_atoi(const char **s)
{
    int i=0;

    while (is_digit(**s))
        i = i*10 + *((*s)++) - '0';
    return i;
}

把整数转换为二进制的字符串

static char * number(char * str, int num, int base, int size, int precision
    ,int type)
{
    char c,sign,tmp[36];
    const char *digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int i;

    if (type&SMALL) digits="0123456789abcdefghijklmnopqrstuvwxyz";
    if (type&LEFT) type &= ~ZEROPAD;
    if (base<2 || base>36)
        return 0;
    c = (type & ZEROPAD) ? '0' : ' ' ;
    if (type&SIGN && num<0) {
        sign='-';
        num = -num;
    } else
        sign=(type&PLUS) ? '+' : ((type&SPACE) ? ' ' : 0);
    if (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;
}

格式化输出

int vsprintf(char *buf, const char *fmt, va_list args)
{
    int len;
    int i;
    char * str;
    char *s;
    int *ip;

    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 */

    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 (is_digit(*fmt))
            field_width = skip_atoi(&fmt);
        else if (*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 (is_digit(*fmt))
                precision = skip_atoi(&fmt);
            else if (*fmt == '*') {
                /* it's the next argument */
                precision = va_arg(args, int);
            }
            if (precision < 0)
                precision = 0;
        }

        /* get the conversion qualifier */
        qualifier = -1;
        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
            qualifier = *fmt;
            ++fmt;
        }

        switch (*fmt) {
        case 'c':
            if (!(flags & LEFT))
                while (--field_width > 0)
                    *str++ = ' ';
            *str++ = (unsigned char) va_arg(args, int);
            while (--field_width > 0)
                *str++ = ' ';
            break;

        case 's':
            s = va_arg(args, char *);
            len = strlen(s);
            if (precision < 0)
                precision = len;
            else if (len > precision)
                len = precision;

            if (!(flags & LEFT))
                while (len < field_width--)
                    *str++ = ' ';
            for (i = 0; i < len; ++i)
                *str++ = *s++;
            while (len < field_width--)
                *str++ = ' ';
            break;

        case 'o':
            str = number(str, va_arg(args, unsigned long), 8,
                field_width, precision, flags);
            break;

        case 'p':
            if (field_width == -1) {
                field_width = 8;
                flags |= ZEROPAD;
            }
            str = number(str,
                (unsigned long) va_arg(args, void *), 16,
                field_width, precision, flags);
            break;

        case 'x':
            flags |= SMALL;
        case 'X':
            str = number(str, va_arg(args, unsigned long), 16,
                field_width, precision, flags);
            break;

        case 'd':
        case 'i':
            flags |= SIGN;
        case 'u':
            str = number(str, va_arg(args, unsigned long), 10,
                field_width, precision, flags);
            break;

        case 'n':
            ip = va_arg(args, int *);
            *ip = (str - buf);
            break;

        default:
            if (*fmt != '%')
                *str++ = '%';
            if (*fmt)
                *str++ = *fmt;
            else
                --fmt;
            break;
        }
    }
    *str = '\0';
    return str-buf;
}

2 printk.c

/*
 *  linux/kernel/printk.c
 *
 *  (C) 1991  Linus Torvalds
 */

/*
 * When in kernel-mode, we cannot use printf, as fs is liable to
 * point to 'interesting' things. Make a printf with fs-saving, and
 * all is well.
 */
#include <stdarg.h>
#include <stddef.h>

#include <linux/kernel.h>

static char buf[1024];

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

int printk(const char *fmt, ...)
{
    va_list args;
    int i;

    va_start(args, fmt);
    i=vsprintf(buf,fmt,args);
    va_end(args);
    __asm__("push %%fs\n\t"
        "push %%ds\n\t"
        "pop %%fs\n\t"
        "pushl %0\n\t"
        "pushl $_buf\n\t"
        "pushl $0\n\t"
        "call _tty_write\n\t"
        "addl $8,%%esp\n\t"
        "popl %0\n\t"
        "pop %%fs"
        ::"r" (i):"ax","cx","dx");
    return i;
}
View Code

3 panic.c

在内核出现很严重错误的时候，用于打印内核错误信息，并进入死循环

#include <linux/kernel.h>
#include <linux/sched.h>

void sys_sync(void);    /* it's really int */

volatile void panic(const char * s)
{
    printk("Kernel panic: %s\n\r",s);
    if (current == task[0])
        printk("In swapper task - not syncing\n\r");
    else
        sys_sync();
    for(;;);
}
zhenjingcool
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c标准库中的 string.c / printf.c / vsprintf.c 文件
02-26
`printf.c`和`vsprintf.c`文件涉及到的是C语言的I/O格式化功能，主要用于输出和格式化数据。`printf`函数是最常用的输出函数，可以格式化并打印各种类型的变量。它的主要特点是可以根据占位符（如`%d`、`%s`、`%f`等...
Vsprintf简介--附实现源码
johnsonxjq的专栏
03-26 2436
Vsprintf简介--附实现源码 vsprintf 　　 　　#include <stdarg.h> 　　char buffer[80]; 　　int vspf(char *fmt, ...) 　　{ 　　va_list argptr; 　　int cnt; 　　va_start(argptr, fmt); 　　cnt = vsprintf(buffer, fmt, argptr); 　　va_end(argptr); 　　return(c...
printf()函数的底层实现
zion--6135的博客
06-05 1451
printf()的源码如下:需要了解va_list及我的上一篇博客va_start()的基本使用作为这篇文章的基础 static char sprint_buf[1024]; int printf(const char *fmt, ...) { va_list args; int n; va_start(args, fmt); //以传入的形参为内存基准 n = vsprintf(sprint_buf, fmt, args); va_end(args); //args指针置0 r
vsprintf.c 源码
咕唧咕唧shubo.lk的专栏
05-29 3916
Goto sanos source index//// vsprintf.c//// Print formatting routines//// Copyright (C) 2002 Michael Ringgaard. All rights reserved.//// Redistribution and use in source and binary forms, with or witho
09 sprintf、printf函数的源码
weixin_43684667的博客
03-24 1001
sprintf、printf函数的源码
printf()+sprintf()源码解析笔记
HZS8520223520的博客
07-23 5026
printf的Linux C源码解析 文章目录printf的Linux C源码解析头文件引用及宏定义strnlen函数__div64_32函数宏- -do_divskip_atoi函数number函数vsprintf函数sprintf函数printf函数 该笔记是我看的第一个源码所做的笔记，有些地方的解读可能不是很合理，之后有时间会继续进行优化笔记。 头文件引用及宏定义 #include <stdarg.h> #include <stddef.h> #include "string.
c语言中常用的函数和头文件.docx
11-03
本文将详细介绍C语言中的一些常用函数和头文件，这些是编写C程序的基础。 1. `ctype.h`头文件：这个头文件包含了一系列用于字符测试的函数，如`isalnum()`、`isalpha()`、`iscntrl()`、`isdigit()`、`isgraph()`、`...
可方便移植的printf.c
05-02
可方便移植的printf.c
vsprintf源代码.txt#资源达人分享计划#
08-06
vsprintf源代码.txt#资源达人分享计划#
C语言基本库函数——C.pdf
09-30
C语言是一种强大的、高效且灵活的编程语言，广泛应用于系统...在编写C程序时，应根据需求选择合适的函数，同时注意避免内存泄漏和资源浪费。通过深入理解和实践，可以充分利用C语言的灵活性和效率，实现复杂的功能。
vsprintf 单片机测试
01-22
vsprintf 新唐单片机测试 log 添加 可以通过宏定义，设置是否打印程序中的log调试信息。 但是加上vsprintf之后，编译出来的二进制文件的大小会变大。 谁知道更好的方法，可以告诉我。
vsprintf()
07-20
本文章是关于vsprintf()。
从va_list、va_start、va_arg、va_end想到了vsprintf的源码
认知 行动 坚持
04-11 8814
在前面的博文中， 我彻谈了从va_list、va_start、va_arg、va_end的用法， 但是， 当我看到某个程序后， 非常纳闷， 于是迫不及待得想知道vsprintf的实现。 在我的第一印象中， vsprintf貌似和vs有关， 也就是和微软有关， 所以懒得去管微软那些东东， 其实， vsprintf和微软没有毛关系， linux也有这个东东，而v是variable的缩
vsprintf解析
木牛的博客
07-17 5839
printf函数： 栈是从内存的高地址向低地址生长的，函数参数压栈顺序是从右到左，printf的第一个参数就是那个字符指针即为被双引号括起来的那一部分，函数通过判断字符串里控制参数的个数（%5.4lf等等）来判断参数个数及数据类型。例如printf("%d,%d",a,b);汇编代码为： 1 2 3 4 5 6 7 ...
linux中的vsprintf_Git29 年超 100 万次 commit，Linux 内核何以发展至今？
weixin_39996478的博客
12-21 64
1991 年，21 岁的芬兰大学生 Linus Torvalds 写下第一行 Linux 内核代码时，多半没有想到它会成长为今天这样的庞然大物。当年 8 月 25 日，Torvalds 在 Minix Usenet 新闻组里发了一封帖子，称自己正在做一个自由的操作系统，“就是个兴趣爱好，不会搞得像 GNU 那么大那么专业”。事情的发展显然远超他的预期，如今小到传感器，大到超级计算机，从智...
自己实现的vsprintf函数（未完待续）
火云的专栏
05-12 1827
#include <ctype.h> #include <stdarg.h> #include <stdint.h> #include <limits.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <strin...
《linux 内核完全剖析》 vsprintf.c 代码笔记
Jason Leaster | Rebuilding the tower of babel
05-08 2885
vsprintf.c 代码笔记 你 /* * linux/kernel/vsprintf.c * * (C) 1991 Linus Torvalds */ /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */ /* * Wirzenius wrote this portably, Torvalds fucked
Linux多线程编程-生产者与消费者模型详解与实现（C语言）
最新发布
qq_42037383的博客
07-14 285
生产者-消费者模型是并发编程中的经典问题，描述了多个线程（或进程）如何安全、有效地共享有限的缓冲区资源。：负责生成数据或者将数据放置到共享缓冲区中。：负责从共享缓冲区中取出数据并进行处理或消费。
vsnprintf和vsprintf
09-13
vsnprintf和vsprintf是C语言中的两个函数，用于格式化字符串输出。它们都可以将一个可变数量的参数根据指定的格式串输出到一个字符串中。 vsnprintf函数是一个可变参数版本的snprintf函数。snprintf函数用于将格式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值