acct.c 16.6 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>
Linus Torvalds's avatar
Linus Torvalds committed
58 59 60
#include <asm/uaccess.h>
#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 137 138 139 140
		if (act)
			res = act>0;
		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(const char *name)
197 198
{
	struct file *file;
199
	struct vfsmount *mnt;
200 201
	struct pid_namespace *ns;
	struct bsd_acct_struct *acct = NULL;
202 203 204 205 206 207

	/* Difference from BSD - they don't do O_APPEND */
	file = filp_open(name, O_WRONLY|O_APPEND|O_LARGEFILE, 0);
	if (IS_ERR(file))
		return PTR_ERR(file);

208
	if (!S_ISREG(file->f_path.dentry->d_inode->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))
Linus Torvalds's avatar
Linus Torvalds committed
265
			return (PTR_ERR(tmp));
266
		error = acct_on(tmp->name);
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 452 453
 */

/*
 *  do_acct_process does all actual work. Caller holds the reference to file.
 */
454 455
static void do_acct_process(struct bsd_acct_struct *acct,
		struct pid_namespace *ns, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
456
{
457
	struct pacct_struct *pacct = &current->signal->pacct;
Linus Torvalds's avatar
Linus Torvalds committed
458 459 460 461 462 463
	acct_t ac;
	mm_segment_t fs;
	unsigned long flim;
	u64 elapsed;
	u64 run_time;
	struct timespec uptime;
464
	struct tty_struct *tty;
465 466 467 468
	const struct cred *orig_cred;

	/* Perform file operations on behalf of whoever enabled accounting */
	orig_cred = override_creds(file->f_cred);
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473

	/*
	 * First check to see if there is enough free_space to continue
	 * the process accounting system.
	 */
474
	if (!check_free_space(acct, file))
475
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
476 477 478 479 480

	/*
	 * Fill the accounting struct with the needed info as recorded
	 * by the different kernel functions.
	 */
Al Viro's avatar
Al Viro committed
481
	memset(&ac, 0, sizeof(acct_t));
Linus Torvalds's avatar
Linus Torvalds committed
482 483 484 485 486 487 488

	ac.ac_version = ACCT_VERSION | ACCT_BYTEORDER;
	strlcpy(ac.ac_comm, current->comm, sizeof(ac.ac_comm));

	/* calculate run_time in nsec*/
	do_posix_clock_monotonic_gettime(&uptime);
	run_time = (u64)uptime.tv_sec*NSEC_PER_SEC + uptime.tv_nsec;
489 490
	run_time -= (u64)current->group_leader->start_time.tv_sec * NSEC_PER_SEC
		       + current->group_leader->start_time.tv_nsec;
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
	/* convert nsec -> AHZ */
	elapsed = nsec_to_AHZ(run_time);
#if ACCT_VERSION==3
	ac.ac_etime = encode_float(elapsed);
#else
	ac.ac_etime = encode_comp_t(elapsed < (unsigned long) -1l ?
	                       (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);
		ac.ac_etime_hi = etime >> 16;
		ac.ac_etime_lo = (u16) etime;
	}
#endif
	do_div(elapsed, AHZ);
508
	ac.ac_btime = get_seconds() - elapsed;
Linus Torvalds's avatar
Linus Torvalds committed
509
	/* we really need to bite the bullet and change layout */
510 511
	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
512 513 514 515 516
#if ACCT_VERSION==2
	ac.ac_ahz = AHZ;
#endif
#if ACCT_VERSION==1 || ACCT_VERSION==2
	/* backward-compatible 16 bit fields */
517 518
	ac.ac_uid16 = ac.ac_uid;
	ac.ac_gid16 = ac.ac_gid;
Linus Torvalds's avatar
Linus Torvalds committed
519 520
#endif
#if ACCT_VERSION==3
521
	ac.ac_pid = task_tgid_nr_ns(current, ns);
522
	rcu_read_lock();
523
	ac.ac_ppid = task_tgid_nr_ns(rcu_dereference(current->real_parent), ns);
524
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
525 526
#endif

527
	spin_lock_irq(&current->sighand->siglock);
528
	tty = current->signal->tty;	/* Safe as we hold the siglock */
529
	ac.ac_tty = tty ? old_encode_dev(tty_devnum(tty)) : 0;
530 531
	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)));
532
	ac.ac_flag = pacct->ac_flag;
533
	ac.ac_mem = encode_comp_t(pacct->ac_mem);
534 535
	ac.ac_minflt = encode_comp_t(pacct->ac_minflt);
	ac.ac_majflt = encode_comp_t(pacct->ac_majflt);
536
	ac.ac_exitcode = pacct->ac_exitcode;
537
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541 542
	ac.ac_io = encode_comp_t(0 /* current->io_usage */);	/* %% */
	ac.ac_rw = encode_comp_t(ac.ac_io / 1024);
	ac.ac_swaps = encode_comp_t(0);

	/*
543 544 545
	 * Kernel segment override to datasegment and write it
	 * to the accounting file.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
546 547 548
	fs = get_fs();
	set_fs(KERNEL_DS);
	/*
549 550
	 * Accounting records are not subject to resource limits.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554 555 556
	flim = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
	current->signal->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
	file->f_op->write(file, (char *)&ac,
			       sizeof(acct_t), &file->f_pos);
	current->signal->rlim[RLIMIT_FSIZE].rlim_cur = flim;
	set_fs(fs);
557 558
out:
	revert_creds(orig_cred);
Linus Torvalds's avatar
Linus Torvalds committed
559 560
}

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

571
	if (group_dead && current->mm) {
572 573 574 575 576 577 578 579 580 581
		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);
	}

582
	spin_lock_irq(&current->sighand->siglock);
583 584 585 586 587 588 589 590 591 592 593 594 595
	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;
596 597
	pacct->ac_utime += current->utime;
	pacct->ac_stime += current->stime;
598 599 600
	pacct->ac_minflt += current->min_flt;
	pacct->ac_majflt += current->maj_flt;
	spin_unlock_irq(&current->sighand->siglock);
601 602
}

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

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

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

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

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

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