20 files changed, 262 insertions, 227 deletions

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 1458706bd2ec..e2b6be03e69b 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -479,10 +479,10 @@ static const match_table_t tokens = {
         {Opt_err, NULL}
 };
 
-static int parse_options(char *options, struct super_block *sb)
+static int parse_options(char *options, struct super_block *sb,
+                         struct ext2_mount_options *opts)
 {
         char *p;
-        struct ext2_sb_info *sbi = EXT2_SB(sb);
         substring_t args[MAX_OPT_ARGS];
         int option;
         kuid_t uid;
@@ -499,16 +499,16 @@ static int parse_options(char *options, struct super_block *sb)
                 token = match_token(p, tokens, args);
                 switch (token) {
                 case Opt_bsd_df:
-                        clear_opt (sbi->s_mount_opt, MINIX_DF);
+                        clear_opt (opts->s_mount_opt, MINIX_DF);
                         break;
                 case Opt_minix_df:
-                        set_opt (sbi->s_mount_opt, MINIX_DF);
+                        set_opt (opts->s_mount_opt, MINIX_DF);
                         break;
                 case Opt_grpid:
-                        set_opt (sbi->s_mount_opt, GRPID);
+                        set_opt (opts->s_mount_opt, GRPID);
                         break;
                 case Opt_nogrpid:
-                        clear_opt (sbi->s_mount_opt, GRPID);
+                        clear_opt (opts->s_mount_opt, GRPID);
                         break;
                 case Opt_resuid:
                         if (match_int(&args[0], &option))
@@ -519,7 +519,7 @@ static int parse_options(char *options, struct super_block *sb)
                                 return 0;
 
                         }
-                        sbi->s_resuid = uid;
+                        opts->s_resuid = uid;
                         break;
                 case Opt_resgid:
                         if (match_int(&args[0], &option))
@@ -529,51 +529,51 @@ static int parse_options(char *options, struct super_block *sb)
                                 ext2_msg(sb, KERN_ERR, "Invalid gid value %d", option);
                                 return 0;
                         }
-                        sbi->s_resgid = gid;
+                        opts->s_resgid = gid;
                         break;
                 case Opt_sb:
                         /* handled by get_sb_block() instead of here */
                         /* *sb_block = match_int(&args[0]); */
                         break;
                 case Opt_err_panic:
-                        clear_opt (sbi->s_mount_opt, ERRORS_CONT);
-                        clear_opt (sbi->s_mount_opt, ERRORS_RO);
-                        set_opt (sbi->s_mount_opt, ERRORS_PANIC);
+                        clear_opt (opts->s_mount_opt, ERRORS_CONT);
+                        clear_opt (opts->s_mount_opt, ERRORS_RO);
+                        set_opt (opts->s_mount_opt, ERRORS_PANIC);
                         break;
                 case Opt_err_ro:
-                        clear_opt (sbi->s_mount_opt, ERRORS_CONT);
-                        clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
-                        set_opt (sbi->s_mount_opt, ERRORS_RO);
+                        clear_opt (opts->s_mount_opt, ERRORS_CONT);
+                        clear_opt (opts->s_mount_opt, ERRORS_PANIC);
+                        set_opt (opts->s_mount_opt, ERRORS_RO);
                         break;
                 case Opt_err_cont:
-                        clear_opt (sbi->s_mount_opt, ERRORS_RO);
-                        clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
-                        set_opt (sbi->s_mount_opt, ERRORS_CONT);
+                        clear_opt (opts->s_mount_opt, ERRORS_RO);
+                        clear_opt (opts->s_mount_opt, ERRORS_PANIC);
+                        set_opt (opts->s_mount_opt, ERRORS_CONT);
                         break;
                 case Opt_nouid32:
-                        set_opt (sbi->s_mount_opt, NO_UID32);
+                        set_opt (opts->s_mount_opt, NO_UID32);
                         break;
                 case Opt_nocheck:
-                        clear_opt (sbi->s_mount_opt, CHECK);
+                        clear_opt (opts->s_mount_opt, CHECK);
                         break;
                 case Opt_debug:
-                        set_opt (sbi->s_mount_opt, DEBUG);
+                        set_opt (opts->s_mount_opt, DEBUG);
                         break;
                 case Opt_oldalloc:
-                        set_opt (sbi->s_mount_opt, OLDALLOC);
+                        set_opt (opts->s_mount_opt, OLDALLOC);
                         break;
                 case Opt_orlov:
-                        clear_opt (sbi->s_mount_opt, OLDALLOC);
+                        clear_opt (opts->s_mount_opt, OLDALLOC);
                         break;
                 case Opt_nobh:
-                        set_opt (sbi->s_mount_opt, NOBH);
+                        set_opt (opts->s_mount_opt, NOBH);
                         break;
 #ifdef CONFIG_EXT2_FS_XATTR
                 case Opt_user_xattr:
-                        set_opt (sbi->s_mount_opt, XATTR_USER);
+                        set_opt (opts->s_mount_opt, XATTR_USER);
                         break;
                 case Opt_nouser_xattr:
-                        clear_opt (sbi->s_mount_opt, XATTR_USER);
+                        clear_opt (opts->s_mount_opt, XATTR_USER);
                         break;
 #else
                 case Opt_user_xattr:
@@ -584,10 +584,10 @@ static int parse_options(char *options, struct super_block *sb)
 #endif
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
                 case Opt_acl:
-                        set_opt(sbi->s_mount_opt, POSIX_ACL);
+                        set_opt(opts->s_mount_opt, POSIX_ACL);
                         break;
                 case Opt_noacl:
-                        clear_opt(sbi->s_mount_opt, POSIX_ACL);
+                        clear_opt(opts->s_mount_opt, POSIX_ACL);
                         break;
 #else
                 case Opt_acl:
@@ -598,13 +598,13 @@ static int parse_options(char *options, struct super_block *sb)
 #endif
                 case Opt_xip:
                         ext2_msg(sb, KERN_INFO, "use dax instead of xip");
