linux kernel pr_info函数来源

客官°小女子只卖身不卖艺 2024-04-18 19:19 20阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3I3NzY4Mzk2Mg_size_16_color_FFFFFF_t_70][]

root@ubuntu:/usr/src/linux-5.0.1/arch\# **grep -Hrn "KERNEL supported" \***  
Binary file x86/boot/compressed/vmlinux.bin matches  
x86/kernel/cpu/common.c:1141: **pr\_info("KERNEL supported cpus:\\n");**

root@ubuntu:/usr/src/linux-5.0.1\# **grep -Hrn "fine pr\_info(fmt" \***  
include/linux/printk.h:309:\#define pr\_info(fmt, ...) \\  
tools/lib/bpf/libbpf.c:79:\#define pr\_info(fmt, ...) \_\_pr(\_\_pr\_info, fmt, \#\#\_\_VA\_ARGS\_\_)  
tools/lib/api/debug-internal.h:18:\#define pr\_info(fmt, ...) \_\_pr(\_\_pr\_info, fmt, \#\#\_\_VA\_ARGS\_\_)  
tools/perf/pmu-events/json.h:24:\#define pr\_info(fmt, ...) \\  
tools/perf/util/debug.h:27:\#define pr\_info(fmt, ...) \\

ot@ubuntu:/usr/src/linux-5.0.1\#  
root@ubuntu:/usr/src/linux-5.0.1\# cat include/linux/printk.h  
/\* SPDX-License-Identifier: GPL-2.0 \*/  
\#ifndef \_\_KERNEL\_PRINTK\_\_  
\#define \_\_KERNEL\_PRINTK\_\_

\#include <stdarg.h>  
\#include <linux/init.h>  
\#include <linux/kern\_levels.h>  
\#include <linux/linkage.h>  
\#include <linux/cache.h>

extern const char linux\_banner\[\];  
extern const char linux\_proc\_banner\[\];

\#define PRINTK\_MAX\_SINGLE\_HEADER\_LEN 2

static inline int printk\_get\_level(const char \*buffer)  
\{  
if (buffer\[0\] == KERN\_SOH\_ASCII && buffer\[1\]) \{  
switch (buffer\[1\]) \{  
case '0' ... '7':  
case 'd': /\* KERN\_DEFAULT \*/  
case 'c': /\* KERN\_CONT \*/  
return buffer\[1\];  
\}  
\}  
return 0;  
\}

static inline const char \*printk\_skip\_level(const char \*buffer)  
\{  
if (printk\_get\_level(buffer))  
return buffer + 2;

return buffer;  
\}

static inline const char \*printk\_skip\_headers(const char \*buffer)  
\{  
while (printk\_get\_level(buffer))  
buffer = printk\_skip\_level(buffer);

return buffer;  
\}

\#define CONSOLE\_EXT\_LOG\_MAX 8192

/\* printk's without a loglevel use this.. \*/  
\#define MESSAGE\_LOGLEVEL\_DEFAULT CONFIG\_MESSAGE\_LOGLEVEL\_DEFAULT

/\* We show everything that is MORE important than this.. \*/  
\#define CONSOLE\_LOGLEVEL\_SILENT 0 /\* Mum's the word \*/  
\#define CONSOLE\_LOGLEVEL\_MIN 1 /\* Minimum loglevel we let people use \*/  
\#define CONSOLE\_LOGLEVEL\_DEBUG 10 /\* issue debug messages \*/  
\#define CONSOLE\_LOGLEVEL\_MOTORMOUTH 15 /\* You can't shut this one up \*/

/\*  
\* Default used to be hard-coded at 7, quiet used to be hardcoded at 4,  
\* we're now allowing both to be set from kernel config.  
\*/  
\#define CONSOLE\_LOGLEVEL\_DEFAULT CONFIG\_CONSOLE\_LOGLEVEL\_DEFAULT  
\#define CONSOLE\_LOGLEVEL\_QUIET CONFIG\_CONSOLE\_LOGLEVEL\_QUIET

extern int console\_printk\[\];

\#define console\_loglevel (console\_printk\[0\])  
\#define default\_message\_loglevel (console\_printk\[1\])  
\#define minimum\_console\_loglevel (console\_printk\[2\])  
\#define default\_console\_loglevel (console\_printk\[3\])

static inline void console\_silent(void)  
\{  
console\_loglevel = CONSOLE\_LOGLEVEL\_SILENT;  
\}

