Process Notification / pnotify

Index: linux/fs/exec.c
===================================================================
@@ -48,6 +48,7 @@
 #include <linux/syscalls.h>
 #include <linux/rmap.h>
 #include <linux/acct.h>
+#include <linux/pnotify.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>

@@ -1203,6 +1204,7 @@
 	retval = search_binary_handler(bprm,regs);
 	if (retval >= 0) {
 		free_arg_pages(bprm);
+		pnotify_exec(current);
 
 		/* execve success */
 		security_bprm_free(bprm);

Index: linux/include/linux/init_task.h
===================================================================
@@ -2,6 +2,7 @@
 #define _LINUX__INIT_TASK_H
 
 #include <linux/file.h>
+#include <linux/pnotify.h>
 #include <linux/rcupdate.h>
 
 #define INIT_FDTABLE \

@@ -121,6 +122,7 @@
 	.proc_lock	= SPIN_LOCK_UNLOCKED,				\
 	.journal_info	= NULL,						\
 	.cpu_timers	= INIT_CPU_TIMERS(tsk.cpu_timers),		\
+	INIT_TASK_PNOTIFY(tsk)						\
 	.fs_excl	= ATOMIC_INIT(0),				\
 }
 

Index: linux/include/linux/sched.h
===================================================================
@@ -795,6 +795,11 @@
   	struct mempolicy *mempolicy;
 	short il_next;
 #endif
+#ifdef CONFIG_PNOTIFY
+/* List of pnotify kernel module subscribers */
+	struct list_head pnotify_subscriber_list;
+	struct rw_semaphore pnotify_subscriber_list_sem;
+#endif
 #ifdef CONFIG_CPUSETS
 	struct cpuset *cpuset;
 	nodemask_t mems_allowed;

Index: linux/kernel/fork.c
===================================================================
@@ -42,6 +42,7 @@
 #include <linux/profile.h>
 #include <linux/rmap.h>
 #include <linux/acct.h>
+#include <linux/pnotify.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>

@@ -151,6 +152,9 @@
 	init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
 	init_task.signal->rlim[RLIMIT_SIGPENDING] =
 		init_task.signal->rlim[RLIMIT_NPROC];
+
+	/* Initialize the pnotify list in pid 0 before it can clone itself. */
+	INIT_PNOTIFY_LIST(current);
 }
 
 static struct task_struct *dup_task_struct(struct task_struct *orig)

@@ -1039,6 +1043,15 @@
 	p->exit_state = 0;
 
 	/*
+	 * Call pnotify kernel module subscribers and add the same subscribers the
+	 * parent has to the new process.
+	 * Fail the fork on error.
+	 */
+	retval = pnotify_fork(p, current);
+	if (retval)
+ 		goto bad_fork_cleanup_namespace;
+
+	/*
 	 * Ok, make it visible to the rest of the system.
 	 * We dont wake it up yet.
 	 */

@@ -1073,7 +1086,7 @@
 	if (sigismember(&current->pending.signal, SIGKILL)) {
 		write_unlock_irq(&tasklist_lock);
 		retval = -EINTR;
-		goto bad_fork_cleanup_namespace;
+		goto bad_fork_cleanup_pnotify;
 	}
 
 	/* CLONE_PARENT re-uses the old parent */

@@ -1159,6 +1172,8 @@
 		return ERR_PTR(retval);
 	return p;
 
+bad_fork_cleanup_pnotify:
+	pnotify_exit(p);
 bad_fork_cleanup_namespace:
 	exit_namespace(p);
 bad_fork_cleanup_keys:

Index: linux/kernel/exit.c
===================================================================
@@ -29,6 +29,7 @@
 #include <linux/proc_fs.h>
 #include <linux/mempolicy.h>
 #include <linux/cpuset.h>
+#include <linux/pnotify.h>
 #include <linux/syscalls.h>
 #include <linux/signal.h>
 