-                        set_opt(sbi->s_mount_opt, XIP);
+                        set_opt(opts->s_mount_opt, XIP);
                         /* Fall through */
                 case Opt_dax:
 #ifdef CONFIG_FS_DAX
                         ext2_msg(sb, KERN_WARNING,
                 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
-                        set_opt(sbi->s_mount_opt, DAX);
+                        set_opt(opts->s_mount_opt, DAX);
 #else
                         ext2_msg(sb, KERN_INFO, "dax option not supported");
 #endif
@@ -613,11 +613,11 @@ static int parse_options(char *options, struct super_block *sb)
 #if defined(CONFIG_QUOTA)
                 case Opt_quota:
                 case Opt_usrquota:
-                        set_opt(sbi->s_mount_opt, USRQUOTA);
+                        set_opt(opts->s_mount_opt, USRQUOTA);
                         break;
 
                 case Opt_grpquota:
-                        set_opt(sbi->s_mount_opt, GRPQUOTA);
+                        set_opt(opts->s_mount_opt, GRPQUOTA);
                         break;
 #else
                 case Opt_quota:
@@ -629,11 +629,11 @@ static int parse_options(char *options, struct super_block *sb)
 #endif
 
                 case Opt_reservation:
-                        set_opt(sbi->s_mount_opt, RESERVATION);
+                        set_opt(opts->s_mount_opt, RESERVATION);
                         ext2_msg(sb, KERN_INFO, "reservations ON");
                         break;
                 case Opt_noreservation:
-                        clear_opt(sbi->s_mount_opt, RESERVATION);
+                        clear_opt(opts->s_mount_opt, RESERVATION);
                         ext2_msg(sb, KERN_INFO, "reservations OFF");
                         break;
                 case Opt_ignore:
@@ -830,6 +830,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
         int i, j;
         __le32 features;
         int err;
+        struct ext2_mount_options opts;
 
         err = -ENOMEM;
         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
@@ -890,35 +891,39 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
         /* Set defaults before we parse the mount options */
         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
         if (def_mount_opts & EXT2_DEFM_DEBUG)
-                set_opt(sbi->s_mount_opt, DEBUG);
+                set_opt(opts.s_mount_opt, DEBUG);
         if (def_mount_opts & EXT2_DEFM_BSDGROUPS)
-                set_opt(sbi->s_mount_opt, GRPID);
+                set_opt(opts.s_mount_opt, GRPID);
         if (def_mount_opts & EXT2_DEFM_UID16)
-                set_opt(sbi->s_mount_opt, NO_UID32);
+                set_opt(opts.s_mount_opt, NO_UID32);
 #ifdef CONFIG_EXT2_FS_XATTR
         if (def_mount_opts & EXT2_DEFM_XATTR_USER)
-                set_opt(sbi->s_mount_opt, XATTR_USER);
+                set_opt(opts.s_mount_opt, XATTR_USER);
 #endif
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
         if (def_mount_opts & EXT2_DEFM_ACL)
-                set_opt(sbi->s_mount_opt, POSIX_ACL);
+                set_opt(opts.s_mount_opt, POSIX_ACL);
 #endif
         
         if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
-                set_opt(sbi->s_mount_opt, ERRORS_PANIC);
+                set_opt(opts.s_mount_opt, ERRORS_PANIC);
         else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)
-                set_opt(sbi->s_mount_opt, ERRORS_CONT);
+                set_opt(opts.s_mount_opt, ERRORS_CONT);
         else
-                set_opt(sbi->s_mount_opt, ERRORS_RO);
+                set_opt(opts.s_mount_opt, ERRORS_RO);
 
-        sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
-        sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
+        opts.s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
+        opts.s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
         
-        set_opt(sbi->s_mount_opt, RESERVATION);
+        set_opt(opts.s_mount_opt, RESERVATION);
 
-        if (!parse_options((char *) data, sb))
+        if (!parse_options((char *) data, sb, &opts))
                 goto failed_mount;
 
+        sbi->s_mount_opt = opts.s_mount_opt;
+        sbi->s_resuid = opts.s_resuid;
+        sbi->s_resgid = opts.s_resgid;
+
         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
                 ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
                  MS_POSIXACL : 0);
@@ -1312,46 +1317,36 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
 {
         struct ext2_sb_info * sbi = EXT2_SB(sb);
         struct ext2_super_block * es;
-        struct ext2_mount_options old_opts;
-        unsigned long old_sb_flags;
+        struct ext2_mount_options new_opts;
         int err;
 
         sync_filesystem(sb);
-        spin_lock(&sbi->s_lock);
 
-        /* Store the old options */
-        old_sb_flags = sb->s_flags;
-        old_opts.s_mount_opt = sbi->s_mount_opt;
-        old_opts.s_resuid = sbi->s_resuid;
-        old_opts.s_resgid = sbi->s_resgid;
+        spin_lock(&sbi->s_lock);
+        new_opts.s_mount_opt = sbi->s_mount_opt;
+        new_opts.s_resuid = sbi->s_resuid;
+        new_opts.s_resgid = sbi->s_resgid;
+        spin_unlock(&sbi->s_lock);
 
         /*
          * Allow the "check" option to be passed as a remount option.
          */
-        if (!parse_options(data, sb)) {
-                err = -EINVAL;
-                goto restore_opts;
-        }
-
-        sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
-                ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
+        if (!parse_options(data, sb, &new_opts))
+                return -EINVAL;
 
+        spin_lock(&sbi->s_lock);
         es = sbi->s_es;
-        if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT2_MOUNT_DAX) {
+        if ((sbi->s_mount_opt ^ new_opts.s_mount_opt) & EXT2_MOUNT_DAX) {
                 ext2_msg(sb, KERN_WARNING, "warning: refusing change of "
                          "dax flag with busy inodes while remounting");
-                sbi->s_mount_opt ^= EXT2_MOUNT_DAX;
-        }
-        if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) {
-                spin_unlock(&sbi->s_lock);
-                return 0;
+                new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
         }
+        if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
+                goto out_set;
         if (*flags & MS_RDONLY) {
                 if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
-                    !(sbi->s_mount_state & EXT2_VALID_FS)) {
-                        spin_unlock(&sbi->s_lock);
-                        return 0;
-                }
+                    !(sbi->s_mount_state & EXT2_VALID_FS))
+                        goto out_set;
 
                 /*
                  * OK, we are remounting a valid rw partition rdonly, so set
@@ -1362,22 +1357,20 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
                 spin_unlock(&sbi->s_lock);
 
                 err = dquot_suspend(sb, -1);
-                if (err < 0) {
-                        spin_lock(&sbi->s_lock);
-                        goto restore_opts;
-                }
+                if (err < 0)
+                        return err;
 
                 ext2_sync_super(sb, es, 1);
         } else {
                 __le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
                                                ~EXT2_FEATURE_RO_COMPAT_SUPP);
                 if (ret) {
+                        spin_unlock(&sbi->s_lock);
                         ext2_msg(sb, KERN_WARNING,
                                 "warning: couldn't remount RDWR because of "
                                 "unsupported optional features (%x).",
                                 le32_to_cpu(ret));
-                        err = -EROFS;
-                        goto restore_opts;
+                        return -EROFS;
                 }
                 /*
                  * Mounting a RDONLY partition read-write, so reread and
@@ -1394,14 +1387,16 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
                 dquot_resume(sb, -1);
         }
 
-        return 0;
-restore_opts:
-        sbi->s_mount_opt = old_opts.s_mount_opt;
-        sbi->s_resuid = old_opts.s_resuid;
-        sbi->s_resgid = old_opts.s_resgid;
-        sb->s_flags = old_sb_flags;
+        spin_lock(&sbi->s_lock);
+out_set:
+        sbi->s_mount_opt = new_opts.s_mount_opt;
+        sbi->s_resuid = new_opts.s_resuid;
+        sbi->s_resgid = new_opts.s_resgid;
+        sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
+                ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
         spin_unlock(&sbi->s_lock);
-        return err;
+
+        return 0;
 }
 
 static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index 57d4c3e2e94a..055ec6c586f7 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -73,41 +73,41 @@ static inline struct iso_inode_info *ISOFS_I(struct inode *inode)
         return container_of(inode, struct iso_inode_info, vfs_inode);
 }
 
-static inline int isonum_711(char *p)
+static inline int isonum_711(u8 *p)
 {
-        return *(u8 *)p;
+        return *p;
 }
-static inline int isonum_712(char *p)
+static inline int isonum_712(s8 *p)
 {
-        return *(s8 *)p;
+        return *p;
 }
-static inline unsigned int isonum_721(char *p)
+static inline unsigned int isonum_721(u8 *p)
 {
         return get_unaligned_le16(p);
 }
-static inline unsigned int isonum_722(char *p)
+static inline unsigned int isonum_722(u8 *p)
 {
         return get_unaligned_be16(p);
 }
-static inline unsigned int isonum_723(char *p)
+static inline unsigned int isonum_723(u8 *p)
 {
         /* Ignore bigendian datum due to broken mastering programs */
         return get_unaligned_le16(p);
 }
