- Kernel - mailweb.openeuler.org

[PATCH OLK-6.6] kabi: reserve space for bpf related structures
by Pu Lehui 09 Jan '24

09 Jan '24

From: Pu Lehui <pulehui(a)huaweicloud.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I8UOP9 -------------------------------- reserve space for bpf related structures. Signed-off-by: Pu Lehui <pulehui(a)huawei.com> --- include/linux/bpf.h | 115 +++++++++++++++++++++++++++++++++++ include/linux/bpf_verifier.h | 36 +++++++++++ include/uapi/linux/bpf.h | 16 +++++ 3 files changed, 167 insertions(+) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 392f581af2ce..f37e681cd4f5 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -29,6 +29,7 @@ #include <linux/rcupdate_trace.h> #include <linux/static_call.h> #include <linux/memcontrol.h> +#include <linux/kabi.h> struct bpf_verifier_env; struct bpf_verifier_log; @@ -163,6 +164,11 @@ struct bpf_map_ops { u64 (*map_mem_usage)(const struct bpf_map *map); + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) + /* BTF id of struct allocated by map_alloc */ int *map_btf_id; @@ -288,6 +294,11 @@ struct bpf_map { bool bypass_spec_v1; bool frozen; /* write-once; write-protected by freeze_mutex */ s64 __percpu *elem_count; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; static inline const char *btf_field_type_name(enum btf_field_type type) @@ -664,6 +675,13 @@ enum bpf_type_flag { /* DYNPTR points to xdp_buff */ DYNPTR_TYPE_XDP = BIT(16 + BPF_BASE_TYPE_BITS), +#ifdef CONFIG_KABI_RESERVE + BPF_TYPE_FLAG_RESERVE_1 = BIT(17 + BPF_BASE_TYPE_BITS), + BPF_TYPE_FLAG_RESERVE_2 = BIT(18 + BPF_BASE_TYPE_BITS), + BPF_TYPE_FLAG_RESERVE_3 = BIT(19 + BPF_BASE_TYPE_BITS), + BPF_TYPE_FLAG_RESERVE_4 = BIT(20 + BPF_BASE_TYPE_BITS), +#endif + __BPF_TYPE_FLAG_MAX, __BPF_TYPE_LAST_FLAG = __BPF_TYPE_FLAG_MAX - 1, }; @@ -730,6 +748,13 @@ enum bpf_arg_type { /* Pointer to valid memory of size known at compile time. */ ARG_PTR_TO_FIXED_SIZE_MEM = MEM_FIXED_SIZE | ARG_PTR_TO_MEM, +#ifdef CONFIG_KABI_RESERVE + BPF_ARG_TYPE_RESERVE_1, + BPF_ARG_TYPE_RESERVE_2, + BPF_ARG_TYPE_RESERVE_3, + BPF_ARG_TYPE_RESERVE_4, +#endif + /* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */ @@ -760,6 +785,13 @@ enum bpf_return_type { RET_PTR_TO_BTF_ID_OR_NULL = PTR_MAYBE_NULL | RET_PTR_TO_BTF_ID, RET_PTR_TO_BTF_ID_TRUSTED = PTR_TRUSTED | RET_PTR_TO_BTF_ID, +#ifdef CONFIG_KABI_RESERVE + BPF_RET_TYPE_RESERVE_1, + BPF_RET_TYPE_RESERVE_2, + BPF_RET_TYPE_RESERVE_3, + BPF_RET_TYPE_RESERVE_4, +#endif + /* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */ @@ -807,6 +839,9 @@ struct bpf_func_proto { }; int *ret_btf_id; /* return value btf_id */ bool (*allowed)(const struct bpf_prog *prog); + + KABI_RESERVE(1) + KABI_RESERVE(2) }; /* bpf_context is intentionally undefined structure. Pointer to bpf_context is @@ -875,6 +910,13 @@ enum bpf_reg_type { PTR_TO_TCP_SOCK_OR_NULL = PTR_MAYBE_NULL | PTR_TO_TCP_SOCK, PTR_TO_BTF_ID_OR_NULL = PTR_MAYBE_NULL | PTR_TO_BTF_ID, +#ifdef CONFIG_KABI_RESERVE + BPF_REG_TYPE_RESERVE_1, + BPF_REG_TYPE_RESERVE_2, + BPF_REG_TYPE_RESERVE_3, + BPF_REG_TYPE_RESERVE_4, +#endif + /* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */ @@ -895,6 +937,9 @@ struct bpf_insn_access_aux { }; }; struct bpf_verifier_log *log; /* for verbose logs */ + + KABI_RESERVE(1) + KABI_RESERVE(2) }; static inline void @@ -942,6 +987,11 @@ struct bpf_verifier_ops { int (*btf_struct_access)(struct bpf_verifier_log *log, const struct bpf_reg_state *reg, int off, int size); + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; struct bpf_prog_offload_ops { @@ -1121,6 +1171,9 @@ struct bpf_tramp_image { struct rcu_head rcu; struct work_struct work; }; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_trampoline { @@ -1149,6 +1202,11 @@ struct bpf_trampoline { /* Executable image of trampoline */ struct bpf_tramp_image *cur_image; struct module *mod; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; struct bpf_attach_target_info { @@ -1180,6 +1238,11 @@ struct bpf_dispatcher { struct static_call_key *sc_key; void *sc_tramp; #endif + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func( @@ -1339,6 +1402,9 @@ static inline bool bpf_prog_has_trampoline(const struct bpf_prog *prog) struct bpf_func_info_aux { u16 linkage; bool unreliable; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; enum bpf_jit_poke_reason { @@ -1361,6 +1427,9 @@ struct bpf_jit_poke_descriptor { u8 adj_off; u16 reason; u32 insn_idx; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; /* reg_type info for ctx arguments */ @@ -1368,6 +1437,9 @@ struct bpf_ctx_arg_aux { u32 offset; enum bpf_reg_type reg_type; u32 btf_id; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct btf_mod_pair { @@ -1465,6 +1537,15 @@ struct bpf_prog_aux { struct work_struct work; struct rcu_head rcu; }; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) + KABI_RESERVE(5) + KABI_RESERVE(6) + KABI_RESERVE(7) + KABI_RESERVE(8) }; struct bpf_prog { @@ -1499,6 +1580,11 @@ struct bpf_prog { DECLARE_FLEX_ARRAY(struct sock_filter, insns); DECLARE_FLEX_ARRAY(struct bpf_insn, insnsi); }; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; struct bpf_array_aux { @@ -1507,6 +1593,9 @@ struct bpf_array_aux { struct bpf_map *map; struct mutex poke_mutex; struct work_struct work; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_link { @@ -1516,6 +1605,9 @@ struct bpf_link { const struct bpf_link_ops *ops; struct bpf_prog *prog; struct work_struct work; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_link_ops { @@ -1529,12 +1621,18 @@ struct bpf_link_ops { struct bpf_link_info *info); int (*update_map)(struct bpf_link *link, struct bpf_map *new_map, struct bpf_map *old_map); + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_tramp_link { struct bpf_link link; struct hlist_node tramp_hlist; u64 cookie; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_shim_tramp_link { @@ -1554,6 +1652,9 @@ struct bpf_link_primer { struct file *file; int fd; u32 id; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_struct_ops_value; @@ -1626,6 +1727,11 @@ struct bpf_struct_ops { struct btf_func_model func_models[BPF_STRUCT_OPS_MAX_NR_MEMBERS]; u32 type_id; u32 value_id; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; #if defined(CONFIG_BPF_JIT) && defined(CONFIG_BPF_SYSCALL) @@ -1727,6 +1833,9 @@ struct bpf_array { DECLARE_FLEX_ARRAY(void *, ptrs) __aligned(8); DECLARE_FLEX_ARRAY(void __percpu *, pptrs) __aligned(8); }; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; #define BPF_COMPLEXITY_LIMIT_INSNS 1000000 /* yes. 1M insns */ @@ -2222,6 +2331,9 @@ struct bpf_iter_aux_info { enum bpf_iter_task_type type; u32 pid; } task; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog, @@ -2252,6 +2364,9 @@ struct bpf_iter_reg { u32 feature; struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX]; const struct bpf_iter_seq_info *seq_info; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct bpf_iter_meta { diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h index b6e58dab8e27..78ad34886e17 100644 --- a/include/linux/bpf_verifier.h +++ b/include/linux/bpf_verifier.h @@ -8,6 +8,7 @@ #include <linux/btf.h> /* for struct btf and btf_id() */ #include <linux/filter.h> /* for MAX_BPF_STACK */ #include <linux/tnum.h> +#include <linux/kabi.h> /* Maximum variable offset umax_value permitted when resolving memory accesses. * In practice this is far bigger than any realistic pointer offset; this limit @@ -225,6 +226,11 @@ struct bpf_reg_state { enum bpf_reg_liveness live; /* if (!precise && SCALAR_VALUE) min/max/tnum don't affect safety */ bool precise; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; enum bpf_stack_slot_type { @@ -273,6 +279,11 @@ struct bpf_reference_state { * exiting a callback function. */ int callback_ref; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; /* state of the program: @@ -306,6 +317,11 @@ struct bpf_func_state { struct bpf_reference_state *refs; int allocated_stack; struct bpf_stack_state *stack; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; struct bpf_idx_pair { @@ -383,6 +399,11 @@ struct bpf_verifier_state { */ struct bpf_idx_pair *jmp_history; u32 jmp_history_cnt; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; #define bpf_get_spilled_reg(slot, frame) \ @@ -490,6 +511,11 @@ struct bpf_insn_aux_data { * this instruction, regardless of any heuristics */ bool force_checkpoint; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; #define MAX_USED_MAPS 64 /* max number of maps accessed by one eBPF program */ @@ -541,6 +567,11 @@ struct bpf_subprog_info { bool tail_call_reachable; bool has_ld_abs; bool is_async_cb; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; struct bpf_verifier_env; @@ -640,6 +671,11 @@ struct bpf_verifier_env { * e.g., in reg_type_str() to generate reg_type string */ char tmp_str_buf[TMP_STR_BUF_LEN]; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; __printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log, diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 4924f0cde1bc..d0171d5461a5 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -944,6 +944,10 @@ enum bpf_map_type { BPF_MAP_TYPE_BLOOM_FILTER, BPF_MAP_TYPE_USER_RINGBUF, BPF_MAP_TYPE_CGRP_STORAGE, + BPF_MAP_TYPE_RESERVE_1, + BPF_MAP_TYPE_RESERVE_2, + BPF_MAP_TYPE_RESERVE_3, + BPF_MAP_TYPE_RESERVE_4, }; /* Note that tracing related programs such as @@ -988,6 +992,10 @@ enum bpf_prog_type { BPF_PROG_TYPE_SK_LOOKUP, BPF_PROG_TYPE_SYSCALL, /* a program that can execute syscalls */ BPF_PROG_TYPE_NETFILTER, + BPF_PROG_TYPE_RESERVE_1, + BPF_PROG_TYPE_RESERVE_2, + BPF_PROG_TYPE_RESERVE_3, + BPF_PROG_TYPE_RESERVE_4, }; enum bpf_attach_type { @@ -1040,6 +1048,10 @@ enum bpf_attach_type { BPF_TCX_INGRESS, BPF_TCX_EGRESS, BPF_TRACE_UPROBE_MULTI, + BPF_ATTACH_TYPE_RESERVE_1, + BPF_ATTACH_TYPE_RESERVE_2, + BPF_ATTACH_TYPE_RESERVE_3, + BPF_ATTACH_TYPE_RESERVE_4, __MAX_BPF_ATTACH_TYPE }; @@ -1059,6 +1071,10 @@ enum bpf_link_type { BPF_LINK_TYPE_NETFILTER = 10, BPF_LINK_TYPE_TCX = 11, BPF_LINK_TYPE_UPROBE_MULTI = 12, + BPF_LINK_TYPE_RESERVE_1 = 13, + BPF_LINK_TYPE_RESERVE_2 = 14, + BPF_LINK_TYPE_RESERVE_3 = 15, + BPF_LINK_TYPE_RESERVE_4 = 16, MAX_BPF_LINK_TYPE, }; -- 2.34.1

