acct.c 16 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
static void do_acct_process(struct pid_namespace *ns, struct file *);
Linus Torvalds's avatar
Linus Torvalds committed
79 80 81 82 83 84

/*
 * 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.
 */
85
struct bsd_acct_struct {
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88
	volatile int		active;
	volatile int		needcheck;
	struct file		*file;
89
	struct pid_namespace	*ns;
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92
	struct timer_list	timer;
};

93 94 95
static DEFINE_SPINLOCK(acct_lock);

static struct bsd_acct_struct acct_globals __cacheline_aligned;
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98 99

/*
 * Called whenever the timer says to check the free space.
 */
100
static void acct_timeout(unsigned long x)
Linus Torvalds's avatar
Linus Torvalds committed
101
{
102 103
	struct bsd_acct_struct *acct = (struct bsd_acct_struct *)x;
	acct->needcheck = 1;
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107 108 109 110 111 112 113 114 115 116
}

/*
 * Check the amount of free space and suspend/resume accordingly.
 */
static int check_free_space(struct file *file)
{
	struct kstatfs sbuf;
	int res;
	int act;
	sector_t resume;
	sector_t suspend;

117
	spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120
	res = acct_globals.active;
	if (!file || !acct_globals.needcheck)
		goto out;
121
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
122 123

	/* May block */
124
	if (vfs_statfs(file->f_path.dentry, &sbuf))
Linus Torvalds's avatar
Linus Torvalds committed
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
		return res;
	suspend = sbuf.f_blocks * SUSPEND;
	resume = sbuf.f_blocks * RESUME;

	sector_div(suspend, 100);
	sector_div(resume, 100);

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

	/*
	 * If some joker switched acct_globals.file under us we'ld better be
	 * silent and _not_ touch anything.
	 */
143
	spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
	if (file != acct_globals.file) {
		if (act)
			res = act>0;
		goto out;
	}

	if (acct_globals.active) {
		if (act < 0) {
			acct_globals.active = 0;
			printk(KERN_INFO "Process accounting paused\n");
		}
	} else {
		if (act > 0) {
			acct_globals.active = 1;
			printk(KERN_INFO "Process accounting resumed\n");
		}
	}

	del_timer(&acct_globals.timer);
	acct_globals.needcheck = 0;
	acct_globals.timer.expires = jiffies + ACCT_TIMEOUT*HZ;
	add_timer(&acct_globals.timer);
	res = acct_globals.active;
out:
168
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172
	return res;
}

/*
173
 * Close the old accounting file (if currently open) and then replace
Linus Torvalds's avatar
Linus Torvalds committed
174 175
 * it with file (if non-NULL).
 *
176
 * NOTE: acct_lock MUST be held on entry and exit.
Linus Torvalds's avatar
Linus Torvalds committed
177 178 179 180
 */
static void acct_file_reopen(struct file *file)
{
	struct file *old_acct = NULL;
181
	struct pid_namespace *old_ns = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184

	if (acct_globals.file) {
		old_acct = acct_globals.file;
185
		old_ns = acct_globals.ns;
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188 189 190 191 192
		del_timer(&acct_globals.timer);
		acct_globals.active = 0;
		acct_globals.needcheck = 0;
		acct_globals.file = NULL;
	}
	if (file) {
		acct_globals.file = file;
193
		acct_globals.ns = get_pid_ns(task_active_pid_ns(current));
Linus Torvalds's avatar
Linus Torvalds committed
194 195 196
		acct_globals.needcheck = 0;
		acct_globals.active = 1;
		/* It's been deleted if it was used before so this is safe */
197 198
		setup_timer(&acct_globals.timer, acct_timeout,
				(unsigned long)&acct_globals);
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202
		acct_globals.timer.expires = jiffies + ACCT_TIMEOUT*HZ;
		add_timer(&acct_globals.timer);
	}
	if (old_acct) {
203
		mnt_unpin(old_acct->f_path.mnt);
204
		spin_unlock(&acct_lock);
205
		do_acct_process(old_ns, old_acct);
Linus Torvalds's avatar
Linus Torvalds committed
206
		filp_close(old_acct, NULL);
207
		put_pid_ns(old_ns);
208
		spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
209 210 211
	}
}

