Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Two entries being added at the same time to the IFLA policy table, whilst parallel bug fixes to decnet routing dst handling overlapping with the dst gc removal in net-next.

David S. Miller committed 9 years ago

Commit 3d091982 parents 52f80dc 48b6bbe213 files · +2109 −1711Browse files

Showing the changes to kernel (8 of 213 files). Show all

Unified · Split

8 files

kernel/irq/manage.c +3 −1
kernel/livepatch/patch.c +6 −2
kernel/livepatch/transition.c +31 −5
kernel/sched/core.c +1 −1
kernel/sched/fair.c +1 −1
kernel/time/alarmtimer.c +11 −3
kernel/time/tick-broadcast.c +3 −1
kernel/time/tick-internal.h +0 −2

kernel/irq/manage.c+3−1

 			ret = __irq_set_trigger(desc,
 						new->flags & IRQF_TRIGGER_MASK);
-			if (ret)
+			if (ret) {
+				irq_release_resources(desc);
 				goto out_mask;
+			}
 		}
 		desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \

kernel/livepatch/patch.c+6−2

 	ops = container_of(fops, struct klp_ops, fops);
-	rcu_read_lock();
+	/*
+	 * A variant of synchronize_sched() is used to allow patching functions
+	 * where RCU is not watching, see klp_synchronize_transition().
+	 */
+	preempt_disable_notrace();
 	func = list_first_or_null_rcu(&ops->func_stack, struct klp_func,
 				      stack_node);
 	klp_arch_set_pc(regs, (unsigned long)func->new_func);
 unlock:
-	rcu_read_unlock();
+	preempt_enable_notrace();
 }
 /*

kernel/livepatch/transition.c+31−5

 }
 static DECLARE_DELAYED_WORK(klp_transition_work, klp_transition_work_fn);
+/*
+ * This function is just a stub to implement a hard force
+ * of synchronize_sched(). This requires synchronizing
+ * tasks even in userspace and idle.
+ */
+static void klp_sync(struct work_struct *work)
+{
+}
+/*
+ * We allow to patch also functions where RCU is not watching,
+ * e.g. before user_exit(). We can not rely on the RCU infrastructure
+ * to do the synchronization. Instead hard force the sched synchronization.
+ *
+ * This approach allows to use RCU functions for manipulating func_stack
+ * safely.
+ */
+static void klp_synchronize_transition(void)
+{
+	schedule_on_each_cpu(klp_sync);
+}
 /*
  * The transition to the target patch state is complete.  Clean up the data
  * structures.
 		 * func->transition gets cleared, the handler may choose a
 		 * removed function.
 		 */
-		synchronize_rcu();
+		klp_synchronize_transition();
 	}
 	if (klp_transition_patch->immediate)
 	/* Prevent klp_ftrace_handler() from seeing KLP_UNDEFINED state */
 	if (klp_target_state == KLP_PATCHED)
