acct.c 16.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
/*
 *  linux/kernel/acct.c
 *
 *  BSD Process Accounting for Linux
 *
 *  Author: Marco van Wieringen <mvw@planets.elm.net>
 *
 *  Some code based on ideas and code from:
 *  Thomas K. Dyas <tdyas@eden.rutgers.edu>
 *
 *  This file implements BSD-style process accounting. Whenever any
 *  process exits, an accounting record of type "struct acct" is
 *  written to the file specified with the acct() system call. It is
 *  up to user-level programs to do useful things with the accounting
 *  log. The kernel just provides the raw accounting information.
 *
 * (C) Copyright 1995 - 1997 Marco van Wieringen - ELM Consultancy B.V.
 *
 *  Plugged two leaks. 1) It didn't return acct_file into the free_filps if
 *  the file happened to be read-only. 2) If the accounting was suspended
 *  due to the lack of space it happily allowed to reopen it and completely
 *  lost the old acct_file. 3/10/98, Al Viro.
 *
 *  Now we silently close acct_file on attempt to reopen. Cleaned sys_acct().
 *  XTerms and EMACS are manifestations of pure evil. 21/10/98, AV.
 *
 *  Fixed a nasty interaction with with sys_umount(). If the accointing
 *  was suspeneded we failed to stop it on umount(). Messy.
 *  Another one: remount to readonly didn't stop accounting.
 *	Question: what should we do if we have CAP_SYS_ADMIN but not
 *  CAP_SYS_PACCT? Current code does the following: umount returns -EBUSY
 *  unless we are messing with the root. In that case we are getting a
 *  real mess with do_remount_sb(). 9/11/98, AV.
 *
 *  Fixed a bunch of races (and pair of leaks). Probably not the best way,
 *  but this one obviously doesn't introduce deadlocks. Later. BTW, found
 *  one race (and leak) in BSD implementation.
 *  OK, that's better. ANOTHER race and leak in BSD variant. There always
 *  is one more bug... 10/11/98, AV.
 *
 *	Oh, fsck... Oopsable SMP race in do_process_acct() - we must hold
 * ->mmap_sem to walk the vma list of current->mm. Nasty, since it leaks
 * a struct file opened for write. Fixed. 2/6/2000, AV.
 */

#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/acct.h>
49
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
50 51 52 53 54 55 56
#include <linux/file.h>
#include <linux/tty.h>
#include <linux/security.h>
#include <linux/vfs.h>
#include <linux/jiffies.h>
#include <linux/times.h>
#include <linux/syscalls.h>
57
#include <linux/mount.h>
58
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
59 60
#include <asm/div64.h>
#include <linux/blkdev.h> /* sector_div */
61
#include <linux/pid_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

/*
 * These constants control the amount of freespace that suspend and
 * resume the process accounting system, and the time delay between
 * each check.
 * Turned into sysctl-controllable parameters. AV, 12/11/98
 */

int acct_parm[3] = {4, 2, 30};
#define RESUME		(acct_parm[0])	/* >foo% free space - resume */
#define SUSPEND		(acct_parm[1])	/* <foo% free space - suspend */
#define ACCT_TIMEOUT	(acct_parm[2])	/* foo second timeout between checks */

/*
 * External references and all of the globals.
 */
78 79
static void do_acct_process(struct bsd_acct_struct *acct,
		struct pid_namespace *ns, struct file *);
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82 83 84 85

/*
 * This structure is used so that all the data protected by lock
 * can be placed in the same cache line as the lock.  This primes
 * the cache line to have the data after getting the lock.
 */
86
struct bsd_acct_struct {
Al Viro's avatar
Al Viro committed
87 88
	int			active;
	unsigned long		needcheck;
Linus Torvalds's avatar
Linus Torvalds committed
89
	struct file		*file;
90
	struct pid_namespace	*ns;
91
	struct list_head	list;
Linus Torvalds's avatar
Linus Torvalds committed
92 93
};

94
static DEFINE_SPINLOCK(acct_lock);
95
static LIST_HEAD(acct_list);
96

Linus Torvalds's avatar
Linus Torvalds committed
97 98 99
/*
 * Check the amount of free space and suspend/resume accordingly.
 */
