// SPDX-License-Identifier: GPL-2.0 #include <linux/slab.h>#include <linux/file.h>#include <linux/fdtable.h>#include <linux/freezer.h>#include <linux/mm.h>#include <linux/stat.h>#include <linux/fcntl.h>#include <linux/swap.h>#include <linux/ctype.h>#include <linux/string.h>#include <linux/init.h>#include <linux/pagemap.h>#include <linux/perf_event.h>#include <linux/highmem.h>#include <linux/spinlock.h>#include <linux/key.h>#include <linux/personality.h>#include <linux/binfmts.h>#include <linux/coredump.h>#include <linux/sort.h>#include <linux/sched/coredump.h>#include <linux/sched/signal.h>#include <linux/sched/task_stack.h>#include <linux/utsname.h>#include <linux/pid_namespace.h>#include <linux/module.h>#include <linux/namei.h>#include <linux/mount.h>#include <linux/security.h>#include <linux/syscalls.h>#include <linux/tsacct_kern.h>#include <linux/cn_proc.h>#include <linux/audit.h>#include <linux/kmod.h>#include <linux/fsnotify.h>#include <linux/fs_struct.h>#include <linux/pipe_fs_i.h>#include <linux/oom.h>#include <linux/compat.h>#include <linux/fs.h>#include <linux/path.h>#include <linux/timekeeping.h>#include <linux/sysctl.h>#include <linux/elf.h>#include <linux/pidfs.h>#include <linux/net.h>#include <linux/socket.h>#include <net/af_unix.h>#include <net/net_namespace.h>#include <net/sock.h>#include <uapi/linux/pidfd.h>#include <uapi/linux/un.h>#include <uapi/linux/coredump.h>#include <linux/uaccess.h>#include <asm /mmu_context.h>#include <asm /tlb.h>#include <asm /exec.h>#include <trace/events/task.h>#include "internal.h" #include <trace/events/sched.h>static bool dump_vma_snapshot(struct coredump_params *cprm);static void free_vma_snapshot(struct coredump_params *cprm);#define CORE_FILE_NOTE_SIZE_DEFAULT (4 *1024 *1024 )/* Define a reasonable max cap */ #define CORE_FILE_NOTE_SIZE_MAX (16 *1024 *1024 )/* * File descriptor number for the pidfd for the thread - group leader of * the coredumping task installed into the usermode helper ' s file * descriptor table . #define COREDUMP_PIDFD_NUMBER 3 static int core_uses_pid;static unsigned int core_pipe_limit;static unsigned int core_sort_vma;static char core_pattern[CORENAME_MAX_SIZE] = "core" ;static int core_name_size = CORENAME_MAX_SIZE;unsigned int core_file_note_size_limit = CORE_FILE_NOTE_SIZE_DEFAULT;static atomic_t core_pipe_count = ATOMIC_INIT(0 );enum coredump_type_t {1 ,2 ,3 ,4 ,struct core_name {char *corename;int used, size;unsigned int core_pipe_limit;bool core_dumped;enum coredump_type_t core_type;static int expand_corename(struct core_name *cn, int size)char *corename;if (!corename)return -ENOMEM;if (size > core_name_size) /* racy but harmless */ return 0 ;static __printf(2 , 0 ) int cn_vprintf(struct core_name *cn, const char *fmt,int free, need;if (need < free) {return 0 ;if (!expand_corename(cn, cn->size + need - free + 1 ))goto again;return -ENOMEM;static __printf(2 , 3 ) int cn_printf(struct core_name *cn, const char *fmt, ...)int ret;return ret;static __printf(2 , 3 )int cn_esc_printf(struct core_name *cn, const char *fmt, ...)int cur = cn->used;int ret;if (ret == 0 ) {/* * Ensure that this coredump name component can ' t cause the * resulting corefile path to consist of a " . . " or " . " . if ((cn->used - cur == 1 && cn->corename[cur] == '.' ) ||2 && cn->corename[cur] == '.' 1 ] == '.' ))'!' ;/* * Empty names are fishy and could be used to create a " //" in a * corefile name , causing the coredump to happen one directory * level too high . Enforce that all components of the core * pattern are at least one character long . if (cn->used == cur)"!" );for (; cur < cn->used; ++cur) {if (cn->corename[cur] == '/' )'!' ;return ret;static int cn_print_exe_file(struct core_name *cn, bool name_only)struct file *exe_file;char *pathbuf, *path, *ptr;int ret;if (!exe_file)return cn_esc_printf(cn, "%s (path unknown)" , current->comm);if (!pathbuf) {goto put_exe_file;if (IS_ERR(path)) {goto free_buf;if (name_only) {'/' );if (ptr)1 ;"%s" , path);return ret;/* * coredump_parse will inspect the pattern parameter , and output a name * into corename , which must have space for at least CORENAME_MAX_SIZE * bytes plus one byte for the zero terminator . static bool coredump_parse(struct core_name *cn, struct coredump_params *cprm,int *argc)const struct cred *cred = current_cred();const char *pat_ptr = core_pattern;bool was_space = false ;int pid_in_pattern = 0 ;int err = 0 ;if (core_pipe_limit)0 ;0 ;false ;if (*pat_ptr == '|' )else if (*pat_ptr == '@' )else if (expand_corename(cn, core_name_size))return false ;0 ] = '\0' ;switch (cn->core_type) {case COREDUMP_PIPE: {int argvs = sizeof (core_pattern) / 2 ;sizeof (**argv), GFP_KERNEL);if (!(*argv))return false ;0 ;if (!(*pat_ptr))return false ;break ;case COREDUMP_SOCK: {/* skip the @ */ if (!(*pat_ptr))return false ;if (*pat_ptr == '@' ) {if (!(*pat_ptr))return false ;"%s" , pat_ptr);if (err)return false ;/* Require absolute paths. */ if (cn->corename[0 ] != '/' )return false ;/* * Ensure we can uses spaces to indicate additional * parameters in the future . if (strchr(cn->corename, ' ' )) {"Coredump socket may not %s contain spaces" , cn->corename);return false ;/* Must not contain ".." in the path. */ if (name_contains_dotdot(cn->corename)) {"Coredump socket may not %s contain '..' spaces" , cn->corename);return false ;if (strlen(cn->corename) >= UNIX_PATH_MAX) {"Coredump socket path %s too long" , cn->corename);return false ;/* * Currently no need to parse any other options . * Relevant information can be retrieved from the peer * pidfd retrievable via SO_PEERPIDFD by the receiver or * via / proc / < pid > , using the SO_PEERPIDFD to guard * against pid recycling when opening / proc / < pid > . return true ;case COREDUMP_FILE:break ;default :true );return false ;/* Repeat as long as we have more pattern to process and more output while (*pat_ptr) {/* * Split on spaces before doing template expansion so that * % e and % E don ' t get split if they have spaces in them if (cn->core_type == COREDUMP_PIPE) {if (isspace(*pat_ptr)) {if (cn->used != 0 )true ;continue ;else if (was_space) {false ;"%c" , '\0' );if (err)return false ;if (*pat_ptr != '%' ) {"%c" , *pat_ptr++);else {switch (*++pat_ptr) {/* single % at the end, drop that */ case 0 :goto out;/* Double percent, output one percent */ case '%' :"%c" , '%' );break ;/* pid */ case 'p' :1 ;"%d" ,break ;/* global pid */ case 'P' :"%d" ,break ;case 'i' :"%d" ,break ;case 'I' :"%d" ,break ;/* uid */ case 'u' :"%u" ,break ;/* gid */ case 'g' :"%u" ,break ;case 'd' :"%d" ,break ;/* signal that caused the coredump */ case 's' :"%d" ,break ;/* UNIX time of coredump */ case 't' : {"%lld" , time);break ;/* hostname */ case 'h' :"%s" ,break ;/* executable, could be changed by prctl PR_SET_NAME etc */ case 'e' :"%s" , current->comm);break ;/* file name of executable */ case 'f' :true );break ;case 'E' :false );break ;/* core limit size */ case 'c' :"%lu" ,break ;/* CPU the task ran on */ case 'C' :"%d" , cprm->cpu);break ;/* pidfd number */ case 'F' : {/* * Installing a pidfd only makes sense if * we actually spawn a usermode helper . if (cn->core_type != COREDUMP_PIPE)break ;/* * Note that we ' ll install a pidfd for the * thread - group leader . We know that task * linkage hasn ' t been removed yet and even if * this @ current isn ' t the actual thread - group * leader we know that the thread - group leader * cannot be reaped until @ current has exited . "%d" , COREDUMP_PIDFD_NUMBER);break ;default :break ;if (err)return false ;/* Backward compatibility with core_uses_pid: * * If core_pattern does not include a % p ( as is the default ) * and core_uses_pid is set , then . % pid will be appended to if (cn->core_type == COREDUMP_FILE && !pid_in_pattern && core_uses_pid)return cn_printf(cn, ".%d" , task_tgid_vnr(current)) == 0 ;return true ;static int zap_process(struct signal_struct *signal, int exit_code)struct task_struct *t;int nr = 0 ;0 ;if (t != current && !(t->flags & PF_POSTCOREDUMP)) {1 );return nr;static int zap_threads(struct task_struct *tsk,struct core_state *core_state, int exit_code)struct signal_struct *signal = tsk->signal;int nr = -EAGAIN;if (!(signal->flags & SIGNAL_GROUP_EXIT) && !signal->group_exec_task) {/* Allow SIGKILL, see prepare_signal() */ return nr;static int coredump_wait(int exit_code, struct core_state *core_state)struct task_struct *tsk = current;int core_waiters = -EBUSY;if (core_waiters > 0 ) {struct core_thread *ptr;/* * Wait for all the threads to become inactive , so that * all the thread context ( extended register state , like * fpu etc ) gets copied to the memory . while (ptr != NULL) {return core_waiters;static void coredump_finish(bool core_dumped)struct core_thread *curr, *next;struct task_struct *task;if (core_dumped && !__fatal_signal_pending(current))0 x80;while ((curr = next) != NULL) {/* * see coredump_task_exit ( ) , curr - > task must not see * - > task = = NULL before we read - > next . static bool dump_interrupted(void )/* * SIGKILL or freezing ( ) interrupt the coredumping . Perhaps we * can do try_to_freeze ( ) and check _ _ fatal_signal_pending ( ) , * but then we need to teach dump_write ( ) to restart and clear * TIF_SIGPENDING . return fatal_signal_pending(current) || freezing(current);static void wait_for_dump_helpers(struct file *file)struct pipe_inode_info *pipe = file->private_data;/* * We actually want wait_event_freezable ( ) but then we need * to clear TIF_SIGPENDING and improve dump_interrupted ( ) . 1 );/* * umh_coredump_setup * helper function to customize the process used * to collect the core in userspace . Specifically * it sets up a pipe and installs it as fd 0 ( stdin ) * for the process . Returns 0 on success , or * PTR_ERR on failure . * Note that it also sets the core limit to 1 . This * is a special value that we use to trap recursive * core dumps static int umh_coredump_setup(struct subprocess_info *info, struct cred *new )struct file *files[2 ];struct coredump_params *cp = (struct coredump_params *)info->data;int err;if (cp->pid) {struct file *pidfs_file __free(fput) = NULL;0 );if (IS_ERR(pidfs_file))return PTR_ERR(pidfs_file);/* * Usermode helpers are childen of either * system_unbound_wq or of kthreadd . So we know that * we ' re starting off with a clean file descriptor * table . So we should always be able to use * COREDUMP_PIDFD_NUMBER as our file descriptor value . 0 );if (err < 0 )return err;0 );if (err)return err;1 ];0 , files[0 ], 0 );0 ]);if (err < 0 )return err;/* and disallow core files too */ struct rlimit){1 , 1 };return 0 ;#ifdef CONFIG_UNIXstatic bool coredump_sock_connect(struct core_name *cn, struct coredump_params *cprm)struct file *file __free(fput) = NULL;struct sockaddr_un addr = {int retval;struct socket *socket;if (addr_len < 0 )return false ;struct sockaddr_un, sun_path) + 1 ;/* * It is possible that the userspace process which is supposed * to handle the coredump and is listening on the AF_UNIX socket * coredumps . Userspace should just mark itself non dumpable . 0 , &socket);if (retval < 0 )return false ;0 , NULL);if (IS_ERR(file))return false ;/* * Set the thread - group leader pid which is used for the peer * credentials during connect ( ) below . Then immediately register * it in pidfs . . . if (retval)return false ;/* * . . . and set the coredump information so userspace has it * available after connect ( ) . . . struct sockaddr *)(&addr), addr_len,if (retval) {if (retval == -EAGAIN)"Coredump socket %s receive queue full" , addr.sun_path);else "Coredump socket connection %s failed %d" , addr.sun_path, retval);return false ;/* ... and validate that @sk_peer_pid matches @cprm.pid. */ if (WARN_ON_ONCE(unix_peer(socket->sk)->sk_peer_pid != cprm->pid))return false ;return true ;static inline bool coredump_sock_recv(struct file *file, struct coredump_ack *ack, size_t size, int flags)struct msghdr msg = {};struct kvec iov = { .iov_base = ack, .iov_len = size };0 , size);1 , size, flags);return ret == size;static inline bool coredump_sock_send(struct file *file, struct coredump_req *req)struct msghdr msg = { .msg_flags = MSG_NOSIGNAL };struct kvec iov = { .iov_base = req, .iov_len = sizeof (*req) };1 , sizeof (*req));return ret == sizeof (*req);sizeof (enum coredump_mark) == sizeof (__u32));static inline bool coredump_sock_mark(struct file *file, enum coredump_mark mark)struct msghdr msg = { .msg_flags = MSG_NOSIGNAL };struct kvec iov = { .iov_base = &mark, .iov_len = sizeof (mark) };1 , sizeof (mark));return ret == sizeof (mark);static inline void coredump_sock_wait(struct file *file)/* * We use a simple read to wait for the coredump processing to * finish . Either the socket is closed or we get sent unexpected * data . In both cases , we ' re done . char ){ 0 }, 1 , NULL);if (n > 0 )"Coredump socket had unexpected data" );else if (n < 0 )"Coredump socket failed" );static inline void coredump_sock_shutdown(struct file *file)struct socket *socket;if (!socket)return ;/* Let userspace know we're done processing the coredump. */ static bool coredump_sock_request(struct core_name *cn, struct coredump_params *cprm)struct coredump_req req = {sizeof (struct coredump_req),sizeof (struct coredump_ack),struct coredump_ack ack = {};if (cn->core_type != COREDUMP_SOCK_REQ)return true ;/* Let userspace know what we support. */ if (!coredump_sock_send(cprm->file, &req))return false ;/* Peek the size of the coredump_ack. */ if (!coredump_sock_recv(cprm->file, &ack, sizeof (ack.size),return false ;/* Refuse unknown coredump_ack sizes. */ if (usize < COREDUMP_ACK_SIZE_VER0) {return false ;if (usize > sizeof (ack)) {return false ;/* Now retrieve the coredump_ack. */ if (!coredump_sock_recv(cprm->file, &ack, usize, MSG_WAITALL))return false ;if (ack.size != usize)return false ;/* Refuse unknown coredump_ack flags. */ if (ack.mask & ~req.mask) {return false ;/* Refuse mutually exclusive options. */ if (hweight64(ack.mask & (COREDUMP_USERSPACE | COREDUMP_KERNEL |1 ) {return false ;if (ack.spare) {return false ;return coredump_sock_mark(cprm->file, COREDUMP_MARK_REQACK);static bool coredump_socket(struct core_name *cn, struct coredump_params *cprm)if (!coredump_sock_connect(cn, cprm))return false ;return coredump_sock_request(cn, cprm);#else static inline void coredump_sock_wait(struct file *file) { }static inline void coredump_sock_shutdown(struct file *file) { }static inline bool coredump_socket(struct core_name *cn, struct coredump_params *cprm) { return false ; }#endif /* cprm->mm_flags contains a stable snapshot of dumpability flags. */ static inline bool coredump_force_suid_safe(const struct coredump_params *cprm)/* Require nonrelative corefile path and be extra careful. */ return __get_dumpable(cprm->mm_flags) == SUID_DUMP_ROOT;static bool coredump_file(struct core_name *cn, struct coredump_params *cprm,const struct linux_binfmt *binfmt)struct mnt_idmap *idmap;struct inode *inode;struct file *file __free(fput) = NULL;int open_flags = O_CREAT | O_WRONLY | O_NOFOLLOW | O_LARGEFILE | O_EXCL;if (cprm->limit < binfmt->min_coredump)return false ;if (coredump_force_suid_safe(cprm) && cn->corename[0 ] != '/' ) {"this process can only dump core to a fully qualified path, skipping core dump" );return false ;/* * Unlink the file if it exists unless this is a SUID * binary - in that case , we ' re running around with root * privs and don ' t want to unlink another user ' s coredump . if (!coredump_force_suid_safe(cprm)) {/* * If it doesn ' t exist , that ' s fine . If there ' s some * other problem , we ' ll catch it at the filp_open ( ) . /* * There is a race between unlinking and creating the * file , but if that causes an EEXIST here , that ' s * fine - another process raced with us while creating * the corefile , and the other process won . To userspace , * what matters is that at least one of the two processes * writes its coredump successfully , not which one . if (coredump_force_suid_safe(cprm)) {/* * Using user namespaces , normal user tasks can change * their current - > fs - > root to point to arbitrary * directories . Since the intention of the " only dump * with a fully qualified path " rule is to control where * coredumps may be placed using root privileges , * current - > fs - > root must not be used . Instead , use the * root directory of init_task . struct path root;0600 );else {0600 );if (IS_ERR(file))return false ;if (inode->i_nlink > 1 )return false ;if (d_unhashed(file->f_path.dentry))return false ;/* * AK : actually i see no reason to not allow this for named * pipes etc , but keep the previous behaviour for now . if (!S_ISREG(inode->i_mode))return false ;/* * Don ' t dump core if the filesystem changed owner or mode * of the file during file creation . This is an issue when * a process dumps core while its cwd is e . g . on a vfat * filesystem . if (!vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid())) {"Core dump to %s aborted: cannot preserve file owner" , cn->corename);return false ;if ((inode->i_mode & 0677 ) != 0600 ) {"Core dump to %s aborted: cannot preserve file permissions" , cn->corename);return false ;if (!(file->f_mode & FMODE_CAN_WRITE))return false ;if (do_truncate(idmap, file->f_path.dentry, 0 , 0 , file))return false ;return true ;static bool coredump_pipe(struct core_name *cn, struct coredump_params *cprm,int argc)int argi;char **helper_argv __free(kfree) = NULL;struct subprocess_info *sub_info;if (cprm->limit == 1 ) {/* See umh_coredump_setup() which sets RLIMIT_CORE = 1. * * Normally core limits are irrelevant to pipes , since * we ' re not writing to the file system , but we use * cprm . limit of 1 here as a special value , this is a * consistent way to catch recursive crashes . * We can still crash if the core_pattern binary sets * RLIM_CORE = ! 1 , but it runs as root , and can do * lots of stupid things . * * Note that we use task_tgid_vnr here to grab the pid * of the process group leader . That way we get the * right pid if a thread in a multi - threaded * core_pattern process dies . "RLIMIT_CORE is set to 1, aborting core" );return false ;if (core_pipe_limit && (core_pipe_limit < cn->core_pipe_limit)) {"over core_pipe_limit, skipping core dump" );return false ;1 , sizeof (*helper_argv), GFP_KERNEL);if (!helper_argv) {"%s failed to allocate memory" , __func__);return false ;for (argi = 0 ; argi < argc; argi++)0 ], helper_argv, NULL,if (!sub_info)return false ;if (call_usermodehelper_exec(sub_info, UMH_WAIT_EXEC)) {"|%s pipe failed" , cn->corename);return false ;/* * umh disabled with CONFIG_STATIC_USERMODEHELPER_PATH = " " would * have this set to NULL . if (!cprm->file) {"Core dump to |%s disabled" , cn->corename);return false ;return true ;static bool coredump_write(struct core_name *cn,struct coredump_params *cprm,struct linux_binfmt *binfmt)if (dump_interrupted())return true ;if (!dump_vma_snapshot(cprm))return false ;/* * Ensures that file size is big enough to contain the current * file postion . This prevents gdb from complaining about * a truncated file if the last " write " to the file was * dump_skip . if (cprm->to_skip) {"" , 1 );return true ;static void coredump_cleanup(struct core_name *cn, struct coredump_params *cprm)if (cprm->file)if (cn->core_pipe_limit) {static inline bool coredump_skip(const struct coredump_params *cprm,const struct linux_binfmt *binfmt)if (!binfmt)return true ;if (!binfmt->core_dump)return true ;if (!__get_dumpable(cprm->mm_flags))return true ;return false ;void vfs_coredump(const kernel_siginfo_t *siginfo)struct cred *cred __free(put_cred) = NULL;struct core_state core_state;struct core_name cn;struct mm_struct *mm = current->mm;struct linux_binfmt *binfmt = mm->binfmt;const struct cred *old_cred;int argc = 0 ;struct coredump_params cprm = {/* * We must use the same mm - > flags while dumping core to avoid * inconsistency of bit flags , since this flag is not protected * by any locks . if (coredump_skip(&cprm, binfmt))return ;if (!cred)return ;/* * We cannot trust fsuid as being the " true " uid of the process * nor do we know its entire history . We only know it was tainted * so we dump it as root in mode 2 , and only into a controlled * environment ( pipe handler or fully qualified path ) . if (coredump_force_suid_safe(&cprm))if (coredump_wait(siginfo->si_signo, &core_state) < 0 )return ;if (!coredump_parse(&cn, &cprm, &argv, &argc)) {"format_corename failed, aborting core" );goto close_fail;switch (cn.core_type) {case COREDUMP_FILE:if (!coredump_file(&cn, &cprm, binfmt))goto close_fail;break ;case COREDUMP_PIPE:if (!coredump_pipe(&cn, &cprm, argv, argc))goto close_fail;break ;case COREDUMP_SOCK_REQ:case COREDUMP_SOCK:if (!coredump_socket(&cn, &cprm))goto close_fail;break ;default :true );goto close_fail;/* Don't even generate the coredump. */ if (cn.mask & COREDUMP_REJECT)goto close_fail;/* get us an unshared descriptor table; almost always a no-op */ /* The cell spufs coredump code reads the file descriptor tables */ if (unshare_files())goto close_fail;if ((cn.mask & COREDUMP_KERNEL) && !coredump_write(&cn, &cprm, binfmt))goto close_fail;/* Let the parent know that a coredump was generated. */ if (cn.mask & COREDUMP_USERSPACE)true ;/* * When core_pipe_limit is set we wait for the coredump server * or usermodehelper to finish before exiting so it can e . g . , * inspect / proc / < pid > . if (cn.mask & COREDUMP_WAIT) {switch (cn.core_type) {case COREDUMP_PIPE:break ;case COREDUMP_SOCK_REQ:case COREDUMP_SOCK:break ;default :break ;return ;/* * Core dumping helper functions . These are the only things you should * do on a core - file : use only these functions to write out all the * necessary info . static int __dump_emit(struct coredump_params *cprm, const void *addr, int nr)struct file *file = cprm->file;if (cprm->written + nr > cprm->limit)return 0 ;if (dump_interrupted())return 0 ;if (n != nr)return 0 ;return 1 ;static int __dump_skip(struct coredump_params *cprm, size_t nr)static char zeroes[PAGE_SIZE];struct file *file = cprm->file;if (file->f_mode & FMODE_LSEEK) {if (dump_interrupted() || vfs_llseek(file, nr, SEEK_CUR) < 0 )return 0 ;return 1 ;while (nr > PAGE_SIZE) {if (!__dump_emit(cprm, zeroes, PAGE_SIZE))return 0 ;return __dump_emit(cprm, zeroes, nr);int dump_emit(struct coredump_params *cprm, const void *addr, int nr)if (cprm->to_skip) {if (!__dump_skip(cprm, cprm->to_skip))return 0 ;0 ;return __dump_emit(cprm, addr, nr);void dump_skip_to(struct coredump_params *cprm, unsigned long pos)void dump_skip(struct coredump_params *cprm, size_t nr)#ifdef CONFIG_ELF_COREstatic int dump_emit_page(struct coredump_params *cprm, struct page *page)struct bio_vec bvec;struct iov_iter iter;struct file *file = cprm->file;if (!page)return 0 ;if (cprm->to_skip) {if (!__dump_skip(cprm, cprm->to_skip))return 0 ;0 ;if (cprm->written + PAGE_SIZE > cprm->limit)return 0 ;if (dump_interrupted())return 0 ;0 );1 , PAGE_SIZE);if (n != PAGE_SIZE)return 0 ;return 1 ;/* * If we might get machine checks from kernel accesses during the * core dump , let ' s get those errors early rather than during the * IO . This is not performance - critical enough to warrant having * all the machine check logic in the iovec paths . #ifdef copy_mc_to_kernel#define dump_page_alloc() alloc_page(GFP_KERNEL)#define dump_page_free(x) __free_page(x)static struct page *dump_page_copy(struct page *src, struct page *dst)void *buf = kmap_local_page(src);return left ? NULL : dst;#else /* We just want to return non-NULL; it's never used. */ #define dump_page_alloc() ERR_PTR(-EINVAL)#define dump_page_free(x) ((void )(x))static inline struct page *dump_page_copy(struct page *src, struct page *dst)return src;#endif int dump_user_range(struct coredump_params *cprm, unsigned long start,unsigned long len)unsigned long addr;struct page *dump_page;int locked, ret;if (!dump_page)return 0 ;0 ;0 ;for (addr = start; addr < start + len; addr += PAGE_SIZE) {struct page *page;if (!locked) {if (mmap_read_lock_killable(current->mm))goto out;1 ;/* * To avoid having to allocate page tables for virtual address * ranges that have never been used yet , and also to make it * easy to generate sparse core files , use a helper that returns * NULL when encountering an empty page table entry that would * otherwise have been filled with the zero page . if (page) {if (locked) {0 ;int stop = !dump_emit_page(cprm, dump_page_copy(page, dump_page));if (stop)goto out;else {if (dump_interrupted())goto out;if (!need_resched())continue ;if (locked) {0 ;1 ;if (locked)return ret;#endif int dump_align(struct coredump_params *cprm, int align)unsigned mod = (cprm->pos + cprm->to_skip) & (align - 1 );if (align & (align - 1 ))return 0 ;if (mod)return 1 ;#ifdef CONFIG_SYSCTLvoid validate_coredump_safety(void )if (suid_dumpable == SUID_DUMP_ROOT &&0 ] != '/' && core_pattern[0 ] != '|' && core_pattern[0 ] != '@' ) {"Unsafe core_pattern used with fs.suid_dumpable=2: " "pipe handler or fully qualified core dump path required. " "Set kernel.core_pattern before fs.suid_dumpable." );static inline bool check_coredump_socket(void )const char *p;if (core_pattern[0 ] != '@' )return true ;/* * Coredump socket must be located in the initial mount * namespace . Don ' t give the impression that anything else is * supported right now . if (current->nsproxy->mnt_ns != init_task.nsproxy->mnt_ns)return false ;/* Must be an absolute path... */ if (core_pattern[1 ] != '/' ) {/* ... or the socket request protocol... */ if (core_pattern[1 ] != '@' )return false ;/* ... and if so must be an absolute path. */ if (core_pattern[2 ] != '/' )return false ;2 ];else {1 ];/* The path obviously cannot exceed UNIX_PATH_MAX. */ if (strlen(p) >= UNIX_PATH_MAX)return false ;/* Must not contain ".." in the path. */ if (name_contains_dotdot(core_pattern))return false ;return true ;static int proc_dostring_coredump(const struct ctl_table *table, int write,void *buffer, size_t *lenp, loff_t *ppos)int error;char old_core_pattern[CORENAME_MAX_SIZE];if (!write)return proc_dostring(table, write, buffer, lenp, ppos);if (error)return error;if (!check_coredump_socket()) {1 );return -EINVAL;return error;static const unsigned int core_file_note_size_min = CORE_FILE_NOTE_SIZE_DEFAULT;static const unsigned int core_file_note_size_max = CORE_FILE_NOTE_SIZE_MAX;static char core_modes[] = {"file\npipe" #ifdef CONFIG_UNIX"\nsocket" #endif static const struct ctl_table coredump_sysctls[] = {"core_uses_pid" ,sizeof (int ),0644 ,"core_pattern" ,0644 ,"core_pipe_limit" ,sizeof (unsigned int ),0644 ,"core_file_note_size_limit" ,sizeof (unsigned int ),0644 ,unsigned int *)&core_file_note_size_min,unsigned int *)&core_file_note_size_max,"core_sort_vma" ,sizeof (int ),0644 ,"core_modes" ,sizeof (core_modes) - 1 ,0444 ,static int __init init_fs_coredump_sysctls(void )"kernel" , coredump_sysctls);return 0 ;#endif /* CONFIG_SYSCTL */ /* * The purpose of always_dump_vma ( ) is to make sure that special kernel mappings * that are useful for post - mortem analysis are included in every core dump . * In that way we ensure that the core dump is fully interpretable later * without matching up the same kernel and hardware config to see what PC values * meant . These special mappings include - vDSO , vsyscall , and other * architecture specific mappings static bool always_dump_vma(struct vm_area_struct *vma)/* Any vsyscall mappings? */ if (vma == get_gate_vma(vma->vm_mm))return true ;/* * Assume that all vmas with a . name op should always be dumped . * If this changes , a new vm_ops field can easily be added . if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))return true ;/* * arch_vma_name ( ) returns non - NULL for special architecture mappings , * such as vDSO sections . if (arch_vma_name(vma))return true ;return false ;#define DUMP_SIZE_MAYBE_ELFHDR_PLACEHOLDER 1 /* * Decide how much of @ vma ' s contents should be included in a core dump . static unsigned long vma_dump_size(struct vm_area_struct *vma,unsigned long mm_flags)#define FILTER(type) (mm_flags & (1 UL << MMF_DUMP_## type))/* always dump the vdso and vsyscall sections */ if (always_dump_vma(vma))goto whole;if (vma->vm_flags & VM_DONTDUMP)return 0 ;/* support for DAX */ if (vma_is_dax(vma)) {if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))goto whole;if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))goto whole;return 0 ;/* Hugetlb memory check */ if (is_vm_hugetlb_page(vma)) {if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))goto whole;if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))goto whole;return 0 ;/* Do not dump I/O mapped devices or special mappings */ if (vma->vm_flags & VM_IO)return 0 ;/* By default, dump shared memory if mapped from an anonymous file. */ if (vma->vm_flags & VM_SHARED) {if (file_inode(vma->vm_file)->i_nlink == 0 ?goto whole;return 0 ;/* Dump segments that have been written to. */ if ((!IS_ENABLED(CONFIG_MMU) || vma->anon_vma) && FILTER(ANON_PRIVATE))goto whole;if (vma->vm_file == NULL)return 0 ;if (FILTER(MAPPED_PRIVATE))goto whole;/* * If this is the beginning of an executable file mapping , * dump the first page to aid in determining what was mapped here . if (FILTER(ELF_HEADERS) &&0 && (vma->vm_flags & VM_READ)) {if ((READ_ONCE(file_inode(vma->vm_file)->i_mode) & 0111 ) != 0 )return PAGE_SIZE;/* * ELF libraries aren ' t always executable . * We ' ll want to check whether the mapping starts with the ELF * magic , but not now - we ' re holding the mmap lock , * so copy_from_user ( ) doesn ' t work here . * Use a placeholder instead , and fix it up later in * dump_vma_snapshot ( ) . return DUMP_SIZE_MAYBE_ELFHDR_PLACEHOLDER;#undef FILTERreturn 0 ;return vma->vm_end - vma->vm_start;/* * Helper function for iterating across a vma list . It ensures that the caller * will visit ` gate_vma ' prior to terminating the search . static struct vm_area_struct *coredump_next_vma(struct vma_iterator *vmi,struct vm_area_struct *vma,struct vm_area_struct *gate_vma)if (gate_vma && (vma == gate_vma))return NULL;if (vma)return vma;return gate_vma;static void free_vma_snapshot(struct coredump_params *cprm)if (cprm->vma_meta) {int i;for (i = 0 ; i < cprm->vma_count; i++) {struct file *file = cprm->vma_meta[i].file;if (file)static int cmp_vma_size(const void *vma_meta_lhs_ptr, const void *vma_meta_rhs_ptr)const struct core_vma_metadata *vma_meta_lhs = vma_meta_lhs_ptr;const struct core_vma_metadata *vma_meta_rhs = vma_meta_rhs_ptr;if (vma_meta_lhs->dump_size < vma_meta_rhs->dump_size)return -1 ;if (vma_meta_lhs->dump_size > vma_meta_rhs->dump_size)return 1 ;return 0 ;/* * Under the mmap_lock , take a snapshot of relevant information about the task ' s * VMAs . static bool dump_vma_snapshot(struct coredump_params *cprm)struct vm_area_struct *gate_vma, *vma = NULL;struct mm_struct *mm = current->mm;0 );int i = 0 ;/* * Once the stack expansion code is fixed to not change VMA bounds * under mmap_lock in read mode , this can be changed to take the * mmap_lock in read mode . if (mmap_write_lock_killable(mm))return false ;0 ;1 : 0 );sizeof (*cprm->vma_meta), GFP_KERNEL);if (!cprm->vma_meta) {return false ;while ((vma = coredump_next_vma(&vmi, vma, gate_vma)) != NULL) {struct core_vma_metadata *m = cprm->vma_meta + i;if (m->file)for (i = 0 ; i < cprm->vma_count; i++) {struct core_vma_metadata *m = cprm->vma_meta + i;if (m->dump_size == DUMP_SIZE_MAYBE_ELFHDR_PLACEHOLDER) {char elfmag[SELFMAG];if (copy_from_user(elfmag, (void __user *)m->start, SELFMAG) ||0 ) {0 ;else {if (core_sort_vma)sizeof (*cprm->vma_meta),return true ;
Messung V0.5 in Prozent C=95 H=93 G=93
¤ Dauer der Verarbeitung: 0.27 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
