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 #include <linux/proc_fs.h>
  18 #include <linux/devpts_fs.h>
  19 #include <linux/vserver/debug.h>
  20
  21 /* Taken over from the old code... */
  22
  23 /* POSIX UID/GID verification for setting inode attributes. */
  24 int inode_change_ok(struct inode *inode, struct iattr *attr)
  25 {
  26         int retval = -EPERM;
  27         unsigned int ia_valid = attr->ia_valid;
  28
  29         /* If force is set do it anyway. */
  30         if (ia_valid & ATTR_FORCE)
  31                 goto fine;
  32
  33         /* Make sure a caller can chown. */
  34         if ((ia_valid & ATTR_UID) &&
  35             (current->fsuid != inode->i_uid ||
  36              attr->ia_uid != inode->i_uid) && !capable(CAP_CHOWN))
  37                 goto error;
  38
  39         /* Make sure caller can chgrp. */
  40         if ((ia_valid & ATTR_GID) &&
  41             (current->fsuid != inode->i_uid ||
  42             (!in_group_p(attr->ia_gid) && attr->ia_gid != inode->i_gid)) &&
  43             !capable(CAP_CHOWN))
  44                 goto error;
  45
  46         /* Make sure a caller can chmod. */
  47         if (ia_valid & ATTR_MODE) {
  48                 if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
  49                         goto error;
  50                 /* Also check the setgid bit! */
  51                 if (!in_group_p((ia_valid & ATTR_GID) ? attr->ia_gid :
  52                                 inode->i_gid) && !capable(CAP_FSETID))
  53                         attr->ia_mode &= ~S_ISGID;
  54         }
  55
  56         /* Check for setting the inode time. */
  57         if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) {
  58                 if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
  59                         goto error;
  60         }
  61
  62         /* Check for evil vserver activity */
  63         if (vx_check(0, VX_ADMIN))
  64                 goto fine;
  65
  66         if (IS_BARRIER(inode)) {
  67                 vxwprintk(1, "xid=%d messing with the barrier.",
  68                         vx_current_xid());
  69                 goto error;
  70         }
  71         switch (inode->i_sb->s_magic) {
  72                 case PROC_SUPER_MAGIC:
  73                         vxwprintk(1, "xid=%d messing with the procfs.",
  74                                 vx_current_xid());
  75                         goto error;
  76                 case DEVPTS_SUPER_MAGIC:
  77                         if (vx_check(inode->i_xid, VX_IDENT))
  78                                 goto fine;
  79                         vxwprintk(1, "xid=%d messing with the devpts.",
  80                                 vx_current_xid());
  81                         goto error;
  82         }
  83 fine:
  84         retval = 0;
  85 error:
  86         return retval;
  87 }
  88
  89 EXPORT_SYMBOL(inode_change_ok);
  90
  91 int inode_setattr_flags(struct inode *inode, unsigned int flags)
  92 {
  93         unsigned int oldflags, newflags;
  94
  95         oldflags = inode->i_flags;
  96         newflags = oldflags & ~(S_IMMUTABLE | S_IUNLINK | S_BARRIER);
  97         if (flags & ATTR_FLAG_IMMUTABLE)
  98                 newflags |= S_IMMUTABLE;
  99         if (flags & ATTR_FLAG_IUNLINK)
 100                 newflags |= S_IUNLINK;
 101         if (flags & ATTR_FLAG_BARRIER)
 102                 newflags |= S_BARRIER;
 103
 104         if (oldflags ^ newflags)
 105                 inode->i_flags = newflags;
 106         return 0;
 107 }
 108
 109 int inode_setattr(struct inode * inode, struct iattr * attr)
 110 {
 111         unsigned int ia_valid = attr->ia_valid;
 112         int error = 0;
 113
 114         if (ia_valid & ATTR_SIZE) {
 115                 if (attr->ia_size != i_size_read(inode)) {
 116                         error = vmtruncate(inode, attr->ia_size);
 117                         if (error || (ia_valid == ATTR_SIZE))
 118                                 goto out;
 119                 } else {
 120                         /*
 121                          * We skipped the truncate but must still update
 122                          * timestamps
 123                          */
 124                         ia_valid |= ATTR_MTIME|ATTR_CTIME;
 125                 }
 126         }
 127
 128         if (ia_valid & ATTR_UID)
 129                 inode->i_uid = attr->ia_uid;
 130         if (ia_valid & ATTR_GID)
 131                 inode->i_gid = attr->ia_gid;
 132         if (ia_valid & ATTR_XID)
 133                 inode->i_xid = attr->ia_xid;
 134         if (ia_valid & ATTR_ATIME)
 135                 inode->i_atime = attr->ia_atime;
 136         if (ia_valid & ATTR_MTIME)
 137                 inode->i_mtime = attr->ia_mtime;
 138         if (ia_valid & ATTR_CTIME)
 139                 inode->i_ctime = attr->ia_ctime;
 140         if (ia_valid & ATTR_MODE) {
 141                 umode_t mode = attr->ia_mode;
 142
 143                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 144                         mode &= ~S_ISGID;
 145                 inode->i_mode = mode;
 146         }
 147         if (ia_valid & ATTR_ATTR_FLAG)
 148                 inode_setattr_flags(inode, attr->ia_attr_flags);
 149         mark_inode_dirty(inode);
 150 out:
 151         return error;
 152 }
 153
 154 EXPORT_SYMBOL(inode_setattr);
 155
 156 int setattr_mask(unsigned int ia_valid)
 157 {
 158         unsigned long dn_mask = 0;
 159
 160         if (ia_valid & ATTR_UID)
 161                 dn_mask |= DN_ATTRIB;
 162         if (ia_valid & ATTR_GID)
 163                 dn_mask |= DN_ATTRIB;
 164         if (ia_valid & ATTR_XID)
 165                 dn_mask |= DN_ATTRIB;
 166         if (ia_valid & ATTR_SIZE)
 167                 dn_mask |= DN_MODIFY;
 168         /* both times implies a utime(s) call */
 169         if ((ia_valid & (ATTR_ATIME|ATTR_MTIME)) == (ATTR_ATIME|ATTR_MTIME))
 170                 dn_mask |= DN_ATTRIB;
 171         else if (ia_valid & ATTR_ATIME)
 172                 dn_mask |= DN_ACCESS;
 173         else if (ia_valid & ATTR_MTIME)
 174                 dn_mask |= DN_MODIFY;
 175         if (ia_valid & ATTR_MODE)
 176                 dn_mask |= DN_ATTRIB;
 177         return dn_mask;
 178 }
 179
 180 int notify_change(struct dentry * dentry, struct iattr * attr)
 181 {
 182         struct inode *inode = dentry->d_inode;
 183         mode_t mode = inode->i_mode;
 184         int error;
 185         struct timespec now = CURRENT_TIME;
 186         unsigned int ia_valid = attr->ia_valid;
 187
 188         if (!inode)
 189                 BUG();
 190
 191         attr->ia_ctime = now;
 192         if (!(ia_valid & ATTR_ATIME_SET))
 193                 attr->ia_atime = now;
 194         if (!(ia_valid & ATTR_MTIME_SET))
 195                 attr->ia_mtime = now;
 196         if (ia_valid & ATTR_KILL_SUID) {
 197                 attr->ia_valid &= ~ATTR_KILL_SUID;
 198                 if (mode & S_ISUID) {
 199                         if (!(ia_valid & ATTR_MODE)) {
 200                                 ia_valid = attr->ia_valid |= ATTR_MODE;
 201                                 attr->ia_mode = inode->i_mode;
 202                         }
 203                         attr->ia_mode &= ~S_ISUID;
 204                 }
 205         }
 206         if (ia_valid & ATTR_KILL_SGID) {
 207                 attr->ia_valid &= ~ ATTR_KILL_SGID;
 208                 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
 209                         if (!(ia_valid & ATTR_MODE)) {
 210                                 ia_valid = attr->ia_valid |= ATTR_MODE;
 211                                 attr->ia_mode = inode->i_mode;
 212                         }
 213                         attr->ia_mode &= ~S_ISGID;
 214                 }
 215         }
 216         if (!attr->ia_valid)
 217                 return 0;
 218
 219         if (inode->i_op && inode->i_op->setattr) {
 220                 error = security_inode_setattr(dentry, attr);
 221                 if (!error)
 222                         error = inode->i_op->setattr(dentry, attr);
 223         } else {
 224                 error = inode_change_ok(inode, attr);
 225                 if (!error)
 226                         error = security_inode_setattr(dentry, attr);
 227                 if (!error) {
 228                         if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
 229                             (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid) ||
 230                             (ia_valid & ATTR_XID && attr->ia_xid != inode->i_xid))
 231                                 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
 232                         if (!error)
 233                                 error = inode_setattr(inode, attr);
 234                 }
 235         }
 236         if (!error) {
 237                 unsigned long dn_mask = setattr_mask(ia_valid);
 238                 if (dn_mask)
 239                         dnotify_parent(dentry, dn_mask);
 240         }
 241         return error;
 242 }
 243
 244 EXPORT_SYMBOL(notify_change);