212 213 214 215 216 217 218 219 220 221
static int acct_on(char *name)
{
	struct file *file;
	int error;

	/* 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);

222
	if (!S_ISREG(file->f_path.dentry->d_inode->i_mode)) {
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
		filp_close(file, NULL);
		return -EACCES;
	}

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

	error = security_acct(file);
	if (error) {
		filp_close(file, NULL);
		return error;
	}

238
	spin_lock(&acct_lock);
239
	mnt_pin(file->f_path.mnt);
240
	acct_file_reopen(file);
241
	spin_unlock(&acct_lock);
242

243
	mntput(file->f_path.mnt); /* it's pinned, now give up active reference */
244 245 246 247

	return 0;
}

248 249 250 251 252 253 254 255 256 257
/**
 * 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
258 259 260 261 262 263 264 265 266
 */
asmlinkage long sys_acct(const char __user *name)
{
	int error;

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

	if (name) {
267 268
		char *tmp = getname(name);
		if (IS_ERR(tmp))
Linus Torvalds's avatar
Linus Torvalds committed
269
			return (PTR_ERR(tmp));
270
		error = acct_on(tmp);
Linus Torvalds's avatar
Linus Torvalds committed
271
		putname(tmp);
272 273 274
	} else {
		error = security_acct(NULL);
		if (!error) {
275
			spin_lock(&acct_lock);
276
			acct_file_reopen(NULL);
277
			spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
278 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
	spin_lock(&acct_lock);
293
	if (acct_globals.file && acct_globals.file->f_path.mnt == m)
294
		acct_file_reopen(NULL);
295
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
296 297
}

298 299 300 301 302 303
/**
 * 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
304 305 306
 */
void acct_auto_close(struct super_block *sb)
{
307
	spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
308
	if (acct_globals.file &&
309
	    acct_globals.file->f_path.mnt->mnt_sb == sb) {
310
		acct_file_reopen(NULL);
Linus Torvalds's avatar
Linus Torvalds committed
311
	}
312
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
}

/*
 *  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++;
	}

	/*
339 340
	 * If we need to round up, do it (and handle overflow correctly).
	 */
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344 345 346
	if (rnd && (++value > MAXFRACT)) {
		value >>= EXPSIZE;
		exp++;
	}

	/*
347 348
	 * Clean it up and polish it off.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
	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)
{
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
	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
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
}
#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
423
 *  do_exit() or when switching to a different output file.
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428
 */

/*
 *  do_acct_process does all actual work. Caller holds the reference to file.
 */
429
static void do_acct_process(struct pid_namespace *ns, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
430
{
431
	struct pacct_struct *pacct = &current->signal->pacct;
Linus Torvalds's avatar
Linus Torvalds committed
432 433 434 435 436 437
	acct_t ac;
	mm_segment_t fs;
	unsigned long flim;
	u64 elapsed;
	u64 run_time;
	struct timespec uptime;
438
	struct tty_struct *tty;
Linus Torvalds's avatar
Linus Torvalds committed
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458

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

	/*
	 * Fill the accounting struct with the needed info as recorded
	 * by the different kernel functions.
	 */
	memset((caddr_t)&ac, 0, sizeof(acct_t));

	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;
459 460
	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
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
	/* 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);
478
	ac.ac_btime = get_seconds() - elapsed;
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483 484 485 486 487 488 489 490
	/* we really need to bite the bullet and change layout */
	ac.ac_uid = current->uid;
	ac.ac_gid = current->gid;
#if ACCT_VERSION==2
	ac.ac_ahz = AHZ;
#endif
#if ACCT_VERSION==1 || ACCT_VERSION==2
	/* backward-compatible 16 bit fields */
	ac.ac_uid16 = current->uid;
	ac.ac_gid16 = current->gid;
#endif
#if ACCT_VERSION==3
491
	ac.ac_pid = task_tgid_nr_ns(current, ns);
492
	rcu_read_lock();
493
	ac.ac_ppid = task_tgid_nr_ns(rcu_dereference(current->real_parent), ns);
494
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
495 496
#endif

497
	spin_lock_irq(&current->sighand->siglock);
498 499
	tty = current->signal->tty;
	ac.ac_tty = tty ? old_encode_dev(tty_devnum(tty)) : 0;
500 501
	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)));
502
	ac.ac_flag = pacct->ac_flag;
503
	ac.ac_mem = encode_comp_t(pacct->ac_mem);
504 505
	ac.ac_minflt = encode_comp_t(pacct->ac_minflt);
	ac.ac_majflt = encode_comp_t(pacct->ac_majflt);
506
	ac.ac_exitcode = pacct->ac_exitcode;
507
	spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds's avatar
Linus Torvalds committed
508 509 510 511 512
	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);

	/*
513 514 515
	 * Kernel segment override to datasegment and write it
	 * to the accounting file.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518
	fs = get_fs();
	set_fs(KERNEL_DS);
	/*
519 520
	 * Accounting records are not subject to resource limits.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523 524 525 526 527 528
	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);
}

529 530
/**
 * acct_init_pacct - initialize a new pacct_struct
531
 * @pacct: per-process accounting info struct to initialize
532 533 534 535
 */