1 0

[PATCH V4 OLK-6.6 0/8] Spark SQL scenario bpf readahead optimization synchronization to OLK-6.6
by ZhaoLong Wang 09 Jan '24

09 Jan '24

CONFIG: CONFIG_DEBUG_INFO_BTF=y CONFIG_BPF_SYSCALL=y CONFIG_NF_CONNTRACK=y CONFIG_NF_CONNTRACK_MARK=y V2: - Using helpers function, such as i_size_read(), round_up - Fix commit log Signature - Fix the user-mode test program V3 - Do not use the round_up helper function. Use the correct calculation - err = -errno before printf V4 - Drop the "Conflict" in the commit log. Hou Tao (5): vfs: add bare tracepoints for vfs read and release fs: add helper fs_file_read_do_trace() xfs: add trace for read and release of regular file ext4: add trace for the read and release of regular file selftests/bpf: add demo for file read pattern detection Yufen Yu (1): readahead: introduce FMODE_CTL_WILLNEED to read first 2MB of file ZhaoLong Wang (2): VFS: Rolling Back the fmode macro definition and structure members selftests/bpf: Update the demo file_read_pattern to run on libbpf 1.0+ fs/ext4/file.c | 4 + fs/read_write.c | 38 +++++ fs/xfs/xfs_file.c | 3 + include/linux/fs.h | 37 +++++ include/trace/events/fs.h | 33 +++++ mm/readahead.c | 40 ++++- tools/testing/selftests/bpf/Makefile | 1 + .../testing/selftests/bpf/file_read_pattern.c | 76 ++++++++++ .../bpf/progs/file_read_pattern_prog.c | 137 ++++++++++++++++++ 9 files changed, 368 insertions(+), 1 deletion(-) create mode 100644 include/trace/events/fs.h create mode 100644 tools/testing/selftests/bpf/file_read_pattern.c create mode 100644 tools/testing/selftests/bpf/progs/file_read_pattern_prog.c -- 2.39.2

1 8

