【OpenHarmony开发】 tracepoint的机制总结

最新推荐文章于 2024-07-25 15:19:10 发布
最新推荐文章于 2024-07-25 15:19:10 发布
阅读量839 收藏 24
点赞数 19
分类专栏： 前端 OpenHarmony 鸿蒙 文章标签： 前端 javascript harmonyos HarmonyOS Next 鸿蒙开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64422261/article/details/139801210
版权
鸿蒙 同时被 3 个专栏收录
166 篇文章 0 订阅
订阅专栏
OpenHarmony
154 篇文章 0 订阅
订阅专栏
前端
16 篇文章 0 订阅
订阅专栏

一、tracepoint 的机制

1.1 DECLARE_HOOK 解析

DECLARE_HOOK(vendor_bond_check_dev_link,
    TP_PROTO(const struct bonding *bond, const struct slave *slave, int *state), 
    TP_ARGS(bond, slave, state));
​
// 在已经实现如下宏定义的前提下
// CONFIG_TRACEPOINTS 和 CONFIG_VENDOR_HOOKS
#include <trace/hooks/vendor_hooks.h> // 没有的化自行添加
#define DECLARE_HOOK DECLARE_TRACE

#include <linux/tracepoint.h>
#define DECLARE_TRACE(name, proto, args) \
	__DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \
		cpu_online(raw_smp_processor_id()), \
		PARAMS(void *__data, proto))

#define PARAMS(args...) args
#define TP_PROTO(args...)   args
#define TP_ARGS(args...)    args
​

经过转换后

__DECLARE_TRACE(vendor_bond_check_dev_link, PARAMS(const struct bonding *bond, const struct slave *slave, int *state), PARAMS(bond, slave, state), \
		cpu_online(raw_smp_processor_id()), \
		PARAMS(void *__data, const struct bonding *bond, const struct slave *slave, int *state))
    |||||
    |||||
    |||||
    \|||/
     \|/
      |
__DECLARE_TRACE(vendor_bond_check_dev_link, \
    PARAMS(const struct bonding *bond, const struct slave *slave, int *state), \
    PARAMS(bond, slave, state), \
	cpu_online(raw_smp_processor_id()), \
	PARAMS(void *__data, const struct bonding *bond, const struct slave *slave, int *state))
​

进一步解析

