History

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

Trivial conflict in CAN, keep the net-next + the byteswap wrapper. Conflicts: drivers/net/can/usb/gs_usb.c

Jakub Kicinski committed 5 years ago

Commit 5c39f262 parents 6375da9 c84e1ef387 files · +6414 −2991Browse files

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

Unified · Split

8 files
  1. kernel/locking/lockdep.c +4 −2
  2. kernel/printk/printk.c +2 −2
  3. kernel/printk/printk_ringbuffer.c +0 −2
  4. kernel/ptrace.c +5 −11
  5. kernel/sched/core.c +16 −10
  6. kernel/sched/deadline.c +53 −44
  7. kernel/sched/fair.c +2 −1
  8. kernel/seccomp.c +2 −3
kernel/locking/lockdep.c+4−2
@@ -108,19 +108,21 @@ static inline void lockdep_lock(void) · 107 unmodified lines
108108 {
109109 DEBUG_LOCKS_WARN_ON(!irqs_disabled());
110110
111+ __this_cpu_inc(lockdep_recursion);
111112 arch_spin_lock(&__lock);
112113 __owner = current;
113− __this_cpu_inc(lockdep_recursion);
114114 }
115115
116116 static inline void lockdep_unlock(void)
117117 {
118+ DEBUG_LOCKS_WARN_ON(!irqs_disabled());
119+
118120 if (debug_locks && DEBUG_LOCKS_WARN_ON(__owner != current))
119121 return;
120122
121− __this_cpu_dec(lockdep_recursion);
122123 __owner = NULL;
123124 arch_spin_unlock(&__lock);
125+ __this_cpu_dec(lockdep_recursion);
124126 }
125127
126128 static inline bool lockdep_assert_locked(void)
kernel/printk/printk.c+2−2
@@ -528,8 +528,8 @@ static int log_store(u32 caller_id, int facility, int level, · 527 unmodified lines
528528 if (dev_info)
529529 memcpy(&r.info->dev_info, dev_info, sizeof(r.info->dev_info));
530530
531− /* insert message */
532− if ((flags & LOG_CONT) || !(flags & LOG_NEWLINE))
531+ /* A message without a trailing newline can be continued. */
532+ if (!(flags & LOG_NEWLINE))
533533 prb_commit(&e);
534534 else
535535 prb_final_commit(&e);
kernel/printk/printk_ringbuffer.c+0−2
@@ -882,8 +882,6 @@ static bool desc_reserve(struct printk_ringbuffer *rb, unsigned long *id_out) · 881 unmodified lines
882882 head_id = atomic_long_read(&desc_ring->head_id); /* LMM(desc_reserve:A) */
883883
884884 do {
885− desc = to_desc(desc_ring, head_id);
886−
887885 id = DESC_ID(head_id + 1);
888886 id_prev_wrap = DESC_ID_PREV_WRAP(desc_ring, id);
889887
kernel/ptrace.c+5−11
@@ -264,17 +264,11 @@ static int ptrace_check_attach(struct task_struct *child, bool ignore_state) · 263 unmodified lines
264264 return ret;
265265 }
266266
267−static bool ptrace_has_cap(const struct cred *cred, struct user_namespace *ns,
268− unsigned int mode)
267+static bool ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
269268 {
270− int ret;
271−
272269 if (mode & PTRACE_MODE_NOAUDIT)
273− ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NOAUDIT);
274− else
275− ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NONE);
276−
277− return ret == 0;
270+ return ns_capable_noaudit(ns, CAP_SYS_PTRACE);
271+ return ns_capable(ns, CAP_SYS_PTRACE);
278272 }
279273
280274 /* Returns 0 on success, -errno on denial. */
@@ -326,7 +320,7 @@ static int __ptrace_may_access(struct task_struct *task, unsigned int mode) · 45 unmodified lines
326320 gid_eq(caller_gid, tcred->sgid) &&
327321 gid_eq(caller_gid, tcred->gid))
328322 goto ok;
329− if (ptrace_has_cap(cred, tcred->user_ns, mode))
323+ if (ptrace_has_cap(tcred->user_ns, mode))
330324 goto ok;
331325 rcu_read_unlock();
332326 return -EPERM;
@@ -345,7 +339,7 @@ ok: · 12 unmodified lines
345339 mm = task->mm;
346340 if (mm &&
347341 ((get_dumpable(mm) != SUID_DUMP_USER) &&
348− !ptrace_has_cap(cred, mm->user_ns, mode)))
342+ !ptrace_has_cap(mm->user_ns, mode)))
349343 return -EPERM;
350344
351345 return security_ptrace_access_check(task, mode);
kernel/sched/core.c+16−10
@@ -2501,7 +2501,12 @@ ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags, · 2500 unmodified lines
25012501 #ifdef CONFIG_SMP
25022502 if (wake_flags & WF_MIGRATED)
25032503 en_flags |= ENQUEUE_MIGRATED;
2504+ else
25042505 #endif
2506+ if (p->in_iowait) {
2507+ delayacct_blkio_end(p);
2508+ atomic_dec(&task_rq(p)->nr_iowait);
2509+ }
25052510
25062511 activate_task(rq, p, en_flags);
25072512 ttwu_do_wakeup(rq, p, wake_flags, rf);
@@ -2888,11 +2893,6 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) · 380 unmodified lines
28882893 if (READ_ONCE(p->on_rq) && ttwu_runnable(p, wake_flags))
28892894 goto unlock;
28902895
2891− if (p->in_iowait) {
2892− delayacct_blkio_end(p);
2893− atomic_dec(&task_rq(p)->nr_iowait);
2894− }
2895−
28962896 #ifdef CONFIG_SMP
28972897 /*
28982898 * Ensure we load p->on_cpu _after_ p->on_rq, otherwise it would be
@@ -2963,6 +2963,11 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) · 64 unmodified lines
29632963
29642964 cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
29652965 if (task_cpu(p) != cpu) {
2966+ if (p->in_iowait) {
2967+ delayacct_blkio_end(p);
2968+ atomic_dec(&task_rq(p)->nr_iowait);
2969+ }
2970+
29662971 wake_flags |= WF_MIGRATED;
29672972 psi_ttwu_dequeue(p);
29682973 set_task_cpu(p, cpu);
@@ -4907,20 +4912,21 @@ void rt_mutex_setprio(struct task_struct *p, struct task_struct *pi_task) · 1938 unmodified lines
49074912 if (!dl_prio(p->normal_prio) ||
49084913 (pi_task && dl_prio(pi_task->prio) &&
49094914 dl_entity_preempt(&pi_task->dl, &p->dl))) {
4910− p->dl.dl_boosted = 1;
4915+ p->dl.pi_se = pi_task->dl.pi_se;
49114916 queue_flag |= ENQUEUE_REPLENISH;
4912− } else
4913− p->dl.dl_boosted = 0;
4917+ } else {
4918+ p->dl.pi_se = &p->dl;
4919+ }
49144920 p->sched_class = &dl_sched_class;
49154921 } else if (rt_prio(prio)) {
49164922 if (dl_prio(oldprio))
4917− p->dl.dl_boosted = 0;
4923+ p->dl.pi_se = &p->dl;
49184924 if (oldprio < prio)
49194925 queue_flag |= ENQUEUE_HEAD;
49204926 p->sched_class = &rt_sched_class;
49214927 } else {
49224928 if (dl_prio(oldprio))
4923− p->dl.dl_boosted = 0;
4929+ p->dl.pi_se = &p->dl;
49244930 if (rt_prio(oldprio))
49254931 p->rt.timeout = 0;
49264932 p->sched_class = &fair_sched_class;
kernel/sched/deadline.c+53−44
@@ -43,6 +43,28 @@ static inline int on_dl_rq(struct sched_dl_entity *dl_se) · 42 unmodified lines
4343 return !RB_EMPTY_NODE(&dl_se->rb_node);
4444 }
4545
46+#ifdef CONFIG_RT_MUTEXES
47+static inline struct sched_dl_entity *pi_of(struct sched_dl_entity *dl_se)
48+{
49+ return dl_se->pi_se;
50+}
51+
52+static inline bool is_dl_boosted(struct sched_dl_entity *dl_se)
53+{
54+ return pi_of(dl_se) != dl_se;
55+}
56+#else
57+static inline struct sched_dl_entity *pi_of(struct sched_dl_entity *dl_se)
58+{
59+ return dl_se;
60+}
61+
62+static inline bool is_dl_boosted(struct sched_dl_entity *dl_se)
63+{
64+ return false;
65+}
66+#endif
67+
4668 #ifdef CONFIG_SMP
4769 static inline struct dl_bw *dl_bw_of(int i)
4870 {
@@ -698,7 +720,7 @@ static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se) · 649 unmodified lines
698720 struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
699721 struct rq *rq = rq_of_dl_rq(dl_rq);
700722
701− WARN_ON(dl_se->dl_boosted);
723+ WARN_ON(is_dl_boosted(dl_se));
702724 WARN_ON(dl_time_before(rq_clock(rq), dl_se->deadline));
703725
704726 /*
@@ -736,21 +758,20 @@ static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se) · 31 unmodified lines
736758 * could happen are, typically, a entity voluntarily trying to overcome its
737759 * runtime, or it just underestimated it during sched_setattr().
738760 */
739−static void replenish_dl_entity(struct sched_dl_entity *dl_se,
740− struct sched_dl_entity *pi_se)
761+static void replenish_dl_entity(struct sched_dl_entity *dl_se)
741762 {
742763 struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
743764 struct rq *rq = rq_of_dl_rq(dl_rq);
744765
745− BUG_ON(pi_se->dl_runtime <= 0);
766+ BUG_ON(pi_of(dl_se)->dl_runtime <= 0);
746767
747768 /*
748769 * This could be the case for a !-dl task that is boosted.
749770 * Just go with full inherited parameters.
750771 */
751772 if (dl_se->dl_deadline == 0) {
752− dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
753− dl_se->runtime = pi_se->dl_runtime;
773+ dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;
774+ dl_se->runtime = pi_of(dl_se)->dl_runtime;
754775 }
755776
756777 if (dl_se->dl_yielded && dl_se->runtime > 0)
@@ -763,8 +784,8 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se, · 6 unmodified lines
763784 * arbitrary large.
764785 */
765786 while (dl_se->runtime <= 0) {
766− dl_se->deadline += pi_se->dl_period;
767− dl_se->runtime += pi_se->dl_runtime;
787+ dl_se->deadline += pi_of(dl_se)->dl_period;
788+ dl_se->runtime += pi_of(dl_se)->dl_runtime;
768789 }
769790
770791 /*
@@ -778,8 +799,8 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se, · 7 unmodified lines
778799 */
779800 if (dl_time_before(dl_se->deadline, rq_clock(rq))) {
780801 printk_deferred_once("sched: DL replenish lagged too much\n");
781− dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
782− dl_se->runtime = pi_se->dl_runtime;
802+ dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;
803+ dl_se->runtime = pi_of(dl_se)->dl_runtime;
783804 }
784805
785806 if (dl_se->dl_yielded)
@@ -812,8 +833,7 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se, · 26 unmodified lines
812833 * task with deadline equal to period this is the same of using
813834 * dl_period instead of dl_deadline in the equation above.
814835 */
815−static bool dl_entity_overflow(struct sched_dl_entity *dl_se,
816− struct sched_dl_entity *pi_se, u64 t)
836+static bool dl_entity_overflow(struct sched_dl_entity *dl_se, u64 t)
817837 {
818838 u64 left, right;
819839
@@ -835,9 +855,9 @@ static bool dl_entity_overflow(struct sched_dl_entity *dl_se, · 15 unmodified lines
835855 * of anything below microseconds resolution is actually fiction
836856 * (but still we want to give the user that illusion >;).
837857 */
838− left = (pi_se->dl_deadline >> DL_SCALE) * (dl_se->runtime >> DL_SCALE);
858+ left = (pi_of(dl_se)->dl_deadline >> DL_SCALE) * (dl_se->runtime >> DL_SCALE);
839859 right = ((dl_se->deadline - t) >> DL_SCALE) *
840− (pi_se->dl_runtime >> DL_SCALE);
860+ (pi_of(dl_se)->dl_runtime >> DL_SCALE);
841861
842862 return dl_time_before(right, left);
843863 }
@@ -922,24 +942,23 @@ static inline bool dl_is_implicit(struct sched_dl_entity *dl_se) · 78 unmodified lines
922942 * Please refer to the comments update_dl_revised_wakeup() function to find
923943 * more about the Revised CBS rule.
924944 */
925−static void update_dl_entity(struct sched_dl_entity *dl_se,
926− struct sched_dl_entity *pi_se)
945+static void update_dl_entity(struct sched_dl_entity *dl_se)
927946 {
928947 struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
929948 struct rq *rq = rq_of_dl_rq(dl_rq);
930949
931950 if (dl_time_before(dl_se->deadline, rq_clock(rq)) ||
932− dl_entity_overflow(dl_se, pi_se, rq_clock(rq))) {
951+ dl_entity_overflow(dl_se, rq_clock(rq))) {
933952
934953 if (unlikely(!dl_is_implicit(dl_se) &&
935954 !dl_time_before(dl_se->deadline, rq_clock(rq)) &&
936− !dl_se->dl_boosted)){
955+ !is_dl_boosted(dl_se))) {
937956 update_dl_revised_wakeup(dl_se, rq);
938957 return;
939958 }
940959
941− dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
942− dl_se->runtime = pi_se->dl_runtime;
960+ dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;
961+ dl_se->runtime = pi_of(dl_se)->dl_runtime;
943962 }
944963 }
945964
@@ -1038,7 +1057,7 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer) · 92 unmodified lines
10381057 * The task might have been boosted by someone else and might be in the
10391058 * boosting/deboosting path, its not throttled.
10401059 */
1041− if (dl_se->dl_boosted)
1060+ if (is_dl_boosted(dl_se))
10421061 goto unlock;
10431062
10441063 /*
@@ -1066,7 +1085,7 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer) · 21 unmodified lines
10661085 * but do not enqueue -- wait for our wakeup to do that.
10671086 */
10681087 if (!task_on_rq_queued(p)) {
1069− replenish_dl_entity(dl_se, dl_se);
1088+ replenish_dl_entity(dl_se);
10701089 goto unlock;
10711090 }
10721091
@@ -1156,7 +1175,7 @@ static inline void dl_check_constrained_dl(struct sched_dl_entity *dl_se) · 83 unmodified lines
11561175
11571176 if (dl_time_before(dl_se->deadline, rq_clock(rq)) &&
11581177 dl_time_before(rq_clock(rq), dl_next_period(dl_se))) {
1159− if (unlikely(dl_se->dl_boosted || !start_dl_timer(p)))
1178+ if (unlikely(is_dl_boosted(dl_se) || !start_dl_timer(p)))
11601179 return;
11611180 dl_se->dl_throttled = 1;
11621181 if (dl_se->runtime > 0)
@@ -1287,7 +1306,7 @@ throttle: · 124 unmodified lines
12871306 dl_se->dl_overrun = 1;
12881307
12891308 __dequeue_task_dl(rq, curr, 0);
1290− if (unlikely(dl_se->dl_boosted || !start_dl_timer(curr)))
1309+ if (unlikely(is_dl_boosted(dl_se) || !start_dl_timer(curr)))
12911310 enqueue_task_dl(rq, curr, ENQUEUE_REPLENISH);
12921311
12931312 if (!is_leftmost(curr, &rq->dl))
@@ -1481,8 +1500,7 @@ static void __dequeue_dl_entity(struct sched_dl_entity *dl_se) · 187 unmodified lines
14811500 }
14821501
14831502 static void
1484−enqueue_dl_entity(struct sched_dl_entity *dl_se,
1485− struct sched_dl_entity *pi_se, int flags)
1503+enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags)
14861504 {
14871505 BUG_ON(on_dl_rq(dl_se));
14881506
@@ -1493,9 +1511,9 @@ enqueue_dl_entity(struct sched_dl_entity *dl_se, · 4 unmodified lines
14931511 */
14941512 if (flags & ENQUEUE_WAKEUP) {
14951513 task_contending(dl_se, flags);
1496− update_dl_entity(dl_se, pi_se);
1514+ update_dl_entity(dl_se);
14971515 } else if (flags & ENQUEUE_REPLENISH) {
1498− replenish_dl_entity(dl_se, pi_se);
1516+ replenish_dl_entity(dl_se);
14991517 } else if ((flags & ENQUEUE_RESTORE) &&
15001518 dl_time_before(dl_se->deadline,
15011519 rq_clock(rq_of_dl_rq(dl_rq_of_se(dl_se))))) {
@@ -1512,19 +1530,7 @@ static void dequeue_dl_entity(struct sched_dl_entity *dl_se) · 10 unmodified lines
15121530
15131531 static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags)
15141532 {
1515− struct task_struct *pi_task = rt_mutex_get_top_task(p);
1516− struct sched_dl_entity *pi_se = &p->dl;
1517−
1518− /*
1519− * Use the scheduling parameters of the top pi-waiter task if:
1520− * - we have a top pi-waiter which is a SCHED_DEADLINE task AND
1521− * - our dl_boosted is set (i.e. the pi-waiter's (absolute) deadline is
1522− * smaller than our deadline OR we are a !SCHED_DEADLINE task getting
1523− * boosted due to a SCHED_DEADLINE pi-waiter).
1524− * Otherwise we keep our runtime and deadline.
1525− */
1526− if (pi_task && dl_prio(pi_task->normal_prio) && p->dl.dl_boosted) {
1527− pi_se = &pi_task->dl;
1533+ if (is_dl_boosted(&p->dl)) {
15281534 /*
15291535 * Because of delays in the detection of the overrun of a
15301536 * thread's runtime, it might be the case that a thread
@@ -1557,7 +1563,7 @@ static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags) · 26 unmodified lines
15571563 * the throttle.
15581564 */
15591565 p->dl.dl_throttled = 0;
1560− BUG_ON(!p->dl.dl_boosted || flags != ENQUEUE_REPLENISH);
1566+ BUG_ON(!is_dl_boosted(&p->dl) || flags != ENQUEUE_REPLENISH);
15611567 return;
15621568 }
15631569
@@ -1594,7 +1600,7 @@ static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags) · 30 unmodified lines
15941600 return;
15951601 }
15961602
1597− enqueue_dl_entity(&p->dl, pi_se, flags);
1603+ enqueue_dl_entity(&p->dl, flags);
15981604
15991605 if (!task_current(rq, p) && p->nr_cpus_allowed > 1)
16001606 enqueue_pushable_dl_task(rq, p);
@@ -2787,11 +2793,14 @@ void __dl_clear_params(struct task_struct *p) · 1186 unmodified lines
27872793 dl_se->dl_bw = 0;
27882794 dl_se->dl_density = 0;
27892795
2790− dl_se->dl_boosted = 0;
27912796 dl_se->dl_throttled = 0;
27922797 dl_se->dl_yielded = 0;
27932798 dl_se->dl_non_contending = 0;
27942799 dl_se->dl_overrun = 0;
2800+
2801+#ifdef CONFIG_RT_MUTEXES
2802+ dl_se->pi_se = dl_se;
2803+#endif
27952804 }
27962805
27972806 bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr)
kernel/sched/fair.c+2−1
@@ -5477,6 +5477,7 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) · 5476 unmodified lines
54775477 struct cfs_rq *cfs_rq;
54785478 struct sched_entity *se = &p->se;
54795479 int idle_h_nr_running = task_has_idle_policy(p);
5480+ int task_new = !(flags & ENQUEUE_WAKEUP);
54805481
54815482 /*
54825483 * The code below (indirectly) updates schedutil which looks at
@@ -5549,7 +5550,7 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) · 66 unmodified lines
55495550 * into account, but that is not straightforward to implement,
55505551 * and the following generally works well enough in practice.
55515552 */
5552− if (flags & ENQUEUE_WAKEUP)
5553+ if (!task_new)
55535554 update_overutilized_status(rq);
55545555
55555556 enqueue_throttle:
kernel/seccomp.c+2−3
@@ -38,7 +38,7 @@ · 37 unmodified lines
3838 #include <linux/filter.h>
3939 #include <linux/pid.h>
4040 #include <linux/ptrace.h>
41−#include <linux/security.h>
41+#include <linux/capability.h>
4242 #include <linux/tracehook.h>
4343 #include <linux/uaccess.h>
4444 #include <linux/anon_inodes.h>
@@ -558,8 +558,7 @@ static struct seccomp_filter *seccomp_prepare_filter(struct sock_fprog *fprog) · 513 unmodified lines
558558 * behavior of privileged children.
559559 */
560560 if (!task_no_new_privs(current) &&
561− security_capable(current_cred(), current_user_ns(),
562− CAP_SYS_ADMIN, CAP_OPT_NOAUDIT) != 0)
561+ !ns_capable_noaudit(current_user_ns(), CAP_SYS_ADMIN))
563562 return ERR_PTR(-EACCES);
564563
565564 /* Allocate a new seccomp_filter */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t