1 /* 2 * linux/kernel/acct.c 3 * 4 * BSD Process Accounting for Linux 5 * 6 * Author: Marco van Wieringen <mvw@planets.elm.net> 7 * 8 * Some code based on ideas and code from: 9 * Thomas K. Dyas <tdyas@eden.rutgers.edu> 10 * 11 * This file implements BSD-style process accounting. Whenever any 12 * process exits, an accounting record of type "struct acct" is 13 * written to the file specified with the acct() system call. It is 14 * up to user-level programs to do useful things with the accounting 15 * log. The kernel just provides the raw accounting information. 16 * 17 * (C) Copyright 1995 - 1997 Marco van Wieringen - ELM Consultancy B.V. 18 * 19 * Plugged two leaks. 1) It didn't return acct_file into the free_filps if 20 * the file happened to be read-only. 2) If the accounting was suspended 21 * due to the lack of space it happily allowed to reopen it and completely 22 * lost the old acct_file. 3/10/98, Al Viro. 23 * 24 * Now we silently close acct_file on attempt to reopen. Cleaned sys_acct(). 25 * XTerms and EMACS are manifestations of pure evil. 21/10/98, AV. 26 * 27 * Fixed a nasty interaction with with sys_umount(). If the accointing 28 * was suspeneded we failed to stop it on umount(). Messy. 29 * Another one: remount to readonly didn't stop accounting. 30 * Question: what should we do if we have CAP_SYS_ADMIN but not 31 * CAP_SYS_PACCT? Current code does the following: umount returns -EBUSY 32 * unless we are messing with the root. In that case we are getting a 33 * real mess with do_remount_sb(). 9/11/98, AV. 34 * 35 * Fixed a bunch of races (and pair of leaks). Probably not the best way, 36 * but this one obviously doesn't introduce deadlocks. Later. BTW, found 37 * one race (and leak) in BSD implementation. 38 * OK, that's better. ANOTHER race and leak in BSD variant. There always 39 * is one more bug... 10/11/98, AV. 40 * 41 * Oh, fsck... Oopsable SMP race in do_process_acct() - we must hold 42 * ->mmap_sem to walk the vma list of current->mm. Nasty, since it leaks 43 * a struct file opened for write. Fixed. 2/6/2000, AV. 44 */ 45 46 #include <linux/mm.h> 47 #include <linux/slab.h> 48 #include <linux/acct.h> 49 #include <linux/capability.h> 50 #include <linux/file.h> 51 #include <linux/tty.h> 52 #include <linux/security.h> 53 #include <linux/vfs.h> 54 #include <linux/jiffies.h> 55 #include <linux/times.h> 56 #include <linux/syscalls.h> 57 #include <linux/mount.h> 58 #include <linux/uaccess.h> 59 #include <asm/div64.h> 60 #include <linux/blkdev.h> /* sector_div */ 61 #include <linux/pid_namespace.h> 62 63 /* 64 * These constants control the amount of freespace that suspend and 65 * resume the process accounting system, and the time delay between 66 * each check. 67 * Turned into sysctl-controllable parameters. AV, 12/11/98 68 */ 69 70 int acct_parm[3] = {4, 2, 30}; 71 #define RESUME (acct_parm[0]) /* >foo% free space - resume */ 72 #define SUSPEND (acct_parm[1]) /* <foo% free space - suspend */ 73 #define ACCT_TIMEOUT (acct_parm[2]) /* foo second timeout between checks */ 74 75 /* 76 * External references and all of the globals. 77 */ 78 static void do_acct_process(struct bsd_acct_struct *acct, 79 struct pid_namespace *ns, struct file *); 80 81 /* 82 * This structure is used so that all the data protected by lock 83 * can be placed in the same cache line as the lock. This primes 84 * the cache line to have the data after getting the lock. 85 */ 86 struct bsd_acct_struct { 87 int active; 88 unsigned long needcheck; 89 struct file *file; 90 struct pid_namespace *ns; 91 struct list_head list; 92 }; 93 94 static DEFINE_SPINLOCK(acct_lock); 95 static LIST_HEAD(acct_list); 96 97 /* 98 * Check the amount of free space and suspend/resume accordingly. 99 */ 100 static int check_free_space(struct bsd_acct_struct *acct, struct file *file) 101 { 102 struct kstatfs sbuf; 103 int res; 104 int act; 105 u64 resume; 106 u64 suspend; 107 108 spin_lock(&acct_lock); 109 res = acct->active; 110 if (!file || time_is_before_jiffies(acct->needcheck)) 111 goto out; 112 spin_unlock(&acct_lock); 113 114 /* May block */ 115 if (vfs_statfs(&file->f_path, &sbuf)) 116 return res; 117 suspend = sbuf.f_blocks * SUSPEND; 118 resume = sbuf.f_blocks * RESUME; 119 120 do_div(suspend, 100); 121 do_div(resume, 100); 122 123 if (sbuf.f_bavail <= suspend) 124 act = -1; 125 else if (sbuf.f_bavail >= resume) 126 act = 1; 127 else 128 act = 0; 129 130 /* 131 * If some joker switched acct->file under us we'ld better be 132 * silent and _not_ touch anything. 133 */ 134 spin_lock(&acct_lock); 135 if (file != acct->file) { 136 if (act) 137 res = act > 0; 138 goto out; 139 } 140 141 if (acct->active) { 142 if (act < 0) { 143 acct->active = 0; 144 printk(KERN_INFO "Process accounting paused\n"); 145 } 146 } else { 147 if (act > 0) { 148 acct->active = 1; 149 printk(KERN_INFO "Process accounting resumed\n"); 150 } 151 } 152 153 acct->needcheck = jiffies + ACCT_TIMEOUT*HZ; 154 res = acct->active; 155 out: 156 spin_unlock(&acct_lock); 157 return res; 158 } 159 160 /* 161 * Close the old accounting file (if currently open) and then replace 162 * it with file (if non-NULL). 163 * 164 * NOTE: acct_lock MUST be held on entry and exit. 165 */ 166 static void acct_file_reopen(struct bsd_acct_struct *acct, struct file *file, 167 struct pid_namespace *ns) 168 { 169 struct file *old_acct = NULL; 170 struct pid_namespace *old_ns = NULL; 171 172 if (acct->file) { 173 old_acct = acct->file; 174 old_ns = acct->ns; 175 acct->active = 0; 176 acct->file = NULL; 177 acct->ns = NULL; 178 list_del(&acct->list); 179 } 180 if (file) { 181 acct->file = file; 182 acct->ns = ns; 183 acct->needcheck = jiffies; 184 acct->active = 0; 185 list_add(&acct->list, &acct_list); 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); 191 filp_close(old_acct, NULL); 192 spin_lock(&acct_lock); 193 } 194 } 195 196 static int acct_on(struct filename *pathname) 197 { 198 struct file *file; 199 struct vfsmount *mnt; 200 struct pid_namespace *ns; 201 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 if (IS_ERR(file)) 206 return PTR_ERR(file); 207 208 if (!S_ISREG(file_inode(file)->i_mode)) { 209 filp_close(file, NULL); 210 return -EACCES; 211 } 212 213 if (!file->f_op->write) { 214 filp_close(file, NULL); 215 return -EIO; 216 } 217 218 ns = task_active_pid_ns(current); 219 if (ns->bacct == NULL) { 220 acct = kzalloc(sizeof(struct bsd_acct_struct), GFP_KERNEL); 221 if (acct == NULL) { 222 filp_close(file, NULL); 223 return -ENOMEM; 224 } 225 } 226 227 spin_lock(&acct_lock); 228 if (ns->bacct == NULL) { 229 ns->bacct = acct; 230 acct = NULL; 231 } 232 233 mnt = file->f_path.mnt; 234 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 return 0; 242 } 243 244 static DEFINE_MUTEX(acct_on_mutex); 245 246 /** 247 * sys_acct - enable/disable process accounting 248 * @name: file name for accounting records or NULL to shutdown accounting 249 * 250 * Returns 0 for success or negative errno values for failure. 251 * 252 * sys_acct() is the only system call needed to implement process 253 * accounting. It takes the name of the file where accounting records 254 * should be written. If the filename is NULL, accounting will be 255 * shutdown. 256 */ 257 SYSCALL_DEFINE1(acct, const char __user *, name) 258 { 259 int error = 0; 260 261 if (!capable(CAP_SYS_PACCT)) 262 return -EPERM; 263 264 if (name) { 265 struct filename *tmp = getname(name); 266 if (IS_ERR(tmp)) 267 return PTR_ERR(tmp); 268 mutex_lock(&acct_on_mutex); 269 error = acct_on(tmp); 270 mutex_unlock(&acct_on_mutex); 271 putname(tmp); 272 } else { 273 struct bsd_acct_struct *acct; 274 275 acct = task_active_pid_ns(current)->bacct; 276 if (acct == NULL) 277 return 0; 278 279 spin_lock(&acct_lock); 280 acct_file_reopen(acct, NULL, NULL); 281 spin_unlock(&acct_lock); 282 } 283 284 return error; 285 } 286 287 /** 288 * acct_auto_close - turn off a filesystem's accounting if it is on 289 * @m: vfsmount being shut down 290 * 291 * If the accounting is turned on for a file in the subtree pointed to 292 * to by m, turn accounting off. Done when m is about to die. 293 */ 294 void acct_auto_close_mnt(struct vfsmount *m) 295 { 296 struct bsd_acct_struct *acct; 297 298 spin_lock(&acct_lock); 299 restart: 300 list_for_each_entry(acct, &acct_list, list) 301 if (acct->file && acct->file->f_path.mnt == m) { 302 acct_file_reopen(acct, NULL, NULL); 303 goto restart; 304 } 305 spin_unlock(&acct_lock); 306 } 307 308 /** 309 * acct_auto_close - turn off a filesystem's accounting if it is on 310 * @sb: super block for the filesystem 311 * 312 * If the accounting is turned on for a file in the filesystem pointed 313 * to by sb, turn accounting off. 314 */ 315 void acct_auto_close(struct super_block *sb) 316 { 317 struct bsd_acct_struct *acct; 318 319 spin_lock(&acct_lock); 320 restart: 321 list_for_each_entry(acct, &acct_list, list) 322 if (acct->file && acct->file->f_path.dentry->d_sb == sb) { 323 acct_file_reopen(acct, NULL, NULL); 324 goto restart; 325 } 326 spin_unlock(&acct_lock); 327 } 328 329 void acct_exit_ns(struct pid_namespace *ns) 330 { 331 struct bsd_acct_struct *acct = ns->bacct; 332 333 if (acct == NULL) 334 return; 335 336 spin_lock(&acct_lock); 337 if (acct->file != NULL) 338 acct_file_reopen(acct, NULL, NULL); 339 spin_unlock(&acct_lock); 340 341 kfree(acct); 342 } 343 344 /* 345 * encode an unsigned long into a comp_t 346 * 347 * This routine has been adopted from the encode_comp_t() function in 348 * the kern_acct.c file of the FreeBSD operating system. The encoding 349 * is a 13-bit fraction with a 3-bit (base 8) exponent. 350 */ 351 352 #define MANTSIZE 13 /* 13 bit mantissa. */ 353 #define EXPSIZE 3 /* Base 8 (3 bit) exponent. */ 354 #define MAXFRACT ((1 << MANTSIZE) - 1) /* Maximum fractional value. */ 355 356 static comp_t encode_comp_t(unsigned long value) 357 { 358 int exp, rnd; 359 360 exp = rnd = 0; 361 while (value > MAXFRACT) { 362 rnd = value & (1 << (EXPSIZE - 1)); /* Round up? */ 363 value >>= EXPSIZE; /* Base 8 exponent == 3 bit shift. */ 364 exp++; 365 } 366 367 /* 368 * If we need to round up, do it (and handle overflow correctly). 369 */ 370 if (rnd && (++value > MAXFRACT)) { 371 value >>= EXPSIZE; 372 exp++; 373 } 374 375 /* 376 * Clean it up and polish it off. 377 */ 378 exp <<= MANTSIZE; /* Shift the exponent into place */ 379 exp += value; /* and add on the mantissa. */ 380 return exp; 381 } 382 383 #if ACCT_VERSION==1 || ACCT_VERSION==2 384 /* 385 * encode an u64 into a comp2_t (24 bits) 386 * 387 * Format: 5 bit base 2 exponent, 20 bits mantissa. 388 * The leading bit of the mantissa is not stored, but implied for 389 * non-zero exponents. 390 * Largest encodable value is 50 bits. 391 */ 392 393 #define MANTSIZE2 20 /* 20 bit mantissa. */ 394 #define EXPSIZE2 5 /* 5 bit base 2 exponent. */ 395 #define MAXFRACT2 ((1ul << MANTSIZE2) - 1) /* Maximum fractional value. */ 396 #define MAXEXP2 ((1 <<EXPSIZE2) - 1) /* Maximum exponent. */ 397 398 static comp2_t encode_comp2_t(u64 value) 399 { 400 int exp, rnd; 401 402 exp = (value > (MAXFRACT2>>1)); 403 rnd = 0; 404 while (value > MAXFRACT2) { 405 rnd = value & 1; 406 value >>= 1; 407 exp++; 408 } 409 410 /* 411 * If we need to round up, do it (and handle overflow correctly). 412 */ 413 if (rnd && (++value > MAXFRACT2)) { 414 value >>= 1; 415 exp++; 416 } 417 418 if (exp > MAXEXP2) { 419 /* Overflow. Return largest representable number instead. */ 420 return (1ul << (MANTSIZE2+EXPSIZE2-1)) - 1; 421 } else { 422 return (value & (MAXFRACT2>>1)) | (exp << (MANTSIZE2-1)); 423 } 424 } 425 #endif 426 427 #if ACCT_VERSION==3 428 /* 429 * encode an u64 into a 32 bit IEEE float 430 */ 431 static u32 encode_float(u64 value) 432 { 433 unsigned exp = 190; 434 unsigned u; 435 436 if (value==0) return 0; 437 while ((s64)value > 0){ 438 value <<= 1; 439 exp--; 440 } 441 u = (u32)(value >> 40) & 0x7fffffu; 442 return u | (exp << 23); 443 } 444 #endif 445 446 /* 447 * Write an accounting entry for an exiting process 448 * 449 * The acct_process() call is the workhorse of the process 450 * accounting system. The struct acct is built here and then written 451 * into the accounting file. This function should only be called from 452 * do_exit() or when switching to a different output file. 453 */ 454 455 static void fill_ac(acct_t *ac) 456 { 457 struct pacct_struct *pacct = ¤t->signal->pacct; 458 u64 elapsed, run_time; 459 struct tty_struct *tty; 460 461 /* 462 * Fill the accounting struct with the needed info as recorded 463 * by the different kernel functions. 464 */ 465 memset(ac, 0, sizeof(acct_t)); 466 467 ac->ac_version = ACCT_VERSION | ACCT_BYTEORDER; 468 strlcpy(ac->ac_comm, current->comm, sizeof(ac->ac_comm)); 469 470 /* calculate run_time in nsec*/ 471 run_time = ktime_get_ns(); 472 run_time -= current->group_leader->start_time; 473 /* convert nsec -> AHZ */ 474 elapsed = nsec_to_AHZ(run_time); 475 #if ACCT_VERSION==3 476 ac->ac_etime = encode_float(elapsed); 477 #else 478 ac->ac_etime = encode_comp_t(elapsed < (unsigned long) -1l ? 479 (unsigned long) elapsed : (unsigned long) -1l); 480 #endif 481 #if ACCT_VERSION==1 || ACCT_VERSION==2 482 { 483 /* new enlarged etime field */ 484 comp2_t etime = encode_comp2_t(elapsed); 485 ac->ac_etime_hi = etime >> 16; 486 ac->ac_etime_lo = (u16) etime; 487 } 488 #endif 489 do_div(elapsed, AHZ); 490 ac->ac_btime = get_seconds() - elapsed; 491 #if ACCT_VERSION==2 492 ac->ac_ahz = AHZ; 493 #endif 494 495 spin_lock_irq(¤t->sighand->siglock); 496 tty = current->signal->tty; /* Safe as we hold the siglock */ 497 ac->ac_tty = tty ? old_encode_dev(tty_devnum(tty)) : 0; 498 ac->ac_utime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_utime))); 499 ac->ac_stime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_stime))); 500 ac->ac_flag = pacct->ac_flag; 501 ac->ac_mem = encode_comp_t(pacct->ac_mem); 502 ac->ac_minflt = encode_comp_t(pacct->ac_minflt); 503 ac->ac_majflt = encode_comp_t(pacct->ac_majflt); 504 ac->ac_exitcode = pacct->ac_exitcode; 505 spin_unlock_irq(¤t->sighand->siglock); 506 } 507 /* 508 * do_acct_process does all actual work. Caller holds the reference to file. 509 */ 510 static void do_acct_process(struct bsd_acct_struct *acct, 511 struct pid_namespace *ns, struct file *file) 512 { 513 acct_t ac; 514 unsigned long flim; 515 const struct cred *orig_cred; 516 517 /* 518 * Accounting records are not subject to resource limits. 519 */ 520 flim = current->signal->rlim[RLIMIT_FSIZE].rlim_cur; 521 current->signal->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY; 522 /* Perform file operations on behalf of whoever enabled accounting */ 523 orig_cred = override_creds(file->f_cred); 524 525 /* 526 * First check to see if there is enough free_space to continue 527 * the process accounting system. 528 */ 529 if (!check_free_space(acct, file)) 530 goto out; 531 532 fill_ac(&ac); 533 /* we really need to bite the bullet and change layout */ 534 ac.ac_uid = from_kuid_munged(file->f_cred->user_ns, orig_cred->uid); 535 ac.ac_gid = from_kgid_munged(file->f_cred->user_ns, orig_cred->gid); 536 #if ACCT_VERSION==1 || ACCT_VERSION==2 537 /* backward-compatible 16 bit fields */ 538 ac.ac_uid16 = ac.ac_uid; 539 ac.ac_gid16 = ac.ac_gid; 540 #endif 541 #if ACCT_VERSION==3 542 ac.ac_pid = task_tgid_nr_ns(current, ns); 543 rcu_read_lock(); 544 ac.ac_ppid = task_tgid_nr_ns(rcu_dereference(current->real_parent), ns); 545 rcu_read_unlock(); 546 #endif 547 /* 548 * Get freeze protection. If the fs is frozen, just skip the write 549 * as we could deadlock the system otherwise. 550 */ 551 if (file_start_write_trylock(file)) { 552 /* it's been opened O_APPEND, so position is irrelevant */ 553 loff_t pos = 0; 554 __kernel_write(file, (char *)&ac, sizeof(acct_t), &pos); 555 file_end_write(file); 556 } 557 out: 558 current->signal->rlim[RLIMIT_FSIZE].rlim_cur = flim; 559 revert_creds(orig_cred); 560 } 561 562 /** 563 * acct_collect - collect accounting information into pacct_struct 564 * @exitcode: task exit code 565 * @group_dead: not 0, if this thread is the last one in the process. 566 */ 567 void acct_collect(long exitcode, int group_dead) 568 { 569 struct pacct_struct *pacct = ¤t->signal->pacct; 570 cputime_t utime, stime; 571 unsigned long vsize = 0; 572 573 if (group_dead && current->mm) { 574 struct vm_area_struct *vma; 575 down_read(¤t->mm->mmap_sem); 576 vma = current->mm->mmap; 577 while (vma) { 578 vsize += vma->vm_end - vma->vm_start; 579 vma = vma->vm_next; 580 } 581 up_read(¤t->mm->mmap_sem); 582 } 583 584 spin_lock_irq(¤t->sighand->siglock); 585 if (group_dead) 586 pacct->ac_mem = vsize / 1024; 587 if (thread_group_leader(current)) { 588 pacct->ac_exitcode = exitcode; 589 if (current->flags & PF_FORKNOEXEC) 590 pacct->ac_flag |= AFORK; 591 } 592 if (current->flags & PF_SUPERPRIV) 593 pacct->ac_flag |= ASU; 594 if (current->flags & PF_DUMPCORE) 595 pacct->ac_flag |= ACORE; 596 if (current->flags & PF_SIGNALED) 597 pacct->ac_flag |= AXSIG; 598 task_cputime(current, &utime, &stime); 599 pacct->ac_utime += utime; 600 pacct->ac_stime += stime; 601 pacct->ac_minflt += current->min_flt; 602 pacct->ac_majflt += current->maj_flt; 603 spin_unlock_irq(¤t->sighand->siglock); 604 } 605 606 static void slow_acct_process(struct pid_namespace *ns) 607 { 608 for ( ; ns; ns = ns->parent) { 609 struct file *file = NULL; 610 struct bsd_acct_struct *acct; 611 612 acct = ns->bacct; 613 /* 614 * accelerate the common fastpath: 615 */ 616 if (!acct || !acct->file) 617 continue; 618 619 spin_lock(&acct_lock); 620 file = acct->file; 621 if (unlikely(!file)) { 622 spin_unlock(&acct_lock); 623 continue; 624 } 625 get_file(file); 626 spin_unlock(&acct_lock); 627 628 do_acct_process(acct, ns, file); 629 fput(file); 630 } 631 } 632 633 /** 634 * acct_process 635 * 636 * handles process accounting for an exiting task 637 */ 638 void acct_process(void) 639 { 640 struct pid_namespace *ns; 641 642 /* 643 * This loop is safe lockless, since current is still 644 * alive and holds its namespace, which in turn holds 645 * its parent. 646 */ 647 for (ns = task_active_pid_ns(current); ns != NULL; ns = ns->parent) { 648 struct bsd_acct_struct *acct = ns->bacct; 649 if (acct && acct->file) 650 break; 651 } 652 if (unlikely(ns)) 653 slow_acct_process(ns); 654 } 655