[PATCH OLK-6.6 0/1] arm64: Add non nmi ipi backtrace support
by Liao Chen 09 Jan '24

09 Jan '24

Dependencies: CONFIG_DETECT_HUNG_TASK=y CONFIG_WATCHDOG=y Li Zhengyu (1): arm64: Add non nmi ipi backtrace support arch/arm64/Kconfig | 8 +++++ arch/arm64/configs/openeuler_defconfig | 1 + arch/arm64/kernel/ipi_nmi.c | 41 ++++++++++++++++++++++---- 3 files changed, 45 insertions(+), 5 deletions(-) -- 2.34.1

1 1

[PATCH OLK-6.6] kabi: Reserve space for perf subsystem related structures
by Yang Jihong 09 Jan '24

09 Jan '24

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I8UOCZ -------------------------------- Reserve kabi space for `struct pmu`, `struct perf_event`, `struct perf_event_context`, `struct perf_cgroup_info` and `struct perf_sample_data`. Signed-off-by: Yang Jihong <yangjihong1(a)huawei.com> --- include/linux/perf_event.h | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h index e846f87e2d09..a24aa95de1fc 100644 --- a/include/linux/perf_event.h +++ b/include/linux/perf_event.h @@ -62,6 +62,7 @@ struct perf_guest_info_callbacks { #include <linux/security.h> #include <linux/static_call.h> #include <linux/lockdep.h> +#include <linux/kabi.h> #include <asm/local.h> struct perf_callchain_entry { @@ -324,6 +325,11 @@ struct pmu { /* number of address filters this PMU can do */ unsigned int nr_addr_filters; + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) + /* * Fully disable/enable this PMU, can be used to protect from the PMI * as well as for lazy/batch writing of the MSRs. @@ -540,6 +546,11 @@ struct pmu { * Check period value for PERF_EVENT_IOC_PERIOD ioctl. */ int (*check_period) (struct perf_event *event, u64 value); /* optional */ + + KABI_RESERVE(5) + KABI_RESERVE(6) + KABI_RESERVE(7) + KABI_RESERVE(8) }; enum perf_addr_filter_action_t { @@ -839,6 +850,13 @@ struct perf_event { * user. */ __u32 orig_type; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) + KABI_RESERVE(5) + KABI_RESERVE(6) #endif /* CONFIG_PERF_EVENTS */ }; @@ -965,6 +983,11 @@ struct perf_event_context { * that until the signal is delivered. */ local_t nr_pending; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) }; /* @@ -1040,6 +1063,9 @@ struct perf_cgroup_info { u64 timestamp; u64 timeoffset; int active; + + KABI_RESERVE(1) + KABI_RESERVE(2) }; struct perf_cgroup { @@ -1192,6 +1218,11 @@ struct perf_sample_data { u64 data_page_size; u64 code_page_size; u64 aux_size; + + KABI_RESERVE(1) + KABI_RESERVE(2) + KABI_RESERVE(3) + KABI_RESERVE(4) } ____cacheline_aligned; /* default value for data source */ -- 2.34.1

1 0

[PATCH OLK-6.6 V1 00/12] infrastructure for scheduler bpf
by Guan Jing 09 Jan '24

09 Jan '24

infrastructure for scheduler bpf Guan Jing (12): sched: programmable: Introduce bpf sched sched: programmable: Add a tag for the task sched: programmable: Add a tag for the task group sched: programmable: Add user interface of task group tag sched: programmable: Add user interface of task tag sched: basic infrastructure for scheduler bpf sched: introduce bpf_sched_enable() libbpf: add support for scheduler bpf programs bpftool: recognize scheduler programs sched: Add helper functions to get cpu statistics sched: programmable: Add hook in select_task_rq_fair() sched: programmable: Add hook in can_migrate_task() arch/arm64/configs/openeuler_defconfig | 1 + arch/x86/configs/openeuler_defconfig | 1 + fs/proc/base.c | 64 ++++++++++++++ include/linux/bpf_sched.h | 50 +++++++++++ include/linux/bpf_types.h | 4 + include/linux/sched.h | 38 ++++++++ include/linux/sched_hook_defs.h | 4 + include/uapi/linux/bpf.h | 9 ++ init/init_task.c | 3 + kernel/bpf/Kconfig | 12 +++ kernel/bpf/btf.c | 1 + kernel/bpf/syscall.c | 27 ++++++ kernel/bpf/trampoline.c | 1 + kernel/bpf/verifier.c | 11 ++- kernel/sched/bpf_sched.c | 102 +++++++++++++++++++++ kernel/sched/build_utility.c | 4 + kernel/sched/core.c | 118 +++++++++++++++++++++++++ kernel/sched/fair.c | 45 ++++++++++ kernel/sched/sched.h | 10 +++ scripts/bpf_doc.py | 4 + tools/include/uapi/linux/bpf.h | 9 ++ tools/lib/bpf/bpf.c | 1 + tools/lib/bpf/libbpf.c | 23 ++++- tools/lib/bpf/libbpf.h | 2 + tools/lib/bpf/libbpf.map | 1 + 25 files changed, 543 insertions(+), 2 deletions(-) create mode 100644 include/linux/bpf_sched.h create mode 100644 include/linux/sched_hook_defs.h create mode 100644 kernel/sched/bpf_sched.c -- 2.34.1

1 12

[PATCH V3 OLK-6.6] fs/dirty_pages: dump the number of dirty pages for each inode
by Zizhi Wo 09 Jan '24

09 Jan '24

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I8OHM4?from=project-issue CVE: NA ---------------------------------------- In order to analyse the IO performance when using buffer IO, it's useful to obtain the number of dirty pages for each inode in the filesystem. This feature depends on 'CONFIG_DIRTY_PAGES'. It creates 3 interfaces by using procfs. /proc/dirty/buffer_size for buffer allocation and release, /proc/dirty/page_threshold to filter result and /proc/dirty/dirty_list to get dirty pages. Signed-off-by: Zizhi Wo <wozizhi(a)huawei.com> --- arch/arm64/configs/openeuler_defconfig | 1 + arch/x86/configs/openeuler_defconfig | 1 + fs/Kconfig | 13 + fs/Makefile | 1 + fs/dirty_pages.c | 355 +++++++++++++++++++++++++ 5 files changed, 371 insertions(+) create mode 100644 fs/dirty_pages.c diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index 66737e8c8673..677b4cc4668a 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -6924,6 +6924,7 @@ CONFIG_PROC_PAGE_MONITOR=y CONFIG_PROC_CHILDREN=y CONFIG_KERNFS=y CONFIG_SYSFS=y +CONFIG_DIRTY_PAGES=y CONFIG_TMPFS=y CONFIG_TMPFS_POSIX_ACL=y CONFIG_TMPFS_XATTR=y diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig index fcbef6c06587..c16cdb7b2596 100644 --- a/arch/x86/configs/openeuler_defconfig +++ b/arch/x86/configs/openeuler_defconfig @@ -8120,6 +8120,7 @@ CONFIG_PROC_PID_ARCH_STATUS=y CONFIG_PROC_CPU_RESCTRL=y CONFIG_KERNFS=y CONFIG_SYSFS=y +CONFIG_DIRTY_PAGES=y CONFIG_TMPFS=y CONFIG_TMPFS_POSIX_ACL=y CONFIG_TMPFS_XATTR=y diff --git a/fs/Kconfig b/fs/Kconfig index 7c9d45ba9b0f..6dc83223c61b 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -170,6 +170,19 @@ source "fs/proc/Kconfig" source "fs/kernfs/Kconfig" source "fs/sysfs/Kconfig" +config DIRTY_PAGES + bool "Dumps the number of dirty pages of each file" + depends on PROC_FS + default y + help + This config supports the rendering of dirty page data to the user, + which may be useful to analyze the IO performance when using buffer + IO. + + It create 3 interfaces by using procfs. /proc/dirty/buffer_size for + buffer allocation and release; /proc/dirty/page_threshold to filter + result; /proc/dirty/dirty_list to get dirty pages. + config TMPFS bool "Tmpfs virtual memory file system support (former shm fs)" depends on SHMEM diff --git a/fs/Makefile b/fs/Makefile index bb6164200a39..cc4735c23c32 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -44,6 +44,7 @@ obj-$(CONFIG_FS_POSIX_ACL) += posix_acl.o obj-$(CONFIG_NFS_COMMON) += nfs_common/ obj-$(CONFIG_COREDUMP) += coredump.o obj-$(CONFIG_SYSCTL) += drop_caches.o sysctls.o +obj-$(CONFIG_DIRTY_PAGES) += dirty_pages.o obj-$(CONFIG_FHANDLE) += fhandle.o obj-$(CONFIG_CGROUP_FILES) += filescontrol.o diff --git a/fs/dirty_pages.c b/fs/dirty_pages.c new file mode 100644 index 000000000000..d0aea022b68b --- /dev/null +++ b/fs/dirty_pages.c @@ -0,0 +1,355 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/uaccess.h> +#include <linux/pagemap.h> +#include <linux/pagevec.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/sched.h> +#include <linux/proc_fs.h> +#include <linux/kdev_t.h> +#include <linux/vmalloc.h> +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include "internal.h" + +#define DIRTY_ROOT "dirty" /* proc root directory name */ +#define DIRTY_BUFFER_SIZE "buffer_size" /* proc file to control buffer */ +#define DIRTY_PAGES "dirty_list" /* proc file to obtain diry pages */ +#define DIRTY_LIMIT "page_threshold" /* proc file to filter result */ +#define MAX_BUF_NUM 102400 /* max buffer num in number of pages */ +#define TERM_STR "terminated\n" /* tail string for overflowed buffer */ +#define UNKNOW_STR "unknown" /* for unknown file name or fs type */ + +static char *buf_dirty; /* buffer to store number of dirty pages */ +static unsigned long buf_size; /* size of buffer in bytes */ +static unsigned long buf_num; /* size of buffer in number of pages */ +static unsigned long buf_limit; /* filter threshold of dirty pages */ +unsigned long lock_word; /* for exclusive access to buffer */ + +static bool dirty_pages_lock(void) +{ + if (xchg(&lock_word, 1) == 1) + return false; + return true; +} + +static void dirty_pages_unlock(void) +{ + lock_word = 0; +} + +static unsigned long dump_dirtypages_inode(struct inode *inode) +{ + XA_STATE(xas, &inode->i_mapping->i_pages, 0); + unsigned long pages = 0; + void *page; + + if (!mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) + return 0; + + xas_lock_irq(&xas); + xas_for_each_marked(&xas, page, (pgoff_t)-1, PAGECACHE_TAG_DIRTY) { + if (++pages % XA_CHECK_SCHED) + continue; + + xas_pause(&xas); + xas_unlock_irq(&xas); + cond_resched(); + xas_lock_irq(&xas); + } + xas_unlock_irq(&xas); + + return pages; +} + +static char *inode_filename(struct inode *inode) +{ + char *path; + static char buf[PATH_MAX]; + struct dentry *dentry; + + dentry = d_find_alias(inode); + if (!dentry) + return UNKNOW_STR; + + path = dentry_path_raw(dentry, buf, PATH_MAX); + dput(dentry); + + return IS_ERR_OR_NULL(path) ? UNKNOW_STR : path; +} + +static const char *sb_fstype(struct super_block *sb) +{ + if (sb->s_type && sb->s_type->name) + return sb->s_type->name; + else + return UNKNOW_STR; +} + +static inline bool is_sb_writable(struct super_block *sb) +{ + if (sb_rdonly(sb)) + return false; + + if (sb->s_writers.frozen == SB_FREEZE_COMPLETE) + return false; + + return true; +} + +/* + * dump_dirtypages_sb - dump the dirty pages of each inode in the sb + * @sb the super block + * @m the seq_file witch is initialized in proc_dpages_open + * + * For each inode in the sb, call dump_dirtypages_pages to get the number + * of dirty pages. And use seq_printf to store the result in the buffer + * if it's not less than the threshold. The inode in unusual state will + * be skipped. + */ +static void dump_dirtypages_sb(struct super_block *sb, struct seq_file *m) +{ + struct inode *inode, *toput_inode = NULL; + unsigned long limit; + + if (!is_sb_writable(sb) || !sb->s_bdev) + return; + + limit = READ_ONCE(buf_limit); + spin_lock(&sb->s_inode_list_lock); + list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { + unsigned long dirty_pages; + + spin_lock(&inode->i_lock); + if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) { + spin_unlock(&inode->i_lock); + continue; + } + + __iget(inode); + spin_unlock(&inode->i_lock); + spin_unlock(&sb->s_inode_list_lock); + + dirty_pages = dump_dirtypages_inode(inode); + if (!dirty_pages || dirty_pages < limit) + goto skip; + + seq_printf(m, "FSType: %s, Dev ID: %u(%u:%u) ino %lu, dirty pages %lu, path %s\n", + sb_fstype(sb), sb->s_dev, MAJOR(sb->s_dev), + MINOR(sb->s_dev), inode->i_ino, dirty_pages, + inode_filename(inode)); + + if (seq_has_overflowed(m)) { + /* keep size > count to avoid overflow in seq_read_iter() */ + m->size += strlen(TERM_STR) + 1; + seq_puts(m, TERM_STR); + iput(inode); + iput(toput_inode); + return; + } +skip: + iput(toput_inode); + toput_inode = inode; + cond_resched(); + spin_lock(&sb->s_inode_list_lock); + } + spin_unlock(&sb->s_inode_list_lock); + iput(toput_inode); +} + +static int proc_dpages_show(struct seq_file *m, void *v) +{ + iterate_supers((void *)dump_dirtypages_sb, (void *)m); + return 0; +} + +static int proc_dpages_open(struct inode *inode, struct file *filp) +{ + int ret; + struct seq_file *m; + + if (!dirty_pages_lock()) + return -EBUSY; + + if (buf_dirty == NULL || buf_size == 0) { + pr_warn("please allocate buffer before getting dirty pages\n"); + dirty_pages_unlock(); + return -ENOMEM; + } + + ret = single_open(filp, proc_dpages_show, NULL); + if (ret) { + dirty_pages_unlock(); + return ret; + } + + m = (struct seq_file *)filp->private_data; + memset(buf_dirty, 0, buf_size); + m->size = buf_size - (strlen(TERM_STR) + 1); + m->buf = buf_dirty; + + return 0; +} + +static int proc_dpages_release(struct inode *inode, struct file *file) +{ + struct seq_file *m = file->private_data; + + /* we don't want to free the buf */ + m->buf = NULL; + dirty_pages_unlock(); + return single_release(inode, file); +} + +static void free_buf_dirty(void) +{ + if (!buf_dirty) + return; + + vfree(buf_dirty); + buf_dirty = NULL; + buf_size = 0; + WRITE_ONCE(buf_num, 0); +} + +static int proc_buffer_show(struct seq_file *m, void *v) +{ + seq_printf(m, "%lu\n", READ_ONCE(buf_num)); + return 0; +} + +static int proc_buffer_open(struct inode *inode, struct file *filp) +{ + int ret; + + if (((filp->f_flags & O_ACCMODE) != O_RDONLY) && !dirty_pages_lock()) + return -EBUSY; + + ret = single_open(filp, proc_buffer_show, NULL); + if (ret) + dirty_pages_unlock(); + + return ret; +} + +static ssize_t proc_buffer_write(struct file *filp, const char __user *buf, + size_t count, loff_t *offp) +{ + int ret; + unsigned long new_buf_num, new_buf_size; + char *new_buf_dirty; + + ret = kstrtoul_from_user(buf, count, 10, &new_buf_num); + if (ret != 0 || new_buf_num > MAX_BUF_NUM) + return -EINVAL; + + if (new_buf_num == buf_num) + return count; + + if (new_buf_num == 0) { + free_buf_dirty(); + return count; + } + + new_buf_size = PAGE_SIZE * new_buf_num; + new_buf_dirty = vzalloc(new_buf_size); + if (!new_buf_dirty) + return -ENOMEM; + + free_buf_dirty(); + buf_dirty = new_buf_dirty; + buf_size = new_buf_size; + WRITE_ONCE(buf_num, new_buf_num); + + return count; +} + +static int proc_buffer_release(struct inode *inode, struct file *filp) +{ + if ((filp->f_flags & O_ACCMODE) != O_RDONLY) + dirty_pages_unlock(); + return single_release(inode, filp); +} + +static int proc_limit_show(struct seq_file *m, void *v) +{ + seq_printf(m, "%lu\n", READ_ONCE(buf_limit)); + return 0; +} + +static int proc_limit_open(struct inode *inode, struct file *filp) +{ + return single_open(filp, proc_limit_show, NULL); +} + +static ssize_t proc_limit_write(struct file *filp, const char __user *buf, + size_t count, loff_t *offp) +{ + int ret; + unsigned long limit; + + ret = kstrtoul_from_user(buf, count, 10, &limit); + if (ret != 0) + return ret; + + WRITE_ONCE(buf_limit, limit); + + return count; +} + +static const struct proc_ops proc_dpages_operations = { + .proc_open = proc_dpages_open, + .proc_read = seq_read, + .proc_release = proc_dpages_release, +}; + +static const struct proc_ops proc_buffer_operations = { + .proc_open = proc_buffer_open, + .proc_read = seq_read, + .proc_write = proc_buffer_write, + .proc_lseek = seq_lseek, + .proc_release = proc_buffer_release, +}; + +static const struct proc_ops proc_limit_operations = { + .proc_open = proc_limit_open, + .proc_read = seq_read, + .proc_write = proc_limit_write, + .proc_lseek = seq_lseek, + .proc_release = single_release, +}; + +static int __init dpages_proc_init(void) +{ + struct proc_dir_entry *dirty_dir; + + dirty_dir = proc_mkdir(DIRTY_ROOT, NULL); + if (!dirty_dir) + return -ENOMEM; + + if (!proc_create(DIRTY_PAGES, 0440, dirty_dir, &proc_dpages_operations)) + goto fail_pages; + + if (!proc_create(DIRTY_BUFFER_SIZE, 0640, dirty_dir, + &proc_buffer_operations)) + goto fail_switch; + + if (!proc_create(DIRTY_LIMIT, 0640, dirty_dir, &proc_limit_operations)) + goto fail_limit; + + return 0; + +fail_limit: + remove_proc_entry(DIRTY_BUFFER_SIZE, dirty_dir); +fail_switch: + remove_proc_entry(DIRTY_PAGES, dirty_dir); +fail_pages: + remove_proc_entry(DIRTY_ROOT, NULL); + return -ENOMEM; +} + +subsys_initcall(dpages_proc_init); -- 2.39.2