100
static int check_free_space(struct bsd_acct_struct *acct, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104
{
	struct kstatfs sbuf;
	int res;
	int act;
Al Viro's avatar
Al Viro committed
105 106
	u64 resume;
	u64 suspend;
Linus Torvalds's avatar
Linus Torvalds committed
107

108
	spin_lock(&acct_lock);
109
	res = acct->active;
Al Viro's avatar
Al Viro committed
110
	if (!file || time_is_before_jiffies(acct->needcheck))
Linus Torvalds's avatar
Linus Torvalds committed
111
		goto out;
112
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
113 114

	/* May block */
115
	if (vfs_statfs(&file->f_path, &sbuf))
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119
		return res;
	suspend = sbuf.f_blocks * SUSPEND;
	resume = sbuf.f_blocks * RESUME;

Al Viro's avatar
Al Viro committed
120 121
	do_div(suspend, 100);
	do_div(resume, 100);
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124 125 126 127 128 129 130

	if (sbuf.f_bavail <= suspend)
		act = -1;
	else if (sbuf.f_bavail >= resume)
		act = 1;
	else
		act = 0;

	/*
131
	 * If some joker switched acct->file under us we'ld better be
Linus Torvalds's avatar
Linus Torvalds committed
132 133
	 * silent and _not_ touch anything.
	 */
134
	spin_lock(&acct_lock);
135
	if (file != acct->file) {
Linus Torvalds's avatar
Linus Torvalds committed
136
		if (act)
Paul McQuade's avatar
Paul McQuade committed
137
			res = act > 0;
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140
		goto out;
	}

141
	if (acct->active) {
Linus Torvalds's avatar
Linus Torvalds committed
142
		if (act < 0) {
143
			acct->active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147
			printk(KERN_INFO "Process accounting paused\n");
		}
	} else {
		if (act > 0) {
148
			acct->active = 1;
Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152
			printk(KERN_INFO "Process accounting resumed\n");
		}
	}

Al Viro's avatar
Al Viro committed
153
	acct->needcheck = jiffies + ACCT_TIMEOUT*HZ;
154
	res = acct->active;
Linus Torvalds's avatar
Linus Torvalds committed
155
out:
156
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
157 158 159 160
	return res;
}

/*
161
 * Close the old accounting file (if currently open) and then replace
Linus Torvalds's avatar
Linus Torvalds committed
162 163
 * it with file (if non-NULL).
 *
164
 * NOTE: acct_lock MUST be held on entry and exit.
Linus Torvalds's avatar
Linus Torvalds committed
165
 */
166 167
static void acct_file_reopen(struct bsd_acct_struct *acct, struct file *file,
		struct pid_namespace *ns)
Linus Torvalds's avatar
Linus Torvalds committed
168 169
{
	struct file *old_acct = NULL;
170
	struct pid_namespace *old_ns = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
171

172 173 174 175 176
	if (acct->file) {
		old_acct = acct->file;
		old_ns = acct->ns;
		acct->active = 0;
		acct->file = NULL;
177
		acct->ns = NULL;
178
		list_del(&acct->list);
Linus Torvalds's avatar
Linus Torvalds committed
179 180
	}
	if (file) {
181
		acct->file = file;
182
		acct->ns = ns;
Al Viro's avatar
Al Viro committed
183
		acct->needcheck = jiffies + ACCT_TIMEOUT*HZ;
184
		acct->active = 1;
185
		list_add(&acct->list, &acct_list);
Linus Torvalds's avatar
Linus Torvalds committed
186 187
	}
	if (old_acct) {
188
		mnt_unpin(old_acct->f_path.mnt);
189
		spin_unlock(&acct_lock);
190
		do_acct_process(acct, old_ns, old_acct);
Linus Torvalds's avatar
Linus Torvalds committed
191
		filp_close(old_acct, NULL);
192
		spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195
	}
}

196
static int acct_on(struct filename *pathname)
197 198
{
	struct file *file;
199
	struct vfsmount *mnt;
200 201
	struct pid_namespace *ns;
	struct bsd_acct_struct *acct = NULL;
202 203

	/* Difference from BSD - they don't do O_APPEND */
204
	file = file_open_name(pathname, O_WRONLY|O_APPEND|O_LARGEFILE, 0);
205 206 207
	if (IS_ERR(file))
		return PTR_ERR(file);

Al Viro's avatar
Al Viro committed
208
	if (!S_ISREG(file_inode(file)->i_mode)) {
209 210 211 212 213 214 215 216 217
		filp_close(file, NULL);
		return -EACCES;
	}

	if (!file->f_op->write) {
		filp_close(file, NULL);
		return -EIO;
	}

218 219 220 221 222 223 224 225 226
	ns = task_active_pid_ns(current);
	if (ns->bacct == NULL) {
		acct = kzalloc(sizeof(struct bsd_acct_struct), GFP_KERNEL);
		if (acct == NULL) {
			filp_close(file, NULL);
			return -ENOMEM;
		}
	}

227
	spin_lock(&acct_lock);
228 229 230 231 232
	if (ns->bacct == NULL) {
		ns->bacct = acct;
		acct = NULL;
	}

233 234
	mnt = file->f_path.mnt;
	mnt_pin(mnt);
235
	acct_file_reopen(ns->bacct, file, ns);
236
	spin_unlock(&acct_lock);
237

238
	mntput(mnt); /* it's pinned, now give up active reference */
239
	kfree(acct);
240 241 242 243

	return 0;
}

244 245 246 247 248 249 250 251 252 253
/**
 * sys_acct - enable/disable process accounting
 * @name: file name for accounting records or NULL to shutdown accounting
 *
 * Returns 0 for success or negative errno values for failure.
 *
 * sys_acct() is the only system call needed to implement process
 * accounting. It takes the name of the file where accounting records
 * should be written. If the filename is NULL, accounting will be
 * shutdown.
Linus Torvalds's avatar
Linus Torvalds committed
254
 */
255
SYSCALL_DEFINE1(acct, const char __user *, name)
Linus Torvalds's avatar
Linus Torvalds committed
256
{
Eric Paris's avatar
Eric Paris committed
257
	int error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260 261 262

	if (!capable(CAP_SYS_PACCT))
		return -EPERM;

	if (name) {
263
		struct filename *tmp = getname(name);
264
		if (IS_ERR(tmp))
Paul McQuade's avatar
Paul McQuade committed
265
			return PTR_ERR(tmp);
266
		error = acct_on(tmp);
Linus Torvalds's avatar
Linus Torvalds committed
267
		putname(tmp);
268
	} else {
269 270 271 272 273 274
		struct bsd_acct_struct *acct;

		acct = task_active_pid_ns(current)->bacct;
		if (acct == NULL)
			return 0;

Eric Paris's avatar
Eric Paris committed
275 276 277
		spin_lock(&acct_lock);
		acct_file_reopen(acct, NULL, NULL);
		spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
278
	}
Eric Paris's avatar
Eric Paris committed
279

280 281
	return error;
}
Linus Torvalds's avatar
Linus Torvalds committed
282

283 284 285 286 287 288 289 290 291
/**
 * acct_auto_close - turn off a filesystem's accounting if it is on
 * @m: vfsmount being shut down
 *
 * If the accounting is turned on for a file in the subtree pointed to
 * to by m, turn accounting off.  Done when m is about to die.
 */
void acct_auto_close_mnt(struct vfsmount *m)
{
292 293
	struct bsd_acct_struct *acct;

294
	spin_lock(&acct_lock);
295 296 297 298 299 300
restart:
	list_for_each_entry(acct, &acct_list, list)
		if (acct->file && acct->file->f_path.mnt == m) {
			acct_file_reopen(acct, NULL, NULL);
			goto restart;
		}
301
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
302 303
}

304 305 306 307 308 309
/**
 * acct_auto_close - turn off a filesystem's accounting if it is on
 * @sb: super block for the filesystem
 *
 * If the accounting is turned on for a file in the filesystem pointed
 * to by sb, turn accounting off.
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312
 */
void acct_auto_close(struct super_block *sb)
{
313 314
	struct bsd_acct_struct *acct;

315
	spin_lock(&acct_lock);
316 317
restart:
	list_for_each_entry(acct, &acct_list, list)
318
		if (acct->file && acct->file->f_path.dentry->d_sb == sb) {
319 320 321
			acct_file_reopen(acct, NULL, NULL);
			goto restart;
		}
322 323 324 325 326
	spin_unlock(&acct_lock);
}

void acct_exit_ns(struct pid_namespace *ns)
{
327
	struct bsd_acct_struct *acct = ns->bacct;
328

329 330
	if (acct == NULL)
		return;
331

332 333 334
	spin_lock(&acct_lock);
	if (acct->file != NULL)
		acct_file_reopen(acct, NULL, NULL);
335
	spin_unlock(&acct_lock);
336 337

	kfree(acct);
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
}

/*
 *  encode an unsigned long into a comp_t
 *
 *  This routine has been adopted from the encode_comp_t() function in
 *  the kern_acct.c file of the FreeBSD operating system. The encoding
 *  is a 13-bit fraction with a 3-bit (base 8) exponent.
 */

#define	MANTSIZE	13			/* 13 bit mantissa. */
#define	EXPSIZE		3			/* Base 8 (3 bit) exponent. */
#define	MAXFRACT	((1 << MANTSIZE) - 1)	/* Maximum fractional value. */

static comp_t encode_comp_t(unsigned long value)
{
	int exp, rnd;

	exp = rnd = 0;
	while (value > MAXFRACT) {
		rnd = value & (1 << (EXPSIZE - 1));	/* Round up? */
		value >>= EXPSIZE;	/* Base 8 exponent == 3 bit shift. */
		exp++;
	}

	/*
364 365
	 * If we need to round up, do it (and handle overflow correctly).
	 */
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371
	if (rnd && (++value > MAXFRACT)) {
		value >>= EXPSIZE;
		exp++;
	}

	/*
372 373
	 * Clean it up and polish it off.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
	exp <<= MANTSIZE;		/* Shift the exponent into place */
	exp += value;			/* and add on the mantissa. */
	return exp;
}

#if ACCT_VERSION==1 || ACCT_VERSION==2
/*
 * encode an u64 into a comp2_t (24 bits)
 *
 * Format: 5 bit base 2 exponent, 20 bits mantissa.
 * The leading bit of the mantissa is not stored, but implied for
 * non-zero exponents.
 * Largest encodable value is 50 bits.
 */

#define MANTSIZE2       20                      /* 20 bit mantissa. */
#define EXPSIZE2        5                       /* 5 bit base 2 exponent. */
#define MAXFRACT2       ((1ul << MANTSIZE2) - 1) /* Maximum fractional value. */
#define MAXEXP2         ((1 <<EXPSIZE2) - 1)    /* Maximum exponent. */

static comp2_t encode_comp2_t(u64 value)
{
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
	int exp, rnd;

	exp = (value > (MAXFRACT2>>1));
	rnd = 0;
	while (value > MAXFRACT2) {
		rnd = value & 1;
		value >>= 1;
		exp++;
	}

	/*
	 * If we need to round up, do it (and handle overflow correctly).
	 */
	if (rnd && (++value > MAXFRACT2)) {
		value >>= 1;
		exp++;
	}

	if (exp > MAXEXP2) {
		/* Overflow. Return largest representable number instead. */
		return (1ul << (MANTSIZE2+EXPSIZE2-1)) - 1;
	} else {
		return (value & (MAXFRACT2>>1)) | (exp << (MANTSIZE2-1));
	}
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
}
#endif

#if ACCT_VERSION==3
/*
 * encode an u64 into a 32 bit IEEE float
 */
static u32 encode_float(u64 value)
{
	unsigned exp = 190;
	unsigned u;

	if (value==0) return 0;
	while ((s64)value > 0){
		value <<= 1;
		exp--;
	}
	u = (u32)(value >> 40) & 0x7fffffu;
	return u | (exp << 23);
}
#endif

/*
 *  Write an accounting entry for an exiting process
 *
 *  The acct_process() call is the workhorse of the process
 *  accounting system. The struct acct is built here and then written
 *  into the accounting file. This function should only be called from
448
 *  do_exit() or when switching to a different output file.
Linus Torvalds's avatar
Linus Torvalds committed
449 450
 */

451
static void fill_ac(acct_t *ac)
Linus Torvalds's avatar
Linus Torvalds committed
452
{
453
	struct pacct_struct *pacct = &current->signal->pacct;
454
	u64 elapsed, run_time;
455
	struct tty_struct *tty;
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460

	/*
	 * Fill the accounting struct with the needed info as recorded
	 * by the different kernel functions.
	 */
461
	memset(ac, 0, sizeof(acct_t));
Linus Torvalds's avatar
Linus Torvalds committed
462

463 464
	ac->ac_version = ACCT_VERSION | ACCT_BYTEORDER;
	strlcpy(ac->ac_comm, current->comm, sizeof(ac->ac_comm));
Linus Torvalds's avatar
Linus Torvalds committed
465 466

	/* calculate run_time in nsec*/
467 468
	run_time = ktime_get_ns();
	run_time -= current->group_leader->start_time;
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471
	/* convert nsec -> AHZ */
	elapsed = nsec_to_AHZ(run_time);
#if ACCT_VERSION==3
472
	ac->ac_etime = encode_float(elapsed);
Linus Torvalds's avatar
Linus Torvalds committed
473
#else
474
	ac->ac_etime = encode_comp_t(elapsed < (unsigned long) -1l ?
Linus Torvalds's avatar
Linus Torvalds committed
475 476 477 478 479 480
	                       (unsigned long) elapsed : (unsigned long) -1l);
#endif
#if ACCT_VERSION==1 || ACCT_VERSION==2
	{
		/* new enlarged etime field */
		comp2_t etime = encode_comp2_t(elapsed);
481 482
		ac->ac_etime_hi = etime >> 16;
		ac->ac_etime_lo = (u16) etime;
Linus Torvalds's avatar
Linus Torvalds committed
483 484 485
	}
#endif
	do_div(elapsed, AHZ);
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
	ac->ac_btime = get_seconds() - elapsed;
#if ACCT_VERSION==2
	ac->ac_ahz = AHZ;
#endif

	spin_lock_irq(&current->sighand->siglock);
	tty = current->signal->tty;	/* Safe as we hold the siglock */
	ac->ac_tty = tty ? old_encode_dev(tty_devnum(tty)) : 0;
	ac->ac_utime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_utime)));
	ac->ac_stime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_stime)));
	ac->ac_flag = pacct->ac_flag;
	ac->ac_mem = encode_comp_t(pacct->ac_mem);
	ac->ac_minflt = encode_comp_t(pacct->ac_minflt);
	ac->ac_majflt = encode_comp_t(pacct->ac_majflt);
	ac->ac_exitcode = pacct->ac_exitcode;
	spin_unlock_irq(&current->sighand->siglock);
}
/*
 *  do_acct_process does all actual work. Caller holds the reference to file.
 */