static inline void console\_verbose(void)  
\{  
if (console\_loglevel)  
console\_loglevel = CONSOLE\_LOGLEVEL\_MOTORMOUTH;  
\}

/\* strlen("ratelimit") + 1 \*/  
\#define DEVKMSG\_STR\_MAX\_SIZE 10  
extern char devkmsg\_log\_str\[\];  
struct ctl\_table;

struct va\_format \{  
const char \*fmt;  
va\_list \*va;  
\};

/\*  
\* FW\_BUG  
\* Add this to a message where you are sure the firmware is buggy or behaves  
\* really stupid or out of spec. Be aware that the responsible BIOS developer  
\* should be able to fix this issue or at least get a concrete idea of the  
\* problem by reading your message without the need of looking at the kernel  
\* code.  
\*  
\* Use it for definite and high priority BIOS bugs.  
\*  
\* FW\_WARN  
\* Use it for not that clear (e.g. could the kernel messed up things already?)  
\* and medium priority BIOS bugs.  
\*  
\* FW\_INFO  
\* Use this one if you want to tell the user or vendor about something  
\* suspicious, but generally harmless related to the firmware.  
\*  
\* Use it for information or very low priority BIOS bugs.  
\*/  
\#define FW\_BUG "\[Firmware Bug\]: "  
\#define FW\_WARN "\[Firmware Warn\]: "  
\#define FW\_INFO "\[Firmware Info\]: "

/\*  
\* HW\_ERR  
\* Add this to a message for hardware errors, so that user can report  
\* it to hardware vendor instead of LKML or software vendor.  
\*/  
\#define HW\_ERR "\[Hardware Error\]: "

/\*  
\* DEPRECATED  
\* Add this to a message whenever you want to warn user space about the use  
\* of a deprecated aspect of an API so they can stop using it  
\*/  
\#define DEPRECATED "\[Deprecated\]: "