1 0

[PATCH OLK-6.6] fs/dirty_pages: dump the number of dirty pages for each inode
by Zizhi Wo 09 Jan '24

09 Jan '24

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I8OHM4?from=project-issue CVE: NA ---------------------------------------- In order to analyse the IO performance when using buffer IO, it's useful to obtain the number of dirty pages for each inode in the filesystem. This feature depends on 'CONFIG_DIRTY_PAGES'. It creates 3 interfaces by using procfs. /proc/dirty/buffer_size for buffer allocation and release, /proc/dirty/page_threshold to filter result and /proc/dirty/dirty_list to get dirty pages. Signed-off-by: Zizhi Wo <wozizhi(a)huawei.com> --- arch/arm64/configs/openeuler_defconfig | 1 + arch/x86/configs/openeuler_defconfig | 1 + fs/Kconfig | 13 + fs/Makefile | 1 + fs/dirty_pages.c | 350 +++++++++++++++++++++++++ 5 files changed, 366 insertions(+) create mode 100644 fs/dirty_pages.c diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index 66737e8c8673..677b4cc4668a 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -6924,6 +6924,7 @@ CONFIG_PROC_PAGE_MONITOR=y CONFIG_PROC_CHILDREN=y CONFIG_KERNFS=y CONFIG_SYSFS=y +CONFIG_DIRTY_PAGES=y CONFIG_TMPFS=y CONFIG_TMPFS_POSIX_ACL=y CONFIG_TMPFS_XATTR=y diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig index fcbef6c06587..c16cdb7b2596 100644 --- a/arch/x86/configs/openeuler_defconfig +++ b/arch/x86/configs/openeuler_defconfig @@ -8120,6 +8120,7 @@ CONFIG_PROC_PID_ARCH_STATUS=y CONFIG_PROC_CPU_RESCTRL=y CONFIG_KERNFS=y CONFIG_SYSFS=y +CONFIG_DIRTY_PAGES=y CONFIG_TMPFS=y CONFIG_TMPFS_POSIX_ACL=y CONFIG_TMPFS_XATTR=y diff --git a/fs/Kconfig b/fs/Kconfig index 7c9d45ba9b0f..6dc83223c61b 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -170,6 +170,19 @@ source "fs/proc/Kconfig" source "fs/kernfs/Kconfig" source "fs/sysfs/Kconfig" +config DIRTY_PAGES + bool "Dumps the number of dirty pages of each file" + depends on PROC_FS + default y + help + This config supports the rendering of dirty page data to the user, + which may be useful to analyze the IO performance when using buffer + IO. + + It create 3 interfaces by using procfs. /proc/dirty/buffer_size for + buffer allocation and release; /proc/dirty/page_threshold to filter + result; /proc/dirty/dirty_list to get dirty pages. + config TMPFS bool "Tmpfs virtual memory file system support (former shm fs)" depends on SHMEM diff --git a/fs/Makefile b/fs/Makefile index bb6164200a39..cc4735c23c32 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -44,6 +44,7 @@ obj-$(CONFIG_FS_POSIX_ACL) += posix_acl.o obj-$(CONFIG_NFS_COMMON) += nfs_common/ obj-$(CONFIG_COREDUMP) += coredump.o obj-$(CONFIG_SYSCTL) += drop_caches.o sysctls.o +obj-$(CONFIG_DIRTY_PAGES) += dirty_pages.o obj-$(CONFIG_FHANDLE) += fhandle.o obj-$(CONFIG_CGROUP_FILES) += filescontrol.o diff --git a/fs/dirty_pages.c b/fs/dirty_pages.c new file mode 100644 index 000000000000..209a76a6aa46 --- /dev/null +++ b/fs/dirty_pages.c @@ -0,0 +1,350 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/uaccess.h> +#include <linux/pagemap.h> +#include <linux/pagevec.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/sched.h> +#include <linux/proc_fs.h> +#include <linux/kdev_t.h> +#include <linux/vmalloc.h> +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include "internal.h" + +#define DIRTY_ROOT "dirty" /* proc root directory name */ +#define DIRTY_BUFFER_SIZE "buffer_size" /* proc file to control buffer */ +#define DIRTY_PAGES "dirty_list" /* proc file to obtain diry pages */ +#define DIRTY_LIMIT "page_threshold" /* proc file to filter result */ +#define MAX_BUF_NUM 102400 /* max buffer num in number of pages */ +#define TERM_STR "terminated\n" /* tail string for overflowed buffer */ +#define UNKNOW_STR "unknown" /* for unknown file name or fs type */ + +static char *buf_dirty; /* buffer to store number of dirty pages */ +static unsigned long buf_size; /* size of buffer in bytes */ +static unsigned long buf_num; /* size of buffer in number of pages */ +static unsigned long buf_limit; /* filter threshold of dirty pages */ +unsigned long lock_word; /* for exclusive access to buffer */ + +static bool dirty_pages_lock(void) +{ + if (xchg(&lock_word, 1) == 1) + return false; + return true; +} + +static void dirty_pages_unlock(void) +{ + lock_word = 0; +} + +static unsigned long dump_dirtypages_inode(struct inode *inode) +{ + XA_STATE(xas, &inode->i_mapping->i_pages, 0); + unsigned long pages = 0; + void *page; + + if (!mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) + return 0; + + xas_lock_irq(&xas); + xas_for_each_marked(&xas, page, (pgoff_t)-1, PAGECACHE_TAG_DIRTY) { + if (++pages % XA_CHECK_SCHED) + continue; + + xas_pause(&xas); + xas_unlock_irq(&xas); + cond_resched(); + xas_lock_irq(&xas); + } + xas_unlock_irq(&xas); + + return pages; +} + +static char *inode_filename(struct inode *inode) +{ + char *path; + static char buf[PATH_MAX]; + struct dentry *dentry = d_find_alias(inode); + + if (!dentry) + return UNKNOW_STR; + + path = dentry_path_raw(dentry, buf, PATH_MAX); + dput(dentry); + + return IS_ERR_OR_NULL(path) ? UNKNOW_STR : path; +} + +static const char *sb_fstype(struct super_block *sb) +{ + if (sb->s_type && sb->s_type->name) + return sb->s_type->name; + else + return UNKNOW_STR; +} + +static inline bool is_sb_writable(struct super_block *sb) +{ + if (sb_rdonly(sb)) + return false; + + if (sb->s_writers.frozen == SB_FREEZE_COMPLETE) + return false; + + return true; +} + +/* + * dump_dirtypages_sb - dump the dirty pages of each inode in the sb + * @sb the super block + * @m the seq_file witch is initialized in proc_dpages_open + * + * For each inode in the sb, call dump_dirtypages_pages to get the number + * of dirty pages. And use seq_printf to store the result in the buffer + * if it's not less than the threshold. The inode in unusual state will + * be skipped. + */ +static void dump_dirtypages_sb(struct super_block *sb, struct seq_file *m) +{ + struct inode *inode, *toput_inode = NULL; + unsigned long limit = READ_ONCE(buf_limit); + + if (!is_sb_writable(sb) || !sb->s_bdev) + return; + + spin_lock(&sb->s_inode_list_lock); + list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { + unsigned long dirty_pages; + + spin_lock(&inode->i_lock); + if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) { + spin_unlock(&inode->i_lock); + continue; + } + + __iget(inode); + spin_unlock(&inode->i_lock); + spin_unlock(&sb->s_inode_list_lock); + + dirty_pages = dump_dirtypages_inode(inode); + if (!dirty_pages || dirty_pages < limit) + goto skip; + + seq_printf(m, "FSType: %s, Dev ID: %u(%u:%u) ino %lu, dirty pages %lu, path %s\n", + sb_fstype(sb), sb->s_dev, MAJOR(sb->s_dev), + MINOR(sb->s_dev), inode->i_ino, dirty_pages, + inode_filename(inode)); + + if (seq_has_overflowed(m)) { + /* keep size > count to avoid overflow in seq_read_iter() */ + m->size += strlen(TERM_STR) + 1; + seq_puts(m, TERM_STR); + iput(inode); + iput(toput_inode); + return; + } +skip: + iput(toput_inode); + toput_inode = inode; + cond_resched(); + spin_lock(&sb->s_inode_list_lock); + } + spin_unlock(&sb->s_inode_list_lock); + iput(toput_inode); +} + +static int proc_dpages_show(struct seq_file *m, void *v) +{ + iterate_supers((void *)dump_dirtypages_sb, (void *)m); + return 0; +} + +static int proc_dpages_open(struct inode *inode, struct file *filp) +{ + int ret; + struct seq_file *m; + + if (!dirty_pages_lock()) + return -EBUSY; + + if (buf_dirty == NULL || buf_size == 0) { + pr_warn("please allocate buffer before getting dirty pages\n"); + dirty_pages_unlock(); + return -ENOMEM; + } + + ret = single_open(filp, proc_dpages_show, NULL); + if (ret) { + dirty_pages_unlock(); + return ret; + } + + m = (struct seq_file *)filp->private_data; + memset(buf_dirty, 0, buf_size); + m->size = buf_size - (strlen(TERM_STR) + 1); + m->buf = buf_dirty; + + return 0; +} + +static int proc_dpages_release(struct inode *inode, struct file *file) +{ + struct seq_file *m = file->private_data; + + /* we don't want to free the buf */ + m->buf = NULL; + dirty_pages_unlock(); + return single_release(inode, file); +} + +static void free_buf_dirty(void) +{ + if (!buf_dirty) + return; + + vfree(buf_dirty); + buf_dirty = NULL; + buf_size = 0; + WRITE_ONCE(buf_num, 0); +} + +static int proc_buffer_show(struct seq_file *m, void *v) +{ + seq_printf(m, "%lu\n", READ_ONCE(buf_num)); + return 0; +} + +static int proc_buffer_open(struct inode *inode, struct file *filp) +{ + int ret; + + if (((filp->f_flags & O_ACCMODE) != O_RDONLY) && !dirty_pages_lock()) + return -EBUSY; + + ret = single_open(filp, proc_buffer_show, NULL); + if (ret) + dirty_pages_unlock(); + + return ret; +} + +static ssize_t proc_buffer_write(struct file *filp, const char *buf, size_t count, + loff_t *offp) +{ + unsigned long new_buf_num, new_buf_size; + char *new_buf_dirty; + int ret = kstrtoul_from_user(buf, count, 10, &new_buf_num); + + if (ret != 0 || new_buf_num > MAX_BUF_NUM) + return -EINVAL; + + if (new_buf_num == buf_num) + return count; + + if (new_buf_num == 0) { + free_buf_dirty(); + return count; + } + + new_buf_size = PAGE_SIZE * new_buf_num; + new_buf_dirty = vzalloc(new_buf_size); + if (!new_buf_dirty) + return -ENOMEM; + + free_buf_dirty(); + buf_dirty = new_buf_dirty; + buf_size = new_buf_size; + WRITE_ONCE(buf_num, new_buf_num); + + return count; +} + +static int proc_buffer_release(struct inode *inode, struct file *filp) +{ + if ((filp->f_flags & O_ACCMODE) != O_RDONLY) + dirty_pages_unlock(); + return single_release(inode, filp); +} + +static int proc_limit_show(struct seq_file *m, void *v) +{ + seq_printf(m, "%lu\n", READ_ONCE(buf_limit)); + return 0; +} + +static int proc_limit_open(struct inode *inode, struct file *filp) +{ + return single_open(filp, proc_limit_show, NULL); +} + +static ssize_t proc_limit_write(struct file *filp, const char *buf, size_t count, + loff_t *offp) +{ + unsigned long limit; + int ret = kstrtoul_from_user(buf, count, 10, &limit); + + if (ret != 0) + return ret; + + WRITE_ONCE(buf_limit, limit); + + return count; +} + +static const struct proc_ops proc_dpages_operations = { + .proc_open = proc_dpages_open, + .proc_read = seq_read, + .proc_release = proc_dpages_release, +}; + +static const struct proc_ops proc_buffer_operations = { + .proc_open = proc_buffer_open, + .proc_read = seq_read, + .proc_write = proc_buffer_write, + .proc_lseek = seq_lseek, + .proc_release = proc_buffer_release, +}; + +static const struct proc_ops proc_limit_operations = { + .proc_open = proc_limit_open, + .proc_read = seq_read, + .proc_write = proc_limit_write, + .proc_lseek = seq_lseek, + .proc_release = single_release, +}; + +static int __init dpages_proc_init(void) +{ + struct proc_dir_entry *dirty_dir = proc_mkdir(DIRTY_ROOT, NULL); + + if (!dirty_dir) + return -ENOMEM; + + if (!proc_create(DIRTY_PAGES, 0440, dirty_dir, &proc_dpages_operations)) + goto fail_pages; + + if (!proc_create(DIRTY_BUFFER_SIZE, 0640, dirty_dir, + &proc_buffer_operations)) + goto fail_switch; + + if (!proc_create(DIRTY_LIMIT, 0640, dirty_dir, &proc_limit_operations)) + goto fail_limit; + + return 0; + +fail_limit: + remove_proc_entry(DIRTY_BUFFER_SIZE, dirty_dir); +fail_switch: + remove_proc_entry(DIRTY_PAGES, dirty_dir); +fail_pages: + remove_proc_entry(DIRTY_ROOT, NULL); + return -ENOMEM; +} + +subsys_initcall(dpages_proc_init); -- 2.39.2

