LXR linux-bk/fs/attr.c

   1/*
   2 *  linux/fs/attr.c
   3 *
   4 *  Copyright (C) 1991, 1992  Linus Torvalds
   5 *  changes by Thomas Schoebel-Theuer
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/time.h>
  10#include <linux/mm.h>
  11#include <linux/string.h>
  12#include <linux/smp_lock.h>
  13#include <linux/dnotify.h>
  14#include <linux/fcntl.h>
  15#include <linux/quotaops.h>
  16#include <linux/security.h>
  17
  18/* Taken over from the old code... */
  19
  20/* POSIX UID/GID verification for setting inode attributes. */
  21int inode_change_ok(struct inode *inode, struct iattr *attr)
  22{
  23        int retval = -EPERM;
  24        unsigned int ia_valid = attr->ia_valid;
  25
  26        /* If force is set do it anyway. */
  27        if (ia_valid & ATTR_FORCE)
  28                goto fine;
  29
  30        /* Make sure a caller can chown. */
  31        if ((ia_valid & ATTR_UID) &&
  32            (current->fsuid != inode->i_uid ||
  33             attr->ia_uid != inode->i_uid) && !capable(CAP_CHOWN))
  34                goto error;
  35
  36        /* Make sure caller can chgrp. */
  37        if ((ia_valid & ATTR_GID) &&
  38            (!in_group_p(attr->ia_gid) && attr->ia_gid != inode->i_gid) &&
  39            !capable(CAP_CHOWN))
  40                goto error;
  41
  42        /* Make sure a caller can chmod. */
  43        if (ia_valid & ATTR_MODE) {
  44                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  45                        goto error;
  46                /* Also check the setgid bit! */
  47                if (!in_group_p((ia_valid & ATTR_GID) ? attr->ia_gid :
  48                                inode->i_gid) && !capable(CAP_FSETID))
  49                        attr->ia_mode &= ~S_ISGID;
  50        }
  51
  52        /* Check for setting the inode time. */
  53        if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) {
  54                if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
  55                        goto error;
  56        }
  57fine:
  58        retval = 0;
  59error:
  60        return retval;
  61}
  62
  63EXPORT_SYMBOL(inode_change_ok);
  64
  65int inode_setattr(struct inode * inode, struct iattr * attr)
  66{
  67        unsigned int ia_valid = attr->ia_valid;
  68        int error = 0;
  69
  70        if (ia_valid & ATTR_SIZE) {
  71                if (attr->ia_size != i_size_read(inode)) {
  72                        error = vmtruncate(inode, attr->ia_size);
  73                        if (error || (ia_valid == ATTR_SIZE))
  74                                goto out;
  75                } else {
  76                        /*
  77                         * We skipped the truncate but must still update
  78                         * timestamps
  79                         */
  80                        ia_valid |= ATTR_MTIME|ATTR_CTIME;
  81                }
  82        }
  83
  84        if (ia_valid & ATTR_UID)
  85                inode->i_uid = attr->ia_uid;
  86        if (ia_valid & ATTR_GID)
  87                inode->i_gid = attr->ia_gid;
  88        if (ia_valid & ATTR_ATIME)
  89                inode->i_atime = attr->ia_atime;
  90        if (ia_valid & ATTR_MTIME)
  91                inode->i_mtime = attr->ia_mtime;
  92        if (ia_valid & ATTR_CTIME)
  93                inode->i_ctime = attr->ia_ctime;
  94        if (ia_valid & ATTR_MODE) {
  95                umode_t mode = attr->ia_mode;
  96
  97                if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
  98                        mode &= ~S_ISGID;
  99                inode->i_mode = mode;
 100        }
 101        mark_inode_dirty(inode);
 102out:
 103        return error;
 104}
 105
 106EXPORT_SYMBOL(inode_setattr);
 107
 108int setattr_mask(unsigned int ia_valid)
 109{
 110        unsigned long dn_mask = 0;
 111
 112        if (ia_valid & ATTR_UID)
 113                dn_mask |= DN_ATTRIB;
 114        if (ia_valid & ATTR_GID)
 115                dn_mask |= DN_ATTRIB;
 116        if (ia_valid & ATTR_SIZE)
 117                dn_mask |= DN_MODIFY;
 118        /* both times implies a utime(s) call */
 119        if ((ia_valid & (ATTR_ATIME|ATTR_MTIME)) == (ATTR_ATIME|ATTR_MTIME))
 120                dn_mask |= DN_ATTRIB;
 121        else if (ia_valid & ATTR_ATIME)
 122                dn_mask |= DN_ACCESS;
 123        else if (ia_valid & ATTR_MTIME)
 124                dn_mask |= DN_MODIFY;
 125        if (ia_valid & ATTR_MODE)
 126                dn_mask |= DN_ATTRIB;
 127        return dn_mask;
 128}
 129
 130int notify_change(struct dentry * dentry, struct iattr * attr)
 131{
 132        struct inode *inode = dentry->d_inode;
 133        mode_t mode = inode->i_mode;
 134        int error;
 135        struct timespec now = CURRENT_TIME;
 136        unsigned int ia_valid = attr->ia_valid;
 137
 138        if (!inode)
 139                BUG();
 140
 141        attr->ia_ctime = now;
 142        if (!(ia_valid & ATTR_ATIME_SET))
 143                attr->ia_atime = now;
 144        if (!(ia_valid & ATTR_MTIME_SET))
 145                attr->ia_mtime = now;
 146        if (ia_valid & ATTR_KILL_SUID) {
 147                attr->ia_valid &= ~ATTR_KILL_SUID;
 148                if (mode & S_ISUID) {
 149                        if (!(ia_valid & ATTR_MODE)) {
 150                                ia_valid = attr->ia_valid |= ATTR_MODE;
 151                                attr->ia_mode = inode->i_mode;
 152                        }
 153                        attr->ia_mode &= ~S_ISUID;
 154                }
 155        }
 156        if (ia_valid & ATTR_KILL_SGID) {
 157                attr->ia_valid &= ~ ATTR_KILL_SGID;
 158                if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
 159                        if (!(ia_valid & ATTR_MODE)) {
 160                                ia_valid = attr->ia_valid |= ATTR_MODE;
 161                                attr->ia_mode = inode->i_mode;
 162                        }
 163                        attr->ia_mode &= ~S_ISGID;
 164                }
 165        }
 166        if (!attr->ia_valid)
 167                return 0;
 168
 169        if (inode->i_op && inode->i_op->setattr) {
 170                error = security_inode_setattr(dentry, attr);
 171                if (!error)
 172                        error = inode->i_op->setattr(dentry, attr);
 173        } else {
 174                error = inode_change_ok(inode, attr);
 175                if (!error)
 176                        error = security_inode_setattr(dentry, attr);
 177                if (!error) {
 178                        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
 179                            (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid))
 180                                error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
 181                        if (!error)
 182                                error = inode_setattr(inode, attr);
 183                }
 184        }
 185        if (!error) {
 186                unsigned long dn_mask = setattr_mask(ia_valid);
 187                if (dn_mask)
 188                        dnotify_parent(dentry, dn_mask);
 189        }
 190        return error;
 191}
 192
 193EXPORT_SYMBOL(notify_change);
 194