svcrdma: Fix error handling during listening endpoint creation

[safe/jmp/linux-2.6] / kernel / kprobes.c

diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 76275fc..1e0250c 100644 (file)
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -429,6 +429,21 @@ static inline void free_rp_inst(struct kretprobe *rp)
        }
 }
 
+static void __kprobes cleanup_rp_inst(struct kretprobe *rp)
+{
+       unsigned long flags;
+       struct kretprobe_instance *ri;
+       struct hlist_node *pos, *next;
+       /* No race here */
+       spin_lock_irqsave(&kretprobe_lock, flags);
+       hlist_for_each_entry_safe(ri, pos, next, &rp->used_instances, uflist) {
+               ri->rp = NULL;
+               hlist_del(&ri->uflist);
+       }
+       spin_unlock_irqrestore(&kretprobe_lock, flags);
+       free_rp_inst(rp);
+}
+
 /*
  * Keep all fields in the kprobe consistent
  */
@@ -740,24 +755,69 @@ unsigned long __weak arch_deref_entry_point(void *entry)
        return (unsigned long)entry;
 }
 
-int __kprobes register_jprobe(struct jprobe *jp)
+static int __register_jprobes(struct jprobe **jps, int num,
+       unsigned long called_from)
 {
-       unsigned long addr = arch_deref_entry_point(jp->entry);
+       struct jprobe *jp;
+       int ret = 0, i;
 
-       if (!kernel_text_address(addr))
+       if (num <= 0)
                return -EINVAL;
+       for (i = 0; i < num; i++) {
+               unsigned long addr;
+               jp = jps[i];
+               addr = arch_deref_entry_point(jp->entry);
+
+               if (!kernel_text_address(addr))
+                       ret = -EINVAL;
+               else {
+                       /* Todo: Verify probepoint is a function entry point */
+                       jp->kp.pre_handler = setjmp_pre_handler;
+                       jp->kp.break_handler = longjmp_break_handler;
+                       ret = __register_kprobe(&jp->kp, called_from);
+               }
+               if (ret < 0 && i > 0) {
+                       unregister_jprobes(jps, i);
+                       break;
+               }
+       }
+       return ret;
+}
 
