Merge branches 'x86/numa-fixes', 'x86/apic', 'x86/apm', 'x86/bitops', 'x86/build...

[linux-2.6] / fs / fat / file.c

diff --git a/fs/fat/file.c b/fs/fat/file.c
index b61a98f5398a5eaf84bef66a69454f635574192f..771326b8047e0ff5e3483f885c1edc30a604471a 100644 (file)
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -208,7 +208,7 @@ static int fat_free(struct inode *inode, int skip)
                } else if (ret == FAT_ENT_FREE) {
                        fat_fs_panic(sb,
                                     "%s: invalid cluster chain (i_pos %lld)",
-                                    __FUNCTION__, MSDOS_I(inode)->i_pos);
+                                    __func__, MSDOS_I(inode)->i_pos);
                        ret = -EIO;
                } else if (ret > 0) {
                        err = fat_ent_write(inode, &fatent, FAT_ENT_EOF, wait);
@@ -257,25 +257,49 @@ int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 }
 EXPORT_SYMBOL_GPL(fat_getattr);
 
-static int fat_check_mode(const struct msdos_sb_info *sbi, mode_t mode)
+static int fat_sanitize_mode(const struct msdos_sb_info *sbi,
+                            struct inode *inode, umode_t *mode_ptr)
 {
-       mode_t mask, req = mode & ~S_IFMT;
+       mode_t mask, perm;
 
-       if (S_ISREG(mode))
+       /*
+        * Note, the basic check is already done by a caller of
+        * (attr->ia_mode & ~MSDOS_VALID_MODE)
+        */
+
+       if (S_ISREG(inode->i_mode))
                mask = sbi->options.fs_fmask;
        else
                mask = sbi->options.fs_dmask;
 
+       perm = *mode_ptr & ~(S_IFMT | mask);
+
        /*
         * Of the r and x bits, all (subject to umask) must be present. Of the
         * w bits, either all (subject to umask) or none must be present.
         */
-       req &= ~mask;
-       if ((req & (S_IRUGO | S_IXUGO)) != ((S_IRUGO | S_IXUGO) & ~mask))
+       if ((perm & (S_IRUGO | S_IXUGO)) != (inode->i_mode & (S_IRUGO|S_IXUGO)))
                return -EPERM;
-       if ((req & S_IWUGO) && ((req & S_IWUGO) != (S_IWUGO & ~mask)))
+       if ((perm & S_IWUGO) && ((perm & S_IWUGO) != (S_IWUGO & ~mask)))
                return -EPERM;
 
+       *mode_ptr &= S_IFMT | perm;
+
+       return 0;
+}
+
+static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
+{
+       mode_t allow_utime = sbi->options.allow_utime;
+
+       if (current->fsuid != inode->i_uid) {
+               if (in_group_p(inode->i_gid))
+                       allow_utime >>= 3;
+               if (allow_utime & MAY_WRITE)
+                       return 1;
+       }
+
+       /* use a default check */
        return 0;
 }
 
@@ -283,7 +307,8 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
 {
        struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
        struct inode *inode = dentry->d_inode;
-       int mask, error = 0;
+       int error = 0;
+       unsigned int ia_valid;
 
        lock_kernel();
 
@@ -301,16 +326,27 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                }
        }
 
+       /* Check for setting the inode time. */
+       ia_valid = attr->ia_valid;
+       if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) {
+               if (fat_allow_set_time(sbi, inode))
+                       attr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET);
+       }
+
        error = inode_change_ok(inode, attr);
+       attr->ia_valid = ia_valid;
        if (error) {
                if (sbi->options.quiet)
                        error = 0;
                goto out;
        }
+
        if (((attr->ia_valid & ATTR_UID) &&
             (attr->ia_uid != sbi->options.fs_uid)) ||
            ((attr->ia_valid & ATTR_GID) &&
-            (attr->ia_gid != sbi->options.fs_gid)))
+            (attr->ia_gid != sbi->options.fs_gid)) ||
+           ((attr->ia_valid & ATTR_MODE) &&
+            (attr->ia_mode & ~MSDOS_VALID_MODE)))
                error = -EPERM;
 
        if (error) {
@@ -319,21 +355,16 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                goto out;
        }
 
+       /*
+        * We don't return -EPERM here. Yes, strange, but this is too
+        * old behavior.
+        */
        if (attr->ia_valid & ATTR_MODE) {
-               error = fat_check_mode(sbi, attr->ia_mode);
-               if (error != 0 && !sbi->options.quiet)
-                       goto out;
+               if (fat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
+                       attr->ia_valid &= ~ATTR_MODE;
        }
 
        error = inode_setattr(inode, attr);
-       if (error)
-               goto out;
-
-       if (S_ISDIR(inode->i_mode))
-               mask = sbi->options.fs_dmask;
-       else
-               mask = sbi->options.fs_fmask;
-       inode->i_mode &= S_IFMT | (S_IRWXUGO & ~mask);
 out:
        unlock_kernel();
        return error;