-static inline unsigned int isonum_731(char *p)
+static inline unsigned int isonum_731(u8 *p)
 {
         return get_unaligned_le32(p);
 }
-static inline unsigned int isonum_732(char *p)
+static inline unsigned int isonum_732(u8 *p)
 {
         return get_unaligned_be32(p);
 }
-static inline unsigned int isonum_733(char *p)
+static inline unsigned int isonum_733(u8 *p)
 {
         /* Ignore bigendian datum due to broken mastering programs */
         return get_unaligned_le32(p);
 }
-extern int iso_date(char *, int);
+extern int iso_date(u8 *, int);
 
 struct inode;           /* To make gcc happy */
 
diff --git a/fs/isofs/rock.h b/fs/isofs/rock.h
index ef03625431bb..1558cf22ef8a 100644
--- a/fs/isofs/rock.h
+++ b/fs/isofs/rock.h
@@ -7,78 +7,78 @@
  */
 
 struct SU_SP_s {
-        unsigned char magic[2];
-        unsigned char skip;
+        __u8 magic[2];
+        __u8 skip;
 } __attribute__ ((packed));
 
 struct SU_CE_s {
-        char extent[8];
-        char offset[8];
-        char size[8];
+        __u8 extent[8];
+        __u8 offset[8];
+        __u8 size[8];
 };
 
 struct SU_ER_s {
-        unsigned char len_id;
-        unsigned char len_des;
-        unsigned char len_src;
-        unsigned char ext_ver;
-        char data[0];
+        __u8 len_id;
+        __u8 len_des;
+        __u8 len_src;
+        __u8 ext_ver;
+        __u8 data[0];
 } __attribute__ ((packed));
 
 struct RR_RR_s {
-        char flags[1];
+        __u8 flags[1];
 } __attribute__ ((packed));
 
 struct RR_PX_s {
-        char mode[8];
-        char n_links[8];
-        char uid[8];
-        char gid[8];
+        __u8 mode[8];
+        __u8 n_links[8];
+        __u8 uid[8];
+        __u8 gid[8];
 };
 
 struct RR_PN_s {
-        char dev_high[8];
-        char dev_low[8];
+        __u8 dev_high[8];
+        __u8 dev_low[8];
 };
 
 struct SL_component {
-        unsigned char flags;
-        unsigned char len;
-        char text[0];
+        __u8 flags;
+        __u8 len;
+        __u8 text[0];
 } __attribute__ ((packed));
 
 struct RR_SL_s {
-        unsigned char flags;
+        __u8 flags;
         struct SL_component link;
 } __attribute__ ((packed));
 
 struct RR_NM_s {
-        unsigned char flags;
+        __u8 flags;
         char name[0];
 } __attribute__ ((packed));
 
 struct RR_CL_s {
-        char location[8];
+        __u8 location[8];
 };
 
 struct RR_PL_s {
-        char location[8];
+        __u8 location[8];
 };
 
 struct stamp {
-        char time[7];
+        __u8 time[7];           /* actually 6 unsigned, 1 signed */
 } __attribute__ ((packed));
 
 struct RR_TF_s {
-        char flags;
+        __u8 flags;
         struct stamp times[0];  /* Variable number of these beasts */
 } __attribute__ ((packed));
 
 /* Linux-specific extension for transparent decompression */
 struct RR_ZF_s {
-        char algorithm[2];
-        char parms[2];
-        char real_size[8];
+        __u8 algorithm[2];
+        __u8 parms[2];
+        __u8 real_size[8];
 };
 
 /*
@@ -94,9 +94,9 @@ struct RR_ZF_s {
 #define TF_LONG_FORM 128
 
 struct rock_ridge {
-        char signature[2];
-        unsigned char len;
-        unsigned char version;
+        __u8 signature[2];
+        __u8 len;
+        __u8 version;
         union {
                 struct SU_SP_s SP;
                 struct SU_CE_s CE;
diff --git a/fs/isofs/util.c b/fs/isofs/util.c
index 42544bf0e222..e88dba721661 100644
--- a/fs/isofs/util.c
+++ b/fs/isofs/util.c
@@ -16,7 +16,7 @@
  * to GMT.  Thus  we should always be correct.
  */
 