static void do_acct_process(struct bsd_acct_struct *acct,
		struct pid_namespace *ns, struct file *file)
{
	acct_t ac;
	unsigned long flim;
	const struct cred *orig_cred;

	/*
	 * Accounting records are not subject to resource limits.
	 */
	flim = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
	current->signal->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
	/* Perform file operations on behalf of whoever enabled accounting */
	orig_cred = override_creds(file->f_cred);

	/*
	 * First check to see if there is enough free_space to continue
	 * the process accounting system.
	 */
	if (!check_free_space(acct, file))
		goto out;

	fill_ac(&ac);
Linus Torvalds's avatar
Linus Torvalds committed
529
	/* we really need to bite the bullet and change layout */
530 531
	ac.ac_uid = from_kuid_munged(file->f_cred->user_ns, orig_cred->uid);
	ac.ac_gid = from_kgid_munged(file->f_cred->user_ns, orig_cred->gid);
Linus Torvalds's avatar
Linus Torvalds committed
532 533
#if ACCT_VERSION==1 || ACCT_VERSION==2
	/* backward-compatible 16 bit fields */
534 535
	ac.ac_uid16 = ac.ac_uid;
	ac.ac_gid16 = ac.ac_gid;
Linus Torvalds's avatar
Linus Torvalds committed
536 537
#endif
#if ACCT_VERSION==3
538
	ac.ac_pid = task_tgid_nr_ns(current, ns);
539
	rcu_read_lock();
540
	ac.ac_ppid = task_tgid_nr_ns(rcu_dereference(current->real_parent), ns);
541
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
542
#endif
543 544 545 546
	/*
	 * Get freeze protection. If the fs is frozen, just skip the write
	 * as we could deadlock the system otherwise.
	 */
Al Viro's avatar
Al Viro committed
547 548 549 550 551 552
	if (file_start_write_trylock(file)) {
		/* it's been opened O_APPEND, so position is irrelevant */
		loff_t pos = 0;
		__kernel_write(file, (char *)&ac, sizeof(acct_t), &pos);
		file_end_write(file);
	}
553
out:
Al Viro's avatar
Al Viro committed
554
	current->signal->rlim[RLIMIT_FSIZE].rlim_cur = flim;
555
	revert_creds(orig_cred);
Linus Torvalds's avatar
Linus Torvalds committed
556 557
}