void acct_init_pacct(struct pacct_struct *pacct)
{
	memset(pacct, 0, sizeof(struct pacct_struct));
536
	pacct->ac_utime = pacct->ac_stime = cputime_zero;
537 538 539 540
}

/**
 * acct_collect - collect accounting information into pacct_struct
541 542
 * @exitcode: task exit code
 * @group_dead: not 0, if this thread is the last one in the process.
543
 */
544
void acct_collect(long exitcode, int group_dead)
545 546 547 548
{
	struct pacct_struct *pacct = &current->signal->pacct;
	unsigned long vsize = 0;

549
	if (group_dead && current->mm) {
550 551 552 553 554 555 556 557 558 559
		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);
	}

560
	spin_lock_irq(&current->sighand->siglock);
561 562 563 564 565 566 567 568 569 570 571 572 573
	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;
574 575 576 577 578
	pacct->ac_utime = cputime_add(pacct->ac_utime, current->utime);
	pacct->ac_stime = cputime_add(pacct->ac_stime, current->stime);
	pacct->ac_minflt += current->min_flt;
	pacct->ac_majflt += current->maj_flt;
	spin_unlock_irq(&current->sighand->siglock);
579 580
}

581
/**
Linus Torvalds's avatar
Linus Torvalds committed
582
 * acct_process - now just a wrapper around do_acct_process
583 584
 *
 * handles process accounting for an exiting task
Linus Torvalds's avatar
Linus Torvalds committed
585
 */
586
void acct_process(void)
Linus Torvalds's avatar
Linus Torvalds committed
587 588
{
	struct file *file = NULL;
589
	struct pid_namespace *ns;
Linus Torvalds's avatar
Linus Torvalds committed
590 591 592 593 594 595 596

	/*
	 * accelerate the common fastpath:
	 */
	if (!acct_globals.file)
		return;

597
	spin_lock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
598 599
	file = acct_globals.file;
	if (unlikely(!file)) {
600
		spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
601 602 603
		return;
	}
	get_file(file);
604
	ns = get_pid_ns(acct_globals.ns);
605
	spin_unlock(&acct_lock);
Linus Torvalds's avatar
Linus Torvalds committed
606

607
	do_acct_process(ns, file);
Linus Torvalds's avatar
Linus Torvalds committed
608
	fput(file);
609
	put_pid_ns(ns);
Linus Torvalds's avatar
Linus Torvalds committed
610
}