kernel/acct.c

   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
  42 #include <linux/config.h>
  43 #include <linux/errno.h>
  44 #include <linux/kernel.h>
  45
  46 #ifdef CONFIG_BSD_PROCESS_ACCT
  47 #include <linux/mm.h>
  48 #include <linux/acct.h>
  49 #include <linux/smp_lock.h>
  50 #include <linux/file.h>
  51
  52 #include <asm/uaccess.h>
  53
  54 /*
  55  * These constants control the amount of freespace that suspend and
  56  * resume the process accounting system, and the time delay between
  57  * each check.
  58  * Turned into sysctl-controllable parameters. AV, 12/11/98
  59  */
  60
  61 int acct_parm[3] = {4, 2, 30};
  62 #define RESUME          (acct_parm[0])  /* >foo% free space - resume */
  63 #define SUSPEND         (acct_parm[1])  /* <foo% free space - suspend */
  64 #define ACCT_TIMEOUT    (acct_parm[2])  /* foo second timeout between checks */
  65
  66 /*
  67  * External references and all of the globals.
  68  */
  69 void acct_timeout(unsigned long);
  70
  71 static volatile int acct_active;
  72 static volatile int acct_needcheck;
  73 static struct file *acct_file;
  74 static struct timer_list acct_timer = { NULL, NULL, 0, 0, acct_timeout };
  75 static int do_acct_process(long, struct file *);
  76
  77 /*
  78  * Called whenever the timer says to check the free space.
  79  */
  80 void acct_timeout(unsigned long unused)
  81 {
  82         acct_needcheck = 1;
  83 }
  84
  85 /*
  86  * Check the amount of free space and suspend/resume accordingly.
  87  */
  88 static int check_free_space(struct file *file)
  89 {
  90         struct statfs sbuf;
  91         int res = acct_active;
  92         int act;
  93
  94         if (!file || !acct_needcheck)
  95                 return res;
  96
  97         /* May block */
  98         if (vfs_statfs(file->f_dentry->d_inode->i_sb, &sbuf))
  99                 return res;
 100
 101         if (sbuf.f_bavail <= SUSPEND * sbuf.f_blocks / 100)
 102                 act = -1;
 103         else if (sbuf.f_bavail >= RESUME * sbuf.f_blocks / 100)
 104                 act = 1;
 105         else
 106                 act = 0;
 107
 108         /*
 109          * If some joker switched acct_file under us we'ld better be
 110          * silent and _not_ touch anything.
 111          */
 112         if (file != acct_file)
 113                 return act ? (act>0) : res;
 114
 115         if (acct_active) {
 116                 if (act < 0) {
 117                         acct_active = 0;
 118                         printk(KERN_INFO "Process accounting paused\n");
 119                 }
 120         } else {
 121                 if (act > 0) {
 122                         acct_active = 1;
 123                         printk(KERN_INFO "Process accounting resumed\n");
 124                 }
 125         }
 126
 127         del_timer(&acct_timer);
 128         acct_needcheck = 0;
 129         acct_timer.expires = jiffies + ACCT_TIMEOUT*HZ;
 130         add_timer(&acct_timer);
 131         return acct_active;
 132 }
 133
 134 /*
 135  *  sys_acct() is the only system call needed to implement process
 136  *  accounting. It takes the name of the file where accounting records
 137  *  should be written. If the filename is NULL, accounting will be
 138  *  shutdown.
 139  */
 140 asmlinkage long sys_acct(const char *name)
 141 {
 142         struct file *file = NULL, *old_acct = NULL;
 143         char *tmp;
 144         int error;
 145
 146         if (!capable(CAP_SYS_PACCT))
 147                 return -EPERM;
 148
 149         lock_kernel();
 150         if (name) {
 151                 tmp = getname(name);
 152                 error = PTR_ERR(tmp);
 153                 if (IS_ERR(tmp))
 154                         goto out;
 155                 /* Difference from BSD - they don't do O_APPEND */
 156                 file = filp_open(tmp, O_WRONLY|O_APPEND, 0);
 157                 putname(tmp);
 158                 if (IS_ERR(file)) {
 159                         error = PTR_ERR(file);
 160                         goto out;
 161                 }
 162                 error = -EACCES;
 163                 if (!S_ISREG(file->f_dentry->d_inode->i_mode))
 164                         goto out_err;
 165
 166                 error = -EIO;
 167                 if (!file->f_op->write)
 168                         goto out_err;
 169         }
 170
 171         error = 0;
 172         if (acct_file) {
 173                 old_acct = acct_file;
 174                 del_timer(&acct_timer);
 175                 acct_active = 0;
 176                 acct_needcheck = 0;
 177                 acct_file = NULL;
 178         }
 179         if (name) {
 180                 acct_file = file;
 181                 acct_needcheck = 0;
 182                 acct_active = 1;
 183                 acct_timer.expires = jiffies + ACCT_TIMEOUT*HZ;
 184                 add_timer(&acct_timer);
 185         }
 186         if (old_acct) {
 187                 do_acct_process(0,old_acct);
 188                 filp_close(old_acct, NULL);
 189         }
 190 out:
 191         unlock_kernel();
 192         return error;
 193 out_err:
 194         filp_close(file, NULL);
 195         goto out;
 196 }
 197
 198 void acct_auto_close(kdev_t dev)
 199 {
 200         if (acct_file && acct_file->f_dentry->d_inode->i_dev == dev)
 201                 sys_acct((char *)NULL);
 202 }
 203
 204 /*
 205  *  encode an unsigned long into a comp_t
 206  *
 207  *  This routine has been adopted from the encode_comp_t() function in
 208  *  the kern_acct.c file of the FreeBSD operating system. The encoding
 209  *  is a 13-bit fraction with a 3-bit (base 8) exponent.
 210  */
 211
 212 #define MANTSIZE        13                      /* 13 bit mantissa. */
 213 #define EXPSIZE         3                       /* Base 8 (3 bit) exponent. */
 214 #define MAXFRACT        ((1 << MANTSIZE) - 1)   /* Maximum fractional value. */
 215
 216 static comp_t encode_comp_t(unsigned long value)
 217 {
 218         int exp, rnd;
 219
 220         exp = rnd = 0;
 221         while (value > MAXFRACT) {
 222                 rnd = value & (1 << (EXPSIZE - 1));     /* Round up? */
 223                 value >>= EXPSIZE;      /* Base 8 exponent == 3 bit shift. */
 224                 exp++;
 225         }
 226
 227         /*
 228          * If we need to round up, do it (and handle overflow correctly).
 229          */
 230         if (rnd && (++value > MAXFRACT)) {
 231                 value >>= EXPSIZE;
 232                 exp++;
 233         }
 234
 235         /*
 236          * Clean it up and polish it off.
 237          */
 238         exp <<= MANTSIZE;               /* Shift the exponent into place */
 239         exp += value;                   /* and add on the mantissa. */
 240         return exp;
 241 }
 242
 243 /*
 244  *  Write an accounting entry for an exiting process
 245  *
 246  *  The acct_process() call is the workhorse of the process
 247  *  accounting system. The struct acct is built here and then written
 248  *  into the accounting file. This function should only be called from
 249  *  do_exit().
 250  */
 251
 252 /*
 253  *  do_acct_process does all actual work.
 254  */
 255 static int do_acct_process(long exitcode, struct file *file)
 256 {
 257         struct acct ac;
 258         mm_segment_t fs;
 259         unsigned long vsize;
 260         struct inode *inode;
 261
 262         /*
 263          * First check to see if there is enough free_space to continue
 264          * the process accounting system.
 265          */
 266         if (!file)
 267                 return 0;
 268         get_file(file);
 269         if (!check_free_space(file)) {
 270                 fput(file);
 271                 return 0;
 272         }
 273
 274         /*
 275          * Fill the accounting struct with the needed info as recorded
 276          * by the different kernel functions.
 277          */
 278         memset((caddr_t)&ac, 0, sizeof(struct acct));
 279
 280         strncpy(ac.ac_comm, current->comm, ACCT_COMM);
 281         ac.ac_comm[ACCT_COMM - 1] = '\0';
 282
 283         ac.ac_btime = CT_TO_SECS(current->start_time) + (xtime.tv_sec - (jiffies / HZ));
 284         ac.ac_etime = encode_comp_t(jiffies - current->start_time);
 285         ac.ac_utime = encode_comp_t(current->times.tms_utime);
 286         ac.ac_stime = encode_comp_t(current->times.tms_stime);
 287         ac.ac_uid = current->uid;
 288         ac.ac_gid = current->gid;
 289         ac.ac_tty = (current->tty) ? kdev_t_to_nr(current->tty->device) : 0;
 290
 291         ac.ac_flag = 0;
 292         if (current->flags & PF_FORKNOEXEC)
 293                 ac.ac_flag |= AFORK;
 294         if (current->flags & PF_SUPERPRIV)
 295                 ac.ac_flag |= ASU;
 296         if (current->flags & PF_DUMPCORE)
 297                 ac.ac_flag |= ACORE;
 298         if (current->flags & PF_SIGNALED)
 299                 ac.ac_flag |= AXSIG;
 300
 301         vsize = 0;
 302         if (current->mm) {
 303                 struct vm_area_struct *vma = current->mm->mmap;
 304                 while (vma) {
 305                         vsize += vma->vm_end - vma->vm_start;
 306                         vma = vma->vm_next;
 307                 }
 308         }
 309         vsize = vsize / 1024;
 310         ac.ac_mem = encode_comp_t(vsize);
 311         ac.ac_io = encode_comp_t(0 /* current->io_usage */);    /* %% */
 312         ac.ac_rw = encode_comp_t(ac.ac_io / 1024);
 313         ac.ac_minflt = encode_comp_t(current->min_flt);
 314         ac.ac_majflt = encode_comp_t(current->maj_flt);
 315         ac.ac_swaps = encode_comp_t(current->nswap);
 316         ac.ac_exitcode = exitcode;
 317
 318         /*
 319          * Kernel segment override to datasegment and write it
 320          * to the accounting file.
 321          */
 322         fs = get_fs();
 323         set_fs(KERNEL_DS);
 324         inode = file->f_dentry->d_inode;
 325         file->f_op->write(file, (char *)&ac,
 326                                sizeof(struct acct), &file->f_pos);
 327         set_fs(fs);
 328         fput(file);
 329         return 0;
 330 }
 331
 332 /*
 333  * acct_process - now just a wrapper around do_acct_process
 334  */
 335 int acct_process(long exitcode)
 336 {
 337         return do_acct_process(exitcode, acct_file);
 338 }
 339
 340 #else
 341 /*
 342  * Dummy system call when BSD process accounting is not configured
 343  * into the kernel.
 344  */
 345
 346 asmlinkage long sys_acct(const char * filename)
 347 {
 348         return -ENOSYS;
 349 }
 350 #endif