558 559
/**
 * acct_collect - collect accounting information into pacct_struct
560 561
 * @exitcode: task exit code
 * @group_dead: not 0, if this thread is the last one in the process.
562
 */
563
void acct_collect(long exitcode, int group_dead)
564 565
{
	struct pacct_struct *pacct = &current->signal->pacct;
566
	cputime_t utime, stime;
567 568
	unsigned long vsize = 0;

569
	if (group_dead && current->mm) {
570 571 572 573 574 575 576 577 578 579
		struct vm_area_struct *vma;
		down_read(&current->mm->mmap_sem);
		vma = current->mm->mmap;
		while (vma) {
			vsize += vma->vm_end - vma->vm_start;
			vma = vma->vm_next;
		}
		up_read(&current->mm->mmap_sem);
	}

580
	spin_lock_irq(&current->sighand->siglock);
581 582 583 584 585 586 587 588 589 590 591 592 593
	if (group_dead)
		pacct->ac_mem = vsize / 1024;
	if (thread_group_leader(current)) {
		pacct->ac_exitcode = exitcode;
		if (current->flags & PF_FORKNOEXEC)
			pacct->ac_flag |= AFORK;
	}
	if (current->flags & PF_SUPERPRIV)
		pacct->ac_flag |= ASU;
	if (current->flags & PF_DUMPCORE)
		pacct->ac_flag |= ACORE;
	if (current->flags & PF_SIGNALED)
		pacct->ac_flag |= AXSIG;
594 595 596
	task_cputime(current, &utime, &stime);
	pacct->ac_utime += utime;
	pacct->ac_stime += stime;
597 598 599
	pacct->ac_minflt += current->min_flt;
	pacct->ac_majflt += current->maj_flt;
	spin_unlock_irq(&current->sighand->siglock);
600 601
}

