posix-cpu-timers: Move state tracking to struct posix_cputimers
[sfrench/cifs-2.6.git] / kernel / time / posix-cpu-timers.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Implement CPU time clocks for the POSIX clock interface.
4  */
5
6 #include <linux/sched/signal.h>
7 #include <linux/sched/cputime.h>
8 #include <linux/posix-timers.h>
9 #include <linux/errno.h>
10 #include <linux/math64.h>
11 #include <linux/uaccess.h>
12 #include <linux/kernel_stat.h>
13 #include <trace/events/timer.h>
14 #include <linux/tick.h>
15 #include <linux/workqueue.h>
16 #include <linux/compat.h>
17 #include <linux/sched/deadline.h>
18
19 #include "posix-timers.h"
20
21 static void posix_cpu_timer_rearm(struct k_itimer *timer);
22
23 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit)
24 {
25         posix_cputimers_init(pct);
26         if (cpu_limit != RLIM_INFINITY) {
27                 pct->bases[CPUCLOCK_PROF].nextevt = cpu_limit * NSEC_PER_SEC;
28                 pct->timers_active = true;
29         }
30 }
31
32 /*
33  * Called after updating RLIMIT_CPU to run cpu timer and update
34  * tsk->signal->posix_cputimers.bases[clock].nextevt expiration cache if
35  * necessary. Needs siglock protection since other code may update the
36  * expiration cache as well.
37  */
38 void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new)
39 {
40         u64 nsecs = rlim_new * NSEC_PER_SEC;
41
42         spin_lock_irq(&task->sighand->siglock);
43         set_process_cpu_timer(task, CPUCLOCK_PROF, &nsecs, NULL);
44         spin_unlock_irq(&task->sighand->siglock);
45 }
46
47 /*
48  * Functions for validating access to tasks.
49  */
50 static struct task_struct *lookup_task(const pid_t pid, bool thread)
51 {
52         struct task_struct *p;
53
54         if (!pid)
55                 return thread ? current : current->group_leader;
56
57         p = find_task_by_vpid(pid);
58         if (!p || p == current)
59                 return p;
60         if (thread)
61                 return same_thread_group(p, current) ? p : NULL;
62         if (p == current)
63                 return p;
64         return has_group_leader_pid(p) ? p : NULL;
65 }
66
67 static struct task_struct *__get_task_for_clock(const clockid_t clock,
68                                                 bool getref)
69 {
70         const bool thread = !!CPUCLOCK_PERTHREAD(clock);
71         const pid_t pid = CPUCLOCK_PID(clock);
72         struct task_struct *p;
73
74         if (CPUCLOCK_WHICH(clock) >= CPUCLOCK_MAX)
75                 return NULL;
76
77         rcu_read_lock();
78         p = lookup_task(pid, thread);
79         if (p && getref)
80                 get_task_struct(p);
81         rcu_read_unlock();
82         return p;
83 }
84
85 static inline struct task_struct *get_task_for_clock(const clockid_t clock)
86 {
87         return __get_task_for_clock(clock, true);
88 }
89
90 static inline int validate_clock_permissions(const clockid_t clock)
91 {
92         return __get_task_for_clock(clock, false) ? 0 : -EINVAL;
93 }
94
95 /*
96  * Update expiry time from increment, and increase overrun count,
97  * given the current clock sample.
98  */
99 static void bump_cpu_timer(struct k_itimer *timer, u64 now)
100 {
101         int i;
102         u64 delta, incr;
103
104         if (!timer->it_interval)
105                 return;
106
107         if (now < timer->it.cpu.expires)
108                 return;
109
110         incr = timer->it_interval;
111         delta = now + incr - timer->it.cpu.expires;
112
113         /* Don't use (incr*2 < delta), incr*2 might overflow. */
114         for (i = 0; incr < delta - incr; i++)
115                 incr = incr << 1;
116
117         for (; i >= 0; incr >>= 1, i--) {
118                 if (delta < incr)
119                         continue;
120
121                 timer->it.cpu.expires += incr;
122                 timer->it_overrun += 1LL << i;
123                 delta -= incr;
124         }
125 }
126
127 /* Check whether all cache entries contain U64_MAX, i.e. eternal expiry time */
128 static inline bool expiry_cache_is_inactive(const struct posix_cputimers *pct)
129 {
130         return !(~pct->bases[CPUCLOCK_PROF].nextevt |
131                  ~pct->bases[CPUCLOCK_VIRT].nextevt |
132                  ~pct->bases[CPUCLOCK_SCHED].nextevt);
133 }
134
135 static int
136 posix_cpu_clock_getres(const clockid_t which_clock, struct timespec64 *tp)
137 {
138         int error = validate_clock_permissions(which_clock);
139
140         if (!error) {
141                 tp->tv_sec = 0;
142                 tp->tv_nsec = ((NSEC_PER_SEC + HZ - 1) / HZ);
143                 if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
144                         /*
145                          * If sched_clock is using a cycle counter, we
146                          * don't have any idea of its true resolution
147                          * exported, but it is much more than 1s/HZ.
148                          */
149                         tp->tv_nsec = 1;
150                 }
151         }
152         return error;
153 }
154
155 static int
156 posix_cpu_clock_set(const clockid_t clock, const struct timespec64 *tp)
157 {
158         int error = validate_clock_permissions(clock);
159
160         /*
161          * You can never reset a CPU clock, but we check for other errors
162          * in the call before failing with EPERM.
163          */
164         return error ? : -EPERM;
165 }
166
167 /*
168  * Sample a per-thread clock for the given task. clkid is validated.
169  */
170 static u64 cpu_clock_sample(const clockid_t clkid, struct task_struct *p)
171 {
172         u64 utime, stime;
173
174         if (clkid == CPUCLOCK_SCHED)
175                 return task_sched_runtime(p);
176
177         task_cputime(p, &utime, &stime);
178
179         switch (clkid) {
180         case CPUCLOCK_PROF:
181                 return utime + stime;
182         case CPUCLOCK_VIRT:
183                 return utime;
184         default:
185                 WARN_ON_ONCE(1);
186         }
187         return 0;
188 }
189
190 static inline void store_samples(u64 *samples, u64 stime, u64 utime, u64 rtime)
191 {
192         samples[CPUCLOCK_PROF] = stime + utime;
193         samples[CPUCLOCK_VIRT] = utime;
194         samples[CPUCLOCK_SCHED] = rtime;
195 }
196
197 static void task_sample_cputime(struct task_struct *p, u64 *samples)
198 {
199         u64 stime, utime;
200
201         task_cputime(p, &utime, &stime);
202         store_samples(samples, stime, utime, p->se.sum_exec_runtime);
203 }
204
205 static void proc_sample_cputime_atomic(struct task_cputime_atomic *at,
206                                        u64 *samples)
207 {
208         u64 stime, utime, rtime;
209
210         utime = atomic64_read(&at->utime);
211         stime = atomic64_read(&at->stime);
212         rtime = atomic64_read(&at->sum_exec_runtime);
213         store_samples(samples, stime, utime, rtime);
214 }
215
216 /*
217  * Set cputime to sum_cputime if sum_cputime > cputime. Use cmpxchg
218  * to avoid race conditions with concurrent updates to cputime.
219  */
220 static inline void __update_gt_cputime(atomic64_t *cputime, u64 sum_cputime)
221 {
222         u64 curr_cputime;
223 retry:
224         curr_cputime = atomic64_read(cputime);
225         if (sum_cputime > curr_cputime) {
226                 if (atomic64_cmpxchg(cputime, curr_cputime, sum_cputime) != curr_cputime)
227                         goto retry;
228         }
229 }
230
231 static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic,
232                               struct task_cputime *sum)
233 {
234         __update_gt_cputime(&cputime_atomic->utime, sum->utime);
235         __update_gt_cputime(&cputime_atomic->stime, sum->stime);
236         __update_gt_cputime(&cputime_atomic->sum_exec_runtime, sum->sum_exec_runtime);
237 }
238
239 /**
240  * thread_group_sample_cputime - Sample cputime for a given task
241  * @tsk:        Task for which cputime needs to be started
242  * @iimes:      Storage for time samples
243  *
244  * Called from sys_getitimer() to calculate the expiry time of an active
245  * timer. That means group cputime accounting is already active. Called
246  * with task sighand lock held.
247  *
248  * Updates @times with an uptodate sample of the thread group cputimes.
249  */
250 void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples)
251 {
252         struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
253         struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
254
255         WARN_ON_ONCE(!pct->timers_active);
256
257         proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
258 }
259
260 /**
261  * thread_group_start_cputime - Start cputime and return a sample
262  * @tsk:        Task for which cputime needs to be started
263  * @samples:    Storage for time samples
264  *
265  * The thread group cputime accouting is avoided when there are no posix
266  * CPU timers armed. Before starting a timer it's required to check whether
267  * the time accounting is active. If not, a full update of the atomic
268  * accounting store needs to be done and the accounting enabled.
269  *
270  * Updates @times with an uptodate sample of the thread group cputimes.
271  */
272 static void thread_group_start_cputime(struct task_struct *tsk, u64 *samples)
273 {
274         struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
275         struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
276
277         /* Check if cputimer isn't running. This is accessed without locking. */
278         if (!READ_ONCE(pct->timers_active)) {
279                 struct task_cputime sum;
280
281                 /*
282                  * The POSIX timer interface allows for absolute time expiry
283                  * values through the TIMER_ABSTIME flag, therefore we have
284                  * to synchronize the timer to the clock every time we start it.
285                  */
286                 thread_group_cputime(tsk, &sum);
287                 update_gt_cputime(&cputimer->cputime_atomic, &sum);
288
289                 /*
290                  * We're setting timers_active without a lock. Ensure this
291                  * only gets written to in one operation. We set it after
292                  * update_gt_cputime() as a small optimization, but
293                  * barriers are not required because update_gt_cputime()
294                  * can handle concurrent updates.
295                  */
296                 WRITE_ONCE(pct->timers_active, true);
297         }
298         proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
299 }
300
301 static void __thread_group_cputime(struct task_struct *tsk, u64 *samples)
302 {
303         struct task_cputime ct;
304
305         thread_group_cputime(tsk, &ct);
306         store_samples(samples, ct.stime, ct.utime, ct.sum_exec_runtime);
307 }
308
309 /*
310  * Sample a process (thread group) clock for the given task clkid. If the
311  * group's cputime accounting is already enabled, read the atomic
312  * store. Otherwise a full update is required.  Task's sighand lock must be
313  * held to protect the task traversal on a full update. clkid is already
314  * validated.
315  */
316 static u64 cpu_clock_sample_group(const clockid_t clkid, struct task_struct *p,
317                                   bool start)
318 {
319         struct thread_group_cputimer *cputimer = &p->signal->cputimer;
320         struct posix_cputimers *pct = &p->signal->posix_cputimers;
321         u64 samples[CPUCLOCK_MAX];
322
323         if (!READ_ONCE(pct->timers_active)) {
324                 if (start)
325                         thread_group_start_cputime(p, samples);
326                 else
327                         __thread_group_cputime(p, samples);
328         } else {
329                 proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
330         }
331
332         return samples[clkid];
333 }
334
335 static int posix_cpu_clock_get(const clockid_t clock, struct timespec64 *tp)
336 {
337         const clockid_t clkid = CPUCLOCK_WHICH(clock);
338         struct task_struct *tsk;
339         u64 t;
340
341         tsk = get_task_for_clock(clock);
342         if (!tsk)
343                 return -EINVAL;
344
345         if (CPUCLOCK_PERTHREAD(clock))
346                 t = cpu_clock_sample(clkid, tsk);
347         else
348                 t = cpu_clock_sample_group(clkid, tsk, false);
349         put_task_struct(tsk);
350
351         *tp = ns_to_timespec64(t);
352         return 0;
353 }
354
355 /*
356  * Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
357  * This is called from sys_timer_create() and do_cpu_nanosleep() with the
358  * new timer already all-zeros initialized.
359  */
360 static int posix_cpu_timer_create(struct k_itimer *new_timer)
361 {
362         struct task_struct *p = get_task_for_clock(new_timer->it_clock);
363
364         if (!p)
365                 return -EINVAL;
366
367         new_timer->kclock = &clock_posix_cpu;
368         INIT_LIST_HEAD(&new_timer->it.cpu.entry);
369         new_timer->it.cpu.task = p;
370         return 0;
371 }
372
373 /*
374  * Clean up a CPU-clock timer that is about to be destroyed.
375  * This is called from timer deletion with the timer already locked.
376  * If we return TIMER_RETRY, it's necessary to release the timer's lock
377  * and try again.  (This happens when the timer is in the middle of firing.)
378  */
379 static int posix_cpu_timer_del(struct k_itimer *timer)
380 {
381         int ret = 0;
382         unsigned long flags;
383         struct sighand_struct *sighand;
384         struct task_struct *p = timer->it.cpu.task;
385
386         if (WARN_ON_ONCE(!p))
387                 return -EINVAL;
388
389         /*
390          * Protect against sighand release/switch in exit/exec and process/
391          * thread timer list entry concurrent read/writes.
392          */
393         sighand = lock_task_sighand(p, &flags);
394         if (unlikely(sighand == NULL)) {
395                 /*
396                  * We raced with the reaping of the task.
397                  * The deletion should have cleared us off the list.
398                  */
399                 WARN_ON_ONCE(!list_empty(&timer->it.cpu.entry));
400         } else {
401                 if (timer->it.cpu.firing)
402                         ret = TIMER_RETRY;
403                 else
404                         list_del(&timer->it.cpu.entry);
405
406                 unlock_task_sighand(p, &flags);
407         }
408
409         if (!ret)
410                 put_task_struct(p);
411
412         return ret;
413 }
414
415 static void cleanup_timers_list(struct list_head *head)
416 {
417         struct cpu_timer_list *timer, *next;
418
419         list_for_each_entry_safe(timer, next, head, entry)
420                 list_del_init(&timer->entry);
421 }
422
423 /*
424  * Clean out CPU timers which are still armed when a thread exits. The
425  * timers are only removed from the list. No other updates are done. The
426  * corresponding posix timers are still accessible, but cannot be rearmed.
427  *
428  * This must be called with the siglock held.
429  */
430 static void cleanup_timers(struct posix_cputimers *pct)
431 {
432         cleanup_timers_list(&pct->bases[CPUCLOCK_PROF].cpu_timers);
433         cleanup_timers_list(&pct->bases[CPUCLOCK_VIRT].cpu_timers);
434         cleanup_timers_list(&pct->bases[CPUCLOCK_SCHED].cpu_timers);
435 }
436
437 /*
438  * These are both called with the siglock held, when the current thread
439  * is being reaped.  When the final (leader) thread in the group is reaped,
440  * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
441  */
442 void posix_cpu_timers_exit(struct task_struct *tsk)
443 {
444         cleanup_timers(&tsk->posix_cputimers);
445 }
446 void posix_cpu_timers_exit_group(struct task_struct *tsk)
447 {
448         cleanup_timers(&tsk->signal->posix_cputimers);
449 }
450
451 /*
452  * Insert the timer on the appropriate list before any timers that
453  * expire later.  This must be called with the sighand lock held.
454  */
455 static void arm_timer(struct k_itimer *timer)
456 {
457         struct cpu_timer_list *const nt = &timer->it.cpu;
458         int clkidx = CPUCLOCK_WHICH(timer->it_clock);
459         struct task_struct *p = timer->it.cpu.task;
460         u64 newexp = timer->it.cpu.expires;
461         struct posix_cputimer_base *base;
462         struct list_head *head, *listpos;
463         struct cpu_timer_list *next;
464
465         if (CPUCLOCK_PERTHREAD(timer->it_clock))
466                 base = p->posix_cputimers.bases + clkidx;
467         else
468                 base = p->signal->posix_cputimers.bases + clkidx;
469
470         listpos = head = &base->cpu_timers;
471         list_for_each_entry(next,head, entry) {
472                 if (nt->expires < next->expires)
473                         break;
474                 listpos = &next->entry;
475         }
476         list_add(&nt->entry, listpos);
477
478         if (listpos != head)
479                 return;
480
481         /*
482          * We are the new earliest-expiring POSIX 1.b timer, hence
483          * need to update expiration cache. Take into account that
484          * for process timers we share expiration cache with itimers
485          * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
486          */
487         if (newexp < base->nextevt)
488                 base->nextevt = newexp;
489
490         if (CPUCLOCK_PERTHREAD(timer->it_clock))
491                 tick_dep_set_task(p, TICK_DEP_BIT_POSIX_TIMER);
492         else
493                 tick_dep_set_signal(p->signal, TICK_DEP_BIT_POSIX_TIMER);
494 }
495
496 /*
497  * The timer is locked, fire it and arrange for its reload.
498  */
499 static void cpu_timer_fire(struct k_itimer *timer)
500 {
501         if ((timer->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
502                 /*
503                  * User don't want any signal.
504                  */
505                 timer->it.cpu.expires = 0;
506         } else if (unlikely(timer->sigq == NULL)) {
507                 /*
508                  * This a special case for clock_nanosleep,
509                  * not a normal timer from sys_timer_create.
510                  */
511                 wake_up_process(timer->it_process);
512                 timer->it.cpu.expires = 0;
513         } else if (!timer->it_interval) {
514                 /*
515                  * One-shot timer.  Clear it as soon as it's fired.
516                  */
517                 posix_timer_event(timer, 0);
518                 timer->it.cpu.expires = 0;
519         } else if (posix_timer_event(timer, ++timer->it_requeue_pending)) {
520                 /*
521                  * The signal did not get queued because the signal
522                  * was ignored, so we won't get any callback to
523                  * reload the timer.  But we need to keep it
524                  * ticking in case the signal is deliverable next time.
525                  */
526                 posix_cpu_timer_rearm(timer);
527                 ++timer->it_requeue_pending;
528         }
529 }
530
531 /*
532  * Guts of sys_timer_settime for CPU timers.
533  * This is called with the timer locked and interrupts disabled.
534  * If we return TIMER_RETRY, it's necessary to release the timer's lock
535  * and try again.  (This happens when the timer is in the middle of firing.)
536  */
537 static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags,
538                                struct itimerspec64 *new, struct itimerspec64 *old)
539 {
540         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
541         u64 old_expires, new_expires, old_incr, val;
542         struct task_struct *p = timer->it.cpu.task;
543         struct sighand_struct *sighand;
544         unsigned long flags;
545         int ret;
546
547         if (WARN_ON_ONCE(!p))
548                 return -EINVAL;
549
550         /*
551          * Use the to_ktime conversion because that clamps the maximum
552          * value to KTIME_MAX and avoid multiplication overflows.
553          */
554         new_expires = ktime_to_ns(timespec64_to_ktime(new->it_value));
555
556         /*
557          * Protect against sighand release/switch in exit/exec and p->cpu_timers
558          * and p->signal->cpu_timers read/write in arm_timer()
559          */
560         sighand = lock_task_sighand(p, &flags);
561         /*
562          * If p has just been reaped, we can no
563          * longer get any information about it at all.
564          */
565         if (unlikely(sighand == NULL)) {
566                 return -ESRCH;
567         }
568
569         /*
570          * Disarm any old timer after extracting its expiry time.
571          */
572
573         ret = 0;
574         old_incr = timer->it_interval;
575         old_expires = timer->it.cpu.expires;
576         if (unlikely(timer->it.cpu.firing)) {
577                 timer->it.cpu.firing = -1;
578                 ret = TIMER_RETRY;
579         } else
580                 list_del_init(&timer->it.cpu.entry);
581
582         /*
583          * We need to sample the current value to convert the new
584          * value from to relative and absolute, and to convert the
585          * old value from absolute to relative.  To set a process
586          * timer, we need a sample to balance the thread expiry
587          * times (in arm_timer).  With an absolute time, we must
588          * check if it's already passed.  In short, we need a sample.
589          */
590         if (CPUCLOCK_PERTHREAD(timer->it_clock))
591                 val = cpu_clock_sample(clkid, p);
592         else
593                 val = cpu_clock_sample_group(clkid, p, true);
594
595         if (old) {
596                 if (old_expires == 0) {
597                         old->it_value.tv_sec = 0;
598                         old->it_value.tv_nsec = 0;
599                 } else {
600                         /*
601                          * Update the timer in case it has
602                          * overrun already.  If it has,
603                          * we'll report it as having overrun
604                          * and with the next reloaded timer
605                          * already ticking, though we are
606                          * swallowing that pending
607                          * notification here to install the
608                          * new setting.
609                          */
610                         bump_cpu_timer(timer, val);
611                         if (val < timer->it.cpu.expires) {
612                                 old_expires = timer->it.cpu.expires - val;
613                                 old->it_value = ns_to_timespec64(old_expires);
614                         } else {
615                                 old->it_value.tv_nsec = 1;
616                                 old->it_value.tv_sec = 0;
617                         }
618                 }
619         }
620
621         if (unlikely(ret)) {
622                 /*
623                  * We are colliding with the timer actually firing.
624                  * Punt after filling in the timer's old value, and
625                  * disable this firing since we are already reporting
626                  * it as an overrun (thanks to bump_cpu_timer above).
627                  */
628                 unlock_task_sighand(p, &flags);
629                 goto out;
630         }
631
632         if (new_expires != 0 && !(timer_flags & TIMER_ABSTIME)) {
633                 new_expires += val;
634         }
635
636         /*
637          * Install the new expiry time (or zero).
638          * For a timer with no notification action, we don't actually
639          * arm the timer (we'll just fake it for timer_gettime).
640          */
641         timer->it.cpu.expires = new_expires;
642         if (new_expires != 0 && val < new_expires) {
643                 arm_timer(timer);
644         }
645
646         unlock_task_sighand(p, &flags);
647         /*
648          * Install the new reload setting, and
649          * set up the signal and overrun bookkeeping.
650          */
651         timer->it_interval = timespec64_to_ktime(new->it_interval);
652
653         /*
654          * This acts as a modification timestamp for the timer,
655          * so any automatic reload attempt will punt on seeing
656          * that we have reset the timer manually.
657          */
658         timer->it_requeue_pending = (timer->it_requeue_pending + 2) &
659                 ~REQUEUE_PENDING;
660         timer->it_overrun_last = 0;
661         timer->it_overrun = -1;
662
663         if (new_expires != 0 && !(val < new_expires)) {
664                 /*
665                  * The designated time already passed, so we notify
666                  * immediately, even if the thread never runs to
667                  * accumulate more time on this clock.
668                  */
669                 cpu_timer_fire(timer);
670         }
671
672         ret = 0;
673  out:
674         if (old)
675                 old->it_interval = ns_to_timespec64(old_incr);
676
677         return ret;
678 }
679
680 static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp)
681 {
682         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
683         struct task_struct *p = timer->it.cpu.task;
684         u64 now;
685
686         if (WARN_ON_ONCE(!p))
687                 return;
688
689         /*
690          * Easy part: convert the reload time.
691          */
692         itp->it_interval = ktime_to_timespec64(timer->it_interval);
693
694         if (!timer->it.cpu.expires)
695                 return;
696
697         /*
698          * Sample the clock to take the difference with the expiry time.
699          */
700         if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
701                 now = cpu_clock_sample(clkid, p);
702         } else {
703                 struct sighand_struct *sighand;
704                 unsigned long flags;
705
706                 /*
707                  * Protect against sighand release/switch in exit/exec and
708                  * also make timer sampling safe if it ends up calling
709                  * thread_group_cputime().
710                  */
711                 sighand = lock_task_sighand(p, &flags);
712                 if (unlikely(sighand == NULL)) {
713                         /*
714                          * The process has been reaped.
715                          * We can't even collect a sample any more.
716                          * Call the timer disarmed, nothing else to do.
717                          */
718                         timer->it.cpu.expires = 0;
719                         return;
720                 } else {
721                         now = cpu_clock_sample_group(clkid, p, false);
722                         unlock_task_sighand(p, &flags);
723                 }
724         }
725
726         if (now < timer->it.cpu.expires) {
727                 itp->it_value = ns_to_timespec64(timer->it.cpu.expires - now);
728         } else {
729                 /*
730                  * The timer should have expired already, but the firing
731                  * hasn't taken place yet.  Say it's just about to expire.
732                  */
733                 itp->it_value.tv_nsec = 1;
734                 itp->it_value.tv_sec = 0;
735         }
736 }
737
738 static unsigned long long
739 check_timers_list(struct list_head *timers,
740                   struct list_head *firing,
741                   unsigned long long curr)
742 {
743         int maxfire = 20;
744
745         while (!list_empty(timers)) {
746                 struct cpu_timer_list *t;
747
748                 t = list_first_entry(timers, struct cpu_timer_list, entry);
749
750                 if (!--maxfire || curr < t->expires)
751                         return t->expires;
752
753                 t->firing = 1;
754                 list_move_tail(&t->entry, firing);
755         }
756
757         return U64_MAX;
758 }
759
760 static void collect_posix_cputimers(struct posix_cputimers *pct,
761                                     u64 *samples, struct list_head *firing)
762 {
763         struct posix_cputimer_base *base = pct->bases;
764         int i;
765
766         for (i = 0; i < CPUCLOCK_MAX; i++, base++) {
767                 base->nextevt = check_timers_list(&base->cpu_timers, firing,
768                                                    samples[i]);
769         }
770 }
771
772 static inline void check_dl_overrun(struct task_struct *tsk)
773 {
774         if (tsk->dl.dl_overrun) {
775                 tsk->dl.dl_overrun = 0;
776                 __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
777         }
778 }
779
780 static bool check_rlimit(u64 time, u64 limit, int signo, bool rt, bool hard)
781 {
782         if (time < limit)
783                 return false;
784
785         if (print_fatal_signals) {
786                 pr_info("%s Watchdog Timeout (%s): %s[%d]\n",
787                         rt ? "RT" : "CPU", hard ? "hard" : "soft",
788                         current->comm, task_pid_nr(current));
789         }
790         __group_send_sig_info(signo, SEND_SIG_PRIV, current);
791         return true;
792 }
793
794 /*
795  * Check for any per-thread CPU timers that have fired and move them off
796  * the tsk->cpu_timers[N] list onto the firing list.  Here we update the
797  * tsk->it_*_expires values to reflect the remaining thread CPU timers.
798  */
799 static void check_thread_timers(struct task_struct *tsk,
800                                 struct list_head *firing)
801 {
802         struct posix_cputimers *pct = &tsk->posix_cputimers;
803         u64 samples[CPUCLOCK_MAX];
804         unsigned long soft;
805
806         if (dl_task(tsk))
807                 check_dl_overrun(tsk);
808
809         if (expiry_cache_is_inactive(pct))
810                 return;
811
812         task_sample_cputime(tsk, samples);
813         collect_posix_cputimers(pct, samples, firing);
814
815         /*
816          * Check for the special case thread timers.
817          */
818         soft = task_rlimit(tsk, RLIMIT_RTTIME);
819         if (soft != RLIM_INFINITY) {
820                 /* Task RT timeout is accounted in jiffies. RTTIME is usec */
821                 unsigned long rttime = tsk->rt.timeout * (USEC_PER_SEC / HZ);
822                 unsigned long hard = task_rlimit_max(tsk, RLIMIT_RTTIME);
823
824                 /* At the hard limit, send SIGKILL. No further action. */
825                 if (hard != RLIM_INFINITY &&
826                     check_rlimit(rttime, hard, SIGKILL, true, true))
827                         return;
828
829                 /* At the soft limit, send a SIGXCPU every second */
830                 if (check_rlimit(rttime, soft, SIGXCPU, true, false)) {
831                         soft += USEC_PER_SEC;
832                         tsk->signal->rlim[RLIMIT_RTTIME].rlim_cur = soft;
833                 }
834         }
835
836         if (expiry_cache_is_inactive(pct))
837                 tick_dep_clear_task(tsk, TICK_DEP_BIT_POSIX_TIMER);
838 }
839
840 static inline void stop_process_timers(struct signal_struct *sig)
841 {
842         struct posix_cputimers *pct = &sig->posix_cputimers;
843
844         /* Turn off the active flag. This is done without locking. */
845         WRITE_ONCE(pct->timers_active, false);
846         tick_dep_clear_signal(sig, TICK_DEP_BIT_POSIX_TIMER);
847 }
848
849 static void check_cpu_itimer(struct task_struct *tsk, struct cpu_itimer *it,
850                              u64 *expires, u64 cur_time, int signo)
851 {
852         if (!it->expires)
853                 return;
854
855         if (cur_time >= it->expires) {
856                 if (it->incr)
857                         it->expires += it->incr;
858                 else
859                         it->expires = 0;
860
861                 trace_itimer_expire(signo == SIGPROF ?
862                                     ITIMER_PROF : ITIMER_VIRTUAL,
863                                     task_tgid(tsk), cur_time);
864                 __group_send_sig_info(signo, SEND_SIG_PRIV, tsk);
865         }
866
867         if (it->expires && it->expires < *expires)
868                 *expires = it->expires;
869 }
870
871 /*
872  * Check for any per-thread CPU timers that have fired and move them
873  * off the tsk->*_timers list onto the firing list.  Per-thread timers
874  * have already been taken off.
875  */
876 static void check_process_timers(struct task_struct *tsk,
877                                  struct list_head *firing)
878 {
879         struct signal_struct *const sig = tsk->signal;
880         struct posix_cputimers *pct = &sig->posix_cputimers;
881         u64 samples[CPUCLOCK_MAX];
882         unsigned long soft;
883
884         /*
885          * If there are no active process wide timers (POSIX 1.b, itimers,
886          * RLIMIT_CPU) nothing to check.
887          */
888         if (!READ_ONCE(pct->timers_active))
889                 return;
890
891        /*
892          * Signify that a thread is checking for process timers.
893          * Write access to this field is protected by the sighand lock.
894          */
895         pct->timers_active = true;
896
897         /*
898          * Collect the current process totals. Group accounting is active
899          * so the sample can be taken directly.
900          */
901         proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic, samples);
902         collect_posix_cputimers(pct, samples, firing);
903
904         /*
905          * Check for the special case process timers.
906          */
907         check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF],
908                          &pct->bases[CPUCLOCK_PROF].nextevt,
909                          samples[CPUCLOCK_PROF], SIGPROF);
910         check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT],
911                          &pct->bases[CPUCLOCK_VIRT].nextevt,
912                          samples[CPUCLOCK_VIRT], SIGVTALRM);
913
914         soft = task_rlimit(tsk, RLIMIT_CPU);
915         if (soft != RLIM_INFINITY) {
916                 /* RLIMIT_CPU is in seconds. Samples are nanoseconds */
917                 unsigned long hard = task_rlimit_max(tsk, RLIMIT_CPU);
918                 u64 ptime = samples[CPUCLOCK_PROF];
919                 u64 softns = (u64)soft * NSEC_PER_SEC;
920                 u64 hardns = (u64)hard * NSEC_PER_SEC;
921
922                 /* At the hard limit, send SIGKILL. No further action. */
923                 if (hard != RLIM_INFINITY &&
924                     check_rlimit(ptime, hardns, SIGKILL, false, true))
925                         return;
926
927                 /* At the soft limit, send a SIGXCPU every second */
928                 if (check_rlimit(ptime, softns, SIGXCPU, false, false)) {
929                         sig->rlim[RLIMIT_CPU].rlim_cur = soft + 1;
930                         softns += NSEC_PER_SEC;
931                 }
932
933                 /* Update the expiry cache */
934                 if (softns < pct->bases[CPUCLOCK_PROF].nextevt)
935                         pct->bases[CPUCLOCK_PROF].nextevt = softns;
936         }
937
938         if (expiry_cache_is_inactive(pct))
939                 stop_process_timers(sig);
940
941         pct->expiry_active = false;
942 }
943
944 /*
945  * This is called from the signal code (via posixtimer_rearm)
946  * when the last timer signal was delivered and we have to reload the timer.
947  */
948 static void posix_cpu_timer_rearm(struct k_itimer *timer)
949 {
950         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
951         struct task_struct *p = timer->it.cpu.task;
952         struct sighand_struct *sighand;
953         unsigned long flags;
954         u64 now;
955
956         if (WARN_ON_ONCE(!p))
957                 return;
958
959         /*
960          * Fetch the current sample and update the timer's expiry time.
961          */
962         if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
963                 now = cpu_clock_sample(clkid, p);
964                 bump_cpu_timer(timer, now);
965                 if (unlikely(p->exit_state))
966                         return;
967
968                 /* Protect timer list r/w in arm_timer() */
969                 sighand = lock_task_sighand(p, &flags);
970                 if (!sighand)
971                         return;
972         } else {
973                 /*
974                  * Protect arm_timer() and timer sampling in case of call to
975                  * thread_group_cputime().
976                  */
977                 sighand = lock_task_sighand(p, &flags);
978                 if (unlikely(sighand == NULL)) {
979                         /*
980                          * The process has been reaped.
981                          * We can't even collect a sample any more.
982                          */
983                         timer->it.cpu.expires = 0;
984                         return;
985                 } else if (unlikely(p->exit_state) && thread_group_empty(p)) {
986                         /* If the process is dying, no need to rearm */
987                         goto unlock;
988                 }
989                 now = cpu_clock_sample_group(clkid, p, true);
990                 bump_cpu_timer(timer, now);
991                 /* Leave the sighand locked for the call below.  */
992         }
993
994         /*
995          * Now re-arm for the new expiry time.
996          */
997         arm_timer(timer);
998 unlock:
999         unlock_task_sighand(p, &flags);
1000 }
1001
1002 /**
1003  * task_cputimers_expired - Check whether posix CPU timers are expired
1004  *
1005  * @samples:    Array of current samples for the CPUCLOCK clocks
1006  * @pct:        Pointer to a posix_cputimers container
1007  *
1008  * Returns true if any member of @samples is greater than the corresponding
1009  * member of @pct->bases[CLK].nextevt. False otherwise
1010  */
1011 static inline bool
1012 task_cputimers_expired(const u64 *sample, struct posix_cputimers *pct)
1013 {
1014         int i;
1015
1016         for (i = 0; i < CPUCLOCK_MAX; i++) {
1017                 if (sample[i] >= pct->bases[i].nextevt)
1018                         return true;
1019         }
1020         return false;
1021 }
1022
1023 /**
1024  * fastpath_timer_check - POSIX CPU timers fast path.
1025  *
1026  * @tsk:        The task (thread) being checked.
1027  *
1028  * Check the task and thread group timers.  If both are zero (there are no
1029  * timers set) return false.  Otherwise snapshot the task and thread group
1030  * timers and compare them with the corresponding expiration times.  Return
1031  * true if a timer has expired, else return false.
1032  */
1033 static inline bool fastpath_timer_check(struct task_struct *tsk)
1034 {
1035         struct posix_cputimers *pct = &tsk->posix_cputimers;
1036         struct signal_struct *sig;
1037
1038         if (!expiry_cache_is_inactive(pct)) {
1039                 u64 samples[CPUCLOCK_MAX];
1040
1041                 task_sample_cputime(tsk, samples);
1042                 if (task_cputimers_expired(samples, pct))
1043                         return true;
1044         }
1045
1046         sig = tsk->signal;
1047         pct = &sig->posix_cputimers;
1048         /*
1049          * Check if thread group timers expired when timers are active and
1050          * no other thread in the group is already handling expiry for
1051          * thread group cputimers. These fields are read without the
1052          * sighand lock. However, this is fine because this is meant to be
1053          * a fastpath heuristic to determine whether we should try to
1054          * acquire the sighand lock to handle timer expiry.
1055          *
1056          * In the worst case scenario, if concurrently timers_active is set
1057          * or expiry_active is cleared, but the current thread doesn't see
1058          * the change yet, the timer checks are delayed until the next
1059          * thread in the group gets a scheduler interrupt to handle the
1060          * timer. This isn't an issue in practice because these types of
1061          * delays with signals actually getting sent are expected.
1062          */
1063         if (READ_ONCE(pct->timers_active) && !READ_ONCE(pct->expiry_active)) {
1064                 u64 samples[CPUCLOCK_MAX];
1065
1066                 proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic,
1067                                            samples);
1068
1069                 if (task_cputimers_expired(samples, pct))
1070                         return true;
1071         }
1072
1073         if (dl_task(tsk) && tsk->dl.dl_overrun)
1074                 return true;
1075
1076         return false;
1077 }
1078
1079 /*
1080  * This is called from the timer interrupt handler.  The irq handler has
1081  * already updated our counts.  We need to check if any timers fire now.
1082  * Interrupts are disabled.
1083  */
1084 void run_posix_cpu_timers(void)
1085 {
1086         struct task_struct *tsk = current;
1087         struct k_itimer *timer, *next;
1088         unsigned long flags;
1089         LIST_HEAD(firing);
1090
1091         lockdep_assert_irqs_disabled();
1092
1093         /*
1094          * The fast path checks that there are no expired thread or thread
1095          * group timers.  If that's so, just return.
1096          */
1097         if (!fastpath_timer_check(tsk))
1098                 return;
1099
1100         if (!lock_task_sighand(tsk, &flags))
1101                 return;
1102         /*
1103          * Here we take off tsk->signal->cpu_timers[N] and
1104          * tsk->cpu_timers[N] all the timers that are firing, and
1105          * put them on the firing list.
1106          */
1107         check_thread_timers(tsk, &firing);
1108
1109         check_process_timers(tsk, &firing);
1110
1111         /*
1112          * We must release these locks before taking any timer's lock.
1113          * There is a potential race with timer deletion here, as the
1114          * siglock now protects our private firing list.  We have set
1115          * the firing flag in each timer, so that a deletion attempt
1116          * that gets the timer lock before we do will give it up and
1117          * spin until we've taken care of that timer below.
1118          */
1119         unlock_task_sighand(tsk, &flags);
1120
1121         /*
1122          * Now that all the timers on our list have the firing flag,
1123          * no one will touch their list entries but us.  We'll take
1124          * each timer's lock before clearing its firing flag, so no
1125          * timer call will interfere.
1126          */
1127         list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
1128                 int cpu_firing;
1129
1130                 spin_lock(&timer->it_lock);
1131                 list_del_init(&timer->it.cpu.entry);
1132                 cpu_firing = timer->it.cpu.firing;
1133                 timer->it.cpu.firing = 0;
1134                 /*
1135                  * The firing flag is -1 if we collided with a reset
1136                  * of the timer, which already reported this
1137                  * almost-firing as an overrun.  So don't generate an event.
1138                  */
1139                 if (likely(cpu_firing >= 0))
1140                         cpu_timer_fire(timer);
1141                 spin_unlock(&timer->it_lock);
1142         }
1143 }
1144
1145 /*
1146  * Set one of the process-wide special case CPU timers or RLIMIT_CPU.
1147  * The tsk->sighand->siglock must be held by the caller.
1148  */
1149 void set_process_cpu_timer(struct task_struct *tsk, unsigned int clkid,
1150                            u64 *newval, u64 *oldval)
1151 {
1152         u64 now, *nextevt;
1153
1154         if (WARN_ON_ONCE(clkid >= CPUCLOCK_SCHED))
1155                 return;
1156
1157         nextevt = &tsk->signal->posix_cputimers.bases[clkid].nextevt;
1158         now = cpu_clock_sample_group(clkid, tsk, true);
1159
1160         if (oldval) {
1161                 /*
1162                  * We are setting itimer. The *oldval is absolute and we update
1163                  * it to be relative, *newval argument is relative and we update
1164                  * it to be absolute.
1165                  */
1166                 if (*oldval) {
1167                         if (*oldval <= now) {
1168                                 /* Just about to fire. */
1169                                 *oldval = TICK_NSEC;
1170                         } else {
1171                                 *oldval -= now;
1172                         }
1173                 }
1174
1175                 if (!*newval)
1176                         return;
1177                 *newval += now;
1178         }
1179
1180         /*
1181          * Update expiration cache if this is the earliest timer. CPUCLOCK_PROF
1182          * expiry cache is also used by RLIMIT_CPU!.
1183          */
1184         if (*newval < *nextevt)
1185                 *nextevt = *newval;
1186
1187         tick_dep_set_signal(tsk->signal, TICK_DEP_BIT_POSIX_TIMER);
1188 }
1189
1190 static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
1191                             const struct timespec64 *rqtp)
1192 {
1193         struct itimerspec64 it;
1194         struct k_itimer timer;
1195         u64 expires;
1196         int error;
1197
1198         /*
1199          * Set up a temporary timer and then wait for it to go off.
1200          */
1201         memset(&timer, 0, sizeof timer);
1202         spin_lock_init(&timer.it_lock);
1203         timer.it_clock = which_clock;
1204         timer.it_overrun = -1;
1205         error = posix_cpu_timer_create(&timer);
1206         timer.it_process = current;
1207         if (!error) {
1208                 static struct itimerspec64 zero_it;
1209                 struct restart_block *restart;
1210
1211                 memset(&it, 0, sizeof(it));
1212                 it.it_value = *rqtp;
1213
1214                 spin_lock_irq(&timer.it_lock);
1215                 error = posix_cpu_timer_set(&timer, flags, &it, NULL);
1216                 if (error) {
1217                         spin_unlock_irq(&timer.it_lock);
1218                         return error;
1219                 }
1220
1221                 while (!signal_pending(current)) {
1222                         if (timer.it.cpu.expires == 0) {
1223                                 /*
1224                                  * Our timer fired and was reset, below
1225                                  * deletion can not fail.
1226                                  */
1227                                 posix_cpu_timer_del(&timer);
1228                                 spin_unlock_irq(&timer.it_lock);
1229                                 return 0;
1230                         }
1231
1232                         /*
1233                          * Block until cpu_timer_fire (or a signal) wakes us.
1234                          */
1235                         __set_current_state(TASK_INTERRUPTIBLE);
1236                         spin_unlock_irq(&timer.it_lock);
1237                         schedule();
1238                         spin_lock_irq(&timer.it_lock);
1239                 }
1240
1241                 /*
1242                  * We were interrupted by a signal.
1243                  */
1244                 expires = timer.it.cpu.expires;
1245                 error = posix_cpu_timer_set(&timer, 0, &zero_it, &it);
1246                 if (!error) {
1247                         /*
1248                          * Timer is now unarmed, deletion can not fail.
1249                          */
1250                         posix_cpu_timer_del(&timer);
1251                 }
1252                 spin_unlock_irq(&timer.it_lock);
1253
1254                 while (error == TIMER_RETRY) {
1255                         /*
1256                          * We need to handle case when timer was or is in the
1257                          * middle of firing. In other cases we already freed
1258                          * resources.
1259                          */
1260                         spin_lock_irq(&timer.it_lock);
1261                         error = posix_cpu_timer_del(&timer);
1262                         spin_unlock_irq(&timer.it_lock);
1263                 }
1264
1265                 if ((it.it_value.tv_sec | it.it_value.tv_nsec) == 0) {
1266                         /*
1267                          * It actually did fire already.
1268                          */
1269                         return 0;
1270                 }
1271
1272                 error = -ERESTART_RESTARTBLOCK;
1273                 /*
1274                  * Report back to the user the time still remaining.
1275                  */
1276                 restart = &current->restart_block;
1277                 restart->nanosleep.expires = expires;
1278                 if (restart->nanosleep.type != TT_NONE)
1279                         error = nanosleep_copyout(restart, &it.it_value);
1280         }
1281
1282         return error;
1283 }
1284
1285 static long posix_cpu_nsleep_restart(struct restart_block *restart_block);
1286
1287 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
1288                             const struct timespec64 *rqtp)
1289 {
1290         struct restart_block *restart_block = &current->restart_block;
1291         int error;
1292
1293         /*
1294          * Diagnose required errors first.
1295          */
1296         if (CPUCLOCK_PERTHREAD(which_clock) &&
1297             (CPUCLOCK_PID(which_clock) == 0 ||
1298              CPUCLOCK_PID(which_clock) == task_pid_vnr(current)))
1299                 return -EINVAL;
1300
1301         error = do_cpu_nanosleep(which_clock, flags, rqtp);
1302
1303         if (error == -ERESTART_RESTARTBLOCK) {
1304
1305                 if (flags & TIMER_ABSTIME)
1306                         return -ERESTARTNOHAND;
1307
1308                 restart_block->fn = posix_cpu_nsleep_restart;
1309                 restart_block->nanosleep.clockid = which_clock;
1310         }
1311         return error;
1312 }
1313
1314 static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
1315 {
1316         clockid_t which_clock = restart_block->nanosleep.clockid;
1317         struct timespec64 t;
1318
1319         t = ns_to_timespec64(restart_block->nanosleep.expires);
1320
1321         return do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t);
1322 }
1323
1324 #define PROCESS_CLOCK   make_process_cpuclock(0, CPUCLOCK_SCHED)
1325 #define THREAD_CLOCK    make_thread_cpuclock(0, CPUCLOCK_SCHED)
1326
1327 static int process_cpu_clock_getres(const clockid_t which_clock,
1328                                     struct timespec64 *tp)
1329 {
1330         return posix_cpu_clock_getres(PROCESS_CLOCK, tp);
1331 }
1332 static int process_cpu_clock_get(const clockid_t which_clock,
1333                                  struct timespec64 *tp)
1334 {
1335         return posix_cpu_clock_get(PROCESS_CLOCK, tp);
1336 }
1337 static int process_cpu_timer_create(struct k_itimer *timer)
1338 {
1339         timer->it_clock = PROCESS_CLOCK;
1340         return posix_cpu_timer_create(timer);
1341 }
1342 static int process_cpu_nsleep(const clockid_t which_clock, int flags,
1343                               const struct timespec64 *rqtp)
1344 {
1345         return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp);
1346 }
1347 static int thread_cpu_clock_getres(const clockid_t which_clock,
1348                                    struct timespec64 *tp)
1349 {
1350         return posix_cpu_clock_getres(THREAD_CLOCK, tp);
1351 }
1352 static int thread_cpu_clock_get(const clockid_t which_clock,
1353                                 struct timespec64 *tp)
1354 {
1355         return posix_cpu_clock_get(THREAD_CLOCK, tp);
1356 }
1357 static int thread_cpu_timer_create(struct k_itimer *timer)
1358 {
1359         timer->it_clock = THREAD_CLOCK;
1360         return posix_cpu_timer_create(timer);
1361 }
1362
1363 const struct k_clock clock_posix_cpu = {
1364         .clock_getres   = posix_cpu_clock_getres,
1365         .clock_set      = posix_cpu_clock_set,
1366         .clock_get      = posix_cpu_clock_get,
1367         .timer_create   = posix_cpu_timer_create,
1368         .nsleep         = posix_cpu_nsleep,
1369         .timer_set      = posix_cpu_timer_set,
1370         .timer_del      = posix_cpu_timer_del,
1371         .timer_get      = posix_cpu_timer_get,
1372         .timer_rearm    = posix_cpu_timer_rearm,
1373 };
1374
1375 const struct k_clock clock_process = {
1376         .clock_getres   = process_cpu_clock_getres,
1377         .clock_get      = process_cpu_clock_get,
1378         .timer_create   = process_cpu_timer_create,
1379         .nsleep         = process_cpu_nsleep,
1380 };
1381
1382 const struct k_clock clock_thread = {
1383         .clock_getres   = thread_cpu_clock_getres,
1384         .clock_get      = thread_cpu_clock_get,
1385         .timer_create   = thread_cpu_timer_create,
1386 };