2 1

[PATCH OLK-6.6 V1 00/12] infrastructure for scheduler bpf
by Guan Jing 09 Jan '24

09 Jan '24

infrastructure for scheduler bpf Guan Jing (12): sched: programmable: Introduce bpf sched sched: programmable: Add a tag for the task sched: programmable: Add a tag for the task group sched: programmable: Add user interface of task group tag sched: programmable: Add user interface of task tag sched: basic infrastructure for scheduler bpf sched: introduce bpf_sched_enable() libbpf: add support for scheduler bpf programs bpftool: recognize scheduler programs sched: Add helper functions to get cpu statistics sched: programmable: Add hook in select_task_rq_fair() sched: programmable: Add hook in can_migrate_task() arch/arm64/configs/openeuler_defconfig | 1 + arch/x86/configs/openeuler_defconfig | 1 + fs/proc/base.c | 64 ++++++++++++++ include/linux/bpf_sched.h | 50 +++++++++++ include/linux/bpf_types.h | 4 + include/linux/sched.h | 38 ++++++++ include/linux/sched_hook_defs.h | 4 + include/uapi/linux/bpf.h | 9 ++ init/init_task.c | 3 + kernel/bpf/Kconfig | 12 +++ kernel/bpf/btf.c | 1 + kernel/bpf/syscall.c | 27 ++++++ kernel/bpf/trampoline.c | 1 + kernel/bpf/verifier.c | 11 ++- kernel/sched/bpf_sched.c | 102 +++++++++++++++++++++ kernel/sched/build_utility.c | 4 + kernel/sched/core.c | 118 +++++++++++++++++++++++++ kernel/sched/fair.c | 45 ++++++++++ kernel/sched/sched.h | 10 +++ scripts/bpf_doc.py | 4 + tools/include/uapi/linux/bpf.h | 9 ++ tools/lib/bpf/bpf.c | 1 + tools/lib/bpf/libbpf.c | 23 ++++- tools/lib/bpf/libbpf.h | 2 + tools/lib/bpf/libbpf.map | 1 + 25 files changed, 543 insertions(+), 2 deletions(-) create mode 100644 include/linux/bpf_sched.h create mode 100644 include/linux/sched_hook_defs.h create mode 100644 kernel/sched/bpf_sched.c -- 2.34.1