602
static void acct_process_in_ns(struct pid_namespace *ns)
Linus Torvalds's avatar
Linus Torvalds committed
603 604
{
	struct file *file = NULL;
605
	struct bsd_acct_struct *acct;
Linus Torvalds's avatar
Linus Torvalds committed
606

607
	acct = ns->bacct;
Linus Torvalds's avatar
Linus Torvalds committed
608 609 610
	/*
	 * accelerate the common fastpath:
	 */
611
	if (!acct || !acct->file)
Linus Torvalds's avatar
Linus Torvalds committed
612 613
		return;

614
	spin_lock(&acct_lock);
615
	file = acct->file;
Linus Torvalds's avatar
Linus Torvalds committed
616
	if (unlikely(!file)) {
617
		spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620
		return;
	}
	get_file(file);
621
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
622

623
	do_acct_process(acct, ns, file);
Linus Torvalds's avatar
Linus Torvalds committed
624 625
	fput(file);
}
626 627

/**
628 629
 * acct_process - now just a wrapper around acct_process_in_ns,
 * which in turn is a wrapper around do_acct_process.
630 631 632 633 634 635 636
 *
 * handles process accounting for an exiting task
 */
void acct_process(void)
{
	struct pid_namespace *ns;

637 638 639 640 641
	/*
	 * This loop is safe lockless, since current is still
	 * alive and holds its namespace, which in turn holds
	 * its parent.
	 */
642 643 644
	for (ns = task_active_pid_ns(current); ns != NULL; ns = ns->parent)
		acct_process_in_ns(ns);
}