#define raw_smp_processor_id() (current_thread_info()->cpu) // 获取运行当前线程的CPUID
#define cpu_online(cpu)     cpumask_test_cpu((cpu), cpu_online_mask) // 测试 CPU 掩码中的 CPU
​
#define __DECLARE_TRACE(name, proto, args, cond, data_proto)            \
    extern int __traceiter_##name(data_proto);                          \
    DECLARE_STATIC_CALL(tp_func_##name, __traceiter_##name);            \
    extern struct tracepoint __tracepoint_##name;                       \
    static inline void trace_##name(proto)                              \
    {                                                                   \
        if (static_key_false(&__tracepoint_##name.key))                 \
            __DO_TRACE(name,                                            \
                TP_ARGS(args),                                          \
                TP_CONDITION(cond), 0);                                 \
        if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) {                     \
            rcu_read_lock_sched_notrace();                              \
            rcu_dereference_sched(__tracepoint_##name.funcs);           \
            rcu_read_unlock_sched_notrace();                            \
        }                                                               \
    }                                                                   \
    __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args),              \
                PARAMS(cond))                                           \
    static inline int                                                   \
    register_trace_##name(void (*probe)(data_proto), void *data)        \
    {                                                                   \
        return tracepoint_probe_register(&__tracepoint_##name,          \
                        (void *)probe, data);                           \
    }                                                                   \
    static inline int                                                   \
    register_trace_prio_##name(void (*probe)(data_proto), void *data,   \
                   int prio)                                            \
    {                                                                   \
        return tracepoint_probe_register_prio(&__tracepoint_##name,     \
                          (void *)probe, data, prio);                   \
    }                                                                   \
    static inline int                                                   \
    unregister_trace_##name(void (*probe)(data_proto), void *data)      \
    {                                                                   \
        return tracepoint_probe_unregister(&__tracepoint_##name,        \
                        (void *)probe, data);                           \
    }                                                                   \
    static inline void                                                  \
    check_trace_callback_type_##name(void (*cb)(data_proto))            \
    {                                                                   \
    }                                                                   \
    static inline bool                                                  \
    trace_##name##_enabled(void)                                        \
    {                                                                   \
        return static_key_false(&__tracepoint_##name.key);              \
    }
​

转换后结果

__DECLARE_TRACE( \
    vendor_bond_check_dev_link, \
    PARAMS(const struct bonding *bond, const struct slave *slave, int *state), \
    PARAMS(bond, slave, state), \
	cpu_online(raw_smp_processor_id()), \
	PARAMS(void *__data, const struct bonding *bond, const struct slave *slave, int *state) \
)
    |||||
    |||||
    |||||
    \|||/
     \|/
      |
extern int __traceiter_vendor_bond_check_dev_link(
    void *__data, const struct bonding *bond, const struct slave *slave, int *state);
DECLARE_STATIC_CALL(tp_func_vendor_bond_check_dev_link, __traceiter_vendor_bond_check_dev_link);
extern struct tracepoint __tracepoint_vendor_bond_check_dev_link;


static inline void trace_vendor_bond_check_dev_link(
    const struct bonding *bond, const struct slave *slave, int *state)
{
    if (static_key_false(&__tracepoint_vendor_bond_check_dev_link.key))
        __DO_TRACE(vendor_bond_check_dev_link,
            TP_ARGS(bond, slave, state),
            TP_CONDITION(cpu_online(raw_smp_processor_id())), 0);
    if (IS_ENABLED(CONFIG_LOCKDEP) && (cpu_online(raw_smp_processor_id()))) {
        rcu_read_lock_sched_notrace();
        rcu_dereference_sched(__tracepoint_vendor_bond_check_dev_link.funcs);
        rcu_read_unlock_sched_notrace();
    }
}

__DECLARE_TRACE_RCU( \
    vendor_bond_check_dev_link, \
    PARAMS(const struct bonding *bond, const struct slave *slave, int *state), \
    PARAMS(bond, slave, state), \
    PARAMS(cpu_online(raw_smp_processor_id()))
)

static inline int register_trace_vendor_bond_check_dev_link(
    void (*probe)(void *__data, const struct bonding *bond, const struct slave *slave, int *state),
    void *data)
{
    return tracepoint_probe_register(&__tracepoint_vendor_bond_check_dev_link, (void *)probe, data);
}

static inline int register_trace_prio_vendor_bond_check_dev_link(
    void (*probe)(void *__data, const struct bonding *bond, const struct slave *slave, int *state),
    void *data, int prio)
{
    return tracepoint_probe_register_prio(&__tracepoint_vendor_bond_check_dev_link, (void *)probe, data, prio);
}

static inline int unregister_trace_vendor_bond_check_dev_link(
    void (*probe)(void *__data, const struct bonding *bond, const struct slave *slave, int *state),
    void *data)
{
    return tracepoint_probe_unregister(&__tracepoint_vendor_bond_check_dev_link, (void *)probe, data);
}

static inline void check_trace_callback_type_vendor_bond_check_dev_link(
    void (*cb)(void *__data, const struct bonding *bond, const struct slave *slave, int *state))
{
}

static inline bool trace_vendor_bond_check_dev_link_enabled(void)
{
    return static_key_false(&__tracepoint_vendor_bond_check_dev_link.key);
}
​

1.2 DECLARE_STATIC_CALL 解析

  

#define DECLARE_STATIC_CALL(name, func) \
	extern struct static_call_key STATIC_CALL_KEY(name); \
	extern typeof(func) STATIC_CALL_TRAMP(name);

#define STATIC_CALL_KEY(name)       __PASTE(STATIC_CALL_KEY_PREFIX, name)
#define __PASTE(a,b) ___PASTE(a,b)
#define ___PASTE(a,b) a##b
#define STATIC_CALL_KEY_PREFIX      __SCK__

#define STATIC_CALL_TRAMP(name)     __PASTE(STATIC_CALL_TRAMP_PREFIX, name)
#define STATIC_CALL_TRAMP_PREFIX    __SCT__
    |||||
    |||||
    |||||
    \|||/
     \|/
      |
#define DECLARE_STATIC_CALL(name, func) \
	extern struct static_call_key __SCK__##name; \
	extern typeof(func) __SCT__##name;
​

转换后

extern int __traceiter_vendor_bond_check_dev_link(
    void *__data, const struct bonding *bond, const struct slave *slave, int *state);
DECLARE_STATIC_CALL(tp_func_vendor_bond_check_dev_link, __traceiter_vendor_bond_check_dev_link);
    |||||
    |||||
    |||||
    \|||/
     \|/
      |
extern int __traceiter_vendor_bond_check_dev_link(
    void *__data, const struct bonding *bond, const struct slave *slave, int *state);
extern struct static_call_key __SCK__tp_func_vendor_bond_check_dev_link;
extern typeof(__traceiter_vendor_bond_check_dev_link) __SCT__tp_func_vendor_bond_check_dev_link; // 定义一个和__traceiter_vendor_bond_check_dev_link相同类型的变量
​

1.3 trace_vendor_bond_check_dev_link 函数解析---执行钩子函数

struct tracepoint {
    const char *name;
    struct static_key key;
    struct static_call_key *static_call_key;
    void *static_call_tramp;
    void *iterator;
    int (*regfunc)(void);
    void (*unregfunc)(void);
    struct tracepoint_func __rcu *funcs;
};

extern struct tracepoint __tracepoint_vendor_bond_check_dev_link;

static inline void trace_vendor_bond_check_dev_link(
    const struct bonding *bond, const struct slave *slave, int *state)
{
    // 使用了全局变量__tracepoint_vendor_bond_check_dev_link，必定有地方会初始化了该变量
    if (static_key_false(&__tracepoint_vendor_bond_check_dev_link.key))
        __DO_TRACE(vendor_bond_check_dev_link,
            TP_ARGS(bond, slave, state),
            TP_CONDITION(cpu_online(raw_smp_processor_id())), 0);
    if (IS_ENABLED(CONFIG_LOCKDEP) && (cpu_online(raw_smp_processor_id()))) {
        rcu_read_lock_sched_notrace();
        rcu_dereference_sched(__tracepoint_vendor_bond_check_dev_link.funcs);
        rcu_read_unlock_sched_notrace();
    }
}
​

​

1.4 __DECLARE_TRACE_RCU 解析

#define __DECLARE_TRACE_RCU(name, proto, args, cond) \
    static inline void trace_##name##_rcuidle(proto) \
    { \
        if (static_key_false(&__tracepoint_##name.key)) \
            __DO_TRACE(name, \
                TP_ARGS(args), \
                TP_CONDITION(cond), 1); \
    }
​

1.5 register_trace_vendor_bond_check_dev_link 函数介绍---注册钩子函数

static inline int register_trace_vendor_bond_check_dev_link(
    void (*probe)(void *__data, const struct bonding *bond, const struct slave *slave, int *state),
    void *data)
{
    return tracepoint_probe_register(&__tracepoint_vendor_bond_check_dev_link, (void *)probe, data);
}
​
int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data)
{
    return tracepoint_probe_register_prio(tp, probe, data, TRACEPOINT_DEFAULT_PRIO);
}
​
int tracepoint_probe_register_prio(
    struct tracepoint *tp, void *probe, void *data, int prio)
{
    struct tracepoint_func tp_func;
    int ret;

    mutex_lock(&tracepoints_mutex);
    tp_func.func = probe;
    tp_func.data = data;
    tp_func.prio = prio;
    ret = tracepoint_add_func(tp, &tp_func, prio, true); // 整个过程就是显示tp = tp_func
    mutex_unlock(&tracepoints_mutex);
    return ret;
}
​

static int tracepoint_add_func(struct tracepoint *tp,
    struct tracepoint_func *func, int prio, bool warn)
{
    struct tracepoint_func *old, *tp_funcs;
    int ret;

    if (tp->regfunc && !static_key_enabled(&tp->key)) {
        ret = tp->regfunc();
        if (ret < 0)
            return ret;
    }

    // 核心代码1，拿到钩子列表
    tp_funcs = rcu_dereference_protected(tp->funcs,
            lockdep_is_held(&tracepoints_mutex));
    // 核心代码2，注册新的钩子到列表
    old = func_add(&tp_funcs, func, prio);
    if (IS_ERR(old)) {
        WARN_ON_ONCE(warn && PTR_ERR(old) != -ENOMEM);
        return PTR_ERR(old);
    }

    /*
     * rcu_assign_pointer has as smp_store_release() which makes sure
     * that the new probe callbacks array is consistent before setting
     * a pointer to it.  This array is referenced by __DO_TRACE from
     * include/linux/tracepoint.h using rcu_dereference_sched().
     */
    switch (nr_func_state(tp_funcs)) {
    case TP_FUNC_1:        /* 0->1 */
        /*
         * Make sure new static func never uses old data after a
         * 1->0->1 transition sequence.
         */
        tp_rcu_cond_sync(TP_TRANSITION_SYNC_1_0_1);
        /* Set static call to first function */
        tracepoint_update_call(tp, tp_funcs);
        /* Both iterator and static call handle NULL tp->funcs */
        rcu_assign_pointer(tp->funcs, tp_funcs);
        static_key_enable(&tp->key);
        break;
    case TP_FUNC_2:        /* 1->2 */
        /* Set iterator static call */
        tracepoint_update_call(tp, tp_funcs);
        /*
         * Iterator callback installed before updating tp->funcs.
         * Requires ordering between RCU assign/dereference and
         * static call update/call.
         */
        fallthrough;
    case TP_FUNC_N:        /* N->N+1 (N>1) */
        rcu_assign_pointer(tp->funcs, tp_funcs);
        /*
         * Make sure static func never uses incorrect data after a
         * N->...->2->1 (N>1) transition sequence.
         */
        if (tp_funcs[0].data != old[0].data)
            tp_rcu_get_state(TP_TRANSITION_SYNC_N_2_1);
        break;
    default:
        WARN_ON_ONCE(1);
        break;
    }

    release_probes(old);
    return 0;
}
​

1.6 unregister_trace_vendor_bond_check_dev_link 函数解析---注销钩子函数

不做介绍了，和 register 类似

二、tracepiont 其他的功能介绍

【待补充】

三、Demo 实例讲解

后面实现用例的时候补充，当前仅介绍官方的 demo

3.1 驱动侧代码实现

  

#include <trace/hooks/bonding.h>

static void vendor_foo(void *data, const struct bonding *bond,
                       const struct slave *slave, int *state)
{
        pr_info("%s\n", __func__);                                                                                                                                                                                                                                                                            
}

static int __init vendor_bond_init(void)
{
      return register_trace_vendor_bond_check_dev_link(&vendor_foo, NULL);
}

static void __exit vendor_bond_exit(void)
{
        unregister_trace_vendor_bond_check_dev_link(&vendor_foo, NULL);
}

module_init(vendor_bond_init);
module_exit(vendor_bond_exit);
​

3.2 内核侧代码实现

代码合入链接

3.3 测试代码

#include <linux/kernel.h>                                                                                                                                                                                                                                                                                       
#include <linux/module.h>
#include <net/bonding.h>
#include <trace/hooks/bonding.h>

static void vendor_bond_check_dev_link(void *data, const struct bonding *bond,
                                       const struct slave *slave, int *state)
{
        pr_info("%s\n", __func__);
}

static int __init bondingTestInit(void)
{
        return register_trace_vendor_bond_check_dev_link(
                        &vendor_bond_check_dev_link, NULL);
}

static void __exit bondingTestExit(void)
{
        printk("bonding test exit\n");
        unregister_trace_vendor_bond_check_dev_link(&vendor_bond_check_dev_link, NULL);
}

/* 模块入口和出口函数 */
module_init(bondingTestInit)
module_exit(bondingTestExit)

/* 模块信息 */
MODULE_AUTHOR("Wei Yongjun <[email]weiyongjun1@huawei.com[/email]>");
MODULE_LICENSE("GPL");
MODULE_ESCRIPTION("bondtest driver");

最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。 

鸿蒙HarmonyOS Next全套学习资料←点击领取！（安全链接，放心点击）

这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。

希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

鸿蒙（HarmonyOS NEXT）最新学习路线

有了路线图，怎么能没有学习资料呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（OpenHarmony ）学习手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门教学视频，内容包含：ArkTS、ArkUI、Web开发、应用模型、资源分类…等知识点。

获取以上完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习资料

HarmonyOS Next 最新全套视频教程

《鸿蒙 (OpenHarmony)开发基础到实战手册》

OpenHarmony北向、南向开发环境搭建

《鸿蒙开发基础》

  • ArkTS语言
  • 安装DevEco Studio
  • 运用你的第一个ArkTS应用
  • ArkUI声明式UI开发
  • .……

《鸿蒙开发进阶》

  • Stage模型入门
  • 网络管理
  • 数据管理
  • 电话服务
  • 分布式应用开发
  • 通知与窗口管理
  • 多媒体技术
  • 安全技能
  • 任务管理
  • WebGL
  • 国际化开发
  • 应用测试
  • DFX面向未来设计
  • 鸿蒙系统移植和裁剪定制
  • ……

《鸿蒙进阶实战》

  • ArkTS实践
  • UIAbility应用
  • 网络案例
  • ……

大厂面试必问面试题

鸿蒙南向开发技术

鸿蒙APP开发必备

鸿蒙生态应用开发白皮书V2.0PDF

获取以上完整鸿蒙HarmonyOS学习资料，请点击→

纯血版全套鸿蒙HarmonyOS学习资料

总结
总的来说，华为鸿蒙不再兼容安卓，对中年程序员来说是一个挑战，也是一个机会。只有积极应对变化，不断学习和提升自己，他们才能在这个变革的时代中立于不败之地。 

不停留的码牛
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内核的static-key机制
phenix_lord的专栏
10-18 4277
内核的static-key
tracepoint源码示例
08-07
在Linux内核开发中，`tracepoint`是一个强大的动态跟踪机制，它允许开发者在内核代码的特定位置插入钩子，以便在运行时收集信息或进行调试。`tracepoint`比传统的`kprobe`更高效，因为它在编译时被内联到代码中，不...
LWN：利用静态调用来避免retpoline
Linux News搬运工
04-13 1005
关注了就能看到更多这么棒的文章哦～Avoiding retpolines with static callsByJonathan CorbetMarch 26, 2020原文来自：h...
tracepoint简介
HZero
03-14 3750
1. tracepoint原理 tracepoint是预先在函数的插入点中插桩，当执行到函数的插入点，则执行插桩函数，进而触发与插入点预先绑定的probe函数，probe函数可以是一个或者多个，probe函数可以定义为任意的行为，从而可以起到对函数内部观测的租用。 2. 使用tracepoint的步骤 2.1 DECLARE_TRACE 需要在头文件中通过DECLARE_TRACE宏声明，DECLARE_TRACE定义如下： #define DECLARE_TRACE(name, proto, args)
Linux内核 eBPF基础：Tracepoint原理源码分析
RToax
05-10 2863
Linux内核 eBPF基础 Tracepoint原理源码分析 荣涛 2021年5月10日 1. 基本原理 需要注意的几点： 本文将从sched_switch相关的tracepoint展开； 关于static_key，请详见本博客jump-label相关文章Linux Jump Label(x86)、Linux Jump Label/static-key机制详解； 可参见内核注释版代码：https://github.com/Rtoax/linux-5.10.13 1.1. 源码头文件结构 首先看t
x86: perf_events内核初始化
大昱的博客
08-20 1239
Linux性能计数器的使用(perf_events)可能会带来泄露受监控进程访问的敏感数据的巨大风险。在直接使用perf_events系统调用API的情况下，数据泄露都是可能的以及由perf工具用户模式实用程序(perf)生成的数据文件风险取决于perf_events性能监控单元(PMU)的数据的性质和perf收集并公开以进行性能分析。收集的系统和性能数据可分为以下几类尔“架构性能监控”CPUID检测/枚举详细信息struct {} split;};cpu_hw_events CPU硬件事件/**//*
tracepoint_lttng使用详解
03-23
tracepoint_lttng使用详解,主要是对函数耗时进行定性的统计，对性能优化方案有着举足轻重的效果！LTTng 是一个 Linux 平台开源的跟踪工具，是一套软件组件，可允许跟踪 Linux 内核和用户程序，并控制跟踪会话（开始/...
Ruby-TraceLocation可以帮助您跟踪代码的源位置并帮助您阅读Ruby中庞大的开放源库
08-15
Ruby是一种强大的动态编程语言，广泛用于Web开发、脚本编写以及构建复杂的软件系统。在处理大型的Ruby开源库时，理解和调试代码变得尤为关键。`TraceLocation` 是一个实用工具，它为开发者提供了追踪代码执行路径的...
Linux Tracing System浅析 & eBPF框架开发分享
07-20
在Linux系统中，有许多不同的追踪技术，包括Kprobe、Tracepoint、Linux Auditing subsystem (auditd)、SystemTap、LTTng、perf、trace-cmd、eBPF、bpftrace以及BCC等。 Kprobe和Tracepoint是内核动态追踪的基础，...
在Ruby 2中进行调试-Ruby开发
05-27
Byebug Byebug是一个易于使用且功能丰富的...Byebug也是快速的，因为它是作为C扩展开发的，并且可靠，因为它由完整的测试套件支持。 调试器允许在执行过程中了解Ruby程序内部发生的情况，并提供许多传统的调试功能。
ASP.NET Web Api 使用 EF 6，DateTime 字段如何取数据库服务器当前时间
yangshuquan的专栏
07-24 796
在做数据库设计时，为了方便进行数据追踪，通常会有几个字段是每个表都有的，比如创建时间、创建人、更新时间、更新人等，这些时间字段一般存储的是数据库服务器的时间，EF 是操作整个数据表对象，所以需要寻找方法来实现这个目的。本文分享 DB First 和 Code First 两种模式的 EF 中 DateTime 字段如何存储数据库服务器当前时间的方法。
Hutool SoapClient 调用使用@webservice 发布的webService接口，参数传递为空
FangX_u的博客
07-24 581
采用工具类Hutool SoapClient调用@webservice 发布的webService接口时，参数传递不到webService,可以借助SoapUI工具辅助查看。
Windows10+vs 2017中创建WEB API教程
Explinks的博客
07-24 987
本文将介绍如何在Windows10+vs 2017中创建web Api的教程。目前本教程当中的方法在Win10 + VS2017（MVC5）win server2016+vs2017，vs2013 vs2019当中测试通过。
TS如何处理js模块的类型？
闻人放歌的三寸青草园圃
07-24 271
【代码】TS如何处理js模块的类型？
苍穹外卖浏览器前端界面修改
程序员象漂亮的博客
07-25 226
客户原始方案是期望做一个Spring Boot + Vue的饿了么系统，但时间上太仓促，所以建议选择开源的苍穹外码目作为作业提交。客户接受了建议的方案后，期望对前端页面提出了一些个性化的定制修改。
通过不同方式在 Vue 3 中传递路由参数
最新发布
点点滴滴
07-25 536
通过path参数传递：在路由路径中定义动态参数，并使用将其作为 props 传递。通过query参数传递：在路由跳转时通过query参数传递数据，并在组件中使用useRoute获取。通过props选项传递：在路由配置中使用props选项传递静态或动态参数。
前端学习1——自学习梳理
qq_63125992的博客
07-24 321
【代码】前端学习1——自学习梳理。
Vue3扁平化Tree组件的前端分页实现
felix_alone2012的博客
07-24 380
大家好，我是小卷。得益于JuanTree的扁平化设计，在数据量很大的情况下除了懒加载，使用前端分页也是一种解决渲染性能问题的可选方案。
Linux内核中有哪些类型的tracepoint
06-09
在 Linux 内核中，有以下几种类型的 tracepoint： 1. Function tracepoint：跟踪函数的调用和返回，用于函数级别的跟踪； 2. Tracepoint：跟踪内核中的事件，如中断、异常、系统调用等； 3. Kprobe tracepoint：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值