@@ -866,6 +867,9 @@
 		module_put(tsk->binfmt->module);
 
 	tsk->exit_code = code;
+
+	pnotify_exit(tsk);
+
 	exit_notify(tsk);
 #ifdef CONFIG_NUMA
 	mpol_free(tsk->mempolicy);

568 lines not on this page · raw message

227 lines not on this page · raw message

Index: linux/include/linux/key.h
===================================================================
@@ -19,6 +19,7 @@
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <linux/rcupdate.h>
+#include <linux/pnotify.h>
 #include <asm/atomic.h>
 
 #ifdef __KERNEL__

@@ -262,9 +263,9 @@
 extern struct key root_user_keyring, root_session_keyring;
 extern int alloc_uid_keyring(struct user_struct *user);
 extern void switch_uid_keyring(struct user_struct *new_user);
-extern int copy_keys(unsigned long clone_flags, struct task_struct *tsk);
+extern int copy_keys(struct task_struct *tsk, struct pnotify_subscriber *sub, void *olddata);
 extern int copy_thread_group_keys(struct task_struct *tsk);
-extern void exit_keys(struct task_struct *tsk);
+extern void exit_keys(struct task_struct *task, struct pnotify_subscriber *sub);
 extern void exit_thread_group_keys(struct signal_struct *tg);
 extern int suid_keys(struct task_struct *tsk);
 extern int exec_keys(struct task_struct *tsk);

@@ -279,6 +280,22 @@
 	old_session;						\
 })
 
+/* pnotify subscriber service request */
+static struct pnotify_events key_events = {
+	.module = NULL,
+	.name = "key",
+	.data = NULL,
+	.entry = LIST_HEAD_INIT(key_events.entry),
+	.fork = copy_keys,
+	.exit = exit_keys,
+};
+
+/* key info associated with the task struct and managed by pnotify */
+struct key_task {
+	struct key *thread_keyring; /* keyring private to this thread */
+	unsigned char jit_keyring; /* default keyring to attach requested keys to */
+};
+
 #else /* CONFIG_KEYS */
 
 #define key_validate(k)			0

Index: linux/kernel/exit.c
===================================================================
@@ -857,7 +857,6 @@
 	exit_namespace(tsk);
 	exit_thread();
 	cpuset_exit(tsk);
-	exit_keys(tsk);
 
 	if (group_dead && tsk->signal->leader)
 		disassociate_ctty(1);

Index: linux/kernel/fork.c
===================================================================
@@ -1009,10 +1009,8 @@
 		goto bad_fork_cleanup_sighand;
 	if ((retval = copy_mm(clone_flags, p)))
 		goto bad_fork_cleanup_signal;
-	if ((retval = copy_keys(clone_flags, p)))
-		goto bad_fork_cleanup_mm;
 	if ((retval = copy_namespace(clone_flags, p)))
-		goto bad_fork_cleanup_keys;
+		goto bad_fork_cleanup_mm;
 	retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
 	if (retval)
 		goto bad_fork_cleanup_namespace;

@@ -1175,8 +1173,6 @@
 bad_fork_cleanup_namespace:
 	pnotify_exit(p);
 	exit_namespace(p);
-bad_fork_cleanup_keys:
-	exit_keys(p);
 bad_fork_cleanup_mm:
 	if (p->mm)
 		mmput(p->mm);

Index: linux/security/keys/key.c
===================================================================
@@ -15,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/err.h>
+#include <linux/pnotify.h>
 #include "internal.h"
 
 static kmem_cache_t	*key_jar;

