1 // SPDX-License-Identifier: GPL-2.0-or-later <<
2 /* 1 /*
3 * tsacct.c - System accounting over taskstats 2 * tsacct.c - System accounting over taskstats interface
4 * 3 *
5 * Copyright (C) Jay Lan, <jlan@sgi.com> 4 * Copyright (C) Jay Lan, <jlan@sgi.com>
>> 5 *
>> 6 *
>> 7 * This program is free software; you can redistribute it and/or modify
>> 8 * it under the terms of the GNU General Public License as published by
>> 9 * the Free Software Foundation; either version 2 of the License, or
>> 10 * (at your option) any later version.
>> 11 *
>> 12 * This program is distributed in the hope that it will be useful,
>> 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> 15 * GNU General Public License for more details.
>> 16 *
6 */ 17 */
7 18
8 #include <linux/kernel.h> 19 #include <linux/kernel.h>
9 #include <linux/sched/signal.h> !! 20 #include <linux/sched.h>
10 #include <linux/sched/mm.h> <<
11 #include <linux/sched/cputime.h> <<
12 #include <linux/tsacct_kern.h> 21 #include <linux/tsacct_kern.h>
13 #include <linux/acct.h> 22 #include <linux/acct.h>
14 #include <linux/jiffies.h> 23 #include <linux/jiffies.h>
15 #include <linux/mm.h> <<
16 24
17 /* 25 /*
18 * fill in basic accounting fields 26 * fill in basic accounting fields
19 */ 27 */
20 void bacct_add_tsk(struct user_namespace *user !! 28 void bacct_add_tsk(struct taskstats *stats, struct task_struct *tsk)
21 struct pid_namespace *pid_n <<
22 struct taskstats *stats, st <<
23 { 29 {
24 const struct cred *tcred; 30 const struct cred *tcred;
25 u64 utime, stime, utimescaled, stimesc !! 31 struct timespec uptime, ts;
26 u64 now_ns, delta; !! 32 u64 ac_etime;
27 time64_t btime; <<
28 33
29 BUILD_BUG_ON(TS_COMM_LEN < TASK_COMM_L 34 BUILD_BUG_ON(TS_COMM_LEN < TASK_COMM_LEN);
30 35
31 /* calculate task elapsed time in nsec !! 36 /* calculate task elapsed time in timespec */
32 now_ns = ktime_get_ns(); !! 37 do_posix_clock_monotonic_gettime(&uptime);
33 /* store whole group time first */ !! 38 ts = timespec_sub(uptime, tsk->start_time);
34 delta = now_ns - tsk->group_leader->st !! 39 /* rebase elapsed time to usec (should never be negative) */
35 /* Convert to micro seconds */ !! 40 ac_etime = timespec_to_ns(&ts);
36 do_div(delta, NSEC_PER_USEC); !! 41 do_div(ac_etime, NSEC_PER_USEC);
37 stats->ac_tgetime = delta; !! 42 stats->ac_etime = ac_etime;
38 delta = now_ns - tsk->start_time; !! 43 stats->ac_btime = get_seconds() - ts.tv_sec;
39 do_div(delta, NSEC_PER_USEC); !! 44 if (thread_group_leader(tsk)) {
40 stats->ac_etime = delta; <<
41 /* Convert to seconds for btime (note <<
42 btime = ktime_get_real_seconds() - div <<
43 stats->ac_btime = clamp_t(time64_t, bt <<
44 stats->ac_btime64 = btime; <<
45 <<
46 if (tsk->flags & PF_EXITING) <<
47 stats->ac_exitcode = tsk->exit 45 stats->ac_exitcode = tsk->exit_code;
48 if (thread_group_leader(tsk) && (tsk-> !! 46 if (tsk->flags & PF_FORKNOEXEC)
49 stats->ac_flag |= AFORK; !! 47 stats->ac_flag |= AFORK;
>> 48 }
50 if (tsk->flags & PF_SUPERPRIV) 49 if (tsk->flags & PF_SUPERPRIV)
51 stats->ac_flag |= ASU; 50 stats->ac_flag |= ASU;
52 if (tsk->flags & PF_DUMPCORE) 51 if (tsk->flags & PF_DUMPCORE)
53 stats->ac_flag |= ACORE; 52 stats->ac_flag |= ACORE;
54 if (tsk->flags & PF_SIGNALED) 53 if (tsk->flags & PF_SIGNALED)
55 stats->ac_flag |= AXSIG; 54 stats->ac_flag |= AXSIG;
56 stats->ac_nice = task_nice(tsk); 55 stats->ac_nice = task_nice(tsk);
57 stats->ac_sched = tsk->policy; 56 stats->ac_sched = tsk->policy;
58 stats->ac_pid = task_pid_nr_ns(tsk, !! 57 stats->ac_pid = tsk->pid;
59 stats->ac_tgid = task_tgid_nr_ns(tsk <<
60 rcu_read_lock(); 58 rcu_read_lock();
61 tcred = __task_cred(tsk); 59 tcred = __task_cred(tsk);
62 stats->ac_uid = from_kuid_munged(us !! 60 stats->ac_uid = tcred->uid;
63 stats->ac_gid = from_kgid_munged(us !! 61 stats->ac_gid = tcred->gid;
64 stats->ac_ppid = pid_alive(tsk) ? 62 stats->ac_ppid = pid_alive(tsk) ?
65 task_tgid_nr_ns(rcu_dereferenc !! 63 rcu_dereference(tsk->real_parent)->tgid : 0;
66 rcu_read_unlock(); 64 rcu_read_unlock();
67 !! 65 stats->ac_utime = cputime_to_msecs(tsk->utime) * USEC_PER_MSEC;
68 task_cputime(tsk, &utime, &stime); !! 66 stats->ac_stime = cputime_to_msecs(tsk->stime) * USEC_PER_MSEC;
69 stats->ac_utime = div_u64(utime, NSEC_ !! 67 stats->ac_utimescaled =
70 stats->ac_stime = div_u64(stime, NSEC_ !! 68 cputime_to_msecs(tsk->utimescaled) * USEC_PER_MSEC;
71 !! 69 stats->ac_stimescaled =
72 task_cputime_scaled(tsk, &utimescaled, !! 70 cputime_to_msecs(tsk->stimescaled) * USEC_PER_MSEC;
73 stats->ac_utimescaled = div_u64(utimes <<
74 stats->ac_stimescaled = div_u64(stimes <<
75 <<
76 stats->ac_minflt = tsk->min_flt; 71 stats->ac_minflt = tsk->min_flt;
77 stats->ac_majflt = tsk->maj_flt; 72 stats->ac_majflt = tsk->maj_flt;
78 73
79 strscpy_pad(stats->ac_comm, tsk->comm) !! 74 strncpy(stats->ac_comm, tsk->comm, sizeof(stats->ac_comm));
80 } 75 }
81 76
82 77
83 #ifdef CONFIG_TASK_XACCT 78 #ifdef CONFIG_TASK_XACCT
84 79
85 #define KB 1024 80 #define KB 1024
86 #define MB (1024*KB) 81 #define MB (1024*KB)
87 #define KB_MASK (~(KB-1)) <<
88 /* 82 /*
89 * fill in extended accounting fields 83 * fill in extended accounting fields
90 */ 84 */
91 void xacct_add_tsk(struct taskstats *stats, st 85 void xacct_add_tsk(struct taskstats *stats, struct task_struct *p)
92 { 86 {
93 struct mm_struct *mm; 87 struct mm_struct *mm;
94 88
95 /* convert pages-nsec/1024 to Mbyte-us !! 89 /* convert pages-usec to Mbyte-usec */
96 stats->coremem = p->acct_rss_mem1 * PA !! 90 stats->coremem = p->acct_rss_mem1 * PAGE_SIZE / MB;
97 do_div(stats->coremem, 1000 * KB); !! 91 stats->virtmem = p->acct_vm_mem1 * PAGE_SIZE / MB;
98 stats->virtmem = p->acct_vm_mem1 * PAG <<
99 do_div(stats->virtmem, 1000 * KB); <<
100 mm = get_task_mm(p); 92 mm = get_task_mm(p);
101 if (mm) { 93 if (mm) {
102 /* adjust to KB unit */ 94 /* adjust to KB unit */
103 stats->hiwater_rss = get_mm_ 95 stats->hiwater_rss = get_mm_hiwater_rss(mm) * PAGE_SIZE / KB;
104 stats->hiwater_vm = get_mm_ 96 stats->hiwater_vm = get_mm_hiwater_vm(mm) * PAGE_SIZE / KB;
105 mmput(mm); 97 mmput(mm);
106 } 98 }
107 stats->read_char = p->ioac.rcha !! 99 stats->read_char = p->ioac.rchar;
108 stats->write_char = p->ioac.wcha !! 100 stats->write_char = p->ioac.wchar;
109 stats->read_syscalls = p->ioac.sysc !! 101 stats->read_syscalls = p->ioac.syscr;
110 stats->write_syscalls = p->ioac.sysc !! 102 stats->write_syscalls = p->ioac.syscw;
111 #ifdef CONFIG_TASK_IO_ACCOUNTING 103 #ifdef CONFIG_TASK_IO_ACCOUNTING
112 stats->read_bytes = p->ioac.read !! 104 stats->read_bytes = p->ioac.read_bytes;
113 stats->write_bytes = p->ioac.writ !! 105 stats->write_bytes = p->ioac.write_bytes;
114 stats->cancelled_write_bytes = p->ioac !! 106 stats->cancelled_write_bytes = p->ioac.cancelled_write_bytes;
115 #else 107 #else
116 stats->read_bytes = 0; 108 stats->read_bytes = 0;
117 stats->write_bytes = 0; 109 stats->write_bytes = 0;
118 stats->cancelled_write_bytes = 0; 110 stats->cancelled_write_bytes = 0;
119 #endif 111 #endif
120 } 112 }
121 #undef KB 113 #undef KB
122 #undef MB 114 #undef MB
123 115
124 static void __acct_update_integrals(struct tas <<
125 u64 utime, <<
126 { <<
127 u64 time, delta; <<
128 <<
129 if (!likely(tsk->mm)) <<
130 return; <<
131 <<
132 time = stime + utime; <<
133 delta = time - tsk->acct_timexpd; <<
134 <<
135 if (delta < TICK_NSEC) <<
136 return; <<
137 <<
138 tsk->acct_timexpd = time; <<
139 /* <<
140 * Divide by 1024 to avoid overflow, a <<
141 * The final unit reported to userspac <<
142 * the rest of the math is done in xac <<
143 */ <<
144 tsk->acct_rss_mem1 += delta * get_mm_r <<
145 tsk->acct_vm_mem1 += delta * READ_ONCE <<
146 } <<
147 <<
148 /** 116 /**
149 * acct_update_integrals - update mm integral 117 * acct_update_integrals - update mm integral fields in task_struct
150 * @tsk: task_struct for accounting 118 * @tsk: task_struct for accounting
151 */ 119 */
152 void acct_update_integrals(struct task_struct 120 void acct_update_integrals(struct task_struct *tsk)
153 { 121 {
154 u64 utime, stime; !! 122 if (likely(tsk->mm)) {
155 unsigned long flags; !! 123 cputime_t time, dtime;
156 !! 124 struct timeval value;
157 local_irq_save(flags); !! 125 unsigned long flags;
158 task_cputime(tsk, &utime, &stime); !! 126 u64 delta;
159 __acct_update_integrals(tsk, utime, st !! 127
160 local_irq_restore(flags); !! 128 local_irq_save(flags);
161 } !! 129 time = tsk->stime + tsk->utime;
162 !! 130 dtime = cputime_sub(time, tsk->acct_timexpd);
163 /** !! 131 jiffies_to_timeval(cputime_to_jiffies(dtime), &value);
164 * acct_account_cputime - update mm integral a !! 132 delta = value.tv_sec;
165 * @tsk: task_struct for accounting !! 133 delta = delta * USEC_PER_SEC + value.tv_usec;
166 */ !! 134
167 void acct_account_cputime(struct task_struct * !! 135 if (delta == 0)
168 { !! 136 goto out;
169 __acct_update_integrals(tsk, tsk->utim !! 137 tsk->acct_timexpd = time;
>> 138 tsk->acct_rss_mem1 += delta * get_mm_rss(tsk->mm);
>> 139 tsk->acct_vm_mem1 += delta * tsk->mm->total_vm;
>> 140 out:
>> 141 local_irq_restore(flags);
>> 142 }
170 } 143 }
171 144
172 /** 145 /**
173 * acct_clear_integrals - clear the mm integra 146 * acct_clear_integrals - clear the mm integral fields in task_struct
174 * @tsk: task_struct whose accounting fields a 147 * @tsk: task_struct whose accounting fields are cleared
175 */ 148 */
176 void acct_clear_integrals(struct task_struct * 149 void acct_clear_integrals(struct task_struct *tsk)
177 { 150 {
178 tsk->acct_timexpd = 0; 151 tsk->acct_timexpd = 0;
179 tsk->acct_rss_mem1 = 0; 152 tsk->acct_rss_mem1 = 0;
180 tsk->acct_vm_mem1 = 0; 153 tsk->acct_vm_mem1 = 0;
181 } 154 }
182 #endif 155 #endif
183 156
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.