-       /* Todo: Verify probepoint is a function entry point */
-       jp->kp.pre_handler = setjmp_pre_handler;
-       jp->kp.break_handler = longjmp_break_handler;
-
-       return __register_kprobe(&jp->kp,
+int __kprobes register_jprobe(struct jprobe *jp)
+{
+       return __register_jprobes(&jp, 1,
                (unsigned long)__builtin_return_address(0));
 }
 
 void __kprobes unregister_jprobe(struct jprobe *jp)
 {
-       unregister_kprobe(&jp->kp);
+       unregister_jprobes(&jp, 1);
+}
+
+int __kprobes register_jprobes(struct jprobe **jps, int num)
+{
+       return __register_jprobes(jps, num,
+               (unsigned long)__builtin_return_address(0));
+}
+
+void __kprobes unregister_jprobes(struct jprobe **jps, int num)
+{
+       int i;
+
+       if (num <= 0)
+               return;
+       mutex_lock(&kprobe_mutex);
+       for (i = 0; i < num; i++)
+               if (__unregister_kprobe_top(&jps[i]->kp) < 0)
+                       jps[i]->kp.addr = NULL;
+       mutex_unlock(&kprobe_mutex);
+
+       synchronize_sched();
+       for (i = 0; i < num; i++) {
+               if (jps[i]->kp.addr)
+                       __unregister_kprobe_bottom(&jps[i]->kp);
+       }
 }
 
 #ifdef CONFIG_KRETPROBES
@@ -798,7 +858,8 @@ static int __kprobes pre_handler_kretprobe(struct kprobe *p,
        return 0;
 }
 
-int __kprobes register_kretprobe(struct kretprobe *rp)
+static int __kprobes __register_kretprobe(struct kretprobe *rp,
+                                         unsigned long called_from)
 {
        int ret = 0;
        struct kretprobe_instance *inst;
@@ -844,43 +905,93 @@ int __kprobes register_kretprobe(struct kretprobe *rp)
 
        rp->nmissed = 0;
        /* Establish function entry probe point */
-       if ((ret = __register_kprobe(&rp->kp,
-               (unsigned long)__builtin_return_address(0))) != 0)
+       ret = __register_kprobe(&rp->kp, called_from);
+       if (ret != 0)
                free_rp_inst(rp);
        return ret;
 }
 
+static int __register_kretprobes(struct kretprobe **rps, int num,
+       unsigned long called_from)
+{
+       int ret = 0, i;
+
+       if (num <= 0)
+               return -EINVAL;
+       for (i = 0; i < num; i++) {
+               ret = __register_kretprobe(rps[i], called_from);
+               if (ret < 0 && i > 0) {
+                       unregister_kretprobes(rps, i);
+                       break;
+               }
+       }
+       return ret;
+}
+
+int __kprobes register_kretprobe(struct kretprobe *rp)
+{
+       return __register_kretprobes(&rp, 1,
+                       (unsigned long)__builtin_return_address(0));
+}
+
+void __kprobes unregister_kretprobe(struct kretprobe *rp)
+{
+       unregister_kretprobes(&rp, 1);
+}
+
+int __kprobes register_kretprobes(struct kretprobe **rps, int num)
+{
+       return __register_kretprobes(rps, num,
+                       (unsigned long)__builtin_return_address(0));
+}
+
+void __kprobes unregister_kretprobes(struct kretprobe **rps, int num)
+{
+       int i;
+
+       if (num <= 0)
+               return;
+       mutex_lock(&kprobe_mutex);
+       for (i = 0; i < num; i++)
+               if (__unregister_kprobe_top(&rps[i]->kp) < 0)
+                       rps[i]->kp.addr = NULL;
+       mutex_unlock(&kprobe_mutex);
+
+       synchronize_sched();
+       for (i = 0; i < num; i++) {
+               if (rps[i]->kp.addr) {
+                       __unregister_kprobe_bottom(&rps[i]->kp);
+                       cleanup_rp_inst(rps[i]);
+               }
+       }
+}
+
 #else /* CONFIG_KRETPROBES */
 int __kprobes register_kretprobe(struct kretprobe *rp)
 {
        return -ENOSYS;
 }
 
-static int __kprobes pre_handler_kretprobe(struct kprobe *p,
-                                          struct pt_regs *regs)
+int __kprobes register_kretprobes(struct kretprobe **rps, int num)
 {
-       return 0;
+       return -ENOSYS;
 }
-#endif /* CONFIG_KRETPROBES */
-
 void __kprobes unregister_kretprobe(struct kretprobe *rp)
 {
-       unsigned long flags;
-       struct kretprobe_instance *ri;
-       struct hlist_node *pos, *next;
+}
 
-       unregister_kprobe(&rp->kp);
+void __kprobes unregister_kretprobes(struct kretprobe **rps, int num)
+{
+}
 
-       /* No race here */
-       spin_lock_irqsave(&kretprobe_lock, flags);
-       hlist_for_each_entry_safe(ri, pos, next, &rp->used_instances, uflist) {
-               ri->rp = NULL;
-               hlist_del(&ri->uflist);
-       }
-       spin_unlock_irqrestore(&kretprobe_lock, flags);
-       free_rp_inst(rp);
+static int __kprobes pre_handler_kretprobe(struct kprobe *p,
+                                          struct pt_regs *regs)
+{
+       return 0;
 }
 
+#endif /* CONFIG_KRETPROBES */
+
 static int __init init_kprobes(void)
 {
        int i, err = 0;
@@ -1170,6 +1281,8 @@ EXPORT_SYMBOL_GPL(register_kprobes);
 EXPORT_SYMBOL_GPL(unregister_kprobes);
 EXPORT_SYMBOL_GPL(register_jprobe);
 EXPORT_SYMBOL_GPL(unregister_jprobe);
+EXPORT_SYMBOL_GPL(register_jprobes);
+EXPORT_SYMBOL_GPL(unregister_jprobes);
 #ifdef CONFIG_KPROBES
 EXPORT_SYMBOL_GPL(jprobe_return);
 #endif
@@ -1177,4 +1290,6 @@ EXPORT_SYMBOL_GPL(jprobe_return);
 #ifdef CONFIG_KPROBES
 EXPORT_SYMBOL_GPL(register_kretprobe);
 EXPORT_SYMBOL_GPL(unregister_kretprobe);
+EXPORT_SYMBOL_GPL(register_kretprobes);
+EXPORT_SYMBOL_GPL(unregister_kretprobes);
 #endif