@@ -1009,6 +1010,9 @@
  */
 void __init key_init(void)
 {
+	struct key_task *kt;
+	struct pnotify_subscriber *sub;
+
 	/* allocate a slab in which we can store keys */
 	key_jar = kmem_cache_create("key_jar", sizeof(struct key),
 			0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);

@@ -1039,4 +1043,22 @@
 	/* link the two root keyrings together */
 	key_link(&root_session_keyring, &root_user_keyring);
 
+	/* Allocate memory for task assocated key_task structure */
+	kt = (struct key_task *)kmalloc(sizeof(struct key_task),GFP_KERNEL);
+	if (!kt) {
+		printk(KERN_ERR "Insufficient memory to allocate key_task structure"
+		  " in key_init function.\n");
+		return;
+   }
+	kt->thread_keyring = NULL;
+
+	/* subscribe this kernel entity to the subscriber list for current task */
+	sub = pnotify_subscribe(current, &key_events);
+	if (!sub) {
+		printk(KERN_ERR "Insufficient memory to add to subscriber list structure"
+		  " in key_init function.\n");
+	}
+	/* Associate the kt structure with this task via pnotify subscriber */
+	sub->data = (void *)kt;
+
 } /* end key_init() */

259 lines not on this page · raw message

Index: linux/include/linux/sched.h
===================================================================
@@ -718,10 +718,6 @@
 	kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
 	unsigned keep_capabilities:1;
 	struct user_struct *user;
-#ifdef CONFIG_KEYS
-	struct key *thread_keyring;	/* keyring private to this thread */
-	unsigned char jit_keyring;	/* default keyring to attach requested keys to */
-#endif
 	int oomkilladj; /* OOM kill score adjustment (bit shift). */
 	char comm[TASK_COMM_LEN]; /* executable name excluding path
 				     - access with [gs]et_task_comm (which lock

Index: linux/security/keys/keyctl.c
===================================================================
@@ -931,31 +931,51 @@
 long keyctl_set_reqkey_keyring(int reqkey_defl)
 {
 	int ret;
+	unsigned char jit_return;
+	struct pnotify_subscriber *sub;
+	struct key_task *kt;
+
+	down_write(&current->pnotify_subscriber_list_sem);
+	sub = pnotify_get_subscriber(current, key_events.name);
+	if (sub == NULL || sub->data == NULL) { /* shouldn't happen */
+		printk(KERN_ERR "keyctl_set_reqkey_keyring pnotify subscriber or data ptr null, task: %d\n", current->pid);
+		up_write(&current->pnotify_subscriber_list_sem);
+		return -EFAULT;
+	}
+	kt = (struct key_task *)sub->data;
 
 	switch (reqkey_defl) {
 	case KEY_REQKEY_DEFL_THREAD_KEYRING:
 		ret = install_thread_keyring(current);
-		if (ret < 0)
+		if (ret < 0) {
+			up_write(&current->pnotify_subscriber_list_sem);
 			return ret;
+		}
 		goto set;
 
 	case KEY_REQKEY_DEFL_PROCESS_KEYRING:
 		ret = install_process_keyring(current);
-		if (ret < 0)
+		if (ret < 0) {
+			up_write(&current->pnotify_subscriber_list_sem);
 			return ret;
+		}
 
 	case KEY_REQKEY_DEFL_DEFAULT:
 	case KEY_REQKEY_DEFL_SESSION_KEYRING:
 	case KEY_REQKEY_DEFL_USER_KEYRING:
 	case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
 	set:
-		current->jit_keyring = reqkey_defl;
+
+		kt->jit_keyring = reqkey_defl;
 
 	case KEY_REQKEY_DEFL_NO_CHANGE:
-		return current->jit_keyring;
+		jit_return = kt->jit_keyring;
+		up_write(&current->pnotify_subscriber_list_sem);
+		return jit_return;
 
 	case KEY_REQKEY_DEFL_GROUP_KEYRING:
 	default:
+		up_write(&current->pnotify_subscriber_list_sem);
 		return -EINVAL;
 	}
 

Index: linux/security/keys/request_key.c
===================================================================
@@ -14,6 +14,7 @@
 #include <linux/kmod.h>
 #include <linux/err.h>
 #include <linux/keyctl.h>