-int iso_date(char * p, int flag)
+int iso_date(u8 *p, int flag)
 {
         int year, month, day, hour, minute, second, tz;
         int crtime;
diff --git a/fs/notify/fanotify/fanotify.c b/fs/notify/fanotify/fanotify.c
index 54cf2d21b547..6702a6a0bbb5 100644
--- a/fs/notify/fanotify/fanotify.c
+++ b/fs/notify/fanotify/fanotify.c
@@ -10,6 +10,7 @@
 #include <linux/sched/user.h>
 #include <linux/types.h>
 #include <linux/wait.h>
+#include <linux/audit.h>
 
 #include "fanotify.h"
 
@@ -65,7 +66,7 @@ static int fanotify_get_response(struct fsnotify_group *group,
         wait_event(group->fanotify_data.access_waitq, event->response);
 
         /* userspace responded, convert to something usable */
-        switch (event->response) {
+        switch (event->response & ~FAN_AUDIT) {
         case FAN_ALLOW:
                 ret = 0;
                 break;
@@ -73,6 +74,11 @@ static int fanotify_get_response(struct fsnotify_group *group,
         default:
                 ret = -EPERM;
         }
+
+        /* Check if the response should be audited */
+        if (event->response & FAN_AUDIT)
+                audit_fanotify(event->response & ~FAN_AUDIT);
+
         event->response = 0;
 
         pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 55499f5a1c96..d0d4bc4c4b70 100644
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -179,7 +179,7 @@ static int process_access_response(struct fsnotify_group *group,
          * userspace can send a valid response or we will clean it up after the
          * timeout
          */
-        switch (response) {
+        switch (response & ~FAN_AUDIT) {
         case FAN_ALLOW:
         case FAN_DENY:
                 break;
@@ -190,6 +190,9 @@ static int process_access_response(struct fsnotify_group *group,
         if (fd < 0)
                 return -EINVAL;
 
+        if ((response & FAN_AUDIT) && !group->fanotify_data.audit)
+                return -EINVAL;
+
         event = dequeue_event(group, fd);
         if (!event)
                 return -ENOENT;
@@ -713,7 +716,11 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
+#ifdef CONFIG_AUDITSYSCALL
+        if (flags & ~(FAN_ALL_INIT_FLAGS | FAN_ENABLE_AUDIT))
+#else
         if (flags & ~FAN_ALL_INIT_FLAGS)
+#endif
                 return -EINVAL;
 
         if (event_f_flags & ~FANOTIFY_INIT_ALL_EVENT_F_BITS)
@@ -795,6 +802,13 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)
                 group->fanotify_data.max_marks = FANOTIFY_DEFAULT_MAX_MARKS;
         }
 
+        if (flags & FAN_ENABLE_AUDIT) {
+                fd = -EPERM;
+                if (!capable(CAP_AUDIT_WRITE))
+                        goto out_destroy_group;
+                group->fanotify_data.audit = true;
+        }
+
         fd = anon_inode_getfd("[fanotify]", &fanotify_fops, group, f_flags);
         if (fd < 0)
                 goto out_destroy_group;
diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
index 517f88c1dbe5..d478629c728b 100644
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@ -157,6 +157,9 @@ void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
         if (group->fanotify_data.max_marks == UINT_MAX)
                 flags |= FAN_UNLIMITED_MARKS;
 
+        if (group->fanotify_data.audit)
+                flags |= FAN_ENABLE_AUDIT;
+
         seq_printf(m, "fanotify flags:%x event-flags:%x\n",
                    flags, group->fanotify_data.f_flags);
 
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index 9f78b5015f2e..39f1b0b0c76f 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -645,8 +645,15 @@ int dquot_writeback_dquots(struct super_block *sb, int type)
                         spin_unlock(&dq_list_lock);
                         dqstats_inc(DQST_LOOKUPS);
                         err = sb->dq_op->write_dquot(dquot);
-                        if (!ret && err)
-                                ret = err;
+                        if (err) {
+                                /*
+                                 * Clear dirty bit anyway to avoid infinite
+                                 * loop here.
+                                 */
+                                clear_dquot_dirty(dquot);
+                                if (!ret)
+                                        ret = err;
+                        }
                         dqput(dquot);
                         spin_lock(&dq_list_lock);
                 }
@@ -2139,7 +2146,7 @@ int dquot_file_open(struct inode *inode, struct file *file)
 
         error = generic_file_open(inode, file);
         if (!error && (file->f_mode & FMODE_WRITE))
-                dquot_initialize(inode);
+                error = dquot_initialize(inode);
         return error;
 }
 EXPORT_SYMBOL(dquot_file_open);
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index e0fd65fe73e8..1b961b1d9699 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -58,7 +58,7 @@ static int __load_block_bitmap(struct super_block *sb,
         int nr_groups = bitmap->s_nr_groups;
 
         if (block_group >= nr_groups) {
-                udf_debug("block_group (%d) > nr_groups (%d)\n",
+                udf_debug("block_group (%u) > nr_groups (%d)\n",
                           block_group, nr_groups);
         }
 
@@ -122,7 +122,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
         partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
         if (bloc->logicalBlockNum + count < count ||
             (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
-                udf_debug("%d < %d || %d + %d > %d\n",
+                udf_debug("%u < %d || %u + %u > %u\n",
                           bloc->logicalBlockNum, 0,
                           bloc->logicalBlockNum, count,
                           partmap->s_partition_len);
@@ -151,9 +151,9 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
                 bh = bitmap->s_block_bitmap[bitmap_nr];
                 for (i = 0; i < count; i++) {
                         if (udf_set_bit(bit + i, bh->b_data)) {
-                                udf_debug("bit %ld already set\n", bit + i);
+                                udf_debug("bit %lu already set\n", bit + i);
                                 udf_debug("byte=%2x\n",
-                                          ((char *)bh->b_data)[(bit + i) >> 3]);
+                                          ((__u8 *)bh->b_data)[(bit + i) >> 3]);
                         }
                 }
                 udf_add_free_space(sb, sbi->s_partition, count);
@@ -218,16 +218,18 @@ out:
         return alloc_count;
 }
 
-static int udf_bitmap_new_block(struct super_block *sb,
+static udf_pblk_t udf_bitmap_new_block(struct super_block *sb,
                                 struct udf_bitmap *bitmap, uint16_t partition,
                                 uint32_t goal, int *err)
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
-        int newbit, bit = 0, block, block_group, group_start;
+        int newbit, bit = 0;
+        udf_pblk_t block;
+        int block_group, group_start;
         int end_goal, nr_groups, bitmap_nr, i;
         struct buffer_head *bh = NULL;
         char *ptr;
-        int newblock = 0;
+        udf_pblk_t newblock = 0;
 
         *err = -ENOSPC;
         mutex_lock(&sbi->s_alloc_mutex);
@@ -362,7 +364,7 @@ static void udf_table_free_blocks(struct super_block *sb,
         partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
         if (bloc->logicalBlockNum + count < count ||
             (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
-                udf_debug("%d < %d || %d + %d > %d\n",
+                udf_debug("%u < %d || %u + %u > %u\n",
                           bloc->logicalBlockNum, 0,
                           bloc->logicalBlockNum, count,
                           partmap->s_partition_len);
@@ -515,7 +517,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
 
         while (first_block != eloc.logicalBlockNum &&
                (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
-                udf_debug("eloc=%d, elen=%d, first_block=%d\n",
+                udf_debug("eloc=%u, elen=%u, first_block=%u\n",
                           eloc.logicalBlockNum, elen, first_block);
                 ; /* empty loop body */
         }
@@ -545,13 +547,14 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
         return alloc_count;
 }
 
-static int udf_table_new_block(struct super_block *sb,
+static udf_pblk_t udf_table_new_block(struct super_block *sb,
                                struct inode *table, uint16_t partition,
                                uint32_t goal, int *err)
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
         uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
-        uint32_t newblock = 0, adsize;
+        udf_pblk_t newblock = 0;
+        uint32_t adsize;
         uint32_t elen, goal_elen = 0;
         struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
         struct extent_position epos, goal_epos;
@@ -700,12 +703,12 @@ inline int udf_prealloc_blocks(struct super_block *sb,
         return allocated;
 }
 
-inline int udf_new_block(struct super_block *sb,
+inline udf_pblk_t udf_new_block(struct super_block *sb,
                          struct inode *inode,
                          uint16_t partition, uint32_t goal, int *err)
 {
         struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
-        int block;
+        udf_pblk_t block;
 
         if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
                 block = udf_bitmap_new_block(sb,
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index 2d0e028067eb..c19dba45aa20 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -43,7 +43,7 @@ static int udf_readdir(struct file *file, struct dir_context *ctx)
         struct udf_fileident_bh fibh = { .sbh = NULL, .ebh = NULL};
         struct fileIdentDesc *fi = NULL;
         struct fileIdentDesc cfi;
-        int block, iblock;
+        udf_pblk_t block, iblock;
         loff_t nf_pos;
         int flen;
         unsigned char *fname = NULL, *copy_name = NULL;
diff --git a/fs/udf/directory.c b/fs/udf/directory.c
index 7aa48bd7cbaf..0a98a2369738 100644
--- a/fs/udf/directory.c
+++ b/fs/udf/directory.c
@@ -26,7 +26,8 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
                                          sector_t *offset)
 {
         struct fileIdentDesc *fi;
-        int i, num, block;
+        int i, num;
+        udf_pblk_t block;
         struct buffer_head *tmp, *bha[16];
         struct udf_inode_info *iinfo = UDF_I(dir);
 
@@ -51,7 +52,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
         }
 
         if (fibh->eoffset == dir->i_sb->s_blocksize) {
-                int lextoffset = epos->offset;
+                uint32_t lextoffset = epos->offset;
                 unsigned char blocksize_bits = dir->i_sb->s_blocksize_bits;
 
                 if (udf_next_aext(dir, epos, eloc, elen, 1) !=
@@ -110,7 +111,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
                 memcpy((uint8_t *)cfi, (uint8_t *)fi,
                        sizeof(struct fileIdentDesc));
         } else if (fibh->eoffset > dir->i_sb->s_blocksize) {
-                int lextoffset = epos->offset;
+                uint32_t lextoffset = epos->offset;
 
                 if (udf_next_aext(dir, epos, eloc, elen, 1) !=
                     (EXT_RECORDED_ALLOCATED >> 30))
@@ -175,7 +176,7 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
         if (fi->descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
                 udf_debug("0x%x != TAG_IDENT_FID\n",
                           le16_to_cpu(fi->descTag.tagIdent));
-                udf_debug("offset: %u sizeof: %lu bufsize: %u\n",
+                udf_debug("offset: %d sizeof: %lu bufsize: %d\n",
                           *offset, (unsigned long)sizeof(struct fileIdentDesc),
                           bufsize);
                 return NULL;
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index c1ed18a10ce4..b6e420c1bfeb 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -50,7 +50,7 @@ struct inode *udf_new_inode(struct inode *dir, umode_t mode)
         struct super_block *sb = dir->i_sb;
         struct udf_sb_info *sbi = UDF_SB(sb);
         struct inode *inode;
-        int block;
+        udf_pblk_t block;
         uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
         struct udf_inode_info *iinfo;
         struct udf_inode_info *dinfo = UDF_I(dir);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 8dacf4f57414..c23744d5ae5c 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -52,7 +52,7 @@ static int udf_alloc_i_data(struct inode *inode, size_t size);
 static sector_t inode_getblk(struct inode *, sector_t, int *, int *);
 static int8_t udf_insert_aext(struct inode *, struct extent_position,
                               struct kernel_lb_addr, uint32_t);
-static void udf_split_extents(struct inode *, int *, int, int,
+static void udf_split_extents(struct inode *, int *, int, udf_pblk_t,
                               struct kernel_long_ad *, int *);
 static void udf_prealloc_extents(struct inode *, int, int,
                                  struct kernel_long_ad *, int *);
@@ -316,10 +316,10 @@ int udf_expand_file_adinicb(struct inode *inode)
         return err;
 }
 
-struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
-                                           int *err)
+struct buffer_head *udf_expand_dir_adinicb(struct inode *inode,
+                                            udf_pblk_t *block, int *err)
 {
-        int newblock;
+        udf_pblk_t newblock;
         struct buffer_head *dbh = NULL;
         struct kernel_lb_addr eloc;
         uint8_t alloctype;
@@ -446,7 +446,7 @@ abort:
         return err;
 }
 
-static struct buffer_head *udf_getblk(struct inode *inode, long block,
+static struct buffer_head *udf_getblk(struct inode *inode, udf_pblk_t block,
                                       int create, int *err)
 {
         struct buffer_head *bh;
@@ -480,7 +480,7 @@ static int udf_do_extend_file(struct inode *inode,
         int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
         struct super_block *sb = inode->i_sb;
         struct kernel_lb_addr prealloc_loc = {};
-        int prealloc_len = 0;
+        uint32_t prealloc_len = 0;
         struct udf_inode_info *iinfo;
         int err;
 
@@ -663,11 +663,11 @@ static sector_t inode_getblk(struct inode *inode, sector_t block,
         struct kernel_lb_addr eloc, tmpeloc;
         int c = 1;
         loff_t lbcount = 0, b_off = 0;
-        uint32_t newblocknum, newblock;
+        udf_pblk_t newblocknum, newblock;
         sector_t offset = 0;
         int8_t etype;
         struct udf_inode_info *iinfo = UDF_I(inode);
-        int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
+        udf_pblk_t goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
         int lastblock = 0;
         bool isBeyondEOF;
 
@@ -879,8 +879,8 @@ out_free:
 }
 
 static void udf_split_extents(struct inode *inode, int *c, int offset,
-                              int newblocknum, struct kernel_long_ad *laarr,
-                              int *endnum)
+                               udf_pblk_t newblocknum,
+                               struct kernel_long_ad *laarr, int *endnum)
 {
         unsigned long blocksize = inode->i_sb->s_blocksize;
         unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
@@ -1166,7 +1166,7 @@ static void udf_update_extents(struct inode *inode, struct kernel_long_ad *laarr
         }
 }
 
-struct buffer_head *udf_bread(struct inode *inode, int block,
+struct buffer_head *udf_bread(struct inode *inode, udf_pblk_t block,
                               int create, int *err)
 {
         struct buffer_head *bh = NULL;
@@ -1193,7 +1193,7 @@ int udf_setsize(struct inode *inode, loff_t newsize)
 {
         int err;
         struct udf_inode_info *iinfo;
-        int bsize = i_blocksize(inode);
+        unsigned int bsize = i_blocksize(inode);
 
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
               S_ISLNK(inode->i_mode)))
@@ -1278,14 +1278,14 @@ static int udf_read_inode(struct inode *inode, bool hidden_inode)
 
 reread:
         if (iloc->partitionReferenceNum >= sbi->s_partitions) {
-                udf_debug("partition reference: %d > logical volume partitions: %d\n",
+                udf_debug("partition reference: %u > logical volume partitions: %u\n",
                           iloc->partitionReferenceNum, sbi->s_partitions);
                 return -EIO;
         }
 
         if (iloc->logicalBlockNum >=
             sbi->s_partmaps[iloc->partitionReferenceNum].s_partition_len) {
-                udf_debug("block=%d, partition=%d out of range\n",
+                udf_debug("block=%u, partition=%u out of range\n",
                           iloc->logicalBlockNum, iloc->partitionReferenceNum);
                 return -EIO;
         }
@@ -1304,13 +1304,13 @@ reread:
          */
         bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
         if (!bh) {
-                udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino);
+                udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
                 return -EIO;
         }
 
         if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
             ident != TAG_IDENT_USE) {
-                udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n",
+                udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
                         inode->i_ino, ident);
                 goto out;
         }
@@ -1346,7 +1346,7 @@ reread:
                 }
                 brelse(ibh);
         } else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
-                udf_err(inode->i_sb, "unsupported strategy type: %d\n",
+                udf_err(inode->i_sb, "unsupported strategy type: %u\n",
                         le16_to_cpu(fe->icbTag.strategyType));
                 goto out;
         }
@@ -1547,7 +1547,7 @@ reread:
                 udf_debug("METADATA BITMAP FILE-----\n");
                 break;
         default:
-                udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n",
+                udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
                         inode->i_ino, fe->icbTag.fileType);
                 goto out;
         }
@@ -1852,7 +1852,7 @@ struct inode *__udf_iget(struct super_block *sb, struct kernel_lb_addr *ino,
         return inode;
 }
 
-int udf_setup_indirect_aext(struct inode *inode, int block,
+int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
                             struct extent_position *epos)
 {
         struct super_block *sb = inode->i_sb;
@@ -1994,7 +1994,7 @@ int udf_add_aext(struct inode *inode, struct extent_position *epos,
 
         if (epos->offset + (2 * adsize) > sb->s_blocksize) {
                 int err;
-                int new_block;
+                udf_pblk_t new_block;
 
                 new_block = udf_new_block(sb, NULL,
                                           epos->block.partitionReferenceNum,
@@ -2076,7 +2076,7 @@ int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
 
         while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
                (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
-                int block;
+                udf_pblk_t block;
 
                 if (++indirections > UDF_MAX_INDIR_EXTS) {
                         udf_err(inode->i_sb,
@@ -2091,7 +2091,7 @@ int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
                 block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
                 epos->bh = udf_tread(inode->i_sb, block);
                 if (!epos->bh) {
-                        udf_debug("reading block %d failed!\n", block);
+                        udf_debug("reading block %u failed!\n", block);
                         return -1;
                 }
         }
@@ -2146,7 +2146,7 @@ int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
                 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
                 break;
         default:
-                udf_debug("alloc_type = %d unsupported\n", iinfo->i_alloc_type);
+                udf_debug("alloc_type = %u unsupported\n", iinfo->i_alloc_type);
                 return -1;
         }
 
@@ -2289,13 +2289,13 @@ int8_t inode_bmap(struct inode *inode, sector_t block,
         return etype;
 }
 
-long udf_block_map(struct inode *inode, sector_t block)
+udf_pblk_t udf_block_map(struct inode *inode, sector_t block)
 {
         struct kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
         struct extent_position epos = {};
-        int ret;
+        udf_pblk_t ret;
 
         down_read(&UDF_I(inode)->i_data_sem);
 
diff --git a/fs/udf/misc.c b/fs/udf/misc.c
index 3949c4bec3a3..401e64cde1be 100644
--- a/fs/udf/misc.c
+++ b/fs/udf/misc.c
@@ -28,7 +28,7 @@
 #include "udf_i.h"
 #include "udf_sb.h"
 
-struct buffer_head *udf_tgetblk(struct super_block *sb, int block)
+struct buffer_head *udf_tgetblk(struct super_block *sb, udf_pblk_t block)
 {
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
                 return sb_getblk(sb, udf_fixed_to_variable(block));
@@ -36,7 +36,7 @@ struct buffer_head *udf_tgetblk(struct super_block *sb, int block)
                 return sb_getblk(sb, block);
 }
 
-struct buffer_head *udf_tread(struct super_block *sb, int block)
+struct buffer_head *udf_tread(struct super_block *sb, udf_pblk_t block)
 {
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
                 return sb_bread(sb, udf_fixed_to_variable(block));
@@ -209,7 +209,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
 
         bh = udf_tread(sb, block);
         if (!bh) {
-                udf_err(sb, "read failed, block=%u, location=%d\n",
+                udf_err(sb, "read failed, block=%u, location=%u\n",
                         block, location);
                 return NULL;
         }
@@ -247,7 +247,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
                                         le16_to_cpu(tag_p->descCRCLength)))
                 return bh;
 
-        udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", block,
+        udf_debug("Crc failure block %u: crc = %u, crclen = %u\n", block,
                   le16_to_cpu(tag_p->descCRC),
                   le16_to_cpu(tag_p->descCRCLength));
 error_out:
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 885198dfd9f8..0458dd47e105 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -164,7 +164,8 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
 {
         struct fileIdentDesc *fi = NULL;
         loff_t f_pos;
-        int block, flen;
+        udf_pblk_t block;
+        int flen;
         unsigned char *fname = NULL, *copy_name = NULL;
         unsigned char *nameptr;
         uint8_t lfi;
@@ -352,7 +353,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         int nfidlen;
         uint8_t lfi;
         uint16_t liu;
-        int block;
+        udf_pblk_t block;
         struct kernel_lb_addr eloc;
         uint32_t elen = 0;
         sector_t offset;
@@ -749,7 +750,7 @@ static int empty_dir(struct inode *dir)
         struct udf_fileident_bh fibh;
         loff_t f_pos;
         loff_t size = udf_ext0_offset(dir) + dir->i_size;
-        int block;
+        udf_pblk_t block;
         struct kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
@@ -839,7 +840,7 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
         if (retval)
                 goto end_rmdir;
         if (inode->i_nlink != 2)
-                udf_warn(inode->i_sb, "empty directory has nlink != 2 (%d)\n",
+                udf_warn(inode->i_sb, "empty directory has nlink != 2 (%u)\n",
                          inode->i_nlink);
         clear_nlink(inode);
         inode->i_size = 0;
@@ -881,7 +882,7 @@ static int udf_unlink(struct inode *dir, struct dentry *dentry)
                 goto end_unlink;
 
         if (!inode->i_nlink) {
-                udf_debug("Deleting nonexistent file (%lu), %d\n",
+                udf_debug("Deleting nonexistent file (%lu), %u\n",
                           inode->i_ino, inode->i_nlink);
                 set_nlink(inode, 1);
         }
@@ -913,7 +914,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
         int eoffset, elen = 0;
         uint8_t *ea;
         int err;
-        int block;
+        udf_pblk_t block;
         unsigned char *name = NULL;
         int namelen;
         struct udf_inode_info *iinfo;
diff --git a/fs/udf/partition.c b/fs/udf/partition.c
index 888c364b2fe9..090baff83990 100644
--- a/fs/udf/partition.c
+++ b/fs/udf/partition.c
@@ -32,7 +32,7 @@ uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
         struct udf_sb_info *sbi = UDF_SB(sb);
         struct udf_part_map *map;
         if (partition >= sbi->s_partitions) {
-                udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
+                udf_debug("block=%u, partition=%u, offset=%u: invalid partition\n",
                           block, partition, offset);
                 return 0xFFFFFFFF;
         }
@@ -59,7 +59,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
         vdata = &map->s_type_specific.s_virtual;
 
         if (block > vdata->s_num_entries) {
-                udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
+                udf_debug("Trying to access block beyond end of VAT (%u max %u)\n",
                           block, vdata->s_num_entries);
                 return 0xFFFFFFFF;
         }
@@ -83,7 +83,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
 
         bh = sb_bread(sb, loc);
         if (!bh) {
-                udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
+                udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%u,%u) VAT: %u[%u]\n",
                           sb, block, partition, loc, index);
                 return 0xFFFFFFFF;
         }
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 99cb81d0077f..f80e0a0f24d3 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -366,7 +366,7 @@ static int udf_show_options(struct seq_file *seq, struct dentry *root)
         if (sbi->s_dmode != UDF_INVALID_MODE)
                 seq_printf(seq, ",dmode=%ho", sbi->s_dmode);
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
-                seq_printf(seq, ",session=%u", sbi->s_session);
+                seq_printf(seq, ",session=%d", sbi->s_session);
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
                 seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
         if (sbi->s_anchor != 0)
@@ -703,9 +703,9 @@ static loff_t udf_check_vsd(struct super_block *sb)
         else
                 sectorsize = sb->s_blocksize;
 
-        sector += (sbi->s_session << sb->s_blocksize_bits);
+        sector += (((loff_t)sbi->s_session) << sb->s_blocksize_bits);
 
-        udf_debug("Starting at sector %u (%ld byte sectors)\n",
+        udf_debug("Starting at sector %u (%lu byte sectors)\n",
                   (unsigned int)(sector >> sb->s_blocksize_bits),
                   sb->s_blocksize);
         /* Process the sequence (if applicable). The hard limit on the sector
@@ -868,7 +868,7 @@ static int udf_find_fileset(struct super_block *sb,
 
         if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
              fileset->partitionReferenceNum != 0xFFFF) && bh) {
-                udf_debug("Fileset at block=%d, partition=%d\n",
+                udf_debug("Fileset at block=%u, partition=%u\n",
                           fileset->logicalBlockNum,
                           fileset->partitionReferenceNum);
 
@@ -981,14 +981,14 @@ static int udf_load_metadata_files(struct super_block *sb, int partition,
         mdata->s_phys_partition_ref = type1_index;
 
         /* metadata address */
-        udf_debug("Metadata file location: block = %d part = %d\n",
+        udf_debug("Metadata file location: block = %u part = %u\n",
                   mdata->s_meta_file_loc, mdata->s_phys_partition_ref);
 
         fe = udf_find_metadata_inode_efe(sb, mdata->s_meta_file_loc,
                                          mdata->s_phys_partition_ref);
         if (IS_ERR(fe)) {
                 /* mirror file entry */
-                udf_debug("Mirror metadata file location: block = %d part = %d\n",
+                udf_debug("Mirror metadata file location: block = %u part = %u\n",
                           mdata->s_mirror_file_loc, mdata->s_phys_partition_ref);
 
                 fe = udf_find_metadata_inode_efe(sb, mdata->s_mirror_file_loc,
@@ -1012,7 +1012,7 @@ static int udf_load_metadata_files(struct super_block *sb, int partition,
                 addr.logicalBlockNum = mdata->s_bitmap_file_loc;
                 addr.partitionReferenceNum = mdata->s_phys_partition_ref;
 
-                udf_debug("Bitmap file location: block = %d part = %d\n",
+                udf_debug("Bitmap file location: block = %u part = %u\n",
                           addr.logicalBlockNum, addr.partitionReferenceNum);
 
                 fe = udf_iget_special(sb, &addr);
@@ -1042,7 +1042,7 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
 
         UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
 
-        udf_debug("Rootdir at block=%d, partition=%d\n",
+        udf_debug("Rootdir at block=%u, partition=%u\n",
                   root->logicalBlockNum, root->partitionReferenceNum);
 }
 
@@ -1097,7 +1097,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
         if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
                 map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;
 
-        udf_debug("Partition (%d type %x) starts at physical %d, block length %d\n",
+        udf_debug("Partition (%d type %x) starts at physical %u, block length %u\n",
                   p_index, map->s_partition_type,
                   map->s_partition_root, map->s_partition_len);
 
@@ -1122,7 +1122,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 }
                 map->s_uspace.s_table = inode;
                 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
-                udf_debug("unallocSpaceTable (part %d) @ %ld\n",
+                udf_debug("unallocSpaceTable (part %d) @ %lu\n",
                           p_index, map->s_uspace.s_table->i_ino);
         }
 
@@ -1134,7 +1134,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 bitmap->s_extPosition = le32_to_cpu(
                                 phd->unallocSpaceBitmap.extPosition);
                 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
-                udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
+                udf_debug("unallocSpaceBitmap (part %d) @ %u\n",
                           p_index, bitmap->s_extPosition);
         }
 
@@ -1157,7 +1157,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 }
                 map->s_fspace.s_table = inode;
                 map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
-                udf_debug("freedSpaceTable (part %d) @ %ld\n",
+                udf_debug("freedSpaceTable (part %d) @ %lu\n",
                           p_index, map->s_fspace.s_table->i_ino);
         }
 
@@ -1169,7 +1169,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 bitmap->s_extPosition = le32_to_cpu(
                                 phd->freedSpaceBitmap.extPosition);
                 map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
-                udf_debug("freedSpaceBitmap (part %d) @ %d\n",
+                udf_debug("freedSpaceBitmap (part %d) @ %u\n",
                           p_index, bitmap->s_extPosition);
         }
         return 0;
@@ -1282,7 +1282,7 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
         /* First scan for TYPE1 and SPARABLE partitions */
         for (i = 0; i < sbi->s_partitions; i++) {
                 map = &sbi->s_partmaps[i];
-                udf_debug("Searching map: (%d == %d)\n",
+                udf_debug("Searching map: (%u == %u)\n",
                           map->s_partition_num, partitionNumber);
                 if (map->s_partition_num == partitionNumber &&
                     (map->s_partition_type == UDF_TYPE1_MAP15 ||
@@ -1291,7 +1291,7 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
         }
 
         if (i >= sbi->s_partitions) {
-                udf_debug("Partition (%d) not found in partition map\n",
+                udf_debug("Partition (%u) not found in partition map\n",
                           partitionNumber);
                 ret = 0;
                 goto out_bh;
@@ -1483,7 +1483,7 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                                 struct metadataPartitionMap *mdm =
                                                 (struct metadataPartitionMap *)
                                                 &(lvd->partitionMaps[offset]);
-                                udf_debug("Parsing Logical vol part %d type %d  id=%s\n",
+                                udf_debug("Parsing Logical vol part %d type %u  id=%s\n",
                                           i, type, UDF_ID_METADATA);
 
                                 map->s_partition_type = UDF_METADATA_MAP25;
@@ -1505,17 +1505,17 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                                 udf_debug("Metadata Ident suffix=0x%x\n",
                                           le16_to_cpu(*(__le16 *)
                                                       mdm->partIdent.identSuffix));
-                                udf_debug("Metadata part num=%d\n",
+                                udf_debug("Metadata part num=%u\n",
                                           le16_to_cpu(mdm->partitionNum));
-                                udf_debug("Metadata part alloc unit size=%d\n",
+                                udf_debug("Metadata part alloc unit size=%u\n",
                                           le32_to_cpu(mdm->allocUnitSize));
-                                udf_debug("Metadata file loc=%d\n",
+                                udf_debug("Metadata file loc=%u\n",
                                           le32_to_cpu(mdm->metadataFileLoc));
-                                udf_debug("Mirror file loc=%d\n",
+                                udf_debug("Mirror file loc=%u\n",
                                           le32_to_cpu(mdm->metadataMirrorFileLoc));
-                                udf_debug("Bitmap file loc=%d\n",
+                                udf_debug("Bitmap file loc=%u\n",
                                           le32_to_cpu(mdm->metadataBitmapFileLoc));
-                                udf_debug("Flags: %d %d\n",
+                                udf_debug("Flags: %d %u\n",
                                           mdata->s_flags, mdm->flags);
                         } else {
                                 udf_debug("Unknown ident: %s\n",
@@ -1525,7 +1525,7 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                         map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
                         map->s_partition_num = le16_to_cpu(upm2->partitionNum);
                 }
-                udf_debug("Partition (%d:%d) type %d on volume %d\n",
+                udf_debug("Partition (%d:%u) type %u on volume %u\n",
                           i, map->s_partition_num, type, map->s_volumeseqnum);
         }
 
@@ -1533,7 +1533,7 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                 struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
 
                 *fileset = lelb_to_cpu(la->extLocation);
-                udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
+                udf_debug("FileSet found in LogicalVolDesc at block=%u, partition=%u\n",
                           fileset->logicalBlockNum,
                           fileset->partitionReferenceNum);
         }
@@ -2159,7 +2159,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                         ret = udf_load_vrs(sb, &uopt, silent, &fileset);
                         if (ret < 0) {
                                 if (!silent && ret != -EACCES) {
-                                        pr_notice("Scanning with blocksize %d failed\n",
+                                        pr_notice("Scanning with blocksize %u failed\n",
                                                   uopt.blocksize);
                                 }
                                 brelse(sbi->s_lvid_bh);
@@ -2184,7 +2184,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                 goto error_out;
         }
 
-        udf_debug("Lastblock=%d\n", sbi->s_last_block);
+        udf_debug("Lastblock=%u\n", sbi->s_last_block);
 
         if (sbi->s_lvid_bh) {
                 struct logicalVolIntegrityDescImpUse *lvidiu =
@@ -2255,7 +2255,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         /* perhaps it's not extensible enough, but for now ... */
         inode = udf_iget(sb, &rootdir);
         if (IS_ERR(inode)) {
-                udf_err(sb, "Error in udf_iget, block=%d, partition=%d\n",
+                udf_err(sb, "Error in udf_iget, block=%u, partition=%u\n",
                        rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
                 ret = PTR_ERR(inode);
                 goto error_out;
@@ -2389,7 +2389,7 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb,
         struct buffer_head *bh = NULL;
         unsigned int accum = 0;
         int index;
-        int block = 0, newblock;
+        udf_pblk_t block = 0, newblock;
         struct kernel_lb_addr loc;
         uint32_t bytes;
         uint8_t *ptr;
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
index 42b8c57795cb..b647f0bd150c 100644
--- a/fs/udf/truncate.c
+++ b/fs/udf/truncate.c
@@ -48,7 +48,7 @@ static void extent_trunc(struct inode *inode, struct extent_position *epos,
 
         if (elen != nelen) {
                 udf_write_aext(inode, epos, &neloc, nelen, 0);
-                if (last_block - first_block > 0) {
+                if (last_block > first_block) {
                         if (etype == (EXT_RECORDED_ALLOCATED >> 30))
                                 mark_inode_dirty(inode);
 
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index fa206558128d..f5e0fe78979e 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -74,6 +74,8 @@ static inline size_t udf_ext0_offset(struct inode *inode)
 /* computes tag checksum */
 u8 udf_tag_checksum(const struct tag *t);
 
+typedef uint32_t udf_pblk_t;
+
 struct dentry;
 struct inode;
 struct task_struct;
@@ -145,15 +147,17 @@ static inline struct inode *udf_iget(struct super_block *sb,
         return __udf_iget(sb, ino, false);
 }
 extern int udf_expand_file_adinicb(struct inode *);
-extern struct buffer_head *udf_expand_dir_adinicb(struct inode *, int *, int *);
-extern struct buffer_head *udf_bread(struct inode *, int, int, int *);
+extern struct buffer_head *udf_expand_dir_adinicb(struct inode *inode,
+                                                  udf_pblk_t *block, int *err);
+extern struct buffer_head *udf_bread(struct inode *inode, udf_pblk_t block,
+                                      int create, int *err);
 extern int udf_setsize(struct inode *, loff_t);
 extern void udf_evict_inode(struct inode *);
 extern int udf_write_inode(struct inode *, struct writeback_control *wbc);
-extern long udf_block_map(struct inode *, sector_t);
+extern udf_pblk_t udf_block_map(struct inode *inode, sector_t block);
 extern int8_t inode_bmap(struct inode *, sector_t, struct extent_position *,
                          struct kernel_lb_addr *, uint32_t *, sector_t *);
-extern int udf_setup_indirect_aext(struct inode *inode, int block,
+extern int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
                                    struct extent_position *epos);
 extern int __udf_add_aext(struct inode *inode, struct extent_position *epos,
                           struct kernel_lb_addr *eloc, uint32_t elen, int inc);
@@ -169,8 +173,9 @@ extern int8_t udf_current_aext(struct inode *, struct extent_position *,
                                struct kernel_lb_addr *, uint32_t *, int);
 
 /* misc.c */
-extern struct buffer_head *udf_tgetblk(struct super_block *, int);
-extern struct buffer_head *udf_tread(struct super_block *, int);
+extern struct buffer_head *udf_tgetblk(struct super_block *sb,
+                                        udf_pblk_t block);
+extern struct buffer_head *udf_tread(struct super_block *sb, udf_pblk_t block);
 extern struct genericFormat *udf_add_extendedattr(struct inode *, uint32_t,
                                                   uint32_t, uint8_t);
 extern struct genericFormat *udf_get_extendedattr(struct inode *, uint32_t,
@@ -229,8 +234,8 @@ extern void udf_free_blocks(struct super_block *, struct inode *,
                             struct kernel_lb_addr *, uint32_t, uint32_t);
 extern int udf_prealloc_blocks(struct super_block *, struct inode *, uint16_t,
                                uint32_t, uint32_t);
-extern int udf_new_block(struct super_block *, struct inode *, uint16_t,
-                         uint32_t, int *);
+extern udf_pblk_t udf_new_block(struct super_block *sb, struct inode *inode,
+                                 uint16_t partition, uint32_t goal, int *err);
 
 /* directory.c */
 extern struct fileIdentDesc *udf_fileident_read(struct inode *, loff_t *,
diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c
index 695389a4fc23..f897e55f2cd0 100644
--- a/fs/udf/unicode.c
+++ b/fs/udf/unicode.c
@@ -200,7 +200,7 @@ static int udf_name_from_CS0(uint8_t *str_o, int str_max_len,
         cmp_id = ocu[0];
         if (cmp_id != 8 && cmp_id != 16) {
                 memset(str_o, 0, str_max_len);
-                pr_err("unknown compression code (%d)\n", cmp_id);
+                pr_err("unknown compression code (%u)\n", cmp_id);
                 return -EINVAL;
         }
         u_ch = cmp_id >> 3;