-		synchronize_rcu();
+		klp_synchronize_transition();
 	read_lock(&tasklist_lock);
 	for_each_process_thread(g, task) {
  */
 void klp_update_patch_state(struct task_struct *task)
 {
-	rcu_read_lock();
+	/*
+	 * A variant of synchronize_sched() is used to allow patching functions
+	 * where RCU is not watching, see klp_synchronize_transition().
+	 */
+	preempt_disable_notrace();
 	/*
 	 * This test_and_clear_tsk_thread_flag() call also serves as a read
 	if (test_and_clear_tsk_thread_flag(task, TIF_PATCH_PENDING))
 		task->patch_state = READ_ONCE(klp_target_state);
-	rcu_read_unlock();
+	preempt_enable_notrace();
 }
 /*
 		clear_tsk_thread_flag(idle_task(cpu), TIF_PATCH_PENDING);
 	/* Let any remaining calls to klp_update_patch_state() complete */
-	synchronize_rcu();
+	klp_synchronize_transition();
 	klp_start_transition();
 }

kernel/sched/core.c+1−1

@@ -5605,7 +5605,7 @@ void idle_task_exit(void) · 5604 unmodified lines
5605	BUG_ON(cpu_online(smp_processor_id()));	5605	BUG_ON(cpu_online(smp_processor_id()));
5606		5606
5607	if (mm != &init_mm) {	5607	if (mm != &init_mm) {
5608	switch_mm_irqs_off(mm, &init_mm, current);	5608	switch_mm(mm, &init_mm, current);
5609	finish_arch_post_lock_switch();	5609	finish_arch_post_lock_switch();
5610	}	5610	}
5611	mmdrop(mm);	5611	mmdrop(mm);

kernel/sched/fair.c+1−1

@@ -3563,7 +3563,7 @@ static inline void check_schedstat_required(void) · 3562 unmodified lines
3563	trace_sched_stat_runtime_enabled()) {	3563	trace_sched_stat_runtime_enabled()) {
3564	printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "	3564	printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "
3565	"stat_blocked and stat_runtime require the "	3565	"stat_blocked and stat_runtime require the "
3566	"kernel parameter schedstats=enabled or "	3566	"kernel parameter schedstats=enable or "
3567	"kernel.sched_schedstats=1\n");	3567	"kernel.sched_schedstats=1\n");
3568	}	3568	}
3569	#endif	3569	#endif

kernel/time/alarmtimer.c+11−3

 {
 	struct alarm_base *base = &alarm_bases[alarm->type];
-	start = ktime_add(start, base->gettime());
+	start = ktime_add_safe(start, base->gettime());
 	alarm_start(alarm, start);
 }
 EXPORT_SYMBOL_GPL(alarm_start_relative);
 		overrun++;
 	}
-	alarm->node.expires = ktime_add(alarm->node.expires, interval);
+	alarm->node.expires = ktime_add_safe(alarm->node.expires, interval);
 	return overrun;
 }
 EXPORT_SYMBOL_GPL(alarm_forward);
 	/* start the timer */
 	timr->it.alarm.interval = timespec64_to_ktime(new_setting->it_interval);
+	/*
+	 * Rate limit to the tick as a hot fix to prevent DOS. Will be
+	 * mopped up later.
+	 */
+	if (timr->it.alarm.interval < TICK_NSEC)
+		timr->it.alarm.interval = TICK_NSEC;
 	exp = timespec64_to_ktime(new_setting->it_value);
 	/* Convert (if necessary) to absolute time */
 	if (flags != TIMER_ABSTIME) {
 		ktime_t now;
 		now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
-		exp = ktime_add(now, exp);
+		exp = ktime_add_safe(now, exp);
 	}
 	alarm_start(&timr->it.alarm.alarmtimer, exp);

kernel/time/tick-broadcast.c+3−1

 static __cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
 #ifdef CONFIG_TICK_ONESHOT
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 static void tick_broadcast_clear_oneshot(int cpu);
 static void tick_resume_broadcast_oneshot(struct clock_event_device *bc);
 #else
+static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_clear_oneshot(int cpu) { }
 static inline void tick_resume_broadcast_oneshot(struct clock_event_device *bc) { }
 #endif
 /**
  * tick_broadcast_setup_oneshot - setup the broadcast device
  */
-void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
 	int cpu = smp_processor_id();

kernel/time/tick-internal.h+0−2

 /* Functions related to oneshot broadcasting */
 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
-extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 extern void tick_broadcast_switch_to_oneshot(void);
 extern void tick_shutdown_broadcast_oneshot(unsigned int cpu);
 extern int tick_broadcast_oneshot_active(void);
 bool tick_broadcast_oneshot_available(void);
 extern struct cpumask *tick_get_broadcast_oneshot_mask(void);
 #else /* !(BROADCAST && ONESHOT): */
-static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_switch_to_oneshot(void) { }
 static inline void tick_shutdown_broadcast_oneshot(unsigned int cpu) { }
 static inline int tick_broadcast_oneshot_active(void) { return 0; }

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code