a06a4dc3a0
About 6 months ago, I made a set of changes to how the core-dump-to-a-pipe feature in the kernel works. We had reports of several races, including some reports of apps bypassing our recursion check so that a process that was forked as part of a core_pattern setup could infinitely crash and refork until the system crashed. We fixed those by improving our recursion checks. The new check basically refuses to fork a process if its core limit is zero, which works well. Unfortunately, I've been getting grief from maintainer of user space programs that are inserted as the forked process of core_pattern. They contend that in order for their programs (such as abrt and apport) to work, all the running processes in a system must have their core limits set to a non-zero value, to which I say 'yes'. I did this by design, and think thats the right way to do things. But I've been asked to ease this burden on user space enough times that I thought I would take a look at it. The first suggestion was to make the recursion check fail on a non-zero 'special' number, like one. That way the core collector process could set its core size ulimit to 1, and enable the kernel's recursion detection. This isn't a bad idea on the surface, but I don't like it since its opt-in, in that if a program like abrt or apport has a bug and fails to set such a core limit, we're left with a recursively crashing system again. So I've come up with this. What I've done is modify the call_usermodehelper api such that an extra parameter is added, a function pointer which will be called by the user helper task, after it forks, but before it exec's the required process. This will give the caller the opportunity to get a call back in the processes context, allowing it to do whatever it needs to to the process in the kernel prior to exec-ing the user space code. In the case of do_coredump, this callback is ues to set the core ulimit of the helper process to 1. This elimnates the opt-in problem that I had above, as it allows the ulimit for core sizes to be set to the value of 1, which is what the recursion check looks for in do_coredump. This patch: Create new function call_usermodehelper_fns() and allow it to assign both an init and cleanup function, as we'll as arbitrary data. The init function is called from the context of the forked process and allows for customization of the helper process prior to calling exec. Its return code gates the continuation of the process, or causes its exit. Also add an arbitrary data pointer to the subprocess_info struct allowing for data to be passed from the caller to the new process, and the subsequent cleanup process Also, use this patch to cleanup the cleanup function. It currently takes an argp and envp pointer for freeing, which is ugly. Lets instead just make the subprocess_info structure public, and pass that to the cleanup and init routines Signed-off-by: Neil Horman <nhorman@tuxdriver.com> Reviewed-by: Oleg Nesterov <oleg@redhat.com> Cc: Andi Kleen <andi@firstfloor.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
143 lines
4.4 KiB
C
143 lines
4.4 KiB
C
#ifndef __LINUX_KMOD_H__
|
|
#define __LINUX_KMOD_H__
|
|
|
|
/*
|
|
* include/linux/kmod.h
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include <linux/gfp.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/compiler.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
#define KMOD_PATH_LEN 256
|
|
|
|
#ifdef CONFIG_MODULES
|
|
extern char modprobe_path[]; /* for sysctl */
|
|
/* modprobe exit status on success, -ve on error. Return value
|
|
* usually useless though. */
|
|
extern int __request_module(bool wait, const char *name, ...) \
|
|
__attribute__((format(printf, 2, 3)));
|
|
#define request_module(mod...) __request_module(true, mod)
|
|
#define request_module_nowait(mod...) __request_module(false, mod)
|
|
#define try_then_request_module(x, mod...) \
|
|
((x) ?: (__request_module(true, mod), (x)))
|
|
#else
|
|
static inline int request_module(const char *name, ...) { return -ENOSYS; }
|
|
static inline int request_module_nowait(const char *name, ...) { return -ENOSYS; }
|
|
#define try_then_request_module(x, mod...) (x)
|
|
#endif
|
|
|
|
|
|
struct key;
|
|
struct file;
|
|
|
|
enum umh_wait {
|
|
UMH_NO_WAIT = -1, /* don't wait at all */
|
|
UMH_WAIT_EXEC = 0, /* wait for the exec, but not the process */
|
|
UMH_WAIT_PROC = 1, /* wait for the process to complete */
|
|
};
|
|
|
|
struct subprocess_info {
|
|
struct work_struct work;
|
|
struct completion *complete;
|
|
struct cred *cred;
|
|
char *path;
|
|
char **argv;
|
|
char **envp;
|
|
enum umh_wait wait;
|
|
int retval;
|
|
struct file *stdin;
|
|
int (*init)(struct subprocess_info *info);
|
|
void (*cleanup)(struct subprocess_info *info);
|
|
void *data;
|
|
};
|
|
|
|
/* Allocate a subprocess_info structure */
|
|
struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
|
|
char **envp, gfp_t gfp_mask);
|
|
|
|
/* Set various pieces of state into the subprocess_info structure */
|
|
void call_usermodehelper_setkeys(struct subprocess_info *info,
|
|
struct key *session_keyring);
|
|
int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
|
|
struct file **filp);
|
|
void call_usermodehelper_setfns(struct subprocess_info *info,
|
|
int (*init)(struct subprocess_info *info),
|
|
void (*cleanup)(struct subprocess_info *info),
|
|
void *data);
|
|
|
|
/* Actually execute the sub-process */
|
|
int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
|
|
|
|
/* Free the subprocess_info. This is only needed if you're not going
|
|
to call call_usermodehelper_exec */
|
|
void call_usermodehelper_freeinfo(struct subprocess_info *info);
|
|
|
|
static inline int
|
|
call_usermodehelper_fns(char *path, char **argv, char **envp,
|
|
enum umh_wait wait,
|
|
int (*init)(struct subprocess_info *info),
|
|
void (*cleanup)(struct subprocess_info *), void *data)
|
|
{
|
|
struct subprocess_info *info;
|
|
gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
|
|
|
|
info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
|
|
|
|
if (info == NULL)
|
|
return -ENOMEM;
|
|
|
|
call_usermodehelper_setfns(info, init, cleanup, data);
|
|
|
|
return call_usermodehelper_exec(info, wait);
|
|
}
|
|
|
|
static inline int
|
|
call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
|
|
{
|
|
return call_usermodehelper_fns(path, argv, envp, wait,
|
|
NULL, NULL, NULL);
|
|
}
|
|
|
|
static inline int
|
|
call_usermodehelper_keys(char *path, char **argv, char **envp,
|
|
struct key *session_keyring, enum umh_wait wait)
|
|
{
|
|
struct subprocess_info *info;
|
|
gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
|
|
|
|
info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
|
|
if (info == NULL)
|
|
return -ENOMEM;
|
|
|
|
call_usermodehelper_setkeys(info, session_keyring);
|
|
return call_usermodehelper_exec(info, wait);
|
|
}
|
|
|
|
extern void usermodehelper_init(void);
|
|
|
|
struct file;
|
|
extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
|
|
struct file **filp);
|
|
|
|
extern int usermodehelper_disable(void);
|
|
extern void usermodehelper_enable(void);
|
|
|
|
#endif /* __LINUX_KMOD_H__ */
|