1 12

[PATCH OLK-6.6] x86: config: disable network config
by Zhengchao Shao 09 Jan '24

09 Jan '24

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I8UM53 CVE: NA -------------------------------- Disable X86 network config. Signed-off-by: Zhengchao Shao <shaozhengchao(a)huawei.com> --- arch/x86/configs/openeuler_defconfig | 34 ++++++++++++++-------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig index 1ef398404878..dd7a8a3bca0f 100644 --- a/arch/x86/configs/openeuler_defconfig +++ b/arch/x86/configs/openeuler_defconfig @@ -1860,7 +1860,7 @@ CONFIG_BT_CMTP=m CONFIG_BT_HIDP=m CONFIG_BT_HS=y CONFIG_BT_LE=y -CONFIG_BT_LE_L2CAP_ECRED=y +# CONFIG_BT_LE_L2CAP_ECRED is not set # CONFIG_BT_6LOWPAN is not set # CONFIG_BT_LEDS is not set # CONFIG_BT_MSFTEXT is not set @@ -1876,7 +1876,7 @@ CONFIG_BT_BCM=m CONFIG_BT_RTL=m CONFIG_BT_HCIBTUSB=m CONFIG_BT_HCIBTUSB_AUTOSUSPEND=y -CONFIG_BT_HCIBTUSB_POLL_SYNC=y +# CONFIG_BT_HCIBTUSB_POLL_SYNC is not set CONFIG_BT_HCIBTUSB_BCM=y # CONFIG_BT_HCIBTUSB_MTK is not set CONFIG_BT_HCIBTUSB_RTL=y @@ -2788,7 +2788,7 @@ CONFIG_AMD_XGBE_HAVE_ECC=y CONFIG_NET_VENDOR_AQUANTIA=y CONFIG_AQTION=m # CONFIG_NET_VENDOR_ARC is not set -CONFIG_NET_VENDOR_ASIX=y +# CONFIG_NET_VENDOR_ASIX is not set # CONFIG_SPI_AX88796C is not set CONFIG_NET_VENDOR_ATHEROS=y CONFIG_ATL2=m @@ -2836,7 +2836,7 @@ CONFIG_CHELSIO_IPSEC_INLINE=m CONFIG_NET_VENDOR_CISCO=y CONFIG_ENIC=m # CONFIG_NET_VENDOR_CORTINA is not set -CONFIG_NET_VENDOR_DAVICOM=y +# CONFIG_NET_VENDOR_DAVICOM is not set # CONFIG_DM9051 is not set CONFIG_DNET=m CONFIG_NET_VENDOR_DEC=y @@ -2851,10 +2851,10 @@ CONFIG_BE2NET_HWMON=y # CONFIG_BE2NET_BE3 is not set CONFIG_BE2NET_LANCER=y CONFIG_BE2NET_SKYHAWK=y -CONFIG_NET_VENDOR_ENGLEDER=y +# CONFIG_NET_VENDOR_ENGLEDER is not set # CONFIG_TSNEP is not set # CONFIG_NET_VENDOR_EZCHIP is not set -CONFIG_NET_VENDOR_FUNGIBLE=y +# CONFIG_NET_VENDOR_FUNGIBLE is not set # CONFIG_FUN_ETH is not set CONFIG_NET_VENDOR_GOOGLE=y # CONFIG_GVE is not set @@ -2882,14 +2882,14 @@ CONFIG_I40E_DCB=y CONFIG_IAVF=m CONFIG_I40EVF=m CONFIG_ICE=m -CONFIG_ICE_SWITCHDEV=y -CONFIG_ICE_HWTS=y +# CONFIG_ICE_SWITCHDEV is not set +#CONFIG_ICE_HWTS is not set CONFIG_FM10K=m # CONFIG_IGC is not set # CONFIG_JME is not set -CONFIG_NET_VENDOR_ADI=y +# CONFIG_NET_VENDOR_ADI is not set # CONFIG_ADIN1110 is not set -CONFIG_NET_VENDOR_LITEX=y +# CONFIG_NET_VENDOR_LITEX is not set # CONFIG_NET_VENDOR_MARVELL is not set CONFIG_NET_VENDOR_MELLANOX=y CONFIG_MLX4_EN=m @@ -2924,7 +2924,7 @@ CONFIG_MLXFW=m # CONFIG_NET_VENDOR_MICREL is not set # CONFIG_NET_VENDOR_MICROCHIP is not set # CONFIG_NET_VENDOR_MICROSEMI is not set -CONFIG_NET_VENDOR_MICROSOFT=y +# CONFIG_NET_VENDOR_MICROSOFT is not set # CONFIG_MICROSOFT_MANA is not set CONFIG_NET_VENDOR_MYRI=y CONFIG_MYRI10GE=m @@ -2938,7 +2938,7 @@ CONFIG_NET_VENDOR_NETRONOME=y CONFIG_NFP=m CONFIG_NFP_APP_FLOWER=y CONFIG_NFP_APP_ABM_NIC=y -CONFIG_NFP_NET_IPSEC=y +# CONFIG_NFP_NET_IPSEC is not set # CONFIG_NFP_DEBUG is not set # CONFIG_NET_VENDOR_NVIDIA is not set CONFIG_NET_VENDOR_OKI=y @@ -2995,10 +2995,10 @@ CONFIG_SFC_MCDI_LOGGING=y # CONFIG_NET_VENDOR_SYNOPSYS is not set # CONFIG_NET_VENDOR_TEHUTI is not set # CONFIG_NET_VENDOR_TI is not set -CONFIG_NET_VENDOR_VERTEXCOM=y +# CONFIG_NET_VENDOR_VERTEXCOM is not set # CONFIG_MSE102X is not set # CONFIG_NET_VENDOR_VIA is not set -CONFIG_NET_VENDOR_WANGXUN=y +# CONFIG_NET_VENDOR_WANGXUN is not set CONFIG_LIBWX=m CONFIG_NGBE=m CONFIG_TXGBE=m @@ -3325,7 +3325,7 @@ CONFIG_MT76x2U=m CONFIG_WLAN_VENDOR_MICROCHIP=y # CONFIG_WILC1000_SDIO is not set # CONFIG_WILC1000_SPI is not set -CONFIG_WLAN_VENDOR_PURELIFI=y +# CONFIG_WLAN_VENDOR_PURELIFI is not set # CONFIG_PLFXLC is not set CONFIG_WLAN_VENDOR_RALINK=y CONFIG_RT2X00=m @@ -3382,7 +3382,7 @@ CONFIG_RTL8XXXU=m # CONFIG_RTW88 is not set # CONFIG_RTW89 is not set # CONFIG_WLAN_VENDOR_RSI is not set -CONFIG_WLAN_VENDOR_SILABS=y +# CONFIG_WLAN_VENDOR_SILABS is not set # CONFIG_WFX is not set # CONFIG_WLAN_VENDOR_ST is not set # CONFIG_WLAN_VENDOR_TI is not set @@ -8225,7 +8225,7 @@ CONFIG_SUNRPC=m CONFIG_SUNRPC_GSS=m CONFIG_SUNRPC_BACKCHANNEL=y CONFIG_RPCSEC_GSS_KRB5=m -CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA1=y +# CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA1 is not set # CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_CAMELLIA is not set # CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA2 is not set CONFIG_SUNRPC_DEBUG=y -- 2.34.1

1 0

[PATCH OLK-6.6 0/1] arm64: Add non nmi ipi backtrace support
by Liao Chen 09 Jan '24

09 Jan '24

From: linruizhe <linruizhe(a)huawei.com> Dependencies: CONFIG_DETECT_HUNG_TASK=y CONFIG_WATCHDOG=y Li Zhengyu (1): arm64: Add non nmi ipi backtrace support arch/arm64/Kconfig | 8 +++++ arch/arm64/configs/openeuler_defconfig | 1 + arch/arm64/kernel/ipi_nmi.c | 41 ++++++++++++++++++++++---- 3 files changed, 45 insertions(+), 5 deletions(-) -- 2.25.1

1 1

2024

2023

2022

2021

2020

2019

Kernel