/\*  
\* Dummy printk for disabled debugging statements to use whilst maintaining  
\* gcc's format checking.  
\*/  
\#define no\_printk(fmt, ...) \\  
(\{ \\  
if (0) \\  
printk(fmt, \#\#\_\_VA\_ARGS\_\_); \\  
0; \\  
\})

\#ifdef CONFIG\_EARLY\_PRINTK  
extern asmlinkage \_\_printf(1, 2)  
void early\_printk(const char \*fmt, ...);  
\#else  
static inline \_\_printf(1, 2) \_\_cold  
void early\_printk(const char \*s, ...) \{ \}  
\#endif

\#ifdef CONFIG\_PRINTK\_NMI  
extern void printk\_nmi\_enter(void);  
extern void printk\_nmi\_exit(void);  
extern void printk\_nmi\_direct\_enter(void);  
extern void printk\_nmi\_direct\_exit(void);  
\#else  
static inline void printk\_nmi\_enter(void) \{ \}  
static inline void printk\_nmi\_exit(void) \{ \}  
static inline void printk\_nmi\_direct\_enter(void) \{ \}  
static inline void printk\_nmi\_direct\_exit(void) \{ \}  
\#endif /\* PRINTK\_NMI \*/

\#ifdef CONFIG\_PRINTK  
asmlinkage \_\_printf(5, 0)  
int vprintk\_emit(int facility, int level,  
const char \*dict, size\_t dictlen,  
const char \*fmt, va\_list args);

asmlinkage \_\_printf(1, 0)  
int vprintk(const char \*fmt, va\_list args);

asmlinkage \_\_printf(1, 2) \_\_cold  
int printk(const char \*fmt, ...);

/\*  
\* Special printk facility for scheduler/timekeeping use only, \_DO\_NOT\_USE\_ !  
\*/  
\_\_printf(1, 2) \_\_cold int printk\_deferred(const char \*fmt, ...);

/\*  
\* Please don't use printk\_ratelimit(), because it shares ratelimiting state  
\* with all other unrelated printk\_ratelimit() callsites. Instead use  
\* printk\_ratelimited() or plain old \_\_ratelimit().  
\*/  
extern int \_\_printk\_ratelimit(const char \*func);  
\#define printk\_ratelimit() \_\_printk\_ratelimit(\_\_func\_\_)  
extern bool printk\_timed\_ratelimit(unsigned long \*caller\_jiffies,  
unsigned int interval\_msec);

extern int printk\_delay\_msec;  
extern int dmesg\_restrict;

extern int  
devkmsg\_sysctl\_set\_loglvl(struct ctl\_table \*table, int write, void \_\_user \*buf,  
size\_t \*lenp, loff\_t \*ppos);

extern void wake\_up\_klogd(void);

char \*log\_buf\_addr\_get(void);  
u32 log\_buf\_len\_get(void);  
void log\_buf\_vmcoreinfo\_setup(void);  
void \_\_init setup\_log\_buf(int early);  
\_\_printf(1, 2) void dump\_stack\_set\_arch\_desc(const char \*fmt, ...);  
void dump\_stack\_print\_info(const char \*log\_lvl);  
void show\_regs\_print\_info(const char \*log\_lvl);  
extern asmlinkage void dump\_stack(void) \_\_cold;  
extern void printk\_safe\_init(void);  
extern void printk\_safe\_flush(void);  
extern void printk\_safe\_flush\_on\_panic(void);  
\#else  
static inline \_\_printf(1, 0)  
int vprintk(const char \*s, va\_list args)  
\{  
return 0;  
\}  
static inline \_\_printf(1, 2) \_\_cold  
int printk(const char \*s, ...)  
\{  
return 0;  
\}  
static inline \_\_printf(1, 2) \_\_cold  
int printk\_deferred(const char \*s, ...)  
\{  
return 0;  
\}  
static inline int printk\_ratelimit(void)  
\{  
return 0;  
\}  
static inline bool printk\_timed\_ratelimit(unsigned long \*caller\_jiffies,  
unsigned int interval\_msec)  
\{  
return false;  
\}

static inline void wake\_up\_klogd(void)  
\{  
\}

static inline char \*log\_buf\_addr\_get(void)  
\{  
return NULL;  
\}

static inline u32 log\_buf\_len\_get(void)  
\{  
return 0;  
\}

static inline void log\_buf\_vmcoreinfo\_setup(void)  
\{  
\}

static inline void setup\_log\_buf(int early)  
\{  
\}

static inline \_\_printf(1, 2) void dump\_stack\_set\_arch\_desc(const char \*fmt, ...)  
\{  
\}

static inline void dump\_stack\_print\_info(const char \*log\_lvl)  
\{  
\}

static inline void show\_regs\_print\_info(const char \*log\_lvl)  
\{  
\}

static inline void dump\_stack(void)  
\{  
\}

static inline void printk\_safe\_init(void)  
\{  
\}

static inline void printk\_safe\_flush(void)  
\{  
\}

static inline void printk\_safe\_flush\_on\_panic(void)  
\{  
\}  
\#endif

extern int kptr\_restrict;

\#ifndef pr\_fmt  
\#define pr\_fmt(fmt) fmt  
\#endif

/\*  
\* These can be used to print at the various log levels.  
\* All of these will print unconditionally, although note that pr\_debug()  
\* and other debug macros are compiled out unless either DEBUG is defined  
\* or CONFIG\_DYNAMIC\_DEBUG is set.  
\*/  
\#define pr\_emerg(fmt, ...) \\  
printk(KERN\_EMERG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_alert(fmt, ...) \\  
printk(KERN\_ALERT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_crit(fmt, ...) \\  
printk(KERN\_CRIT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_err(fmt, ...) \\  
printk(KERN\_ERR pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_warning(fmt, ...) \\  
printk(KERN\_WARNING pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_warn pr\_warning  
\#define pr\_notice(fmt, ...) \\  
printk(KERN\_NOTICE pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
**\#define pr\_info(fmt, ...) \\  
printk(KERN\_INFO pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)**  
/\*  
\* Like KERN\_CONT, pr\_cont() should only be used when continuing  
\* a line with no newline ('\\n') enclosed. Otherwise it defaults  
\* back to KERN\_DEFAULT.  
\*/  
\#define pr\_cont(fmt, ...) \\  
printk(KERN\_CONT fmt, \#\#\_\_VA\_ARGS\_\_)

/\* pr\_devel() should produce zero code unless DEBUG is defined \*/  
\#ifdef DEBUG  
\#define pr\_devel(fmt, ...) \\  
printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_devel(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

/\* If you are writing a driver, please use dev\_dbg instead \*/  
\#if defined(CONFIG\_DYNAMIC\_DEBUG)  
\#include <linux/dynamic\_debug.h>

/\* dynamic\_pr\_debug() uses pr\_fmt() internally so we don't need it here \*/  
\#define pr\_debug(fmt, ...) \\  
dynamic\_pr\_debug(fmt, \#\#\_\_VA\_ARGS\_\_)  
\#elif defined(DEBUG)  
\#define pr\_debug(fmt, ...) \\  
printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_debug(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

/\*  
\* Print a one-time message (analogous to WARN\_ONCE() et al):  
\*/

\#ifdef CONFIG\_PRINTK  
\#define printk\_once(fmt, ...) \\  
(\{ \\  
static bool \_\_print\_once \_\_read\_mostly; \\  
bool \_\_ret\_print\_once = !\_\_print\_once; \\  
\\  
if (!\_\_print\_once) \{ \\  
\_\_print\_once = true; \\  
printk(fmt, \#\#\_\_VA\_ARGS\_\_); \\  
\} \\  
unlikely(\_\_ret\_print\_once); \\  
\})  
\#define printk\_deferred\_once(fmt, ...) \\  
(\{ \\  
static bool \_\_print\_once \_\_read\_mostly; \\  
bool \_\_ret\_print\_once = !\_\_print\_once; \\  
\\  
if (!\_\_print\_once) \{ \\  
\_\_print\_once = true; \\  
printk\_deferred(fmt, \#\#\_\_VA\_ARGS\_\_); \\  
\} \\  
unlikely(\_\_ret\_print\_once); \\  
\})  
\#else  
\#define printk\_once(fmt, ...) \\  
no\_printk(fmt, \#\#\_\_VA\_ARGS\_\_)  
\#define printk\_deferred\_once(fmt, ...) \\  
no\_printk(fmt, \#\#\_\_VA\_ARGS\_\_)  
\#endif

\#define pr\_emerg\_once(fmt, ...) \\  
printk\_once(KERN\_EMERG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_alert\_once(fmt, ...) \\  
printk\_once(KERN\_ALERT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_crit\_once(fmt, ...) \\  
printk\_once(KERN\_CRIT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_err\_once(fmt, ...) \\  
printk\_once(KERN\_ERR pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_warn\_once(fmt, ...) \\  
printk\_once(KERN\_WARNING pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_notice\_once(fmt, ...) \\  
printk\_once(KERN\_NOTICE pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_info\_once(fmt, ...) \\  
printk\_once(KERN\_INFO pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_cont\_once(fmt, ...) \\  
printk\_once(KERN\_CONT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)

\#if defined(DEBUG)  
\#define pr\_devel\_once(fmt, ...) \\  
printk\_once(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_devel\_once(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

/\* If you are writing a driver, please use dev\_dbg instead \*/  
\#if defined(DEBUG)  
\#define pr\_debug\_once(fmt, ...) \\  
printk\_once(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_debug\_once(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

/\*  
\* ratelimited messages with local ratelimit\_state,  
\* no local ratelimit\_state used in the !PRINTK case  
\*/  
\#ifdef CONFIG\_PRINTK  
\#define printk\_ratelimited(fmt, ...) \\  
(\{ \\  
static DEFINE\_RATELIMIT\_STATE(\_rs, \\  
DEFAULT\_RATELIMIT\_INTERVAL, \\  
DEFAULT\_RATELIMIT\_BURST); \\  
\\  
if (\_\_ratelimit(&\_rs)) \\  
printk(fmt, \#\#\_\_VA\_ARGS\_\_); \\  
\})  
\#else  
\#define printk\_ratelimited(fmt, ...) \\  
no\_printk(fmt, \#\#\_\_VA\_ARGS\_\_)  
\#endif

\#define pr\_emerg\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_EMERG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_alert\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_ALERT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_crit\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_CRIT pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_err\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_ERR pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_warn\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_WARNING pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_notice\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_NOTICE pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#define pr\_info\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_INFO pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
/\* no pr\_cont\_ratelimited, don't do that... \*/

\#if defined(DEBUG)  
\#define pr\_devel\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_devel\_ratelimited(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

/\* If you are writing a driver, please use dev\_dbg instead \*/  
\#if defined(CONFIG\_DYNAMIC\_DEBUG)  
/\* descriptor check is first to prevent flooding with "callbacks suppressed" \*/  
\#define pr\_debug\_ratelimited(fmt, ...) \\  
do \{ \\  
static DEFINE\_RATELIMIT\_STATE(\_rs, \\  
DEFAULT\_RATELIMIT\_INTERVAL, \\  
DEFAULT\_RATELIMIT\_BURST); \\  
DEFINE\_DYNAMIC\_DEBUG\_METADATA(descriptor, pr\_fmt(fmt)); \\  
if (unlikely(descriptor.flags & \_DPRINTK\_FLAGS\_PRINT) && \\  
\_\_ratelimit(&\_rs)) \\  
\_\_dynamic\_pr\_debug(&descriptor, pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_); \\  
\} while (0)  
\#elif defined(DEBUG)  
\#define pr\_debug\_ratelimited(fmt, ...) \\  
printk\_ratelimited(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#else  
\#define pr\_debug\_ratelimited(fmt, ...) \\  
no\_printk(KERN\_DEBUG pr\_fmt(fmt), \#\#\_\_VA\_ARGS\_\_)  
\#endif

extern const struct file\_operations kmsg\_fops;

enum \{  
DUMP\_PREFIX\_NONE,  
DUMP\_PREFIX\_ADDRESS,  
DUMP\_PREFIX\_OFFSET  
\};  
extern int hex\_dump\_to\_buffer(const void \*buf, size\_t len, int rowsize,  
int groupsize, char \*linebuf, size\_t linebuflen,  
bool ascii);  
\#ifdef CONFIG\_PRINTK  
extern void print\_hex\_dump(const char \*level, const char \*prefix\_str,  
int prefix\_type, int rowsize, int groupsize,  
const void \*buf, size\_t len, bool ascii);  
\#if defined(CONFIG\_DYNAMIC\_DEBUG)  
\#define print\_hex\_dump\_bytes(prefix\_str, prefix\_type, buf, len) \\  
dynamic\_hex\_dump(prefix\_str, prefix\_type, 16, 1, buf, len, true)  
\#else  
extern void print\_hex\_dump\_bytes(const char \*prefix\_str, int prefix\_type,  
const void \*buf, size\_t len);  
\#endif /\* defined(CONFIG\_DYNAMIC\_DEBUG) \*/  
\#else  
static inline void print\_hex\_dump(const char \*level, const char \*prefix\_str,  
int prefix\_type, int rowsize, int groupsize,  
const void \*buf, size\_t len, bool ascii)  
\{  
\}  
static inline void print\_hex\_dump\_bytes(const char \*prefix\_str, int prefix\_type,  
const void \*buf, size\_t len)  
\{  
\}

\#endif

\#if defined(CONFIG\_DYNAMIC\_DEBUG)  
\#define print\_hex\_dump\_debug(prefix\_str, prefix\_type, rowsize, \\  
groupsize, buf, len, ascii) \\  
dynamic\_hex\_dump(prefix\_str, prefix\_type, rowsize, \\  
groupsize, buf, len, ascii)  
\#elif defined(DEBUG)  
\#define print\_hex\_dump\_debug(prefix\_str, prefix\_type, rowsize, \\  
groupsize, buf, len, ascii) \\  
print\_hex\_dump(KERN\_DEBUG, prefix\_str, prefix\_type, rowsize, \\  
groupsize, buf, len, ascii)  
\#else  
static inline void print\_hex\_dump\_debug(const char \*prefix\_str, int prefix\_type,  
int rowsize, int groupsize,  
const void \*buf, size\_t len, bool ascii)  
\{  
\}  
\#endif

\#endif  
root@ubuntu:/usr/src/linux-5.0.1\#

Pq.h (e:\\programs\\linux-5.0.1\\linux-5.0.1\\include\\linux\\raid) 6354 2019/03/10

\# define printk printf  
int vsprintf(char \*buf, const char \*fmt, va\_list args)  
\{  
int len;  
unsigned 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 \*/

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 (isdigit(\*fmt))  
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 (isdigit(\*fmt))  
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 == 'h' || \*fmt == 'l' || \*fmt == 'L') \{  
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 \*);  
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 \{  
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 |= SMALL;  
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);  
else if (qualifier == 'h') \{  
num = (unsigned short)va\_arg(args, int);  
if (flags & SIGN)  
num = (short)num;  
\} else if (flags & SIGN)  
num = va\_arg(args, int);  
else  
num = va\_arg(args, unsigned int);  
str = number(str, num, base, field\_width, precision, flags);  
\}  
\*str = '\\0';  
return str - buf;  
\}

int sprintf(char \*buf, const char \*fmt, ...)  
\{  
va\_list args;  
int i;

va\_start(args, fmt);  
i = vsprintf(buf, fmt, args);  
va\_end(args);  
return i;  
\}

int printf(const char \*fmt, ...)  
\{  
char printf\_buf\[1024\];  
va\_list args;  
int printed;

va\_start(args, fmt);  
printed = vsprintf(printf\_buf, fmt, args);  
va\_end(args);

puts(printf\_buf);

return printed;  
\}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3I3NzY4Mzk2Mg_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/02e58cfc65c0496497c95cb09562db60.png