Branch data     Line data    Source code

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