+#include <linux/pnotify.h>
 #include "internal.h"
 
 struct key_construction {

@@ -39,6 +40,17 @@
 	char *argv[10], *envp[3], uid_str[12], gid_str[12];
 	char key_str[12], keyring_str[3][12];
 	int ret, i;
+	struct pnotify_subscriber *sub;
+	struct key_task *kt;
+
+	down_write(&tsk->pnotify_subscriber_list_sem);
+	sub = pnotify_get_subscriber(current, key_events.name);
+	if (sub == NULL || sub->data == NULL) { /* shouldn't happen */
+		printk(KERN_ERR "call_request_key pnotify subscriber or data ptr null, task: %d\n", tsk->pid);
+		up_write(&tsk->pnotify_subscriber_list_sem);
+		return -EFAULT;
+	}
+	kt = (struct key_task *)sub->data;
 
 	kenter("{%d},%s,%s", key->serial, op, callout_info);
 

@@ -58,7 +70,7 @@
 
 	/* we specify the process's default keyrings */
 	sprintf(keyring_str[0], "%d",
-		tsk->thread_keyring ? tsk->thread_keyring->serial : 0);
+		kt->thread_keyring ? kt->thread_keyring->serial : 0);
 
 	prkey = 0;
 	if (tsk->signal->process_keyring)

@@ -105,6 +117,7 @@
 	key_put(session_keyring);
 
  error:
+	up_write(&tsk->pnotify_subscriber_list_sem);
 	kleave(" = %d", ret);
 	return ret;
 

@@ -300,15 +313,26 @@
 {
 	struct task_struct *tsk = current;
 	struct key *drop = NULL;
+	struct pnotify_subscriber *sub;
+	struct key_task *kt;
+
+	down_write(&tsk->pnotify_subscriber_list_sem);
+	sub = pnotify_get_subscriber(current, key_events.name);
+	if (sub == NULL || sub->data == NULL) { /* shouldn't happen */
+		printk(KERN_ERR "request_key_link pnotify subscriber or data ptr null, task: %d\n", tsk->pid);
+		up_write(&tsk->pnotify_subscriber_list_sem);
+		return;
+	}
+	kt = (struct key_task *)sub->data;
 
 	kenter("{%d},%p", key->serial, dest_keyring);
 
 	/* find the appropriate keyring */
 	if (!dest_keyring) {
-		switch (tsk->jit_keyring) {
+		switch (kt->jit_keyring) {
 		case KEY_REQKEY_DEFL_DEFAULT:
 		case KEY_REQKEY_DEFL_THREAD_KEYRING:
-			dest_keyring = tsk->thread_keyring;
+			dest_keyring = kt->thread_keyring;
 			if (dest_keyring)
 				break;
 

@@ -347,6 +371,7 @@
 	key_put(drop);
 
 	kleave("");
+	down_write(&tsk->pnotify_subscriber_list_sem);
 
 } /* end request_key_link() */
 

1,871 lines not on this page · raw message

185 lines not on this page · raw message

124 lines not on this page · raw message

Index: linux/kernel/fork.c
===================================================================
@@ -122,6 +122,7 @@
 	if (!profile_handoff_task(tsk))
 		free_task(tsk);
 }
+EXPORT_SYMBOL_GPL(__put_task_struct);
 
 void __init fork_init(unsigned long mempages)
 {

Index: linux/kernel/signal.c
===================================================================
@@ -1978,6 +1978,7 @@
 EXPORT_SYMBOL(ptrace_notify);
 EXPORT_SYMBOL(send_sig);
 EXPORT_SYMBOL(send_sig_info);
+EXPORT_SYMBOL(send_group_sig_info);
 EXPORT_SYMBOL(sigprocmask);
 EXPORT_SYMBOL(block_all_signals);
 EXPORT_SYMBOL(unblock_all_signals);