DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-20 18:26:32 +00:00
Code Issues Releases Wiki Activity

fix: remove useless c code (#1116)

Browse Source 
* fix: remove useless c code

remove printk.c file
remove old test_ebpf file
implement `lookup_kallsyms` and `addr_from_symbol` using rust

* fix the weak linkage

* feat(kernel): 添加cfg-if依赖并优化panic模块的条件编译

Signed-off-by: longjin <longjin@DragonOS.org>

---------

Signed-off-by: longjin <longjin@DragonOS.org>
Co-authored-by: longjin <longjin@DragonOS.org>
This commit is contained in:
linfeng
2025-03-27 14:16:10 +08:00
committed by GitHub
parent 4729ec69c4
commit 3d663af8a2
19 changed files with 88 additions and 2352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
kernel/Cargo.lock generated
View File

@ -449,6 +449,7 @@ dependencies = [
"bitfield-struct",
"bitflags 1.3.2",
"bitmap",
"cfg-if",
"defer",
"driver_base_macros",
"elf 0.7.2",

1
kernel/Cargo.toml
View File

@ -76,6 +76,7 @@ unwinding = { git = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/unwi
"personality"
]}
defer = "0.2.1"
cfg-if = { version = "1.0.0" }
# target为x86_64时，使用下面的依赖
[target.'cfg(target_arch = "x86_64")'.dependencies]

65
kernel/src/common/kprint.h
View File

@ -11,68 +11,3 @@
#pragma once
#include "printk.h"
#define ksuccess(...) \
do \
{ \
printk("[ "); \
printk_color(GREEN, BLACK, "SUCCESS"); \
printk(" ] "); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kinfo(...) \
do \
{ \
printk("[ INFO ] "); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kdebug(...) \
do \
{ \
printk("[ DEBUG ] (%s:%d)\t", __FILE__, __LINE__); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kwarn(...) \
do \
{ \
printk("[ "); \
printk_color(YELLOW, BLACK, "WARN"); \
printk(" ] "); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kerror(...) \
do \
{ \
printk("[ "); \
printk_color(RED, BLACK, "ERROR"); \
printk(" ] "); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kterminated(...) \
do \
{ \
printk("[ "); \
printk_color(RED, BLACK, "TERMINATED"); \
printk(" ] "); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)
#define kBUG(...) \
do \
{ \
printk("[ "); \
printk_color(RED, BLACK, "BUG"); \
printk(" ] (%s:%d)\t", __FILE__, __LINE__); \
printk(__VA_ARGS__); \
printk("\n"); \
} while (0)

42
kernel/src/common/printk.h
View File

@ -34,46 +34,4 @@
#include "glib.h"
#include <stdarg.h>
/**
* @brief 将字符串按照fmt和args中的内容进行格式化，然后保存到buf中
*
* @param buf 结果缓冲区
* @param fmt 格式化字符串
* @param args 内容
* @return 最终字符串的长度
*/
int vsprintf(char *buf, const char *fmt, va_list args);
/**
* @brief 将字符串按照fmt和args中的内容进行格式化，截取字符串前buf_size-1，保存到buf中
*
* @param buf 结果缓冲区，大小为buf_size
* @param fmt 格式化字符串
* @param buf_size 缓冲区长度
* @param args 内容
* @return 最终字符串的长度
*/
int vsnprintf(char *buf, const char *fmt, int buf_size, va_list args);
/**
* @brief 格式化打印字符串
*
* @param FRcolor 前景色
* @param BKcolor 背景色
* @param ... 格式化字符串
*/
#define printk(...) printk_color(WHITE, BLACK, __VA_ARGS__)
int printk_color(unsigned int FRcolor, unsigned int BKcolor, const char *fmt, ...);
/**
* @brief 格式化字符串并输出到buf
*
* @param buf 输出缓冲区
* @param fmt 格式
* @param ... 参数
* @return int 字符串长度
*/
int sprintk(char *buf, const char *fmt, ...);
#pragma GCC pop_options

4
kernel/src/common/stdio.h
View File

@ -7,7 +7,3 @@
#define SEEK_END 2 /* Seek relative to end-of-file */
#define SEEK_MAX 3
extern int vsprintf(char *buf, const char *fmt, va_list args);
extern int sprintk(char *buf, const char *fmt, ...);

4
kernel/src/debug/Makefile
View File

@ -9,10 +9,6 @@ kallsyms.o: kallsyms.c
gcc -o kallsyms kallsyms.c
rm -rf kallsyms.o
traceback.o: traceback/traceback.c
$(CC) $(CFLAGS) -c traceback/traceback.c -o traceback/traceback.o
# 生成内核栈符号表的汇编文件
generate_kallsyms: kallsyms.o
echo "Generating kallsyms..."

16
kernel/src/debug/kprobe/args.rs
View File

@ -1,3 +1,4 @@
use crate::debug::traceback::addr_from_symbol;
use alloc::boxed::Box;
use alloc::string::String;
use kprobe::{CallBackFunc, KprobeBuilder, ProbeArgs};
@ -15,10 +16,6 @@ pub struct KprobeInfo {
pub enable: bool,
}
extern "C" {
fn addr_from_symbol(symbol: *const u8) -> usize;
}
impl TryFrom<KprobeInfo> for KprobeBuilder {
type Error = SystemError;
fn try_from(kprobe_info: KprobeInfo) -> Result<Self, Self::Error> {
@ -30,20 +27,15 @@ impl TryFrom<KprobeInfo> for KprobeBuilder {
return Err(SystemError::EINVAL);
}
let func_addr = if let Some(symbol) = kprobe_info.symbol.clone() {
let mut symbol_sting = symbol;
if !symbol_sting.ends_with("\0") {
symbol_sting.push('\0');
}
let symbol = symbol_sting.as_ptr();
let func_addr = unsafe { addr_from_symbol(symbol) };
if func_addr == 0 {
let func_addr = unsafe { addr_from_symbol(symbol.as_str()) };
if func_addr.is_none() {
warn!(
"register_kprobe: the symbol: {:?} not found",
kprobe_info.symbol
);
return Err(SystemError::ENXIO);
}
func_addr
func_addr.unwrap() as usize
} else {
kprobe_info.addr.unwrap()
};

1
kernel/src/debug/mod.rs
View File

@ -2,3 +2,4 @@ pub mod jump_label;
pub mod klog;
pub mod kprobe;
pub mod panic;
pub mod traceback;

5
kernel/src/debug/panic/hook.rs
View File

@ -1,10 +1,7 @@
use crate::debug::traceback::lookup_kallsyms;
use unwinding::abi::{UnwindContext, UnwindReasonCode, _Unwind_GetIP};
use unwinding::panic::UserUnwindTrace;
extern "C" {
fn lookup_kallsyms(addr: u64, level: i32) -> i32;
}
/// User hook for unwinding
///
/// During stack backtrace, the user can print the function location of the current stack frame.

19
kernel/src/debug/panic/mod.rs
View File

@ -1,7 +1,15 @@
#[cfg(feature = "backtrace")]
mod hook;
use core::panic::PanicInfo;
use cfg_if::cfg_if;
cfg_if! {
if #[cfg(target_os = "none")] {
use core::panic::PanicInfo;
use core::sync::atomic::AtomicU8;
static PANIC_COUNTER: AtomicU8 = AtomicU8::new(0);
}
}
/// 全局的panic处理函数
///
#[cfg(target_os = "none")]
@ -11,7 +19,7 @@ pub fn panic(info: &PanicInfo) -> ! {
use log::error;
use crate::process;
PANIC_COUNTER.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
error!("Kernel Panic Occurred.");
match info.location() {
@ -28,6 +36,13 @@ pub fn panic(info: &PanicInfo) -> ! {
}
}
println!("Message:\n\t{}", info.message());
if PANIC_COUNTER.load(core::sync::atomic::Ordering::Relaxed) > 8 {
println!(
"Panic Counter: {}, too many panics, halt.",
PANIC_COUNTER.load(core::sync::atomic::Ordering::Relaxed)
);
loop {}
}
#[cfg(feature = "backtrace")]
{
let mut data = hook::CallbackData { counter: 0 };

62
kernel/src/debug/traceback/mod.rs Normal file
View File

@ -0,0 +1,62 @@
use core::ffi::CStr;
#[linkage = "weak"]
#[no_mangle]
fn kallsyms_address() {}
#[linkage = "weak"]
#[no_mangle]
fn kallsyms_num() {}
#[linkage = "weak"]
#[no_mangle]
fn kallsyms_names_index() {}
#[linkage = "weak"]
#[no_mangle]
fn kallsyms_names() {}
pub unsafe fn lookup_kallsyms(addr: u64, level: i32) -> Option<()> {
let sym_names = kallsyms_names as *const u8;
// 由于符号表使用nm -n生成，因此是按照地址升序排列的，因此可以二分
let sym_num = kallsyms_num as usize;
let kallsyms_address_list =
core::slice::from_raw_parts(kallsyms_address as *const u64, sym_num);
let sym_names_index = kallsyms_names_index as *const u64;
let sym_names_index = core::slice::from_raw_parts(sym_names_index, sym_num);
let mut index = usize::MAX;
for i in 0..sym_num - 1 {
if addr > kallsyms_address_list[i] && addr <= kallsyms_address_list[i + 1] {
index = i;
break;
}
}
return if index < sym_num {
let sym_name = CStr::from_ptr(sym_names.add(sym_names_index[index] as usize) as _)
.to_str()
.unwrap();
println!(
"[{}] function:{}() \t(+) {:04} address:{:#018x}",
level,
sym_name,
addr - kallsyms_address_list[index],
addr
);
Some(())
} else {
None
};
}
pub unsafe fn addr_from_symbol(symbol: &str) -> Option<u64> {
let sym_num = kallsyms_num as usize;
let sym_names = kallsyms_names as *const u8;
let kallsyms_address_list =
core::slice::from_raw_parts(kallsyms_address as *const u64, sym_num);
let sym_names_index = kallsyms_names_index as *const u64;
let sym_names_index_list = core::slice::from_raw_parts(sym_names_index, sym_num);
for i in 0..sym_num {
let sym_name_cstr = CStr::from_ptr(sym_names.add(sym_names_index_list[i] as usize) as _);
let sym_name = sym_name_cstr.to_str().unwrap();
if sym_name == symbol {
return Some(kallsyms_address_list[i]);
}
}
None
}

84
kernel/src/debug/traceback/traceback.c
View File

@ -1,84 +0,0 @@
#include "traceback.h"
#include <common/printk.h>
#include <common/string.h>
#include <process/process.h>
int lookup_kallsyms(uint64_t addr, int level)
{
const char *str = (const char *)&kallsyms_names;
// 暴力查找符合要求的symbol
// todo: 改用二分搜索。
// 由于符号表使用nm -n生成，因此是按照地址升序排列的，因此可以二分
uint64_t index = 0;
for (index = 0; index < kallsyms_num - 1; ++index)
{
if (addr > kallsyms_address[index] && addr <= kallsyms_address[index + 1])
break;
}
if (index < kallsyms_num) // 找到对应的函数
{
// 依次输出函数名称、rip离函数起始处的偏移量、函数执行的rip
printk("function:%s() \t(+) %04d address:%#018lx\n", &str[kallsyms_names_index[index]], addr - kallsyms_address[index], addr);
return 0;
}
else
return -1;
}
uint64_t addr_from_symbol(const char *symbol)
{
const char *str = (const char *)&kallsyms_names;
for (uint64_t i = 0; i < kallsyms_num; ++i)
{
if (strcmp(&str[kallsyms_names_index[i]], symbol) == 0)
return kallsyms_address[i];
}
return 0;
}
/**
* @brief 追溯内核栈调用情况
*
* @param regs 内核栈结构体
*/
void traceback(struct pt_regs *regs)
{
// 先检验是否为用户态出错，若为用户态出错，则直接返回
if (verify_area(regs->rbp, 0))
{
printk_color(YELLOW, BLACK, "Kernel traceback: Fault in userland. pid=%ld, rbp=%#018lx\n", rs_current_pcb_pid(), regs->rbp);
return;
}
uint64_t *rbp = (uint64_t *)regs->rbp;
printk_color(YELLOW, BLACK, "======== Kernel traceback =======\n");
// printk("&kallsyms_address:%#018lx,kallsyms_address:%#018lx\n", &kallsyms_address, kallsyms_address);
// printk("&kallsyms_syms_num:%#018lx,kallsyms_syms_num:%d\n", &kallsyms_num, kallsyms_num);
// printk("&kallsyms_index:%#018lx\n", &kallsyms_names_index);
// printk("&kallsyms_names:%#018lx,kallsyms_names:%s\n", &kallsyms_names, &kallsyms_names);
uint64_t ret_addr = regs->rip;
// 最大追踪10层调用栈
for (int i = 0; i < 10; ++i)
{
if (lookup_kallsyms(ret_addr, i) != 0)
break;
// 当前栈帧的rbp的地址大于等于内核栈的rbp的时候，表明调用栈已经到头了，追踪结束。
// 当前rbp的地址为用户空间时，直接退出
if ((uint64_t)(rbp) >= rs_current_pcb_thread_rbp() || ((uint64_t)rbp < regs->rsp))
break;
printk_color(ORANGE, BLACK, "rbp:%#018lx,*rbp:%#018lx\n", rbp, *rbp);
// 由于x86处理器在执行call指令时，先将调用返回地址压入栈中，然后再把函数的rbp入栈，最后将rsp设为新的rbp。
// 因此，此处的rbp就是上一层的rsp，那么，*(rbp+1)得到的就是上一层函数的返回地址
ret_addr = *(rbp + 1);
rbp = (uint64_t *)(*rbp);
printk("\n");
}
printk_color(YELLOW, BLACK, "======== Kernel traceback end =======\n");
}

18
kernel/src/debug/traceback/traceback.h
View File

@ -1,18 +0,0 @@
#pragma once
#include <common/glib.h>
#include <process/ptrace.h>
// 使用弱引用属性导出kallsyms中的符号表。
// 采用weak属性是由于第一次编译时，kallsyms还未链接进来，若不使用weak属性则会报错
extern const uint64_t kallsyms_address[] __attribute__((weak));
extern const uint64_t kallsyms_num __attribute__((weak));
extern const uint64_t kallsyms_names_index[] __attribute__((weak));
extern const char *kallsyms_names __attribute__((weak));
/**
* @brief 追溯内核栈调用情况
*
* @param regs 内核栈结构体
*/
void traceback(struct pt_regs *regs);
uint64_t addr_from_symbol(const char *symbol);

1
kernel/src/lib.rs
View File

@ -19,6 +19,7 @@
#![feature(vec_into_raw_parts)]
#![feature(c_variadic)]
#![feature(asm_goto)]
#![feature(linkage)]
#![cfg_attr(target_os = "none", no_std)]
#![allow(static_mut_refs, non_local_definitions, internal_features)]
// clippy的配置

631
kernel/src/libs/printk.c
View File

@ -1,631 +0,0 @@
//
// Created by longjin on 2022/1/22.
//
#include <common/kprint.h>
#include <common/printk.h>
#include <common/spinlock.h>
#include <libs/lib_ui/textui.h>
#include <mm/mm.h>
#include <common/math.h>
#include <common/string.h>
static spinlock_t __printk_lock = {1};
/**
* @brief 将数字按照指定的要求转换成对应的字符串（2~36进制）
*
* @param str 要返回的字符串
* @param num 要打印的数值
* @param base 基数
* @param field_width 区域宽度
* @param precision 精度
* @param flags 标志位
*/
static char *write_num(char *str, ul num, int base, int field_width, int precision, int flags);
static char *write_float_point_num(char *str, double num, int field_width, int precision, int flags);
static int skip_and_atoi(const char **s)
{
/**
* @brief 获取连续的一段字符对应整数的值
* @param:**s 指向 指向字符串的指针 的指针
*/
int ans = 0;
while (is_digit(**s))
{
ans = ans * 10 + (**s) - '0';
++(*s);
}
return ans;
}
/**
* @brief 将字符串按照fmt和args中的内容进行格式化，当buf_size为-1时，字符串直接保存到buf中
* 否则将字符串前buf_size-1个字符放入，大小为buf_size的buf数组中
*
* @param buf 结果缓冲区
* @param fmt 格式化字符串
* @param args 内容
* @param buf_size buf_size为-1时，不指定buf的大小，否则buf大小为buf_size
* @return 最终字符串的长度
*/
static int __do_vsprintf(char *buf, const char *fmt, int buf_size, va_list args)
{
// 当需要输出的字符串的指针为空时，使用该字符填充目标字符串的指针
static const char __end_zero_char = '\0';
char *str = NULL, *s = NULL, *end = NULL;
str = buf;
int flags; // 用来存储格式信息的bitmap
int field_width; //区域宽度
int precision; //精度
int qualifier; //数据显示的类型
int len;
if (buf_size != -1)
{
end = buf + buf_size;
}
//开始解析字符串
for (; *fmt; ++fmt)
{
//内容不涉及到格式化，直接输出
if (*fmt != '%')
{
*str = *fmt;
++str;
continue;
}
//开始格式化字符串
//清空标志位和field宽度
field_width = flags = 0;
bool flag_tmp = true;
bool flag_break = false;
++fmt;
while (flag_tmp)
{
switch (*fmt)
{
case '\0':
//结束解析
flag_break = true;
flag_tmp = false;
break;
case '-':
// 左对齐
flags |= LEFT;
++fmt;
break;
case '+':
//在正数前面显示加号
flags |= PLUS;
++fmt;
break;
case ' ':
flags |= SPACE;
++fmt;
break;
case '#':
//在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
flags |= SPECIAL;
++fmt;
break;
case '0':
//显示的数字之前填充‘0’来取代空格
flags |= PAD_ZERO;
++fmt;
break;
default:
flag_tmp = false;
break;
}
}
if (flag_break)
break;
//获取区域宽度
field_width = -1;
if (*fmt == '*')
{
field_width = va_arg(args, int);
++fmt;
}
else if (is_digit(*fmt))
{
field_width = skip_and_atoi(&fmt);
if (field_width < 0)
{
field_width = -field_width;
flags |= LEFT;
}
}
//获取小数精度
precision = -1;
if (*fmt == '.')
{
++fmt;
if (*fmt == '*')
{
precision = va_arg(args, int);
++fmt;
}
else if (is_digit(*fmt))
{
precision = skip_and_atoi(&fmt);
}
}
//获取要显示的数据的类型
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'Z')
{
qualifier = *fmt;
++fmt;
}
//为了支持lld
if (qualifier == 'l' && *fmt == 'l', *(fmt + 1) == 'd')
++fmt;
//转化成字符串
long long *ip;
switch (*fmt)
{
//输出 %
case '%':
*str++ = '%';
break;
// 显示一个字符
case 'c':
//靠右对齐
if (!(flags & LEFT))
{
while (--field_width > 0)
{
*str = ' ';
++str;
}
}
*str++ = (unsigned char)va_arg(args, int);
while (--field_width > 0)
{
*str = ' ';
++str;
}
break;
//显示一个字符串
case 's':
s = va_arg(args, char *);
if (!s)
s = &__end_zero_char;
len = strlen(s);
if (precision < 0)
{
//未指定精度
precision = len;
}
else if (len > precision)
{
len = precision;
}
//靠右对齐
if (!(flags & LEFT))
while (len < field_width--)
{
*str = ' ';
++str;
}
for (int i = 0; i < len; i++)
{
*str = *s;
++s;
++str;
}
while (len < field_width--)
{
*str = ' ';
++str;
}
break;
//以八进制显示字符串
case 'o':
flags |= SMALL;
case 'O':
flags |= SPECIAL;
if (qualifier == 'l')
str = write_num(str, va_arg(args, long long), 8, field_width, precision, flags);
else
str = write_num(str, va_arg(args, int), 8, field_width, precision, flags);
break;
//打印指针指向的地址
case 'p':
if (field_width == 0)
{
field_width = 2 * sizeof(void *);
flags |= PAD_ZERO;
}
str = write_num(str, (unsigned long)va_arg(args, void *), 16, field_width, precision, flags);
break;
//打印十六进制
case 'x':
flags |= SMALL;
case 'X':
// flags |= SPECIAL;
if (qualifier == 'l')
str = write_num(str, va_arg(args, ll), 16, field_width, precision, flags);
else
str = write_num(str, va_arg(args, int), 16, field_width, precision, flags);
break;
//打印十进制有符号整数
case 'i':
case 'd':
flags |= SIGN;
if (qualifier == 'l')
str = write_num(str, va_arg(args, long long), 10, field_width, precision, flags);
else
str = write_num(str, va_arg(args, int), 10, field_width, precision, flags);
break;
//打印十进制无符号整数
case 'u':
if (qualifier == 'l')
str = write_num(str, va_arg(args, unsigned long long), 10, field_width, precision, flags);
else
str = write_num(str, va_arg(args, unsigned int), 10, field_width, precision, flags);
break;
//输出有效字符数量到*ip对应的变量
case 'n':
if (qualifier == 'l')
ip = va_arg(args, long long *);
else
ip = (ll *)va_arg(args, int *);
*ip = str - buf;
break;
case 'f':
// 默认精度为3
// printk("1111\n");
// va_arg(args, double);
// printk("222\n");
if (precision < 0)
precision = 3;
str = write_float_point_num(str, va_arg(args, double), field_width, precision, flags);
break;
//对于不识别的控制符，直接输出
default:
*str++ = '%';
if (*fmt)
*str++ = *fmt;
else
--fmt;
break;
}
}
//实现vsnprintf 的功能
if (buf_size > 0)
{
if (str < end)
{
*str = '\0';
}
else
{
*(end-1) = '\0';
}
return buf_size;
}
else
{
*str = '\0';
}
//返回缓冲区已有字符串的长度。
return str - buf;
}
/**
* 将字符串按照fmt和args中的内容进行格式化，然后保存到buf中
* @param buf 结果缓冲区
* @param fmt 格式化字符串
* @param args 内容
* @return 最终字符串的长度
*/
int vsprintf(char *buf, const char *fmt, va_list args)
{
return __do_vsprintf(buf, fmt, -1, args);
}
/**
* @brief 将字符串按照fmt和args中的内容进行格式化，截取字符串前buf_size-1，保存到buf中
*
* @param buf 结果缓冲区，大小为buf_size
* @param fmt 格式化字符串
* @param buf_size 缓冲区长度
* @param args 内容
* @return 最终字符串的长度
*/
int vsnprintf(char *buf, const char *fmt, int buf_size, va_list args)
{
return __do_vsprintf(buf, fmt, buf_size, args);
}
static char *write_num(char *str, ul num, int base, int field_width, int precision, int flags)
{
/**
* @brief 将数字按照指定的要求转换成对应的字符串
*
* @param str 要返回的字符串
* @param num 要打印的数值
* @param base 基数
* @param field_width 区域宽度
* @param precision 精度
* @param flags 标志位
*/
// 首先判断是否支持该进制
if (base < 2 || base > 36)
return 0;
char pad, sign, tmp_num[100];
const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// 显示小写字母
if (flags & SMALL)
digits = "0123456789abcdefghijklmnopqrstuvwxyz";
if (flags & LEFT)
flags &= ~PAD_ZERO;
// 设置填充元素
pad = (flags & PAD_ZERO) ? '0' : ' ';
sign = 0;
if (flags & SIGN)
{
int64_t signed_num = (int64_t)num;
if (signed_num < 0)
{
sign = '-';
num = -signed_num;
}
else
num = signed_num;
}
else
{
// 设置符号
sign = (flags & PLUS) ? '+' : ((flags & SPACE) ? ' ' : 0);
}
// sign占用了一个宽度
if (sign)
--field_width;
if (flags & SPECIAL)
if (base == 16) // 0x占用2个位置
field_width -= 2;
else if (base == 8) // O占用一个位置
--field_width;
int js_num = 0; // 临时数字字符串tmp_num的长度
if (num == 0)
tmp_num[js_num++] = '0';
else
{
num = ABS(num);
//进制转换
while (num > 0)
{
tmp_num[js_num++] = digits[num % base]; // 注意这里，输出的数字，是小端对齐的。低位存低位
num /= base;
}
}
if (js_num > precision)
precision = js_num;
field_width -= precision;
// 靠右对齐
if (!(flags & (LEFT + PAD_ZERO)))
while (field_width-- > 0)
*str++ = ' ';
if (sign)
*str++ = sign;
if (flags & SPECIAL)
if (base == 16)
{
*str++ = '0';
*str++ = digits[33];
}
else if (base == 8)
*str++ = digits[24]; //注意这里是英文字母O或者o
if (!(flags & LEFT))
while (field_width-- > 0)
*str++ = pad;
while (js_num < precision)
{
--precision;
*str++ = '0';
}
while (js_num-- > 0)
*str++ = tmp_num[js_num];
while (field_width-- > 0)
*str++ = ' ';
return str;
}
static char *write_float_point_num(char *str, double num, int field_width, int precision, int flags)
{
/**
* @brief 将浮点数按照指定的要求转换成对应的字符串
*
* @param str 要返回的字符串
* @param num 要打印的数值
* @param field_width 区域宽度
* @param precision 精度
* @param flags 标志位
*/
char pad, sign, tmp_num_z[100], tmp_num_d[350];
const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// 显示小写字母
if (flags & SMALL)
digits = "0123456789abcdefghijklmnopqrstuvwxyz";
// 设置填充元素
pad = (flags & PAD_ZERO) ? '0' : ' ';
sign = 0;
if (flags & SIGN && num < 0)
{
sign = '-';
num = -num;
}
else
{
// 设置符号
sign = (flags & PLUS) ? '+' : ((flags & SPACE) ? ' ' : 0);
}
// sign占用了一个宽度
if (sign)
--field_width;
int js_num_z = 0, js_num_d = 0; // 临时数字字符串tmp_num_z tmp_num_d的长度
uint64_t num_z = (uint64_t)(num); // 获取整数部分
uint64_t num_decimal = (uint64_t)(round(1.0 * (num - num_z) * pow(10, precision))); // 获取小数部分
if (num == 0 || num_z == 0)
tmp_num_z[js_num_z++] = '0';
else
{
//存储整数部分
while (num_z > 0)
{
tmp_num_z[js_num_z++] = digits[num_z % 10]; // 注意这里，输出的数字，是小端对齐的。低位存低位
num_z /= 10;
}
}
while (num_decimal > 0)
{
tmp_num_d[js_num_d++] = digits[num_decimal % 10];
num_decimal /= 10;
}
field_width -= (precision + 1 + js_num_z);
// 靠右对齐
if (!(flags & LEFT))
while (field_width-- > 0)
*str++ = pad;
if (sign)
*str++ = sign;
// 输出整数部分
while (js_num_z > 0)
{
*str++ = tmp_num_z[js_num_z - 1];
--js_num_z;
}
*str++ = '.';
// 输出小数部分
int total_dec_count = js_num_d;
for (int i = 0; i < precision && js_num_d-- > 0; ++i)
*str++ = tmp_num_d[js_num_d];
while (total_dec_count < precision)
{
++total_dec_count;
*str++ = '0';
}
while (field_width-- > 0)
*str++ = ' ';
return str;
}
/**
* @brief 格式化打印字符串
*
* @param FRcolor 前景色
* @param BKcolor 背景色
* @param ... 格式化字符串
*/
int printk_color(unsigned int FRcolor, unsigned int BKcolor, const char *fmt, ...)
{
uint64_t rflags;
io_mfence();
spin_lock_irqsave(&__printk_lock, rflags);
io_mfence();
va_list args;
va_start(args, fmt);
static char buf[4096]; // vsprintf()的缓冲区
int len = vsprintf(buf, fmt, args);
va_end(args);
unsigned char current;
int i; // 总共输出的字符数
for (i = 0; i < len; ++i)
{
current = *(buf + i);
// 输出
rs_textui_putchar(current, FRcolor, BKcolor);
}
io_mfence();
spin_unlock_irqrestore(&__printk_lock, rflags);
io_mfence();
return i;
}
int sprintk(char *buf, const char *fmt, ...)
{
int count = 0;
va_list args;
va_start(args, fmt);
count = vsprintf(buf, fmt, args);
va_end(args);
return count;
}