85 files changed, 1111 insertions, 803 deletions
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index 25b23b1e7f22..9bca88159725 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -1,3 +1,9 @@
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
@@ -206,7 +212,7 @@ affs_set_blocksize(struct super_block *sb, int size)
 static inline struct buffer_head *
 affs_bread(struct super_block *sb, int block)
 {
-        pr_debug("affs_bread: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
        if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                return sb_bread(sb, block);
        return NULL;
@@ -214,7 +220,7 @@ affs_bread(struct super_block *sb, int block)
 static inline struct buffer_head *
 affs_getblk(struct super_block *sb, int block)
 {
-        pr_debug("affs_getblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
        if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                return sb_getblk(sb, block);
        return NULL;
@@ -223,7 +229,7 @@ static inline struct buffer_head *
 affs_getzeroblk(struct super_block *sb, int block)
 {
        struct buffer_head *bh;
-        pr_debug("affs_getzeroblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
        if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                bh = sb_getblk(sb, block);
                lock_buffer(bh);
@@ -238,7 +244,7 @@ static inline struct buffer_head *
 affs_getemptyblk(struct super_block *sb, int block)
 {
        struct buffer_head *bh;
-        pr_debug("affs_getemptyblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
        if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                bh = sb_getblk(sb, block);
                wait_on_buffer(bh);
@@ -251,7 +257,7 @@ static inline void
 affs_brelse(struct buffer_head *bh)
 {
        if (bh)
-                pr_debug("affs_brelse: %lld\n", (long long) bh->b_blocknr);
+                pr_debug("%s: %lld\n", __func__, (long long) bh->b_blocknr);
        brelse(bh);
 }
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 533a322c41c0..406b29836b19 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -34,7 +34,7 @@ affs_insert_hash(struct inode *dir, struct buffer_head *bh)
        ino = bh->b_blocknr;
        offset = affs_hash_name(sb, AFFS_TAIL(sb, bh)->name + 1, AFFS_TAIL(sb, bh)->name[0]);
-        pr_debug("AFFS: insert_hash(dir=%u, ino=%d)\n", (u32)dir->i_ino, ino);
+        pr_debug("%s(dir=%u, ino=%d)\n", __func__, (u32)dir->i_ino, ino);
        dir_bh = affs_bread(sb, dir->i_ino);
        if (!dir_bh)
@@ -84,7 +84,8 @@ affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
        sb = dir->i_sb;
        rem_ino = rem_bh->b_blocknr;
        offset = affs_hash_name(sb, AFFS_TAIL(sb, rem_bh)->name+1, AFFS_TAIL(sb, rem_bh)->name[0]);
-        pr_debug("AFFS: remove_hash(dir=%d, ino=%d, hashval=%d)\n", (u32)dir->i_ino, rem_ino, offset);
+        pr_debug("%s(dir=%d, ino=%d, hashval=%d)\n",
+                 __func__, (u32)dir->i_ino, rem_ino, offset);
        bh = affs_bread(sb, dir->i_ino);
        if (!bh)
@@ -147,7 +148,7 @@ affs_remove_link(struct dentry *dentry)
        u32 link_ino, ino;
        int retval;
-        pr_debug("AFFS: remove_link(key=%ld)\n", inode->i_ino);
+        pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
        retval = -EIO;
        bh = affs_bread(sb, inode->i_ino);
        if (!bh)
@@ -279,7 +280,7 @@ affs_remove_header(struct dentry *dentry)
        if (!inode)
                goto done;
-        pr_debug("AFFS: remove_header(key=%ld)\n", inode->i_ino);
+        pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
        retval = -EIO;
        bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
        if (!bh)
@@ -451,10 +452,10 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
        vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
        va_end(args);
-        printk(KERN_CRIT "AFFS error (device %s): %s(): %s\n", sb->s_id,
+        pr_crit("error (device %s): %s(): %s\n", sb->s_id,
                function,ErrorBuffer);
        if (!(sb->s_flags & MS_RDONLY))
-                printk(KERN_WARNING "AFFS: Remounting filesystem read-only\n");
+                pr_warn("Remounting filesystem read-only\n");
        sb->s_flags |= MS_RDONLY;
 }
@@ -467,7 +468,7 @@ affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
        vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
        va_end(args);
-        printk(KERN_WARNING "AFFS warning (device %s): %s(): %s\n", sb->s_id,
+        pr_warn("(device %s): %s(): %s\n", sb->s_id,
                function,ErrorBuffer);
 }
diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
index a32246b8359e..c8de51185c23 100644
--- a/fs/affs/bitmap.c
+++ b/fs/affs/bitmap.c
@@ -17,7 +17,7 @@ affs_count_free_blocks(struct super_block *sb)
        u32 free;
        int i;
-        pr_debug("AFFS: count_free_blocks()\n");
+        pr_debug("%s()\n", __func__);
        if (sb->s_flags & MS_RDONLY)
                return 0;
@@ -43,7 +43,7 @@ affs_free_block(struct super_block *sb, u32 block)
        u32 blk, bmap, bit, mask, tmp;
        __be32 *data;
-        pr_debug("AFFS: free_block(%u)\n", block);
+        pr_debug("%s(%u)\n", __func__, block);
        if (block > sbi->s_partition_size)
                goto err_range;
@@ -125,7 +125,7 @@ affs_alloc_block(struct inode *inode, u32 goal)
        sb = inode->i_sb;
        sbi = AFFS_SB(sb);
-        pr_debug("AFFS: balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
+        pr_debug("balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
        if (AFFS_I(inode)->i_pa_cnt) {
                pr_debug("%d\n", AFFS_I(inode)->i_lastalloc+1);
@@ -254,8 +254,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                return 0;
        if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
-                printk(KERN_NOTICE "AFFS: Bitmap invalid - mounting %s read only\n",
+                pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);
-                        sb->s_id);
                *flags |= MS_RDONLY;
                return 0;
        }
@@ -268,7 +267,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
        size = sbi->s_bmap_count * sizeof(*bm);
        bm = sbi->s_bitmap = kzalloc(size, GFP_KERNEL);
        if (!sbi->s_bitmap) {
-                printk(KERN_ERR "AFFS: Bitmap allocation failed\n");
+                pr_err("Bitmap allocation failed\n");
                return -ENOMEM;
        }
@@ -282,17 +281,17 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                bm->bm_key = be32_to_cpu(bmap_blk[blk]);
                bh = affs_bread(sb, bm->bm_key);
                if (!bh) {
-                        printk(KERN_ERR "AFFS: Cannot read bitmap\n");
+                        pr_err("Cannot read bitmap\n");
                        res = -EIO;
                        goto out;
                }
                if (affs_checksum_block(sb, bh)) {
-                        printk(KERN_WARNING "AFFS: Bitmap %u invalid - mounting %s read only.\n",
+                        pr_warn("Bitmap %u invalid - mounting %s read only.\n",
-                               bm->bm_key, sb->s_id);
+                                bm->bm_key, sb->s_id);
                        *flags |= MS_RDONLY;
                        goto out;
                }
-                pr_debug("AFFS: read bitmap block %d: %d\n", blk, bm->bm_key);
+                pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key);
                bm->bm_free = memweight(bh->b_data + 4, sb->s_blocksize - 4);
                /* Don't try read the extension if this is the last block,
@@ -304,7 +303,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                        affs_brelse(bmap_bh);
                bmap_bh = affs_bread(sb, be32_to_cpu(bmap_blk[blk]));
                if (!bmap_bh) {
-                        printk(KERN_ERR "AFFS: Cannot read bitmap extension\n");
+                        pr_err("Cannot read bitmap extension\n");
                        res = -EIO;
                        goto out;
                }
diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index cbbda476a805..59f07bec92a6 100644
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -54,8 +54,8 @@ affs_readdir(struct file *file, struct dir_context *ctx)
        u32                      ino;
        int                      error = 0;
-        pr_debug("AFFS: readdir(ino=%lu,f_pos=%lx)\n",
+        pr_debug("%s(ino=%lu,f_pos=%lx)\n",
-                 inode->i_ino, (unsigned long)ctx->pos);
+                 __func__, inode->i_ino, (unsigned long)ctx->pos);
        if (ctx->pos < 2) {
                file->private_data = (void *)0;
@@ -81,7 +81,7 @@ affs_readdir(struct file *file, struct dir_context *ctx)
         */
        ino = (u32)(long)file->private_data;
        if (ino && file->f_version == inode->i_version) {
-                pr_debug("AFFS: readdir() left off=%d\n", ino);
+                pr_debug("readdir() left off=%d\n", ino);
                goto inside;
        }
@@ -117,7 +117,7 @@ inside:
                        namelen = min(AFFS_TAIL(sb, fh_bh)->name[0], (u8)30);
                        name = AFFS_TAIL(sb, fh_bh)->name + 1;
-                        pr_debug("AFFS: readdir(): dir_emit(\"%.*s\", "
+                        pr_debug("readdir(): dir_emit(\"%.*s\", "
                                 "ino=%u), hash=%d, f_pos=%x\n",
                                 namelen, name, ino, hash_pos, (u32)ctx->pos);
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 8669b6ecddee..0270303388ee 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -45,7 +45,7 @@ const struct inode_operations affs_file_inode_operations = {
 static int
 affs_file_open(struct inode *inode, struct file *filp)
 {
-        pr_debug("AFFS: open(%lu,%d)\n",
+        pr_debug("open(%lu,%d)\n",
                 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
        atomic_inc(&AFFS_I(inode)->i_opencnt);
        return 0;
@@ -54,7 +54,7 @@ affs_file_open(struct inode *inode, struct file *filp)
 static int
 affs_file_release(struct inode *inode, struct file *filp)
 {
-        pr_debug("AFFS: release(%lu, %d)\n",
+        pr_debug("release(%lu, %d)\n",
                 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
        if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
@@ -324,7 +324,8 @@ affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_resul
        struct buffer_head      *ext_bh;
        u32                      ext;
-        pr_debug("AFFS: get_block(%u, %lu)\n", (u32)inode->i_ino, (unsigned long)block);
+        pr_debug("%s(%u, %lu)\n",
+                 __func__, (u32)inode->i_ino, (unsigned long)block);
        BUG_ON(block > (sector_t)0x7fffffffUL);
@@ -498,34 +499,36 @@ affs_getemptyblk_ino(struct inode *inode, int block)
 }
 static int
-affs_do_readpage_ofs(struct file *file, struct page *page, unsigned from, unsigned to)
+affs_do_readpage_ofs(struct page *page, unsigned to)
 {
        struct inode *inode = page->mapping->host;
        struct super_block *sb = inode->i_sb;
        struct buffer_head *bh;
        char *data;
+        unsigned pos = 0;
        u32 bidx, boff, bsize;
        u32 tmp;
-        pr_debug("AFFS: read_page(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to);
+        pr_debug("%s(%u, %ld, 0, %d)\n", __func__, (u32)inode->i_ino,
-        BUG_ON(from > to || to > PAGE_CACHE_SIZE);
+                 page->index, to);
+        BUG_ON(to > PAGE_CACHE_SIZE);
        kmap(page);
        data = page_address(page);
        bsize = AFFS_SB(sb)->s_data_blksize;
-        tmp = (page->index << PAGE_CACHE_SHIFT) + from;
+        tmp = page->index << PAGE_CACHE_SHIFT;
        bidx = tmp / bsize;
        boff = tmp % bsize;
-        while (from < to) {
+        while (pos < to) {
                bh = affs_bread_ino(inode, bidx, 0);
                if (IS_ERR(bh))
                        return PTR_ERR(bh);
-                tmp = min(bsize - boff, to - from);
+                tmp = min(bsize - boff, to - pos);
-                BUG_ON(from + tmp > to || tmp > bsize);
+                BUG_ON(pos + tmp > to || tmp > bsize);
-                memcpy(data + from, AFFS_DATA(bh) + boff, tmp);
+                memcpy(data + pos, AFFS_DATA(bh) + boff, tmp);
                affs_brelse(bh);
                bidx++;
-                from += tmp;
+                pos += tmp;
                boff = 0;
        }
        flush_dcache_page(page);
@@ -542,7 +545,7 @@ affs_extent_file_ofs(struct inode *inode, u32 newsize)
        u32 size, bsize;
        u32 tmp;
-        pr_debug("AFFS: extent_file(%u, %d)\n", (u32)inode->i_ino, newsize);
+        pr_debug("%s(%u, %d)\n", __func__, (u32)inode->i_ino, newsize);
        bsize = AFFS_SB(sb)->s_data_blksize;
        bh = NULL;
        size = AFFS_I(inode)->mmu_private;
@@ -608,14 +611,14 @@ affs_readpage_ofs(struct file *file, struct page *page)
        u32 to;
        int err;
-        pr_debug("AFFS: read_page(%u, %ld)\n", (u32)inode->i_ino, page->index);
+        pr_debug("%s(%u, %ld)\n", __func__, (u32)inode->i_ino, page->index);
        to = PAGE_CACHE_SIZE;
        if (((page->index + 1) << PAGE_CACHE_SHIFT) > inode->i_size) {
                to = inode->i_size & ~PAGE_CACHE_MASK;
                memset(page_address(page) + to, 0, PAGE_CACHE_SIZE - to);
        }
-        err = affs_do_readpage_ofs(file, page, 0, to);
+        err = affs_do_readpage_ofs(page, to);
        if (!err)
                SetPageUptodate(page);
        unlock_page(page);
@@ -631,7 +634,8 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
        pgoff_t index;
        int err = 0;
-        pr_debug("AFFS: write_begin(%u, %llu, %llu)\n", (u32)inode->i_ino, (unsigned long long)pos, (unsigned long long)pos + len);
+        pr_debug("%s(%u, %llu, %llu)\n", __func__, (u32)inode->i_ino,
+                 (unsigned long long)pos, (unsigned long long)pos + len);
        if (pos > AFFS_I(inode)->mmu_private) {
                /* XXX: this probably leaves a too-big i_size in case of
                 * failure. Should really be updating i_size at write_end time
@@ -651,7 +655,7 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
                return 0;
        /* XXX: inefficient but safe in the face of short writes */
-        err = affs_do_readpage_ofs(file, page, 0, PAGE_CACHE_SIZE);
+        err = affs_do_readpage_ofs(page, PAGE_CACHE_SIZE);
        if (err) {
                unlock_page(page);
                page_cache_release(page);
@@ -680,7 +684,9 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
         * due to write_begin.
         */
-        pr_debug("AFFS: write_begin(%u, %llu, %llu)\n", (u32)inode->i_ino, (unsigned long long)pos, (unsigned long long)pos + len);
+        pr_debug("%s(%u, %llu, %llu)\n",
+                 __func__, (u32)inode->i_ino, (unsigned long long)pos,
+                (unsigned long long)pos + len);
        bsize = AFFS_SB(sb)->s_data_blksize;
        data = page_address(page);
@@ -802,7 +808,7 @@ affs_free_prealloc(struct inode *inode)
 {
        struct super_block *sb = inode->i_sb;
-        pr_debug("AFFS: free_prealloc(ino=%lu)\n", inode->i_ino);
+        pr_debug("free_prealloc(ino=%lu)\n", inode->i_ino);
        while (AFFS_I(inode)->i_pa_cnt) {
                AFFS_I(inode)->i_pa_cnt--;
@@ -822,7 +828,7 @@ affs_truncate(struct inode *inode)
        struct buffer_head *ext_bh;
        int i;
-        pr_debug("AFFS: truncate(inode=%d, oldsize=%u, newsize=%u)\n",
+        pr_debug("truncate(inode=%d, oldsize=%u, newsize=%u)\n",
                 (u32)inode->i_ino, (u32)AFFS_I(inode)->mmu_private, (u32)inode->i_size);
        last_blk = 0;
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 96df91e8c334..bec2d1a0c91c 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -34,7 +34,7 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
        if (!(inode->i_state & I_NEW))
                return inode;
-        pr_debug("AFFS: affs_iget(%lu)\n", inode->i_ino);
+        pr_debug("affs_iget(%lu)\n", inode->i_ino);
        block = inode->i_ino;
        bh = affs_bread(sb, block);
@@ -175,7 +175,7 @@ affs_write_inode(struct inode *inode, struct writeback_control *wbc)
        uid_t                    uid;
        gid_t                    gid;
-        pr_debug("AFFS: write_inode(%lu)\n",inode->i_ino);
+        pr_debug("write_inode(%lu)\n", inode->i_ino);
        if (!inode->i_nlink)
                // possibly free block
@@ -220,7 +220,7 @@ affs_notify_change(struct dentry *dentry, struct iattr *attr)
        struct inode *inode = dentry->d_inode;
        int error;
-        pr_debug("AFFS: notify_change(%lu,0x%x)\n",inode->i_ino,attr->ia_valid);
+        pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
        error = inode_change_ok(inode,attr);
        if (error)
@@ -258,7 +258,8 @@ void
 affs_evict_inode(struct inode *inode)
 {
        unsigned long cache_page;
-        pr_debug("AFFS: evict_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
+        pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
+                 inode->i_ino, inode->i_nlink);
        truncate_inode_pages_final(&inode->i_data);
        if (!inode->i_nlink) {
@@ -271,7 +272,7 @@ affs_evict_inode(struct inode *inode)
        affs_free_prealloc(inode);
        cache_page = (unsigned long)AFFS_I(inode)->i_lc;
        if (cache_page) {
-                pr_debug("AFFS: freeing ext cache\n");
+                pr_debug("freeing ext cache\n");
                AFFS_I(inode)->i_lc = NULL;
                AFFS_I(inode)->i_ac = NULL;
                free_page(cache_page);
@@ -350,7 +351,8 @@ affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s3
        u32 block = 0;
        int retval;
-        pr_debug("AFFS: add_entry(dir=%u, inode=%u, \"%*s\", type=%d)\n", (u32)dir->i_ino,
+        pr_debug("%s(dir=%u, inode=%u, \"%*s\", type=%d)\n",
+                 __func__, (u32)dir->i_ino,
                 (u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type);
        retval = -EIO;
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 6dae1ccd176d..035bd31556fc 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -190,7 +190,8 @@ affs_find_entry(struct inode *dir, struct dentry *dentry)
        toupper_t toupper = affs_get_toupper(sb);
        u32 key;
-        pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);
+        pr_debug("%s(\"%.*s\")\n",
+                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
        bh = affs_bread(sb, dir->i_ino);
        if (!bh)
@@ -218,7 +219,8 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
        struct buffer_head *bh;
        struct inode *inode = NULL;
-        pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);
+        pr_debug("%s(\"%.*s\")\n",
+                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
        affs_lock_dir(dir);
        bh = affs_find_entry(dir, dentry);
@@ -248,9 +250,9 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
+        pr_debug("%s(dir=%d, %lu \"%.*s\")\n",
-                 dentry->d_inode->i_ino,
+                 __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
-                 (int)dentry->d_name.len, dentry->d_name.name);
+                (int)dentry->d_name.len, dentry->d_name.name);
        return affs_remove_header(dentry);
 }
@@ -262,7 +264,8 @@ affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
        struct inode    *inode;
        int              error;
-        pr_debug("AFFS: create(%lu,\"%.*s\",0%ho)\n",dir->i_ino,(int)dentry->d_name.len,
+        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
                 dentry->d_name.name,mode);
        inode = affs_new_inode(dir);
@@ -291,8 +294,9 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
        struct inode            *inode;
        int                      error;
-        pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%ho)\n",dir->i_ino,
+        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
-                 (int)dentry->d_name.len,dentry->d_name.name,mode);
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
+                 dentry->d_name.name, mode);
        inode = affs_new_inode(dir);
        if (!inode)
@@ -317,8 +321,8 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
+        pr_debug("%s(dir=%u, %lu \"%.*s\")\n",
-                 dentry->d_inode->i_ino,
+                __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
                 (int)dentry->d_name.len, dentry->d_name.name);
        return affs_remove_header(dentry);
@@ -334,8 +338,9 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
        int                      i, maxlen, error;
        char                     c, lc;
-        pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
+        pr_debug("%s(%lu,\"%.*s\" -> \"%s\")\n",
-                 (int)dentry->d_name.len,dentry->d_name.name,symname);
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
+                 dentry->d_name.name, symname);
        maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
        inode  = affs_new_inode(dir);
@@ -404,7 +409,8 @@ affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
        struct inode *inode = old_dentry->d_inode;
-        pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,
+        pr_debug("%s(%u, %u, \"%.*s\")\n",
+                 __func__, (u32)inode->i_ino, (u32)dir->i_ino,
                 (int)dentry->d_name.len,dentry->d_name.name);
        return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
@@ -418,9 +424,10 @@ affs_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct buffer_head *bh = NULL;
        int retval;
-        pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
+        pr_debug("%s(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
-                 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,
+                 __func__, (u32)old_dir->i_ino, (int)old_dentry->d_name.len,
-                 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);
+                 old_dentry->d_name.name, (u32)new_dir->i_ino,
+                (int)new_dentry->d_name.len, new_dentry->d_name.name);
        retval = affs_check_name(new_dentry->d_name.name,
                                 new_dentry->d_name.len,
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 895ac7dc9dbf..51f1a95bff73 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -46,7 +46,7 @@ static void
 affs_put_super(struct super_block *sb)
 {
        struct affs_sb_info *sbi = AFFS_SB(sb);
-        pr_debug("AFFS: put_super()\n");
+        pr_debug("%s()\n", __func__);
        cancel_delayed_work_sync(&sbi->sb_work);
 }
@@ -220,7 +220,7 @@ parse_options(char *options, kuid_t *uid, kgid_t *gid, int *mode, int *reserved,
                                return 0;
                        if (n != 512 && n != 1024 && n != 2048
                            && n != 4096) {
-                                printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n");
+                                pr_warn("Invalid blocksize (512, 1024, 2048, 4096 allowed)\n");
                                return 0;
                        }
                        *blocksize = n;
@@ -285,8 +285,8 @@ parse_options(char *options, kuid_t *uid, kgid_t *gid, int *mode, int *reserved,
                        /* Silently ignore the quota options */
                        break;
                default:
-                        printk("AFFS: Unrecognized mount option \"%s\" "
+                        pr_warn("Unrecognized mount option \"%s\" or missing value\n",
-                                        "or missing value\n", p);
+                                p);
                        return 0;
                }
        }
@@ -319,7 +319,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        save_mount_options(sb, data);
-        pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
+        pr_debug("read_super(%s)\n", data ? (const char *)data : "no options");
        sb->s_magic             = AFFS_SUPER_MAGIC;
        sb->s_op                = &affs_sops;
@@ -339,7 +339,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
                                &blocksize,&sbi->s_prefix,
                                sbi->s_volume, &mount_flags)) {
-                printk(KERN_ERR "AFFS: Error parsing options\n");
+                pr_err("Error parsing options\n");
                return -EINVAL;
        }
        /* N.B. after this point s_prefix must be released */
@@ -356,7 +356,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
         */
        size = sb->s_bdev->bd_inode->i_size >> 9;
-        pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);
+        pr_debug("initial blocksize=%d, #blocks=%d\n", 512, size);
        affs_set_blocksize(sb, PAGE_SIZE);
        /* Try to find root block. Its location depends on the block size. */
@@ -371,7 +371,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                sbi->s_root_block = root_block;
                if (root_block < 0)
                        sbi->s_root_block = (reserved + size - 1) / 2;
-                pr_debug("AFFS: setting blocksize to %d\n", blocksize);
+                pr_debug("setting blocksize to %d\n", blocksize);
                affs_set_blocksize(sb, blocksize);
                sbi->s_partition_size = size;
@@ -386,7 +386,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                 * block behind the calculated one. So we check this one, too.
                 */
                for (num_bm = 0; num_bm < 2; num_bm++) {
-                        pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
+                        pr_debug("Dev %s, trying root=%u, bs=%d, "
                                "size=%d, reserved=%d\n",
                                sb->s_id,
                                sbi->s_root_block + num_bm,
@@ -407,8 +407,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                }
        }
        if (!silent)
-                printk(KERN_ERR "AFFS: No valid root block on device %s\n",
+                pr_err("No valid root block on device %s\n", sb->s_id);
-                        sb->s_id);
        return -EINVAL;
        /* N.B. after this point bh must be released */
@@ -420,7 +419,7 @@ got_root:
        /* Find out which kind of FS we have */
        boot_bh = sb_bread(sb, 0);
        if (!boot_bh) {
-                printk(KERN_ERR "AFFS: Cannot read boot block\n");
+                pr_err("Cannot read boot block\n");
                return -EINVAL;
        }
        memcpy(sig, boot_bh->b_data, 4);
@@ -433,8 +432,7 @@ got_root:
         */
        if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
             || chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {
-                printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
+                pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);
-                        sb->s_id);
                sb->s_flags |= MS_RDONLY;
        }
        switch (chksum) {
@@ -468,14 +466,14 @@ got_root:
                        sb->s_flags |= MS_NOEXEC;
                        break;
                default:
-                        printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",
+                        pr_err("Unknown filesystem on device %s: %08X\n",
-                                sb->s_id, chksum);
+                               sb->s_id, chksum);
                        return -EINVAL;
        }
        if (mount_flags & SF_VERBOSE) {
                u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
-                printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
+                pr_notice("Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
                        len > 31 ? 31 : len,
                        AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
                        sig, sig[3] + '0', blocksize);
@@ -506,11 +504,11 @@ got_root:
        sb->s_root = d_make_root(root_inode);
        if (!sb->s_root) {
-                printk(KERN_ERR "AFFS: Get root inode failed\n");
+                pr_err("AFFS: Get root inode failed\n");
                return -ENOMEM;
        }
-        pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
+        pr_debug("s_flags=%lX\n", sb->s_flags);
        return 0;
 }
@@ -530,7 +528,7 @@ affs_remount(struct super_block *sb, int *flags, char *data)
        char                     volume[32];
        char                    *prefix = NULL;
-        pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
+        pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);
        sync_filesystem(sb);
        *flags |= MS_NODIRATIME;
@@ -578,8 +576,9 @@ affs_statfs(struct dentry *dentry, struct kstatfs *buf)
        int              free;
        u64              id = huge_encode_dev(sb->s_bdev->bd_dev);
-        pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
+        pr_debug("%s() partsize=%d, reserved=%d\n",
-             AFFS_SB(sb)->s_reserved);
+                 __func__, AFFS_SB(sb)->s_partition_size,
+                 AFFS_SB(sb)->s_reserved);
        free          = affs_count_free_blocks(sb);
        buf->f_type    = AFFS_SUPER_MAGIC;
diff --git a/fs/affs/symlink.c b/fs/affs/symlink.c
index ee00f08c4f53..f39b71c3981e 100644
--- a/fs/affs/symlink.c
+++ b/fs/affs/symlink.c
@@ -21,7 +21,7 @@ static int affs_symlink_readpage(struct file *file, struct page *page)
        char                     c;
        char                     lc;
-        pr_debug("AFFS: follow_link(ino=%lu)\n",inode->i_ino);
+        pr_debug("follow_link(ino=%lu)\n", inode->i_ino);
        err = -EIO;
        bh = affs_bread(inode->i_sb, inode->i_ino);
diff --git a/fs/befs/btree.c b/fs/befs/btree.c
index a2cd305a993a..9c7faa8a9288 100644
--- a/fs/befs/btree.c
+++ b/fs/befs/btree.c
@@ -318,7 +318,7 @@ befs_btree_find(struct super_block *sb, befs_data_stream * ds,
 * befs_find_key - Search for a key within a node
 * @sb: Filesystem superblock
 * @node: Node to find the key within
- * @key: Keystring to search for
+ * @findkey: Keystring to search for
 * @value: If key is found, the value stored with the key is put here
 *
 * finds exact match if one exists, and returns BEFS_BT_MATCH
@@ -405,7 +405,7 @@ befs_find_key(struct super_block *sb, befs_btree_node * node,
 * Heres how it works: Key_no is the index of the key/value pair to 
 * return in keybuf/value.
 * Bufsize is the size of keybuf (BEFS_NAME_LEN+1 is a good size). Keysize is 
- * the number of charecters in the key (just a convenience).
+ * the number of characters in the key (just a convenience).
 *
 * Algorithm:
 *   Get the first leafnode of the tree. See if the requested key is in that
@@ -502,12 +502,11 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
                           "for key of size %d", __func__, bufsize, keylen);
                brelse(this_node->bh);
                goto error_alloc;
-        };
+        }
-        strncpy(keybuf, keystart, keylen);
+        strlcpy(keybuf, keystart, keylen + 1);
        *value = fs64_to_cpu(sb, valarray[cur_key]);
        *keysize = keylen;
-        keybuf[keylen] = '\0';
        befs_debug(sb, "Read [%llu,%d]: Key \"%.*s\", Value %llu", node_off,
                   cur_key, keylen, keybuf, *value);
@@ -707,7 +706,7 @@ befs_bt_get_key(struct super_block *sb, befs_btree_node * node,
 * @key1: pointer to the first key to be compared 
 * @keylen1: length in bytes of key1
 * @key2: pointer to the second key to be compared
- * @kelen2: length in bytes of key2
+ * @keylen2: length in bytes of key2
 *
 * Returns 0 if @key1 and @key2 are equal.
 * Returns >0 if @key1 is greater.
diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index c467bebd50af..1e8e0b8d8836 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -116,7 +116,7 @@ befs_fblock2brun(struct super_block *sb, befs_data_stream * data,
 * befs_read_lsmylink - read long symlink from datastream.
 * @sb: Filesystem superblock 
 * @ds: Datastrem to read from
- * @buf: Buffer in which to place long symlink data
+ * @buff: Buffer in which to place long symlink data
 * @len: Length of the long symlink in bytes
 *
 * Returns the number of bytes read
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index d626756ff721..a16fbd4e8241 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -133,14 +133,6 @@ befs_get_block(struct inode *inode, sector_t block,
        befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",
                   (unsigned long)inode->i_ino, (long)block);
-        if (block < 0) {
-                befs_error(sb, "befs_get_block() was asked for a block "
-                           "number less than zero: block %ld in inode %lu",
-                           (long)block, (unsigned long)inode->i_ino);
-                return -EIO;
-        }
        if (create) {
                befs_error(sb, "befs_get_block() was asked to write to "
                           "block %ld in inode %lu", (long)block,
@@ -396,9 +388,8 @@ static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
        if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){
                inode->i_size = 0;
                inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE;
-                strncpy(befs_ino->i_data.symlink, raw_inode->data.symlink,
+                strlcpy(befs_ino->i_data.symlink, raw_inode->data.symlink,
-                        BEFS_SYMLINK_LEN - 1);
+                        BEFS_SYMLINK_LEN);
-                befs_ino->i_data.symlink[BEFS_SYMLINK_LEN - 1] = '\0';
        } else {
                int num_blks;
@@ -591,21 +582,21 @@ befs_utf2nls(struct super_block *sb, const char *in,
 /**
 * befs_nls2utf - Convert NLS string to utf8 encodeing
 * @sb: Superblock
- * @src: Input string buffer in NLS format
+ * @in: Input string buffer in NLS format
- * @srclen: Length of input string in bytes
+ * @in_len: Length of input string in bytes
- * @dest: The output string in UTF-8 format
+ * @out: The output string in UTF-8 format
- * @destlen: Length of the output buffer
+ * @out_len: Length of the output buffer
 * 
- * Converts input string @src, which is in the format of the loaded NLS map,
+ * Converts input string @in, which is in the format of the loaded NLS map,
 * into a utf8 string.
 * 
- * The destination string @dest is allocated by this function and the caller is
+ * The destination string @out is allocated by this function and the caller is
 * responsible for freeing it with kfree()
 * 
- * On return, *@destlen is the length of @dest in bytes.
+ * On return, *@out_len is the length of @out in bytes.
 *
 * On success, the return value is the number of utf8 characters written to
- * the output buffer @dest.
+ * the output buffer @out.
 *  
 * On Failure, a negative number coresponding to the error code is returned.
 */
diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index 5b99bafc31d1..d749731dc0ee 100644
--- a/fs/cachefiles/bind.c
+++ b/fs/cachefiles/bind.c
@@ -50,18 +50,18 @@ int cachefiles_daemon_bind(struct cachefiles_cache *cache, char *args)
               cache->brun_percent  < 100);
        if (*args) {
-                kerror("'bind' command doesn't take an argument");
+                pr_err("'bind' command doesn't take an argument");
                return -EINVAL;
        }
        if (!cache->rootdirname) {
-                kerror("No cache directory specified");
+                pr_err("No cache directory specified");
                return -EINVAL;
        }
        /* don't permit already bound caches to be re-bound */
        if (test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("Cache already bound");
+                pr_err("Cache already bound");
                return -EBUSY;
        }
@@ -228,9 +228,7 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
        set_bit(CACHEFILES_READY, &cache->flags);
        dput(root);
-        printk(KERN_INFO "CacheFiles:"
+        pr_info("File cache on %s registered\n", cache->cache.identifier);
-               " File cache on %s registered\n",
-               cache->cache.identifier);
        /* check how much space the cache has */
        cachefiles_has_space(cache, 0, 0);
@@ -250,7 +248,7 @@ error_open_root:
        kmem_cache_free(cachefiles_object_jar, fsdef);
 error_root_object:
        cachefiles_end_secure(cache, saved_cred);
-        kerror("Failed to register: %d", ret);
+        pr_err("Failed to register: %d", ret);
        return ret;
 }
@@ -262,9 +260,8 @@ void cachefiles_daemon_unbind(struct cachefiles_cache *cache)
        _enter("");
        if (test_bit(CACHEFILES_READY, &cache->flags)) {
-                printk(KERN_INFO "CacheFiles:"
+                pr_info("File cache on %s unregistering\n",
-                       " File cache on %s unregistering\n",
+                        cache->cache.identifier);
-                       cache->cache.identifier);
                fscache_withdraw_cache(&cache->cache);
        }
diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c
index 0a1467b15516..b078d3081d6c 100644
--- a/fs/cachefiles/daemon.c
+++ b/fs/cachefiles/daemon.c
@@ -315,8 +315,7 @@ static unsigned int cachefiles_daemon_poll(struct file *file,
 static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
                                         char *args)
 {
-        kerror("Free space limits must be in range"
+        pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%");
-               " 0%%<=stop<cull<run<100%%");
        return -EINVAL;
 }
@@ -476,12 +475,12 @@ static int cachefiles_daemon_dir(struct cachefiles_cache *cache, char *args)
        _enter(",%s", args);
        if (!*args) {
-                kerror("Empty directory specified");
+                pr_err("Empty directory specified");
                return -EINVAL;
        }
        if (cache->rootdirname) {
-                kerror("Second cache directory specified");
+                pr_err("Second cache directory specified");
                return -EEXIST;
        }
@@ -504,12 +503,12 @@ static int cachefiles_daemon_secctx(struct cachefiles_cache *cache, char *args)
        _enter(",%s", args);
        if (!*args) {
-                kerror("Empty security context specified");
+                pr_err("Empty security context specified");
                return -EINVAL;
        }
        if (cache->secctx) {
-                kerror("Second security context specified");
+                pr_err("Second security context specified");
                return -EINVAL;
        }
@@ -532,7 +531,7 @@ static int cachefiles_daemon_tag(struct cachefiles_cache *cache, char *args)
        _enter(",%s", args);
        if (!*args) {
-                kerror("Empty tag specified");
+                pr_err("Empty tag specified");
                return -EINVAL;
        }
@@ -563,12 +562,12 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
                goto inval;
        if (!test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("cull applied to unready cache");
+                pr_err("cull applied to unready cache");
                return -EIO;
        }
        if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
-                kerror("cull applied to dead cache");
+                pr_err("cull applied to dead cache");
                return -EIO;
        }
@@ -588,11 +587,11 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
 notdir:
        path_put(&path);
-        kerror("cull command requires dirfd to be a directory");
+        pr_err("cull command requires dirfd to be a directory");
        return -ENOTDIR;
 inval:
-        kerror("cull command requires dirfd and filename");
+        pr_err("cull command requires dirfd and filename");
        return -EINVAL;
 }
@@ -615,7 +614,7 @@ static int cachefiles_daemon_debug(struct cachefiles_cache *cache, char *args)
        return 0;
 inval:
-        kerror("debug command requires mask");
+        pr_err("debug command requires mask");
        return -EINVAL;
 }
@@ -635,12 +634,12 @@ static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
                goto inval;
        if (!test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("inuse applied to unready cache");
+                pr_err("inuse applied to unready cache");
                return -EIO;
        }
        if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
-                kerror("inuse applied to dead cache");
+                pr_err("inuse applied to dead cache");
                return -EIO;
        }
@@ -660,11 +659,11 @@ static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
 notdir:
        path_put(&path);
-        kerror("inuse command requires dirfd to be a directory");
+        pr_err("inuse command requires dirfd to be a directory");
        return -ENOTDIR;
 inval:
-        kerror("inuse command requires dirfd and filename");
+        pr_err("inuse command requires dirfd and filename");
        return -EINVAL;
 }
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 57e17fe6121a..584743d456c3 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -146,8 +146,7 @@ static int cachefiles_lookup_object(struct fscache_object *_object)
        if (ret < 0 && ret != -ETIMEDOUT) {
                if (ret != -ENOBUFS)
-                        printk(KERN_WARNING
+                        pr_warn("Lookup failed error %d\n", ret);
-                               "CacheFiles: Lookup failed error %d\n", ret);
                fscache_object_lookup_error(&object->fscache);
        }
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index 5349473df1b1..3d50998abf57 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -9,6 +9,13 @@
 * 2 of the Licence, or (at your option) any later version.
 */
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) "CacheFiles: " fmt
 #include <linux/fscache-cache.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
@@ -245,11 +252,10 @@ extern int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
 /*
 * error handling
 */
-#define kerror(FMT, ...) printk(KERN_ERR "CacheFiles: "FMT"\n", ##__VA_ARGS__)
 #define cachefiles_io_error(___cache, FMT, ...)         \
 do {                                                    \
-        kerror("I/O Error: " FMT, ##__VA_ARGS__);       \
+        pr_err("I/O Error: " FMT, ##__VA_ARGS__);       \
        fscache_io_error(&(___cache)->cache);           \
        set_bit(CACHEFILES_DEAD, &(___cache)->flags);   \
 } while (0)
@@ -310,8 +316,8 @@ do {							\
 #define ASSERT(X)                                                       \
 do {                                                                    \
        if (unlikely(!(X))) {                                           \
-                printk(KERN_ERR "\n");                                  \
+                pr_err("\n");                                           \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("Assertion failed\n");           \
                BUG();                                                  \
        }                                                               \
 } while (0)
@@ -319,9 +325,9 @@ do {									\
 #define ASSERTCMP(X, OP, Y)                                             \
 do {                                                                    \
        if (unlikely(!((X) OP (Y)))) {                                  \
-                printk(KERN_ERR "\n");                                  \
+                pr_err("\n");                                           \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("Assertion failed\n");           \
-                printk(KERN_ERR "%lx " #OP " %lx is false\n",           \
+                pr_err("%lx " #OP " %lx is false\n",                    \
                       (unsigned long)(X), (unsigned long)(Y));         \
                BUG();                                                  \
        }                                                               \
@@ -330,8 +336,8 @@ do {									\
 #define ASSERTIF(C, X)                                                  \
 do {                                                                    \
        if (unlikely((C) && !(X))) {                                    \
-                printk(KERN_ERR "\n");                                  \
+                pr_err("\n");                                           \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("Assertion failed\n");           \
                BUG();                                                  \
        }                                                               \
 } while (0)
@@ -339,9 +345,9 @@ do {									\
 #define ASSERTIFCMP(C, X, OP, Y)                                        \
 do {                                                                    \
        if (unlikely((C) && !((X) OP (Y)))) {                           \
-                printk(KERN_ERR "\n");                                  \
+                pr_err("\n");                                           \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("Assertion failed\n");           \
-                printk(KERN_ERR "%lx " #OP " %lx is false\n",           \
+                pr_err("%lx " #OP " %lx is false\n",                    \
                       (unsigned long)(X), (unsigned long)(Y));         \
                BUG();                                                  \
        }                                                               \
diff --git a/fs/cachefiles/main.c b/fs/cachefiles/main.c
index 4bfa8cf43bf5..180edfb45f66 100644
--- a/fs/cachefiles/main.c
+++ b/fs/cachefiles/main.c
@@ -68,8 +68,7 @@ static int __init cachefiles_init(void)
                                  SLAB_HWCACHE_ALIGN,
                                  cachefiles_object_init_once);
        if (!cachefiles_object_jar) {
-                printk(KERN_NOTICE
+                pr_notice("Failed to allocate an object jar\n");
-                       "CacheFiles: Failed to allocate an object jar\n");
                goto error_object_jar;
        }
@@ -77,7 +76,7 @@ static int __init cachefiles_init(void)
        if (ret < 0)
                goto error_proc;
-        printk(KERN_INFO "CacheFiles: Loaded\n");
+        pr_info("Loaded\n");
        return 0;
 error_proc:
@@ -85,7 +84,7 @@ error_proc:
 error_object_jar:
        misc_deregister(&cachefiles_dev);
 error_dev:
-        kerror("failed to register: %d", ret);
+        pr_err("failed to register: %d", ret);
        return ret;
 }
@@ -96,7 +95,7 @@ fs_initcall(cachefiles_init);
 */
 static void __exit cachefiles_exit(void)
 {
-        printk(KERN_INFO "CacheFiles: Unloading\n");
+        pr_info("Unloading\n");
        cachefiles_proc_cleanup();
        kmem_cache_destroy(cachefiles_object_jar);
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index c0a681705104..5bf2b41e66d3 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -35,22 +35,21 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
        struct fscache_cookie *cookie;
        unsigned keylen, loop;
-        printk(KERN_ERR "%sobject: OBJ%x\n",
+        pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
-               prefix, object->fscache.debug_id);
+        pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
-        printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
               prefix, object->fscache.state->name,
               object->fscache.flags, work_busy(&object->fscache.work),
               object->fscache.events, object->fscache.event_mask);
-        printk(KERN_ERR "%sops=%u inp=%u exc=%u\n",
+        pr_err("%sops=%u inp=%u exc=%u\n",
               prefix, object->fscache.n_ops, object->fscache.n_in_progress,
               object->fscache.n_exclusive);
-        printk(KERN_ERR "%sparent=%p\n",
+        pr_err("%sparent=%p\n",
               prefix, object->fscache.parent);
        spin_lock(&object->fscache.lock);
        cookie = object->fscache.cookie;
        if (cookie) {
-                printk(KERN_ERR "%scookie=%p [pr=%p nd=%p fl=%lx]\n",
+                pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
                       prefix,
                       object->fscache.cookie,
                       object->fscache.cookie->parent,
@@ -62,16 +61,16 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
                else
                        keylen = 0;
        } else {
-                printk(KERN_ERR "%scookie=NULL\n", prefix);
+                pr_err("%scookie=NULL\n", prefix);
                keylen = 0;
        }
        spin_unlock(&object->fscache.lock);
        if (keylen) {
-                printk(KERN_ERR "%skey=[%u] '", prefix, keylen);
+                pr_err("%skey=[%u] '", prefix, keylen);
                for (loop = 0; loop < keylen; loop++)
-                        printk("%02x", keybuf[loop]);
+                        pr_cont("%02x", keybuf[loop]);
-                printk("'\n");
+                pr_cont("'\n");
        }
 }
@@ -131,13 +130,11 @@ found_dentry:
               dentry);
        if (fscache_object_is_live(&object->fscache)) {
-                printk(KERN_ERR "\n");
+                pr_err("\n");
-                printk(KERN_ERR "CacheFiles: Error:"
+                pr_err("Error: Can't preemptively bury live object\n");
-                       " Can't preemptively bury live object\n");
                cachefiles_printk_object(object, NULL);
        } else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
-                printk(KERN_ERR "CacheFiles: Error:"
+                pr_err("Error: Object already preemptively buried\n");
-                       " Object already preemptively buried\n");
        }
        write_unlock(&cache->active_lock);
@@ -160,7 +157,7 @@ try_again:
        write_lock(&cache->active_lock);
        if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
-                printk(KERN_ERR "CacheFiles: Error: Object already active\n");
+                pr_err("Error: Object already active\n");
                cachefiles_printk_object(object, NULL);
                BUG();
        }
@@ -193,9 +190,8 @@ try_again:
         * need to wait for it to be destroyed */
 wait_for_old_object:
        if (fscache_object_is_live(&object->fscache)) {
-                printk(KERN_ERR "\n");
+                pr_err("\n");
-                printk(KERN_ERR "CacheFiles: Error:"
+                pr_err("Error: Unexpected object collision\n");
-                       " Unexpected object collision\n");
                cachefiles_printk_object(object, xobject);
                BUG();
        }
@@ -241,9 +237,8 @@ wait_for_old_object:
                }
                if (timeout <= 0) {
-                        printk(KERN_ERR "\n");
+                        pr_err("\n");
-                        printk(KERN_ERR "CacheFiles: Error: Overlong"
+                        pr_err("Error: Overlong wait for old active object to go away\n");
-                               " wait for old active object to go away\n");
                        cachefiles_printk_object(object, xobject);
                        goto requeue;
                }
@@ -548,7 +543,7 @@ lookup_again:
                               next, next->d_inode, next->d_inode->i_ino);
                } else if (!S_ISDIR(next->d_inode->i_mode)) {
-                        kerror("inode %lu is not a directory",
+                        pr_err("inode %lu is not a directory",
                               next->d_inode->i_ino);
                        ret = -ENOBUFS;
                        goto error;
@@ -579,7 +574,7 @@ lookup_again:
                } else if (!S_ISDIR(next->d_inode->i_mode) &&
                           !S_ISREG(next->d_inode->i_mode)
                           ) {
-                        kerror("inode %lu is not a file or directory",
+                        pr_err("inode %lu is not a file or directory",
                               next->d_inode->i_ino);
                        ret = -ENOBUFS;
                        goto error;
@@ -773,7 +768,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
        ASSERT(subdir->d_inode);
        if (!S_ISDIR(subdir->d_inode->i_mode)) {
-                kerror("%s is not a directory", dirname);
+                pr_err("%s is not a directory", dirname);
                ret = -EIO;
                goto check_error;
        }
@@ -800,13 +795,13 @@ check_error:
 mkdir_error:
        mutex_unlock(&dir->d_inode->i_mutex);
        dput(subdir);
-        kerror("mkdir %s failed with error %d", dirname, ret);
+        pr_err("mkdir %s failed with error %d", dirname, ret);
        return ERR_PTR(ret);
 lookup_error:
        mutex_unlock(&dir->d_inode->i_mutex);
        ret = PTR_ERR(subdir);
-        kerror("Lookup %s failed with error %d", dirname, ret);
+        pr_err("Lookup %s failed with error %d", dirname, ret);
        return ERR_PTR(ret);
 nomem_d_alloc:
@@ -896,7 +891,7 @@ lookup_error:
        if (ret == -EIO) {
                cachefiles_io_error(cache, "Lookup failed");
        } else if (ret != -ENOMEM) {
-                kerror("Internal error: %d", ret);
+                pr_err("Internal error: %d", ret);
                ret = -EIO;
        }
@@ -955,7 +950,7 @@ error:
        }
        if (ret != -ENOMEM) {
-                kerror("Internal error: %d", ret);
+                pr_err("Internal error: %d", ret);
                ret = -EIO;
        }
diff --git a/fs/cachefiles/security.c b/fs/cachefiles/security.c
index 039b5011d83b..396c18ea2764 100644
--- a/fs/cachefiles/security.c
+++ b/fs/cachefiles/security.c
@@ -34,9 +34,7 @@ int cachefiles_get_security_ID(struct cachefiles_cache *cache)
                ret = set_security_override_from_ctx(new, cache->secctx);
                if (ret < 0) {
                        put_cred(new);
-                        printk(KERN_ERR "CacheFiles:"
+                        pr_err("Security denies permission to nominate security context: error %d\n",
-                               " Security denies permission to nominate"
-                               " security context: error %d\n",
                               ret);
                        goto error;
                }
@@ -59,16 +57,14 @@ static int cachefiles_check_cache_dir(struct cachefiles_cache *cache,
        ret = security_inode_mkdir(root->d_inode, root, 0);
        if (ret < 0) {
-                printk(KERN_ERR "CacheFiles:"
+                pr_err("Security denies permission to make dirs: error %d",
-                       " Security denies permission to make dirs: error %d",
                       ret);
                return ret;
        }
        ret = security_inode_create(root->d_inode, root, 0);
        if (ret < 0)
-                printk(KERN_ERR "CacheFiles:"
+                pr_err("Security denies permission to create files: error %d",
-                       " Security denies permission to create files: error %d",
                       ret);
        return ret;
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index 12b0eef84183..1ad51ffbb275 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -51,7 +51,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
        }
        if (ret != -EEXIST) {
-                kerror("Can't set xattr on %*.*s [%lu] (err %d)",
+                pr_err("Can't set xattr on %*.*s [%lu] (err %d)",
                       dentry->d_name.len, dentry->d_name.len,
                       dentry->d_name.name, dentry->d_inode->i_ino,
                       -ret);
@@ -64,7 +64,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
                if (ret == -ERANGE)
                        goto bad_type_length;
-                kerror("Can't read xattr on %*.*s [%lu] (err %d)",
+                pr_err("Can't read xattr on %*.*s [%lu] (err %d)",
                       dentry->d_name.len, dentry->d_name.len,
                       dentry->d_name.name, dentry->d_inode->i_ino,
                       -ret);
@@ -85,14 +85,14 @@ error:
        return ret;
 bad_type_length:
-        kerror("Cache object %lu type xattr length incorrect",
+        pr_err("Cache object %lu type xattr length incorrect",
               dentry->d_inode->i_ino);
        ret = -EIO;
        goto error;
 bad_type:
        xtype[2] = 0;
-        kerror("Cache object %*.*s [%lu] type %s not %s",
+        pr_err("Cache object %*.*s [%lu] type %s not %s",
               dentry->d_name.len, dentry->d_name.len,
               dentry->d_name.name, dentry->d_inode->i_ino,
               xtype, type);
@@ -293,7 +293,7 @@ error:
        return ret;
 bad_type_length:
-        kerror("Cache object %lu xattr length incorrect",
+        pr_err("Cache object %lu xattr length incorrect",
               dentry->d_inode->i_ino);
        ret = -EIO;
        goto error;
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index b53278c9fd97..65a30e817dd8 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -694,7 +694,7 @@ static int ceph_writepages_start(struct address_space *mapping,
             (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD"));
        if (fsc->mount_state == CEPH_MOUNT_SHUTDOWN) {
-                pr_warning("writepage_start %p on forced umount\n", inode);
+                pr_warn("writepage_start %p on forced umount\n", inode);
                return -EIO; /* we're in a forced umount, don't write! */
        }
        if (fsc->mount_options->wsize && fsc->mount_options->wsize < wsize)
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 16b54aa31f08..5a743ac141ab 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -71,9 +71,9 @@ static int mdsc_show(struct seq_file *s, void *p)
                seq_printf(s, "%s", ceph_mds_op_name(req->r_op));
                if (req->r_got_unsafe)
-                        seq_printf(s, "\t(unsafe)");
+                        seq_puts(s, "\t(unsafe)");
                else
-                        seq_printf(s, "\t");
+                        seq_puts(s, "\t");
                if (req->r_inode) {
                        seq_printf(s, " #%llx", ceph_ino(req->r_inode));
@@ -119,7 +119,7 @@ static int mdsc_show(struct seq_file *s, void *p)
                                seq_printf(s, " %s", req->r_path2);
                }
-                seq_printf(s, "\n");
+                seq_puts(s, "\n");
        }
        mutex_unlock(&mdsc->mutex);
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 233c6f96910a..e4fff9ff1c27 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -821,7 +821,7 @@ no_change:
                        spin_unlock(&ci->i_ceph_lock);
                }
        } else if (cap_fmode >= 0) {
-                pr_warning("mds issued no caps on %llx.%llx\n",
+                pr_warn("mds issued no caps on %llx.%llx\n",
                           ceph_vinop(inode));
                __ceph_get_fmode(ci, cap_fmode);
        }
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 2b4d093d0563..9a33b98cb000 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -2218,13 +2218,13 @@ static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
        /* dup? */
        if ((req->r_got_unsafe && !head->safe) ||
            (req->r_got_safe && head->safe)) {
-                pr_warning("got a dup %s reply on %llu from mds%d\n",
+                pr_warn("got a dup %s reply on %llu from mds%d\n",
                           head->safe ? "safe" : "unsafe", tid, mds);
                mutex_unlock(&mdsc->mutex);
                goto out;
        }
        if (req->r_got_safe && !head->safe) {
-                pr_warning("got unsafe after safe on %llu from mds%d\n",
+                pr_warn("got unsafe after safe on %llu from mds%d\n",
                           tid, mds);
                mutex_unlock(&mdsc->mutex);
                goto out;
@@ -3525,7 +3525,7 @@ static void peer_reset(struct ceph_connection *con)
        struct ceph_mds_session *s = con->private;
        struct ceph_mds_client *mdsc = s->s_mdsc;
-        pr_warning("mds%d closed our session\n", s->s_mds);
+        pr_warn("mds%d closed our session\n", s->s_mds);
        send_mds_reconnect(mdsc, s);
 }
diff --git a/fs/ceph/mdsmap.c b/fs/ceph/mdsmap.c
index 132b64eeecd4..261531e55e9d 100644
--- a/fs/ceph/mdsmap.c
+++ b/fs/ceph/mdsmap.c
@@ -62,7 +62,7 @@ struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end)
        ceph_decode_16_safe(p, end, version, bad);
        if (version > 3) {
-                pr_warning("got mdsmap version %d > 3, failing", version);
+                pr_warn("got mdsmap version %d > 3, failing", version);
                goto bad;
        }
diff --git a/fs/coda/cnode.c b/fs/coda/cnode.c
index 911cf30d057d..7740b1c871c1 100644
--- a/fs/coda/cnode.c
+++ b/fs/coda/cnode.c
@@ -101,7 +101,7 @@ struct inode *coda_cnode_make(struct CodaFid *fid, struct super_block *sb)
        inode = coda_iget(sb, fid, &attr);
        if (IS_ERR(inode))
-                printk("coda_cnode_make: coda_iget failed\n");
+                pr_warn("%s: coda_iget failed\n", __func__);
        return inode;
 }
@@ -137,7 +137,7 @@ struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb)
        unsigned long hash = coda_f2i(fid);
        if ( !sb ) {
-                printk("coda_fid_to_inode: no sb!\n");
+                pr_warn("%s: no sb!\n", __func__);
                return NULL;
        }
diff --git a/fs/coda/coda_linux.h b/fs/coda/coda_linux.h
index e7550cb9fb74..d42b725b1d21 100644
--- a/fs/coda/coda_linux.h
+++ b/fs/coda/coda_linux.h
@@ -12,6 +12,12 @@
 #ifndef _LINUX_CODA_FS
 #define _LINUX_CODA_FS
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/kernel.h>
 #include <linux/param.h>
 #include <linux/mm.h>
@@ -63,7 +69,7 @@ void coda_sysctl_clean(void);
    else \
        ptr = (cast)vzalloc((unsigned long) size); \
    if (!ptr) \
-        printk("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
+        pr_warn("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
 } while (0)
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 5efbb5ee0adc..cd8a63238b11 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -102,7 +102,7 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsig
        int type = 0;
        if (length > CODA_MAXNAMLEN) {
-                printk(KERN_ERR "name too long: lookup, %s (%*s)\n",
+                pr_err("name too long: lookup, %s (%*s)\n",
                       coda_i2s(dir), (int)length, name);
                return ERR_PTR(-ENAMETOOLONG);
        }
@@ -453,23 +453,23 @@ static int coda_venus_readdir(struct file *coda_file, struct dir_context *ctx)
                ret = kernel_read(host_file, ctx->pos - 2, (char *)vdir,
                                  sizeof(*vdir));
                if (ret < 0) {
-                        printk(KERN_ERR "coda readdir: read dir %s failed %d\n",
+                        pr_err("%s: read dir %s failed %d\n",
-                               coda_f2s(&cii->c_fid), ret);
+                               __func__, coda_f2s(&cii->c_fid), ret);
                        break;
                }
                if (ret == 0) break; /* end of directory file reached */
                /* catch truncated reads */
                if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
-                        printk(KERN_ERR "coda readdir: short read on %s\n",
+                        pr_err("%s: short read on %s\n",
-                               coda_f2s(&cii->c_fid));
+                               __func__, coda_f2s(&cii->c_fid));
                        ret = -EBADF;
                        break;
                }
                /* validate whether the directory file actually makes sense */
                if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
-                        printk(KERN_ERR "coda readdir: invalid dir %s\n",
+                        pr_err("%s: invalid dir %s\n",
-                               coda_f2s(&cii->c_fid));
+                               __func__, coda_f2s(&cii->c_fid));
                        ret = -EBADF;
                        break;
                }
@@ -589,8 +589,8 @@ int coda_revalidate_inode(struct inode *inode)
                coda_vattr_to_iattr(inode, &attr);
                if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
-                        printk("Coda: inode %ld, fid %s changed type!\n",
+                        pr_warn("inode %ld, fid %s changed type!\n",
-                               inode->i_ino, coda_f2s(&(cii->c_fid)));
+                                inode->i_ino, coda_f2s(&(cii->c_fid)));
                }
                /* the following can happen when a local fid is replaced 
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index d9c7751f10ac..fe3afb2de880 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -119,12 +119,12 @@ static int get_device_index(struct coda_mount_data *data)
        int idx;
        if (data == NULL) {
-                printk("coda_read_super: Bad mount data\n");
+                pr_warn("%s: Bad mount data\n", __func__);
                return -1;
        }
        if (data->version != CODA_MOUNT_VERSION) {
-                printk("coda_read_super: Bad mount version\n");
+                pr_warn("%s: Bad mount version\n", __func__);
                return -1;
        }
@@ -141,13 +141,13 @@ static int get_device_index(struct coda_mount_data *data)
        fdput(f);
        if (idx < 0 || idx >= MAX_CODADEVS) {
-                printk("coda_read_super: Bad minor number\n");
+                pr_warn("%s: Bad minor number\n", __func__);
                return -1;
        }
        return idx;
 Ebadf:
-        printk("coda_read_super: Bad file\n");
+        pr_warn("%s: Bad file\n", __func__);
        return -1;
 }
@@ -168,19 +168,19 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        if(idx == -1)
                idx = 0;
        
-        printk(KERN_INFO "coda_read_super: device index: %i\n", idx);
+        pr_info("%s: device index: %i\n", __func__,  idx);
        vc = &coda_comms[idx];
        mutex_lock(&vc->vc_mutex);
        if (!vc->vc_inuse) {
-                printk("coda_read_super: No pseudo device\n");
+                pr_warn("%s: No pseudo device\n", __func__);
                error = -EINVAL;
                goto unlock_out;
        }
        if (vc->vc_sb) {
-                printk("coda_read_super: Device already mounted\n");
+                pr_warn("%s: Device already mounted\n", __func__);
                error = -EBUSY;
                goto unlock_out;
        }
@@ -204,22 +204,23 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        /* get root fid from Venus: this needs the root inode */
        error = venus_rootfid(sb, &fid);
        if ( error ) {
-                printk("coda_read_super: coda_get_rootfid failed with %d\n",
+                pr_warn("%s: coda_get_rootfid failed with %d\n",
-                       error);
+                        __func__, error);
                goto error;
        }
-        printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid));
+        pr_info("%s: rootfid is %s\n", __func__, coda_f2s(&fid));
        
        /* make root inode */
        root = coda_cnode_make(&fid, sb);
        if (IS_ERR(root)) {
                error = PTR_ERR(root);
-                printk("Failure of coda_cnode_make for root: error %d\n", error);
+                pr_warn("Failure of coda_cnode_make for root: error %d\n",
+                        error);
                goto error;
        } 
-        printk("coda_read_super: rootinode is %ld dev %s\n", 
+        pr_info("%s: rootinode is %ld dev %s\n",
-               root->i_ino, root->i_sb->s_id);
+                __func__, root->i_ino, root->i_sb->s_id);
        sb->s_root = d_make_root(root);
        if (!sb->s_root) {
                error = -EINVAL;
@@ -246,7 +247,7 @@ static void coda_put_super(struct super_block *sb)
        sb->s_fs_info = NULL;
        mutex_unlock(&vcp->vc_mutex);
-        printk("Coda: Bye bye.\n");
+        pr_info("Bye bye.\n");
 }
 static void coda_evict_inode(struct inode *inode)
diff --git a/fs/coda/psdev.c b/fs/coda/psdev.c
index ebc2bae6c289..5c1e4242368b 100644
--- a/fs/coda/psdev.c
+++ b/fs/coda/psdev.c
@@ -114,14 +114,14 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                int size = sizeof(*dcbuf);
                if  ( nbytes < sizeof(struct coda_out_hdr) ) {
-                        printk("coda_downcall opc %d uniq %d, not enough!\n",
+                        pr_warn("coda_downcall opc %d uniq %d, not enough!\n",
-                               hdr.opcode, hdr.unique);
+                                hdr.opcode, hdr.unique);
                        count = nbytes;
                        goto out;
                }
                if ( nbytes > size ) {
-                        printk("Coda: downcall opc %d, uniq %d, too much!",
+                        pr_warn("downcall opc %d, uniq %d, too much!",
-                               hdr.opcode, hdr.unique);
+                                hdr.opcode, hdr.unique);
                        nbytes = size;
                }
                CODA_ALLOC(dcbuf, union outputArgs *, nbytes);
@@ -136,7 +136,8 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                CODA_FREE(dcbuf, nbytes);
                if (error) {
-                        printk("psdev_write: coda_downcall error: %d\n", error);
+                        pr_warn("%s: coda_downcall error: %d\n",
+                                __func__, error);
                        retval = error;
                        goto out;
                }
@@ -157,16 +158,17 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
        mutex_unlock(&vcp->vc_mutex);
        if (!req) {
-                printk("psdev_write: msg (%d, %d) not found\n", 
+                pr_warn("%s: msg (%d, %d) not found\n",
-                        hdr.opcode, hdr.unique);
+                        __func__, hdr.opcode, hdr.unique);
                retval = -ESRCH;
                goto out;
        }
        /* move data into response buffer. */
        if (req->uc_outSize < nbytes) {
-                printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
+                pr_warn("%s: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
-                       req->uc_outSize, (long)nbytes, hdr.opcode, hdr.unique);
+                        __func__, req->uc_outSize, (long)nbytes,
+                        hdr.opcode, hdr.unique);
                nbytes = req->uc_outSize; /* don't have more space! */
        }
        if (copy_from_user(req->uc_data, buf, nbytes)) {
@@ -240,8 +242,8 @@ static ssize_t coda_psdev_read(struct file * file, char __user * buf,
        /* Move the input args into userspace */
        count = req->uc_inSize;
        if (nbytes < req->uc_inSize) {
-                printk ("psdev_read: Venus read %ld bytes of %d in message\n",
+                pr_warn("%s: Venus read %ld bytes of %d in message\n",
-                        (long)nbytes, req->uc_inSize);
+                        __func__, (long)nbytes, req->uc_inSize);
                count = nbytes;
        }
@@ -305,7 +307,7 @@ static int coda_psdev_release(struct inode * inode, struct file * file)
        struct upc_req *req, *tmp;
        if (!vcp || !vcp->vc_inuse ) {
-                printk("psdev_release: Not open.\n");
+                pr_warn("%s: Not open.\n", __func__);
                return -1;
        }
@@ -354,8 +356,8 @@ static int init_coda_psdev(void)
 {
        int i, err = 0;
        if (register_chrdev(CODA_PSDEV_MAJOR, "coda", &coda_psdev_fops)) {
-              printk(KERN_ERR "coda_psdev: unable to get major %d\n", 
+                pr_err("%s: unable to get major %d\n",
-                     CODA_PSDEV_MAJOR);
+                       __func__, CODA_PSDEV_MAJOR);
              return -EIO;
        }
        coda_psdev_class = class_create(THIS_MODULE, "coda");
@@ -393,13 +395,13 @@ static int __init init_coda(void)
                goto out2;
        status = init_coda_psdev();
        if ( status ) {
-                printk("Problem (%d) in init_coda_psdev\n", status);
+                pr_warn("Problem (%d) in init_coda_psdev\n", status);
                goto out1;
        }
        
        status = register_filesystem(&coda_fs_type);
        if (status) {
-                printk("coda: failed to register filesystem!\n");
+                pr_warn("failed to register filesystem!\n");
                goto out;
        }
        return 0;
@@ -420,9 +422,8 @@ static void __exit exit_coda(void)
        int err, i;
        err = unregister_filesystem(&coda_fs_type);
-        if ( err != 0 ) {
+        if (err != 0)
-                printk("coda: failed to unregister filesystem\n");
+                pr_warn("failed to unregister filesystem\n");
-        }
        for (i = 0; i < MAX_CODADEVS; i++)
                device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));
        class_destroy(coda_psdev_class);
diff --git a/fs/coda/sysctl.c b/fs/coda/sysctl.c
index af56ad56a89a..34218a8a28cd 100644
--- a/fs/coda/sysctl.c
+++ b/fs/coda/sysctl.c
@@ -14,7 +14,7 @@
 #ifdef CONFIG_SYSCTL
 static struct ctl_table_header *fs_table_header;
-static ctl_table coda_table[] = {
+static struct ctl_table coda_table[] = {
        {
                .procname       = "timeout",
                .data           = &coda_timeout,
@@ -39,7 +39,7 @@ static ctl_table coda_table[] = {
        {}
 };
-static ctl_table fs_table[] = {
+static struct ctl_table fs_table[] = {
        {
                .procname       = "coda",
                .mode           = 0555,
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 3a731976dc5e..21fcf8dcb9cd 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -508,8 +508,8 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
        inp->coda_ioctl.data = (char *)(INSIZE(ioctl));
     
        /* get the data out of user space */
-        if ( copy_from_user((char*)inp + (long)inp->coda_ioctl.data,
+        if (copy_from_user((char *)inp + (long)inp->coda_ioctl.data,
-                            data->vi.in, data->vi.in_size) ) {
+                           data->vi.in, data->vi.in_size)) {
                error = -EINVAL;
                goto exit;
        }
@@ -518,8 +518,8 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
                            &outsize, inp);
        if (error) {
-                printk("coda_pioctl: Venus returns: %d for %s\n", 
+                pr_warn("%s: Venus returns: %d for %s\n",
-                       error, coda_f2s(fid));
+                        __func__, error, coda_f2s(fid));
                goto exit; 
        }
@@ -675,7 +675,7 @@ static int coda_upcall(struct venus_comm *vcp,
        mutex_lock(&vcp->vc_mutex);
        if (!vcp->vc_inuse) {
-                printk(KERN_NOTICE "coda: Venus dead, not sending upcall\n");
+                pr_notice("Venus dead, not sending upcall\n");
                error = -ENXIO;
                goto exit;
        }
@@ -725,7 +725,7 @@ static int coda_upcall(struct venus_comm *vcp,
        error = -EINTR;
        if ((req->uc_flags & CODA_REQ_ABORT) || !signal_pending(current)) {
-                printk(KERN_WARNING "coda: Unexpected interruption.\n");
+                pr_warn("Unexpected interruption.\n");
                goto exit;
        }
@@ -735,7 +735,7 @@ static int coda_upcall(struct venus_comm *vcp,
        /* Venus saw the upcall, make sure we can send interrupt signal */
        if (!vcp->vc_inuse) {
-                printk(KERN_INFO "coda: Venus dead, not sending signal.\n");
+                pr_info("Venus dead, not sending signal.\n");
                goto exit;
        }
diff --git a/fs/dcache.c b/fs/dcache.c
index be2bea834bf4..1792d6075b4f 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -150,7 +150,7 @@ static long get_nr_dentry_unused(void)
        return sum < 0 ? 0 : sum;
 }
-int proc_nr_dentry(ctl_table *table, int write, void __user *buffer,
+int proc_nr_dentry(struct ctl_table *table, int write, void __user *buffer,
                   size_t *lenp, loff_t *ppos)
 {
        dentry_stat.nr_dentry = get_nr_dentry();
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index c71038079b47..cfe8466f7fef 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -10,6 +10,8 @@
 *
 * ------------------------------------------------------------------------- */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/fs.h>
@@ -148,10 +150,10 @@ static inline struct super_block *pts_sb_from_inode(struct inode *inode)
 /*
 * parse_mount_options():
- *      Set @opts to mount options specified in @data. If an option is not
+ *      Set @opts to mount options specified in @data. If an option is not
- *      specified in @data, set it to its default value. The exception is
+ *      specified in @data, set it to its default value. The exception is
- *      'newinstance' option which can only be set/cleared on a mount (i.e.
+ *      'newinstance' option which can only be set/cleared on a mount (i.e.
- *      cannot be changed during remount).
+ *      cannot be changed during remount).
 *
 * Note: @data may be NULL (in which case all options are set to default).
 */
@@ -225,7 +227,7 @@ static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
                        break;
 #endif
                default:
-                        printk(KERN_ERR "devpts: called with bogus options\n");
+                        pr_err("called with bogus options\n");
                        return -EINVAL;
                }
        }
@@ -261,7 +263,7 @@ static int mknod_ptmx(struct super_block *sb)
        dentry = d_alloc_name(root, "ptmx");
        if (!dentry) {
-                printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
+                pr_err("Unable to alloc dentry for ptmx node\n");
                goto out;
        }
@@ -270,7 +272,7 @@ static int mknod_ptmx(struct super_block *sb)
         */
        inode = new_inode(sb);
        if (!inode) {
-                printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
+                pr_err("Unable to alloc inode for ptmx node\n");
                dput(dentry);
                goto out;
        }
@@ -303,7 +305,7 @@ static void update_ptmx_mode(struct pts_fs_info *fsi)
 #else
 static inline void update_ptmx_mode(struct pts_fs_info *fsi)
 {
-       return;
+        return;
 }
 #endif
@@ -333,9 +335,11 @@ static int devpts_show_options(struct seq_file *seq, struct dentry *root)
        struct pts_mount_opts *opts = &fsi->mount_opts;
        if (opts->setuid)
-                seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, opts->uid));
+                seq_printf(seq, ",uid=%u",
+                           from_kuid_munged(&init_user_ns, opts->uid));
        if (opts->setgid)
-                seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, opts->gid));
+                seq_printf(seq, ",gid=%u",
+                           from_kgid_munged(&init_user_ns, opts->gid));
        seq_printf(seq, ",mode=%03o", opts->mode);
 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
        seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
@@ -396,7 +400,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
        if (s->s_root)
                return 0;
-        printk(KERN_ERR "devpts: get root dentry failed\n");
+        pr_err("get root dentry failed\n");
 fail:
        return -ENOMEM;
diff --git a/fs/dlm/config.c b/fs/dlm/config.c
index 76feb4b60fa6..d521bddf876d 100644
--- a/fs/dlm/config.c
+++ b/fs/dlm/config.c
@@ -157,11 +157,13 @@ static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,
                           const char *buf, size_t len)
 {
        unsigned int x;
+        int rc;
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
+        rc = kstrtouint(buf, 0, &x);
-        x = simple_strtoul(buf, NULL, 0);
+        if (rc)
+                return rc;
        if (check_zero && !x)
                return -EINVAL;
@@ -730,7 +732,10 @@ static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf)
 static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf,
                                 size_t len)
 {
-        cm->nodeid = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &cm->nodeid);
+        if (rc)
+                return rc;
        return len;
 }
@@ -742,7 +747,10 @@ static ssize_t comm_local_read(struct dlm_comm *cm, char *buf)
 static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf,
                                size_t len)
 {
-        cm->local= simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &cm->local);
+        if (rc)
+                return rc;
        if (cm->local && !local_comm)
                local_comm = cm;
        return len;
@@ -846,7 +854,10 @@ static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf,
                                 size_t len)
 {
        uint32_t seq = 0;
-        nd->nodeid = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &nd->nodeid);
+        if (rc)
+                return rc;
        dlm_comm_seq(nd->nodeid, &seq);
        nd->comm_seq = seq;
        return len;
@@ -860,7 +871,10 @@ static ssize_t node_weight_read(struct dlm_node *nd, char *buf)
 static ssize_t node_weight_write(struct dlm_node *nd, const char *buf,
                                 size_t len)
 {
-        nd->weight = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &nd->weight);
+        if (rc)
+                return rc;
        return len;
 }
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index b969deef9ebb..8d77ba7b1756 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -68,7 +68,7 @@ static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
        if (lkb->lkb_wait_type)
                seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
-        return seq_printf(s, "\n");
+        return seq_puts(s, "\n");
 }
 static int print_format1(struct dlm_rsb *res, struct seq_file *s)
@@ -92,31 +92,31 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
        }
        if (res->res_nodeid > 0)
-                rv = seq_printf(s, "\"  \nLocal Copy, Master is node %d\n",
+                rv = seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
                                res->res_nodeid);
        else if (res->res_nodeid == 0)
-                rv = seq_printf(s, "\"  \nMaster Copy\n");
+                rv = seq_puts(s, "\"\nMaster Copy\n");
        else if (res->res_nodeid == -1)
-                rv = seq_printf(s, "\"  \nLooking up master (lkid %x)\n",
+                rv = seq_printf(s, "\"\nLooking up master (lkid %x)\n",
                                res->res_first_lkid);
        else
-                rv = seq_printf(s, "\"  \nInvalid master %d\n",
+                rv = seq_printf(s, "\"\nInvalid master %d\n",
                                res->res_nodeid);
        if (rv)
                goto out;
        /* Print the LVB: */
        if (res->res_lvbptr) {
-                seq_printf(s, "LVB: ");
+                seq_puts(s, "LVB: ");
                for (i = 0; i < lvblen; i++) {
                        if (i == lvblen / 2)
-                                seq_printf(s, "\n     ");
+                                seq_puts(s, "\n     ");
                        seq_printf(s, "%02x ",
                                   (unsigned char) res->res_lvbptr[i]);
                }
                if (rsb_flag(res, RSB_VALNOTVALID))
-                        seq_printf(s, " (INVALID)");
+                        seq_puts(s, " (INVALID)");
-                rv = seq_printf(s, "\n");
+                rv = seq_puts(s, "\n");
                if (rv)
                        goto out;
        }
@@ -133,21 +133,21 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
        }
        /* Print the locks attached to this resource */
-        seq_printf(s, "Granted Queue\n");
+        seq_puts(s, "Granted Queue\n");
        list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
                rv = print_format1_lock(s, lkb, res);
                if (rv)
                        goto out;
        }
-        seq_printf(s, "Conversion Queue\n");
+        seq_puts(s, "Conversion Queue\n");
        list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
                rv = print_format1_lock(s, lkb, res);
                if (rv)
                        goto out;
        }
-        seq_printf(s, "Waiting Queue\n");
+        seq_puts(s, "Waiting Queue\n");
        list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
                rv = print_format1_lock(s, lkb, res);
                if (rv)
@@ -157,13 +157,13 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
        if (list_empty(&res->res_lookup))
                goto out;
-        seq_printf(s, "Lookup Queue\n");
+        seq_puts(s, "Lookup Queue\n");
        list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
                rv = seq_printf(s, "%08x %s", lkb->lkb_id,
                                print_lockmode(lkb->lkb_rqmode));
                if (lkb->lkb_wait_type)
                        seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
-                rv = seq_printf(s, "\n");
+                rv = seq_puts(s, "\n");
        }
 out:
        unlock_rsb(res);
@@ -300,7 +300,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                else
                        seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
        }
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
        if (rv)
                goto out;
@@ -311,7 +311,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
        for (i = 0; i < lvblen; i++)
                seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
        if (rv)
                goto out;
@@ -377,7 +377,7 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
                else
                        seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
        }
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
 out:
        unlock_rsb(r);
        return rv;
diff --git a/fs/dlm/lockspace.c b/fs/dlm/lockspace.c
index 04d6398c1f1c..f3e72787e7f9 100644
--- a/fs/dlm/lockspace.c
+++ b/fs/dlm/lockspace.c
@@ -35,8 +35,11 @@ static struct task_struct *	scand_task;
 static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
        ssize_t ret = len;
-        int n = simple_strtol(buf, NULL, 0);
+        int n;
+        int rc = kstrtoint(buf, 0, &n);
+        if (rc)
+                return rc;
        ls = dlm_find_lockspace_local(ls->ls_local_handle);
        if (!ls)
                return -EINVAL;
@@ -57,7 +60,10 @@ static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len)
 static ssize_t dlm_event_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        ls->ls_uevent_result = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &ls->ls_uevent_result);
+        if (rc)
+                return rc;
        set_bit(LSFL_UEVENT_WAIT, &ls->ls_flags);
        wake_up(&ls->ls_uevent_wait);
        return len;
@@ -70,7 +76,10 @@ static ssize_t dlm_id_show(struct dlm_ls *ls, char *buf)
 static ssize_t dlm_id_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        ls->ls_global_id = simple_strtoul(buf, NULL, 0);
+        int rc = kstrtouint(buf, 0, &ls->ls_global_id);
+        if (rc)
+                return rc;
        return len;
 }
@@ -81,7 +90,11 @@ static ssize_t dlm_nodir_show(struct dlm_ls *ls, char *buf)
 static ssize_t dlm_nodir_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        int val = simple_strtoul(buf, NULL, 0);
+        int val;
+        int rc = kstrtoint(buf, 0, &val);
+        if (rc)
+                return rc;
        if (val == 1)
                set_bit(LSFL_NODIR, &ls->ls_flags);
        return len;
diff --git a/fs/drop_caches.c b/fs/drop_caches.c
index 9280202e488c..1de7294aad20 100644
--- a/fs/drop_caches.c
+++ b/fs/drop_caches.c
@@ -50,7 +50,7 @@ static void drop_slab(void)
        } while (nr_objects > 10);
 }
-int drop_caches_sysctl_handler(ctl_table *table, int write,
+int drop_caches_sysctl_handler(struct ctl_table *table, int write,
        void __user *buffer, size_t *length, loff_t *ppos)
 {
        int ret;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index af903128891c..b73e0621ce9e 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -293,7 +293,7 @@ static LIST_HEAD(tfile_check_list);
 static long zero;
 static long long_max = LONG_MAX;
-ctl_table epoll_table[] = {
+struct ctl_table epoll_table[] = {
        {
                .procname       = "max_user_watches",
                .data           = &max_user_watches,
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index 7c31f4bc74a9..e0c4ba39a377 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -52,7 +52,8 @@ struct fat_mount_options {
                 usefree:1,        /* Use free_clusters for FAT32 */
                 tz_set:1,         /* Filesystem timestamps' offset set */
                 rodir:1,          /* allow ATTR_RO for directory */
-                 discard:1;        /* Issue discard requests on deletions */
+                 discard:1,        /* Issue discard requests on deletions */
+                 dos1xfloppy:1;    /* Assume default BPB for DOS 1.x floppies */
 };
 #define FAT_HASH_BITS   8
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index b3361fe2bcb5..9c83594d7fb5 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -35,9 +35,71 @@
 #define CONFIG_FAT_DEFAULT_IOCHARSET    ""
 #endif
+#define KB_IN_SECTORS 2
+/*
+ * A deserialized copy of the on-disk structure laid out in struct
+ * fat_boot_sector.
+ */
+struct fat_bios_param_block {
+        u16     fat_sector_size;
+        u8      fat_sec_per_clus;
+        u16     fat_reserved;
+        u8      fat_fats;
+        u16     fat_dir_entries;
+        u16     fat_sectors;
+        u16     fat_fat_length;
+        u32     fat_total_sect;
+        u8      fat16_state;
+        u32     fat16_vol_id;
+        u32     fat32_length;
+        u32     fat32_root_cluster;
+        u16     fat32_info_sector;
+        u8      fat32_state;
+        u32     fat32_vol_id;
+};
 static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
 static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
+static struct fat_floppy_defaults {
+        unsigned nr_sectors;
+        unsigned sec_per_clus;
+        unsigned dir_entries;
+        unsigned media;
+        unsigned fat_length;
+} floppy_defaults[] = {
+{
+        .nr_sectors = 160 * KB_IN_SECTORS,
+        .sec_per_clus = 1,
+        .dir_entries = 64,
+        .media = 0xFE,
+        .fat_length = 1,
+},
+{
+        .nr_sectors = 180 * KB_IN_SECTORS,
+        .sec_per_clus = 1,
+        .dir_entries = 64,
+        .media = 0xFC,
+        .fat_length = 2,
+},
+{
+        .nr_sectors = 320 * KB_IN_SECTORS,
+        .sec_per_clus = 2,
+        .dir_entries = 112,
+        .media = 0xFF,
+        .fat_length = 1,
+},
+{
+        .nr_sectors = 360 * KB_IN_SECTORS,
+        .sec_per_clus = 2,
+        .dir_entries = 112,
+        .media = 0xFD,
+        .fat_length = 2,
+},
+};
 static int fat_add_cluster(struct inode *inode)
 {
@@ -359,7 +421,7 @@ struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
 static int is_exec(unsigned char *extension)
 {
-        unsigned char *exe_extensions = "EXECOMBAT", *walk;
+        unsigned char exe_extensions[] = "EXECOMBAT", *walk;
        for (walk = exe_extensions; *walk; walk += 3)
                if (!strncmp(extension, walk, 3))
@@ -853,6 +915,8 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
                seq_puts(m, ",nfs=stale_rw");
        if (opts->discard)
                seq_puts(m, ",discard");
+        if (opts->dos1xfloppy)
+                seq_puts(m, ",dos1xfloppy");
        return 0;
 }
@@ -867,7 +931,7 @@ enum {
        Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
        Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
        Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
-        Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err,
+        Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err, Opt_dos1xfloppy,
 };
 static const match_table_t fat_tokens = {
@@ -900,6 +964,7 @@ static const match_table_t fat_tokens = {
        {Opt_nfs_stale_rw, "nfs"},
        {Opt_nfs_stale_rw, "nfs=stale_rw"},
        {Opt_nfs_nostale_ro, "nfs=nostale_ro"},
+        {Opt_dos1xfloppy, "dos1xfloppy"},
        {Opt_obsolete, "conv=binary"},
        {Opt_obsolete, "conv=text"},
        {Opt_obsolete, "conv=auto"},
@@ -1102,6 +1167,9 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
                case Opt_nfs_nostale_ro:
                        opts->nfs = FAT_NFS_NOSTALE_RO;
                        break;
+                case Opt_dos1xfloppy:
+                        opts->dos1xfloppy = 1;
+                        break;
                /* msdos specific */
                case Opt_dots:
@@ -1247,6 +1315,169 @@ static unsigned long calc_fat_clusters(struct super_block *sb)
        return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
 }
+static bool fat_bpb_is_zero(struct fat_boot_sector *b)
+{
+        if (get_unaligned_le16(&b->sector_size))
+                return false;
+        if (b->sec_per_clus)
+                return false;
+        if (b->reserved)
+                return false;
+        if (b->fats)
+                return false;
+        if (get_unaligned_le16(&b->dir_entries))
+                return false;
+        if (get_unaligned_le16(&b->sectors))
+                return false;
+        if (b->media)
+                return false;
+        if (b->fat_length)
+                return false;
+        if (b->secs_track)
+                return false;
+        if (b->heads)
+                return false;
+        return true;
+}
+static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b,
+        int silent, struct fat_bios_param_block *bpb)
+{
+        int error = -EINVAL;
+        /* Read in BPB ... */
+        memset(bpb, 0, sizeof(*bpb));
+        bpb->fat_sector_size = get_unaligned_le16(&b->sector_size);
+        bpb->fat_sec_per_clus = b->sec_per_clus;
+        bpb->fat_reserved = le16_to_cpu(b->reserved);
+        bpb->fat_fats = b->fats;
+        bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries);
+        bpb->fat_sectors = get_unaligned_le16(&b->sectors);
+        bpb->fat_fat_length = le16_to_cpu(b->fat_length);
+        bpb->fat_total_sect = le32_to_cpu(b->total_sect);
+        bpb->fat16_state = b->fat16.state;
+        bpb->fat16_vol_id = get_unaligned_le32(b->fat16.vol_id);
+        bpb->fat32_length = le32_to_cpu(b->fat32.length);
+        bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster);
+        bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector);
+        bpb->fat32_state = b->fat32.state;
+        bpb->fat32_vol_id = get_unaligned_le32(b->fat32.vol_id);
+        /* Validate this looks like a FAT filesystem BPB */
+        if (!bpb->fat_reserved) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "bogus number of reserved sectors");
+                goto out;
+        }
+        if (!bpb->fat_fats) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
+                goto out;
+        }
+        /*
+         * Earlier we checked here that b->secs_track and b->head are nonzero,
+         * but it turns out valid FAT filesystems can have zero there.
+         */
+        if (!fat_valid_media(b->media)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
+                                (unsigned)b->media);
+                goto out;
+        }
+        if (!is_power_of_2(bpb->fat_sector_size)
+            || (bpb->fat_sector_size < 512)
+            || (bpb->fat_sector_size > 4096)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
+                               (unsigned)bpb->fat_sector_size);
+                goto out;
+        }
+        if (!is_power_of_2(bpb->fat_sec_per_clus)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
+                                (unsigned)bpb->fat_sec_per_clus);
+                goto out;
+        }
+        error = 0;
+out:
+        return error;
+}
+static int fat_read_static_bpb(struct super_block *sb,
+        struct fat_boot_sector *b, int silent,
+        struct fat_bios_param_block *bpb)
+{
+        static const char *notdos1x = "This doesn't look like a DOS 1.x volume";
+        struct fat_floppy_defaults *fdefaults = NULL;
+        int error = -EINVAL;
+        sector_t bd_sects;
+        unsigned i;
+        bd_sects = i_size_read(sb->s_bdev->bd_inode) / SECTOR_SIZE;
+        /* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */
+        if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "%s; no bootstrapping code", notdos1x);
+                goto out;
+        }
+        /*
+         * If any value in this region is non-zero, it isn't archaic
+         * DOS.
+         */
+        if (!fat_bpb_is_zero(b)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "%s; DOS 2.x BPB is non-zero", notdos1x);
+                goto out;
+        }
+        for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) {
+                if (floppy_defaults[i].nr_sectors == bd_sects) {
+                        fdefaults = &floppy_defaults[i];
+                        break;
+                }
+        }
+        if (fdefaults == NULL) {
+                if (!silent)
+                        fat_msg(sb, KERN_WARNING,
+                                "This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)",
+                                (u64)bd_sects);
+                goto out;
+        }
+        if (!silent)
+                fat_msg(sb, KERN_INFO,
+                        "This looks like a DOS 1.x volume; assuming default BPB values");
+        memset(bpb, 0, sizeof(*bpb));
+        bpb->fat_sector_size = SECTOR_SIZE;
+        bpb->fat_sec_per_clus = fdefaults->sec_per_clus;
+        bpb->fat_reserved = 1;
+        bpb->fat_fats = 2;
+        bpb->fat_dir_entries = fdefaults->dir_entries;
+        bpb->fat_sectors = fdefaults->nr_sectors;
+        bpb->fat_fat_length = fdefaults->fat_length;
+        error = 0;
+out:
+        return error;
+}
 /*
 * Read the super block of an MS-DOS FS.
 */
@@ -1256,12 +1487,11 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        struct inode *root_inode = NULL, *fat_inode = NULL;
        struct inode *fsinfo_inode = NULL;
        struct buffer_head *bh;
-        struct fat_boot_sector *b;
+        struct fat_bios_param_block bpb;
        struct msdos_sb_info *sbi;
        u16 logical_sector_size;
        u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
        int debug;
-        unsigned int media;
        long error;
        char buf[50];
@@ -1298,100 +1528,72 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                goto out_fail;
        }
-        b = (struct fat_boot_sector *) bh->b_data;
+        error = fat_read_bpb(sb, (struct fat_boot_sector *)bh->b_data, silent,
-        if (!b->reserved) {
+                &bpb);
-                if (!silent)
+        if (error == -EINVAL && sbi->options.dos1xfloppy)
-                        fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");
+                error = fat_read_static_bpb(sb,
-                brelse(bh);
+                        (struct fat_boot_sector *)bh->b_data, silent, &bpb);
-                goto out_invalid;
+        brelse(bh);
-        }
-        if (!b->fats) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
-                brelse(bh);
-                goto out_invalid;
-        }
-        /*
-         * Earlier we checked here that b->secs_track and b->head are nonzero,
-         * but it turns out valid FAT filesystems can have zero there.
-         */
-        media = b->media;
+        if (error == -EINVAL)
-        if (!fat_valid_media(media)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
-                               media);
-                brelse(bh);
-                goto out_invalid;
-        }
-        logical_sector_size = get_unaligned_le16(&b->sector_size);
-        if (!is_power_of_2(logical_sector_size)
-            || (logical_sector_size < 512)
-            || (logical_sector_size > 4096)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
-                               logical_sector_size);
-                brelse(bh);
-                goto out_invalid;
-        }
-        sbi->sec_per_clus = b->sec_per_clus;
-        if (!is_power_of_2(sbi->sec_per_clus)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
-                               sbi->sec_per_clus);
-                brelse(bh);
                goto out_invalid;
-        }
+        else if (error)
+                goto out_fail;
+        logical_sector_size = bpb.fat_sector_size;
+        sbi->sec_per_clus = bpb.fat_sec_per_clus;
+        error = -EIO;
        if (logical_sector_size < sb->s_blocksize) {
                fat_msg(sb, KERN_ERR, "logical sector size too small for device"
                       " (logical sector size = %u)", logical_sector_size);
-                brelse(bh);
                goto out_fail;
        }
        if (logical_sector_size > sb->s_blocksize) {
-                brelse(bh);
+                struct buffer_head *bh_resize;
                if (!sb_set_blocksize(sb, logical_sector_size)) {
                        fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
                               logical_sector_size);
                        goto out_fail;
                }
-                bh = sb_bread(sb, 0);
-                if (bh == NULL) {
+                /* Verify that the larger boot sector is fully readable */
+                bh_resize = sb_bread(sb, 0);
+                if (bh_resize == NULL) {
                        fat_msg(sb, KERN_ERR, "unable to read boot sector"
                               " (logical sector size = %lu)",
                               sb->s_blocksize);
                        goto out_fail;
                }
-                b = (struct fat_boot_sector *) bh->b_data;
+                brelse(bh_resize);
        }
        mutex_init(&sbi->s_lock);
        sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
        sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
-        sbi->fats = b->fats;
+        sbi->fats = bpb.fat_fats;
        sbi->fat_bits = 0;              /* Don't know yet */
-        sbi->fat_start = le16_to_cpu(b->reserved);
+        sbi->fat_start = bpb.fat_reserved;
-        sbi->fat_length = le16_to_cpu(b->fat_length);
+        sbi->fat_length = bpb.fat_fat_length;
        sbi->root_cluster = 0;
        sbi->free_clusters = -1;        /* Don't know yet */
        sbi->free_clus_valid = 0;
        sbi->prev_free = FAT_START_ENT;
        sb->s_maxbytes = 0xffffffff;
-        if (!sbi->fat_length && b->fat32.length) {
+        if (!sbi->fat_length && bpb.fat32_length) {
                struct fat_boot_fsinfo *fsinfo;
                struct buffer_head *fsinfo_bh;
                /* Must be FAT32 */
                sbi->fat_bits = 32;
-                sbi->fat_length = le32_to_cpu(b->fat32.length);
+                sbi->fat_length = bpb.fat32_length;
-                sbi->root_cluster = le32_to_cpu(b->fat32.root_cluster);
+                sbi->root_cluster = bpb.fat32_root_cluster;
                /* MC - if info_sector is 0, don't multiply by 0 */
-                sbi->fsinfo_sector = le16_to_cpu(b->fat32.info_sector);
+                sbi->fsinfo_sector = bpb.fat32_info_sector;
                if (sbi->fsinfo_sector == 0)
                        sbi->fsinfo_sector = 1;
@@ -1399,7 +1601,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                if (fsinfo_bh == NULL) {
                        fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
                               " (sector = %lu)", sbi->fsinfo_sector);
-                        brelse(bh);
                        goto out_fail;
                }
@@ -1422,35 +1623,28 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        /* interpret volume ID as a little endian 32 bit integer */
        if (sbi->fat_bits == 32)
-                sbi->vol_id = (((u32)b->fat32.vol_id[0]) |
+                sbi->vol_id = bpb.fat32_vol_id;
-                                        ((u32)b->fat32.vol_id[1] << 8) |
-                                        ((u32)b->fat32.vol_id[2] << 16) |
-                                        ((u32)b->fat32.vol_id[3] << 24));
        else /* fat 16 or 12 */
-                sbi->vol_id = (((u32)b->fat16.vol_id[0]) |
+                sbi->vol_id = bpb.fat16_vol_id;
-                                        ((u32)b->fat16.vol_id[1] << 8) |
-                                        ((u32)b->fat16.vol_id[2] << 16) |
-                                        ((u32)b->fat16.vol_id[3] << 24));
        sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
        sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
        sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
-        sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
+        sbi->dir_entries = bpb.fat_dir_entries;
        if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
                if (!silent)
                        fat_msg(sb, KERN_ERR, "bogus directory-entries per block"
                               " (%u)", sbi->dir_entries);
-                brelse(bh);
                goto out_invalid;
        }
        rootdir_sectors = sbi->dir_entries
                * sizeof(struct msdos_dir_entry) / sb->s_blocksize;
        sbi->data_start = sbi->dir_start + rootdir_sectors;
-        total_sectors = get_unaligned_le16(&b->sectors);
+        total_sectors = bpb.fat_sectors;
        if (total_sectors == 0)
-                total_sectors = le32_to_cpu(b->total_sect);
+                total_sectors = bpb.fat_total_sect;
        total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;
@@ -1459,9 +1653,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
        if (sbi->fat_bits == 32)
-                sbi->dirty = b->fat32.state & FAT_STATE_DIRTY;
+                sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY;
        else /* fat 16 or 12 */
-                sbi->dirty = b->fat16.state & FAT_STATE_DIRTY;
+                sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY;
        /* check that FAT table does not overflow */
        fat_clusters = calc_fat_clusters(sb);
@@ -1470,7 +1664,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                if (!silent)
                        fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
                               total_clusters);
-                brelse(bh);
                goto out_invalid;
        }
@@ -1483,8 +1676,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        if (sbi->prev_free < FAT_START_ENT)
                sbi->prev_free = FAT_START_ENT;
-        brelse(bh);
        /* set up enough so that it can read an inode */
        fat_hash_init(sb);
        dir_hash_init(sb);
diff --git a/fs/file_table.c b/fs/file_table.c
index a374f5033e97..40bf4660f0a3 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -76,14 +76,14 @@ EXPORT_SYMBOL_GPL(get_max_files);
 * Handle nr_files sysctl
 */
 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
-int proc_nr_files(ctl_table *table, int write,
+int proc_nr_files(struct ctl_table *table, int write,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
        files_stat.nr_files = get_nr_files();
        return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
 }
 #else
-int proc_nr_files(ctl_table *table, int write,
+int proc_nr_files(struct ctl_table *table, int write,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
        return -ENOSYS;
diff --git a/fs/fscache/main.c b/fs/fscache/main.c
index acd4bf1fc277..63f868e869b9 100644
--- a/fs/fscache/main.c
+++ b/fs/fscache/main.c
@@ -67,7 +67,7 @@ static int fscache_max_active_sysctl(struct ctl_table *table, int write,
        return ret;
 }
-ctl_table fscache_sysctls[] = {
+struct ctl_table fscache_sysctls[] = {
        {
                .procname       = "object_max_active",
                .data           = &fscache_object_max_active,
@@ -87,7 +87,7 @@ ctl_table fscache_sysctls[] = {
        {}
 };
-ctl_table fscache_sysctls_root[] = {
+struct ctl_table fscache_sysctls_root[] = {
        {
                .procname       = "fscache",
                .mode           = 0555,
diff --git a/fs/hfsplus/attributes.c b/fs/hfsplus/attributes.c
index caf89a7be0a1..e5b221de7de6 100644
--- a/fs/hfsplus/attributes.c
+++ b/fs/hfsplus/attributes.c
@@ -54,14 +54,11 @@ int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
        memset(key, 0, sizeof(struct hfsplus_attr_key));
        key->attr.cnid = cpu_to_be32(cnid);
        if (name) {
-                len = strlen(name);
+                int res = hfsplus_asc2uni(sb,
-                if (len > HFSPLUS_ATTR_MAX_STRLEN) {
-                        pr_err("invalid xattr name's length\n");
-                        return -EINVAL;
-                }
-                hfsplus_asc2uni(sb,
                                (struct hfsplus_unistr *)&key->attr.key_name,
-                                HFSPLUS_ATTR_MAX_STRLEN, name, len);
+                                HFSPLUS_ATTR_MAX_STRLEN, name, strlen(name));
+                if (res)
+                        return res;
                len = be16_to_cpu(key->attr.key_name.length);
        } else {
                key->attr.key_name.length = 0;
@@ -82,31 +79,6 @@ int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
        return 0;
 }
-void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
-                                        u32 cnid,
-                                        struct hfsplus_attr_unistr *name)
-{
-        int ustrlen;
-        memset(key, 0, sizeof(struct hfsplus_attr_key));
-        ustrlen = be16_to_cpu(name->length);
-        key->attr.cnid = cpu_to_be32(cnid);
-        key->attr.key_name.length = cpu_to_be16(ustrlen);
-        ustrlen *= 2;
-        memcpy(key->attr.key_name.unicode, name->unicode, ustrlen);
-        /* The length of the key, as stored in key_len field, does not include
-         * the size of the key_len field itself.
-         * So, offsetof(hfsplus_attr_key, key_name) is a trick because
-         * it takes into consideration key_len field (__be16) of
-         * hfsplus_attr_key structure instead of length field (__be16) of
-         * hfsplus_attr_unistr structure.
-         */
-        key->key_len =
-                cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
-                                ustrlen);
-}
 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void)
 {
        return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL);
diff --git a/fs/hfsplus/bnode.c b/fs/hfsplus/bnode.c
index 11c860204520..759708fd9331 100644
--- a/fs/hfsplus/bnode.c
+++ b/fs/hfsplus/bnode.c
@@ -27,13 +27,13 @@ void hfs_bnode_read(struct hfs_bnode *node, void *buf, int off, int len)
        pagep = node->page + (off >> PAGE_CACHE_SHIFT);
        off &= ~PAGE_CACHE_MASK;
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
        memcpy(buf, kmap(*pagep) + off, l);
        kunmap(*pagep);
        while ((len -= l) != 0) {
                buf += l;
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                memcpy(buf, kmap(*++pagep), l);
                kunmap(*pagep);
        }
@@ -80,14 +80,14 @@ void hfs_bnode_write(struct hfs_bnode *node, void *buf, int off, int len)
        pagep = node->page + (off >> PAGE_CACHE_SHIFT);
        off &= ~PAGE_CACHE_MASK;
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
        memcpy(kmap(*pagep) + off, buf, l);
        set_page_dirty(*pagep);
        kunmap(*pagep);
        while ((len -= l) != 0) {
                buf += l;
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                memcpy(kmap(*++pagep), buf, l);
                set_page_dirty(*pagep);
                kunmap(*pagep);
@@ -110,13 +110,13 @@ void hfs_bnode_clear(struct hfs_bnode *node, int off, int len)
        pagep = node->page + (off >> PAGE_CACHE_SHIFT);
        off &= ~PAGE_CACHE_MASK;
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
        memset(kmap(*pagep) + off, 0, l);
        set_page_dirty(*pagep);
        kunmap(*pagep);
        while ((len -= l) != 0) {
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                memset(kmap(*++pagep), 0, l);
                set_page_dirty(*pagep);
                kunmap(*pagep);
@@ -142,14 +142,14 @@ void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
        dst &= ~PAGE_CACHE_MASK;
        if (src == dst) {
-                l = min(len, (int)PAGE_CACHE_SIZE - src);
+                l = min_t(int, len, PAGE_CACHE_SIZE - src);
                memcpy(kmap(*dst_page) + src, kmap(*src_page) + src, l);
                kunmap(*src_page);
                set_page_dirty(*dst_page);
                kunmap(*dst_page);
                while ((len -= l) != 0) {
-                        l = min(len, (int)PAGE_CACHE_SIZE);
+                        l = min_t(int, len, PAGE_CACHE_SIZE);
                        memcpy(kmap(*++dst_page), kmap(*++src_page), l);
                        kunmap(*src_page);
                        set_page_dirty(*dst_page);
@@ -251,7 +251,7 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
                dst &= ~PAGE_CACHE_MASK;
                if (src == dst) {
-                        l = min(len, (int)PAGE_CACHE_SIZE - src);
+                        l = min_t(int, len, PAGE_CACHE_SIZE - src);
                        memmove(kmap(*dst_page) + src,
                                kmap(*src_page) + src, l);
                        kunmap(*src_page);
@@ -259,7 +259,7 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
                        kunmap(*dst_page);
                        while ((len -= l) != 0) {
-                                l = min(len, (int)PAGE_CACHE_SIZE);
+                                l = min_t(int, len, PAGE_CACHE_SIZE);
                                memmove(kmap(*++dst_page),
                                        kmap(*++src_page), l);
                                kunmap(*src_page);
@@ -386,9 +386,8 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
        struct hfs_bnode *node;
        if (cnid >= tree->node_count) {
-                pr_err("request for non-existent node "
+                pr_err("request for non-existent node %d in B*Tree\n",
-                                "%d in B*Tree\n",
+                       cnid);
-                        cnid);
                return NULL;
        }
@@ -409,9 +408,8 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
        loff_t off;
        if (cnid >= tree->node_count) {
-                pr_err("request for non-existent node "
+                pr_err("request for non-existent node %d in B*Tree\n",
-                                "%d in B*Tree\n",
+                       cnid);
-                        cnid);
                return NULL;
        }
@@ -602,7 +600,7 @@ struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num)
        pagep = node->page;
        memset(kmap(*pagep) + node->page_offset, 0,
-               min((int)PAGE_CACHE_SIZE, (int)tree->node_size));
+               min_t(int, PAGE_CACHE_SIZE, tree->node_size));
        set_page_dirty(*pagep);
        kunmap(*pagep);
        for (i = 1; i < tree->pages_per_bnode; i++) {
@@ -648,8 +646,8 @@ void hfs_bnode_put(struct hfs_bnode *node)
                if (test_bit(HFS_BNODE_DELETED, &node->flags)) {
                        hfs_bnode_unhash(node);
                        spin_unlock(&tree->hash_lock);
-                        hfs_bnode_clear(node, 0,
+                        if (hfs_bnode_need_zeroout(tree))
-                                PAGE_CACHE_SIZE * tree->pages_per_bnode);
+                                hfs_bnode_clear(node, 0, tree->node_size);
                        hfs_bmap_free(node);
                        hfs_bnode_free(node);
                        return;
@@ -658,3 +656,16 @@ void hfs_bnode_put(struct hfs_bnode *node)
        }
 }
+/*
+ * Unused nodes have to be zeroed if this is the catalog tree and
+ * a corresponding flag in the volume header is set.
+ */
+bool hfs_bnode_need_zeroout(struct hfs_btree *tree)
+{
+        struct super_block *sb = tree->inode->i_sb;
+        struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
+        const u32 volume_attr = be32_to_cpu(sbi->s_vhdr->attributes);
+        return tree->cnid == HFSPLUS_CAT_CNID &&
+                volume_attr & HFSPLUS_VOL_UNUSED_NODE_FIX;
+}
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 0fcec8b2a90b..3345c7553edc 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -358,7 +358,7 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
                u32 count;
                int res;
-                res = hfsplus_file_extend(inode);
+                res = hfsplus_file_extend(inode, hfs_bnode_need_zeroout(tree));
                if (res)
                        return ERR_PTR(res);
                hip->phys_size = inode->i_size =
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index bdec66522de3..610a3260bef1 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -12,6 +12,7 @@
 #include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/random.h>
+#include <linux/nls.h>
 #include "hfsplus_fs.h"
 #include "hfsplus_raw.h"
@@ -127,7 +128,7 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
        struct inode *inode = file_inode(file);
        struct super_block *sb = inode->i_sb;
        int len, err;
-        char strbuf[HFSPLUS_MAX_STRLEN + 1];
+        char *strbuf;
        hfsplus_cat_entry entry;
        struct hfs_find_data fd;
        struct hfsplus_readdir_data *rd;
@@ -139,6 +140,11 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
        err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
        if (err)
                return err;
+        strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_MAX_STRLEN + 1, GFP_KERNEL);
+        if (!strbuf) {
+                err = -ENOMEM;
+                goto out;
+        }
        hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
        err = hfs_brec_find(&fd, hfs_find_rec_by_key);
        if (err)
@@ -193,7 +199,7 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
                hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
                        fd.entrylength);
                type = be16_to_cpu(entry.type);
-                len = HFSPLUS_MAX_STRLEN;
+                len = NLS_MAX_CHARSET_SIZE * HFSPLUS_MAX_STRLEN;
                err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
                if (err)
                        goto out;
@@ -212,13 +218,31 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
                                    be32_to_cpu(entry.folder.id), DT_DIR))
                                break;
                } else if (type == HFSPLUS_FILE) {
+                        u16 mode;
+                        unsigned type = DT_UNKNOWN;
                        if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
                                pr_err("small file entry\n");
                                err = -EIO;
                                goto out;
                        }
+                        mode = be16_to_cpu(entry.file.permissions.mode);
+                        if (S_ISREG(mode))
+                                type = DT_REG;
+                        else if (S_ISLNK(mode))
+                                type = DT_LNK;
+                        else if (S_ISFIFO(mode))
+                                type = DT_FIFO;
+                        else if (S_ISCHR(mode))
+                                type = DT_CHR;
+                        else if (S_ISBLK(mode))
+                                type = DT_BLK;
+                        else if (S_ISSOCK(mode))
+                                type = DT_SOCK;
                        if (!dir_emit(ctx, strbuf, len,
-                                    be32_to_cpu(entry.file.id), DT_REG))
+                                      be32_to_cpu(entry.file.id), type))
                                break;
                } else {
                        pr_err("bad catalog entry type\n");
@@ -246,6 +270,7 @@ next:
        }
        memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
 out:
+        kfree(strbuf);
        hfs_find_exit(&fd);
        return err;
 }
diff --git a/fs/hfsplus/extents.c b/fs/hfsplus/extents.c
index a7aafb35b624..feca524ce2a5 100644
--- a/fs/hfsplus/extents.c
+++ b/fs/hfsplus/extents.c
@@ -235,7 +235,7 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock,
                if (iblock > hip->fs_blocks || !create)
                        return -EIO;
                if (ablock >= hip->alloc_blocks) {
-                        res = hfsplus_file_extend(inode);
+                        res = hfsplus_file_extend(inode, false);
                        if (res)
                                return res;
                }
@@ -425,7 +425,7 @@ int hfsplus_free_fork(struct super_block *sb, u32 cnid,
        return res;
 }
-int hfsplus_file_extend(struct inode *inode)
+int hfsplus_file_extend(struct inode *inode, bool zeroout)
 {
        struct super_block *sb = inode->i_sb;
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
@@ -436,10 +436,9 @@ int hfsplus_file_extend(struct inode *inode)
        if (sbi->alloc_file->i_size * 8 <
            sbi->total_blocks - sbi->free_blocks + 8) {
                /* extend alloc file */
-                pr_err("extend alloc file! "
+                pr_err("extend alloc file! (%llu,%u,%u)\n",
-                                "(%llu,%u,%u)\n",
+                       sbi->alloc_file->i_size * 8,
-                        sbi->alloc_file->i_size * 8,
+                       sbi->total_blocks, sbi->free_blocks);
-                        sbi->total_blocks, sbi->free_blocks);
                return -ENOSPC;
        }
@@ -463,6 +462,12 @@ int hfsplus_file_extend(struct inode *inode)
                }
        }
+        if (zeroout) {
+                res = sb_issue_zeroout(sb, start, len, GFP_NOFS);
+                if (res)
+                        goto out;
+        }
        hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
        if (hip->alloc_blocks <= hip->first_blocks) {
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 83dc29286b10..eb5e059f481a 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -369,114 +369,119 @@ typedef int (*search_strategy_t)(struct hfs_bnode *,
 /* attributes.c */
 int __init hfsplus_create_attr_tree_cache(void);
 void hfsplus_destroy_attr_tree_cache(void);
+int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1,
+                             const hfsplus_btree_key *k2);
+int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
+                           u32 cnid, const char *name);
 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void);
-void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry_p);
+void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry);
-int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *,
+int hfsplus_find_attr(struct super_block *sb, u32 cnid, const char *name,
-                const hfsplus_btree_key *);
+                      struct hfs_find_data *fd);
-int hfsplus_attr_build_key(struct super_block *, hfsplus_btree_key *,
-                        u32, const char *);
-void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
-                                        u32 cnid,
-                                        struct hfsplus_attr_unistr *name);
-int hfsplus_find_attr(struct super_block *, u32,
-                        const char *, struct hfs_find_data *);
 int hfsplus_attr_exists(struct inode *inode, const char *name);
-int hfsplus_create_attr(struct inode *, const char *, const void *, size_t);
+int hfsplus_create_attr(struct inode *inode, const char *name,
-int hfsplus_delete_attr(struct inode *, const char *);
+                        const void *value, size_t size);
+int hfsplus_delete_attr(struct inode *inode, const char *name);
 int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid);
 /* bitmap.c */
-int hfsplus_block_allocate(struct super_block *, u32, u32, u32 *);
+int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset,
-int hfsplus_block_free(struct super_block *, u32, u32);
+                           u32 *max);
+int hfsplus_block_free(struct super_block *sb, u32 offset, u32 count);
 /* btree.c */
-u32 hfsplus_calc_btree_clump_size(u32, u32, u64, int);
+u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, u64 sectors,
-struct hfs_btree *hfs_btree_open(struct super_block *, u32);
+                                  int file_id);
-void hfs_btree_close(struct hfs_btree *);
+struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id);
-int hfs_btree_write(struct hfs_btree *);
+void hfs_btree_close(struct hfs_btree *tree);
-struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *);
+int hfs_btree_write(struct hfs_btree *tree);
-void hfs_bmap_free(struct hfs_bnode *);
+struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree);
+void hfs_bmap_free(struct hfs_bnode *node);
 /* bnode.c */
-void hfs_bnode_read(struct hfs_bnode *, void *, int, int);
+void hfs_bnode_read(struct hfs_bnode *node, void *buf, int off, int len);
-u16 hfs_bnode_read_u16(struct hfs_bnode *, int);
+u16 hfs_bnode_read_u16(struct hfs_bnode *node, int off);
-u8 hfs_bnode_read_u8(struct hfs_bnode *, int);
+u8 hfs_bnode_read_u8(struct hfs_bnode *node, int off);
-void hfs_bnode_read_key(struct hfs_bnode *, void *, int);
+void hfs_bnode_read_key(struct hfs_bnode *node, void *key, int off);
-void hfs_bnode_write(struct hfs_bnode *, void *, int, int);
+void hfs_bnode_write(struct hfs_bnode *node, void *buf, int off, int len);
-void hfs_bnode_write_u16(struct hfs_bnode *, int, u16);
+void hfs_bnode_write_u16(struct hfs_bnode *node, int off, u16 data);
-void hfs_bnode_clear(struct hfs_bnode *, int, int);
+void hfs_bnode_clear(struct hfs_bnode *node, int off, int len);
-void hfs_bnode_copy(struct hfs_bnode *, int,
+void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
-                    struct hfs_bnode *, int, int);
+                    struct hfs_bnode *src_node, int src, int len);
-void hfs_bnode_move(struct hfs_bnode *, int, int, int);
+void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len);
-void hfs_bnode_dump(struct hfs_bnode *);
+void hfs_bnode_dump(struct hfs_bnode *node);
-void hfs_bnode_unlink(struct hfs_bnode *);
+void hfs_bnode_unlink(struct hfs_bnode *node);
-struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *, u32);
+struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid);
-struct hfs_bnode *hfs_bnode_find(struct hfs_btree *, u32);
+void hfs_bnode_unhash(struct hfs_bnode *node);
-void hfs_bnode_unhash(struct hfs_bnode *);
+struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num);
-void hfs_bnode_free(struct hfs_bnode *);
+void hfs_bnode_free(struct hfs_bnode *node);
-struct hfs_bnode *hfs_bnode_create(struct hfs_btree *, u32);
+struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num);
-void hfs_bnode_get(struct hfs_bnode *);
+void hfs_bnode_get(struct hfs_bnode *node);
-void hfs_bnode_put(struct hfs_bnode *);
+void hfs_bnode_put(struct hfs_bnode *node);
+bool hfs_bnode_need_zeroout(struct hfs_btree *tree);
 /* brec.c */
-u16 hfs_brec_lenoff(struct hfs_bnode *, u16, u16 *);
+u16 hfs_brec_lenoff(struct hfs_bnode *node, u16 rec, u16 *off);
-u16 hfs_brec_keylen(struct hfs_bnode *, u16);
+u16 hfs_brec_keylen(struct hfs_bnode *node, u16 rec);
-int hfs_brec_insert(struct hfs_find_data *, void *, int);
+int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len);
-int hfs_brec_remove(struct hfs_find_data *);
+int hfs_brec_remove(struct hfs_find_data *fd);
 /* bfind.c */
-int hfs_find_init(struct hfs_btree *, struct hfs_find_data *);
+int hfs_find_init(struct hfs_btree *tree, struct hfs_find_data *fd);
-void hfs_find_exit(struct hfs_find_data *);
+void hfs_find_exit(struct hfs_find_data *fd);
-int hfs_find_1st_rec_by_cnid(struct hfs_bnode *,
+int hfs_find_1st_rec_by_cnid(struct hfs_bnode *bnode, struct hfs_find_data *fd,
-                                struct hfs_find_data *,
+                             int *begin, int *end, int *cur_rec);
-                                int *, int *, int *);
+int hfs_find_rec_by_key(struct hfs_bnode *bnode, struct hfs_find_data *fd,
-int hfs_find_rec_by_key(struct hfs_bnode *,
+                        int *begin, int *end, int *cur_rec);
-                                struct hfs_find_data *,
+int __hfs_brec_find(struct hfs_bnode *bnode, struct hfs_find_data *fd,
-                                int *, int *, int *);
+                    search_strategy_t rec_found);
-int __hfs_brec_find(struct hfs_bnode *, struct hfs_find_data *,
+int hfs_brec_find(struct hfs_find_data *fd, search_strategy_t do_key_compare);
-                                search_strategy_t);
+int hfs_brec_read(struct hfs_find_data *fd, void *rec, int rec_len);
-int hfs_brec_find(struct hfs_find_data *, search_strategy_t);
+int hfs_brec_goto(struct hfs_find_data *fd, int cnt);
-int hfs_brec_read(struct hfs_find_data *, void *, int);
-int hfs_brec_goto(struct hfs_find_data *, int);
 /* catalog.c */
-int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *,
+int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1,
-                const hfsplus_btree_key *);
+                             const hfsplus_btree_key *k2);
-int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *,
+int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1,
-                const hfsplus_btree_key *);
+                            const hfsplus_btree_key *k2);
-void hfsplus_cat_build_key(struct super_block *sb,
+void hfsplus_cat_build_key(struct super_block *sb, hfsplus_btree_key *key,
-                hfsplus_btree_key *, u32, struct qstr *);
+                           u32 parent, struct qstr *str);
-int hfsplus_find_cat(struct super_block *, u32, struct hfs_find_data *);
-int hfsplus_create_cat(u32, struct inode *, struct qstr *, struct inode *);
-int hfsplus_delete_cat(u32, struct inode *, struct qstr *);
-int hfsplus_rename_cat(u32, struct inode *, struct qstr *,
-                       struct inode *, struct qstr *);
 void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms);
+int hfsplus_find_cat(struct super_block *sb, u32 cnid,
+                     struct hfs_find_data *fd);
+int hfsplus_create_cat(u32 cnid, struct inode *dir, struct qstr *str,
+                       struct inode *inode);
+int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str);
+int hfsplus_rename_cat(u32 cnid, struct inode *src_dir, struct qstr *src_name,
+                       struct inode *dst_dir, struct qstr *dst_name);
 /* dir.c */
 extern const struct inode_operations hfsplus_dir_inode_operations;
 extern const struct file_operations hfsplus_dir_operations;
 /* extents.c */
-int hfsplus_ext_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
+int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1,
-int hfsplus_ext_write_extent(struct inode *);
+                        const hfsplus_btree_key *k2);
-int hfsplus_get_block(struct inode *, sector_t, struct buffer_head *, int);
+int hfsplus_ext_write_extent(struct inode *inode);
-int hfsplus_free_fork(struct super_block *, u32,
+int hfsplus_get_block(struct inode *inode, sector_t iblock,
-                struct hfsplus_fork_raw *, int);
+                      struct buffer_head *bh_result, int create);
-int hfsplus_file_extend(struct inode *);
+int hfsplus_free_fork(struct super_block *sb, u32 cnid,
-void hfsplus_file_truncate(struct inode *);
+                      struct hfsplus_fork_raw *fork, int type);
+int hfsplus_file_extend(struct inode *inode, bool zeroout);
+void hfsplus_file_truncate(struct inode *inode);
 /* inode.c */
 extern const struct address_space_operations hfsplus_aops;
 extern const struct address_space_operations hfsplus_btree_aops;
 extern const struct dentry_operations hfsplus_dentry_operations;
-void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
+struct inode *hfsplus_new_inode(struct super_block *sb, umode_t mode);
-void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
+void hfsplus_delete_inode(struct inode *inode);
-int hfsplus_cat_read_inode(struct inode *, struct hfs_find_data *);
+void hfsplus_inode_read_fork(struct inode *inode,
-int hfsplus_cat_write_inode(struct inode *);
+                             struct hfsplus_fork_raw *fork);
-struct inode *hfsplus_new_inode(struct super_block *, umode_t);
+void hfsplus_inode_write_fork(struct inode *inode,
-void hfsplus_delete_inode(struct inode *);
+                              struct hfsplus_fork_raw *fork);
+int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd);
+int hfsplus_cat_write_inode(struct inode *inode);
 int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
                       int datasync);
@@ -484,13 +489,17 @@ int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
 long hfsplus_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 /* options.c */
-int hfsplus_parse_options(char *, struct hfsplus_sb_info *);
+void hfsplus_fill_defaults(struct hfsplus_sb_info *opts);
 int hfsplus_parse_options_remount(char *input, int *force);
-void hfsplus_fill_defaults(struct hfsplus_sb_info *);
+int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi);
-int hfsplus_show_options(struct seq_file *, struct dentry *);
+int hfsplus_show_options(struct seq_file *seq, struct dentry *root);
+/* part_tbl.c */
+int hfs_part_find(struct super_block *sb, sector_t *part_start,
+                  sector_t *part_size);
 /* super.c */
-struct inode *hfsplus_iget(struct super_block *, unsigned long);
+struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino);
 void hfsplus_mark_mdb_dirty(struct super_block *sb);
 /* tables.c */
@@ -499,23 +508,23 @@ extern u16 hfsplus_decompose_table[];
 extern u16 hfsplus_compose_table[];
 /* unicode.c */
-int hfsplus_strcasecmp(const struct hfsplus_unistr *,
+int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
-                const struct hfsplus_unistr *);
+                       const struct hfsplus_unistr *s2);
-int hfsplus_strcmp(const struct hfsplus_unistr *,
+int hfsplus_strcmp(const struct hfsplus_unistr *s1,
-                const struct hfsplus_unistr *);
+                   const struct hfsplus_unistr *s2);
-int hfsplus_uni2asc(struct super_block *,
+int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr,
-                const struct hfsplus_unistr *, char *, int *);
+                    char *astr, int *len_p);
-int hfsplus_asc2uni(struct super_block *,
+int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
-                struct hfsplus_unistr *, int, const char *, int);
+                    int max_unistr_len, const char *astr, int len);
 int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str);
-int hfsplus_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
+int hfsplus_compare_dentry(const struct dentry *parent,
-                unsigned int len, const char *str, const struct qstr *name);
+                           const struct dentry *dentry, unsigned int len,
+                           const char *str, const struct qstr *name);
 /* wrapper.c */
-int hfsplus_read_wrapper(struct super_block *);
+int hfsplus_submit_bio(struct super_block *sb, sector_t sector, void *buf,
-int hfs_part_find(struct super_block *, sector_t *, sector_t *);
+                       void **data, int rw);
-int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
+int hfsplus_read_wrapper(struct super_block *sb);
-                void *buf, void **data, int rw);
 /* time macros */
 #define __hfsp_mt2ut(t)         (be32_to_cpu(t) - 2082844800U)
diff --git a/fs/hfsplus/hfsplus_raw.h b/fs/hfsplus/hfsplus_raw.h
index 5a126828d85e..8298d0985f81 100644
--- a/fs/hfsplus/hfsplus_raw.h
+++ b/fs/hfsplus/hfsplus_raw.h
@@ -144,6 +144,7 @@ struct hfsplus_vh {
 #define HFSPLUS_VOL_NODEID_REUSED       (1 << 12)
 #define HFSPLUS_VOL_JOURNALED           (1 << 13)
 #define HFSPLUS_VOL_SOFTLOCK            (1 << 15)
+#define HFSPLUS_VOL_UNUSED_NODE_FIX     (1 << 31)
 /* HFS+ BTree node descriptor */
 struct hfs_bnode_desc {
diff --git a/fs/hfsplus/options.c b/fs/hfsplus/options.c
index 68537e8b7a09..c90b72ee676d 100644
--- a/fs/hfsplus/options.c
+++ b/fs/hfsplus/options.c
@@ -173,9 +173,8 @@ int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi)
                        if (p)
                                sbi->nls = load_nls(p);
                        if (!sbi->nls) {
-                                pr_err("unable to load "
+                                pr_err("unable to load nls mapping \"%s\"\n",
-                                                "nls mapping \"%s\"\n",
+                                       p);
-                                        p);
                                kfree(p);
                                return 0;
                        }
@@ -232,8 +231,8 @@ int hfsplus_show_options(struct seq_file *seq, struct dentry *root)
        if (sbi->nls)
                seq_printf(seq, ",nls=%s", sbi->nls->charset);
        if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))
-                seq_printf(seq, ",nodecompose");
+                seq_puts(seq, ",nodecompose");
        if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
-                seq_printf(seq, ",nobarrier");
+                seq_puts(seq, ",nobarrier");
        return 0;
 }
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index a513d2d36be9..4cf2024b87da 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -131,9 +131,10 @@ static int hfsplus_system_write_inode(struct inode *inode)
        hfsplus_inode_write_fork(inode, fork);
        if (tree) {
                int err = hfs_btree_write(tree);
                if (err) {
                        pr_err("b-tree write err: %d, ino %lu\n",
-                                        err, inode->i_ino);
+                               err, inode->i_ino);
                        return err;
                }
        }
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 3f999649587f..cc6235671437 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -24,8 +24,8 @@ struct hfsplus_wd {
        u16 embed_count;
 };
-/*
+/**
- * hfsplus_submit_bio - Perfrom block I/O
+ * hfsplus_submit_bio - Perform block I/O
 * @sb: super block of volume for I/O
 * @sector: block to read or write, for blocks of HFSPLUS_SECTOR_SIZE bytes
 * @buf: buffer for I/O
@@ -231,10 +231,8 @@ reread:
        if (blocksize < HFSPLUS_SECTOR_SIZE || ((blocksize - 1) & blocksize))
                goto out_free_backup_vhdr;
        sbi->alloc_blksz = blocksize;
-        sbi->alloc_blksz_shift = 0;
+        sbi->alloc_blksz_shift = ilog2(blocksize);
-        while ((blocksize >>= 1) != 0)
+        blocksize = min_t(u32, sbi->alloc_blksz, PAGE_SIZE);
-                sbi->alloc_blksz_shift++;
-        blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);
        /*
         * Align block size to block offset.
diff --git a/fs/hfsplus/xattr.c b/fs/hfsplus/xattr.c
index 4e27edc082a4..d98094a9f476 100644
--- a/fs/hfsplus/xattr.c
+++ b/fs/hfsplus/xattr.c
@@ -8,6 +8,7 @@
 #include "hfsplus_fs.h"
 #include <linux/posix_acl_xattr.h>
+#include <linux/nls.h>
 #include "xattr.h"
 #include "acl.h"
@@ -66,10 +67,10 @@ static void hfsplus_init_header_node(struct inode *attr_file,
        char *bmp;
        u32 used_nodes;
        u32 used_bmp_bytes;
-        loff_t tmp;
+        u64 tmp;
        hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
-                                clump_size, node_size);
+                clump_size, node_size);
        /* The end of the node contains list of record offsets */
        rec_offsets = (__be16 *)(buf + node_size);
@@ -195,7 +196,7 @@ check_attr_tree_state_again:
        }
        while (hip->alloc_blocks < hip->clump_blocks) {
-                err = hfsplus_file_extend(attr_file);
+                err = hfsplus_file_extend(attr_file, false);
                if (unlikely(err)) {
                        pr_err("failed to extend attributes file\n");
                        goto end_attr_file_creation;
@@ -645,8 +646,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
        struct hfs_find_data fd;
        u16 key_len = 0;
        struct hfsplus_attr_key attr_key;
-        char strbuf[HFSPLUS_ATTR_MAX_STRLEN +
+        char *strbuf;
-                        XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
        int xattr_name_len;
        if ((!S_ISREG(inode->i_mode) &&
@@ -666,6 +666,13 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
                return err;
        }
+        strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN +
+                        XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!strbuf) {
+                res = -ENOMEM;
+                goto out;
+        }
        err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
        if (err) {
                if (err == -ENOENT) {
@@ -692,7 +699,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
                if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
                        goto end_listxattr;
-                xattr_name_len = HFSPLUS_ATTR_MAX_STRLEN;
+                xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN;
                if (hfsplus_uni2asc(inode->i_sb,
                        (const struct hfsplus_unistr *)&fd.key->attr.key_name,
                                        strbuf, &xattr_name_len)) {
@@ -718,6 +725,8 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
        }
 end_listxattr:
+        kfree(strbuf);
+out:
        hfs_find_exit(&fd);
        return res;
 }
@@ -797,47 +806,55 @@ end_removexattr:
 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
                                        void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
+        char *xattr_name;
-                                XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
+        int res;
-        size_t len = strlen(name);
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
        /*
         * Don't allow retrieving properly prefixed attributes
         * by prepending them with "osx."
         */
        if (is_known_namespace(name))
                return -EOPNOTSUPP;
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN
+                + XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
+        strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
+        strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
                const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
+        char *xattr_name;
-                                XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
+        int res;
-        size_t len = strlen(name);
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
        /*
         * Don't allow setting properly prefixed attributes
         * by prepending them with "osx."
         */
        if (is_known_namespace(name))
                return -EOPNOTSUPP;
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN
+                + XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
+        strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
+        strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hfsplus/xattr_security.c b/fs/hfsplus/xattr_security.c
index 00722765ea79..6ec5e107691f 100644
--- a/fs/hfsplus/xattr_security.c
+++ b/fs/hfsplus/xattr_security.c
@@ -7,6 +7,8 @@
 */
 #include <linux/security.h>
+#include <linux/nls.h>
 #include "hfsplus_fs.h"
 #include "xattr.h"
 #include "acl.h"
@@ -14,37 +16,43 @@
 static int hfsplus_security_getxattr(struct dentry *dentry, const char *name,
                                        void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_SECURITY_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_SECURITY_PREFIX);
        strcpy(xattr_name + XATTR_SECURITY_PREFIX_LEN, name);
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 static int hfsplus_security_setxattr(struct dentry *dentry, const char *name,
                const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_SECURITY_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_SECURITY_PREFIX);
        strcpy(xattr_name + XATTR_SECURITY_PREFIX_LEN, name);
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 static size_t hfsplus_security_listxattr(struct dentry *dentry, char *list,
@@ -62,31 +70,30 @@ static int hfsplus_initxattrs(struct inode *inode,
                                void *fs_info)
 {
        const struct xattr *xattr;
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t xattr_name_len;
        int err = 0;
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
-                xattr_name_len = strlen(xattr->name);
-                if (xattr_name_len == 0)
+                if (!strcmp(xattr->name, ""))
                        continue;
-                if (xattr_name_len + XATTR_SECURITY_PREFIX_LEN >
-                                HFSPLUS_ATTR_MAX_STRLEN)
-                        return -EOPNOTSUPP;
                strcpy(xattr_name, XATTR_SECURITY_PREFIX);
                strcpy(xattr_name +
                        XATTR_SECURITY_PREFIX_LEN, xattr->name);
                memset(xattr_name +
-                        XATTR_SECURITY_PREFIX_LEN + xattr_name_len, 0, 1);
+                        XATTR_SECURITY_PREFIX_LEN + strlen(xattr->name), 0, 1);
                err = __hfsplus_setxattr(inode, xattr_name,
                                        xattr->value, xattr->value_len, 0);
                if (err)
                        break;
        }
+        kfree(xattr_name);
        return err;
 }
diff --git a/fs/hfsplus/xattr_trusted.c b/fs/hfsplus/xattr_trusted.c
index 426cee277542..3c5f27e4746a 100644
--- a/fs/hfsplus/xattr_trusted.c
+++ b/fs/hfsplus/xattr_trusted.c
@@ -6,43 +6,51 @@
 * Handler for trusted extended attributes.
 */
+#include <linux/nls.h>
 #include "hfsplus_fs.h"
 #include "xattr.h"
 static int hfsplus_trusted_getxattr(struct dentry *dentry, const char *name,
                                        void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_TRUSTED_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_TRUSTED_PREFIX);
        strcpy(xattr_name + XATTR_TRUSTED_PREFIX_LEN, name);
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 static int hfsplus_trusted_setxattr(struct dentry *dentry, const char *name,
                const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_TRUSTED_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_TRUSTED_PREFIX);
        strcpy(xattr_name + XATTR_TRUSTED_PREFIX_LEN, name);
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 static size_t hfsplus_trusted_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hfsplus/xattr_user.c b/fs/hfsplus/xattr_user.c
index e34016561ae0..2b625a538b64 100644
--- a/fs/hfsplus/xattr_user.c
+++ b/fs/hfsplus/xattr_user.c
@@ -6,43 +6,51 @@
 * Handler for user extended attributes.
 */
+#include <linux/nls.h>
 #include "hfsplus_fs.h"
 #include "xattr.h"
 static int hfsplus_user_getxattr(struct dentry *dentry, const char *name,
                                        void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_USER_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_USER_PREFIX);
        strcpy(xattr_name + XATTR_USER_PREFIX_LEN, name);
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 static int hfsplus_user_setxattr(struct dentry *dentry, const char *name,
                const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
+        char *xattr_name;
-        size_t len = strlen(name);
+        int res;
        if (!strcmp(name, ""))
                return -EINVAL;
-        if (len + XATTR_USER_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
-                return -EOPNOTSUPP;
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
        strcpy(xattr_name, XATTR_USER_PREFIX);
        strcpy(xattr_name + XATTR_USER_PREFIX_LEN, name);
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 static size_t hfsplus_user_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hpfs/alloc.c b/fs/hpfs/alloc.c
index 58b5106186d0..f005046e1591 100644
--- a/fs/hpfs/alloc.c
+++ b/fs/hpfs/alloc.c
@@ -316,7 +316,7 @@ void hpfs_free_sectors(struct super_block *s, secno sec, unsigned n)
        struct quad_buffer_head qbh;
        __le32 *bmp;
        struct hpfs_sb_info *sbi = hpfs_sb(s);
-        /*printk("2 - ");*/
+        /*pr_info("2 - ");*/
        if (!n) return;
        if (sec < 0x12) {
                hpfs_error(s, "Trying to free reserved sector %08x", sec);
diff --git a/fs/hpfs/buffer.c b/fs/hpfs/buffer.c
index 139ef1684d07..8057fe4e6574 100644
--- a/fs/hpfs/buffer.c
+++ b/fs/hpfs/buffer.c
@@ -55,7 +55,7 @@ void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head
        if (bh != NULL)
                return bh->b_data;
        else {
-                printk("HPFS: hpfs_map_sector: read error\n");
+                pr_err("%s(): read error\n", __func__);
                return NULL;
        }
 }
@@ -76,7 +76,7 @@ void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head
                set_buffer_uptodate(bh);
                return bh->b_data;
        } else {
-                printk("HPFS: hpfs_get_sector: getblk failed\n");
+                pr_err("%s(): getblk failed\n", __func__);
                return NULL;
        }
 }
@@ -93,7 +93,7 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe
        cond_resched();
        if (secno & 3) {
-                printk("HPFS: hpfs_map_4sectors: unaligned read\n");
+                pr_err("%s(): unaligned read\n", __func__);
                return NULL;
        }
@@ -112,7 +112,7 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe
        qbh->data = data = kmalloc(2048, GFP_NOFS);
        if (!data) {
-                printk("HPFS: hpfs_map_4sectors: out of memory\n");
+                pr_err("%s(): out of memory\n", __func__);
                goto bail4;
        }
@@ -145,7 +145,7 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
        hpfs_lock_assert(s);
        if (secno & 3) {
-                printk("HPFS: hpfs_get_4sectors: unaligned read\n");
+                pr_err("%s(): unaligned read\n", __func__);
                return NULL;
        }
@@ -161,7 +161,7 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
        }
        if (!(qbh->data = kmalloc(2048, GFP_NOFS))) {
-                printk("HPFS: hpfs_get_4sectors: out of memory\n");
+                pr_err("%s(): out of memory\n", __func__);
                goto bail4;
        }
        return qbh->data;
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index 292b1acb9b81..2a8e07425de0 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -36,7 +36,7 @@ static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
        mutex_lock(&i->i_mutex);
        hpfs_lock(s);
-        /*printk("dir lseek\n");*/
+        /*pr_info("dir lseek\n");*/
        if (new_off == 0 || new_off == 1 || new_off == 11 || new_off == 12 || new_off == 13) goto ok;
        pos = ((loff_t) hpfs_de_as_down_as_possible(s, hpfs_inode->i_dno) << 4) + 1;
        while (pos != new_off) {
@@ -51,7 +51,7 @@ ok:
        mutex_unlock(&i->i_mutex);
        return new_off;
 fail:
-        /*printk("illegal lseek: %016llx\n", new_off);*/
+        /*pr_warn("illegal lseek: %016llx\n", new_off);*/
        hpfs_unlock(s);
        mutex_unlock(&i->i_mutex);
        return -ESPIPE;
@@ -127,7 +127,7 @@ static int hpfs_readdir(struct file *file, struct dir_context *ctx)
                if (ctx->pos == 12)
                        goto out;
                if (ctx->pos == 3 || ctx->pos == 4 || ctx->pos == 5) {
-                        printk("HPFS: warning: pos==%d\n",(int)ctx->pos);
+                        pr_err("pos==%d\n", (int)ctx->pos);
                        goto out;
                }
                if (ctx->pos == 0) {
diff --git a/fs/hpfs/dnode.c b/fs/hpfs/dnode.c
index 4364b2a02c5d..f36fc010fccb 100644
--- a/fs/hpfs/dnode.c
+++ b/fs/hpfs/dnode.c
@@ -17,7 +17,7 @@ static loff_t get_pos(struct dnode *d, struct hpfs_dirent *fde)
                if (de == fde) return ((loff_t) le32_to_cpu(d->self) << 4) | (loff_t)i;
                i++;
        }
-        printk("HPFS: get_pos: not_found\n");
+        pr_info("%s(): not_found\n", __func__);
        return ((loff_t)le32_to_cpu(d->self) << 4) | (loff_t)1;
 }
@@ -32,7 +32,7 @@ void hpfs_add_pos(struct inode *inode, loff_t *pos)
                        if (hpfs_inode->i_rddir_off[i] == pos) return;
        if (!(i&0x0f)) {
                if (!(ppos = kmalloc((i+0x11) * sizeof(loff_t*), GFP_NOFS))) {
-                        printk("HPFS: out of memory for position list\n");
+                        pr_err("out of memory for position list\n");
                        return;
                }
                if (hpfs_inode->i_rddir_off) {
@@ -63,7 +63,8 @@ void hpfs_del_pos(struct inode *inode, loff_t *pos)
        }
        return;
        not_f:
-        /*printk("HPFS: warning: position pointer %p->%08x not found\n", pos, (int)*pos);*/
+        /*pr_warn("position pointer %p->%08x not found\n",
+                  pos, (int)*pos);*/
        return;
 }
@@ -92,8 +93,11 @@ static void hpfs_pos_ins(loff_t *p, loff_t d, loff_t c)
 {
        if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) {
                int n = (*p & 0x3f) + c;
-                if (n > 0x3f) printk("HPFS: hpfs_pos_ins: %08x + %d\n", (int)*p, (int)c >> 8);
+                if (n > 0x3f)
-                else *p = (*p & ~0x3f) | n;
+                        pr_err("%s(): %08x + %d\n",
+                                __func__, (int)*p, (int)c >> 8);
+                else
+                        *p = (*p & ~0x3f) | n;
        }
 }
@@ -101,8 +105,11 @@ static void hpfs_pos_del(loff_t *p, loff_t d, loff_t c)
 {
        if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) {
                int n = (*p & 0x3f) - c;
-                if (n < 1) printk("HPFS: hpfs_pos_ins: %08x - %d\n", (int)*p, (int)c >> 8);
+                if (n < 1)
-                else *p = (*p & ~0x3f) | n;
+                        pr_err("%s(): %08x - %d\n",
+                                __func__, (int)*p, (int)c >> 8);
+                else
+                        *p = (*p & ~0x3f) | n;
        }
 }
@@ -239,12 +246,12 @@ static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno,
        struct fnode *fnode;
        int c1, c2 = 0;
        if (!(nname = kmalloc(256, GFP_NOFS))) {
-                printk("HPFS: out of memory, can't add to dnode\n");
+                pr_err("out of memory, can't add to dnode\n");
                return 1;
        }
        go_up:
        if (namelen >= 256) {
-                hpfs_error(i->i_sb, "hpfs_add_to_dnode: namelen == %d", namelen);
+                hpfs_error(i->i_sb, "%s(): namelen == %d", __func__, namelen);
                kfree(nd);
                kfree(nname);
                return 1;
@@ -281,7 +288,7 @@ static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno,
                   not be any error while splitting dnodes, otherwise the
                   whole directory, not only file we're adding, would
                   be lost. */
-                printk("HPFS: out of memory for dnode splitting\n");
+                pr_err("out of memory for dnode splitting\n");
                hpfs_brelse4(&qbh);
                kfree(nname);
                return 1;
@@ -597,7 +604,7 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                if (!de_next->down) goto endm;
                ndown = de_down_pointer(de_next);
                if (!(de_cp = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) {
-                        printk("HPFS: out of memory for dtree balancing\n");
+                        pr_err("out of memory for dtree balancing\n");
                        goto endm;
                }
                memcpy(de_cp, de, le16_to_cpu(de->length));
@@ -612,7 +619,8 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                        hpfs_brelse4(&qbh1);
                }
                hpfs_add_to_dnode(i, ndown, de_cp->name, de_cp->namelen, de_cp, de_cp->down ? de_down_pointer(de_cp) : 0);
-                /*printk("UP-TO-DNODE: %08x (ndown = %08x, down = %08x, dno = %08x)\n", up, ndown, down, dno);*/
+                /*pr_info("UP-TO-DNODE: %08x (ndown = %08x, down = %08x, dno = %08x)\n",
+                  up, ndown, down, dno);*/
                dno = up;
                kfree(de_cp);
                goto try_it_again;
@@ -637,15 +645,15 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                        if (!dlp && down) {
                                if (le32_to_cpu(d1->first_free) > 2044) {
                                        if (hpfs_sb(i->i_sb)->sb_chk >= 2) {
-                                                printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
+                                                pr_err("unbalanced dnode tree, see hpfs.txt 4 more info\n");
-                                                printk("HPFS: warning: terminating balancing operation\n");
+                                                pr_err("terminating balancing operation\n");
                                        }
                                        hpfs_brelse4(&qbh1);
                                        goto endm;
                                }
                                if (hpfs_sb(i->i_sb)->sb_chk >= 2) {
-                                        printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
+                                        pr_err("unbalanced dnode tree, see hpfs.txt 4 more info\n");
-                                        printk("HPFS: warning: goin'on\n");
+                                        pr_err("goin'on\n");
                                }
                                le16_add_cpu(&del->length, 4);
                                del->down = 1;
@@ -659,7 +667,7 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                                *(__le32 *) ((void *) del + le16_to_cpu(del->length) - 4) = cpu_to_le32(down);
                } else goto endm;
                if (!(de_cp = kmalloc(le16_to_cpu(de_prev->length), GFP_NOFS))) {
-                        printk("HPFS: out of memory for dtree balancing\n");
+                        pr_err("out of memory for dtree balancing\n");
                        hpfs_brelse4(&qbh1);
                        goto endm;
                }
@@ -1000,7 +1008,7 @@ struct hpfs_dirent *map_fnode_dirent(struct super_block *s, fnode_secno fno,
        int d1, d2 = 0;
        name1 = f->name;
        if (!(name2 = kmalloc(256, GFP_NOFS))) {
-                printk("HPFS: out of memory, can't map dirent\n");
+                pr_err("out of memory, can't map dirent\n");
                return NULL;
        }
        if (f->len <= 15)
diff --git a/fs/hpfs/ea.c b/fs/hpfs/ea.c
index bcaafcd2666a..ce3f98ba993a 100644
--- a/fs/hpfs/ea.c
+++ b/fs/hpfs/ea.c
@@ -51,7 +51,7 @@ static char *get_indirect_ea(struct super_block *s, int ano, secno a, int size)
 {
        char *ret;
        if (!(ret = kmalloc(size + 1, GFP_NOFS))) {
-                printk("HPFS: out of memory for EA\n");
+                pr_err("out of memory for EA\n");
                return NULL;
        }
        if (hpfs_ea_read(s, a, ano, 0, size, ret)) {
@@ -139,7 +139,7 @@ char *hpfs_get_ea(struct super_block *s, struct fnode *fnode, char *key, int *si
                        if (ea_indirect(ea))
                                return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
                        if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
-                                printk("HPFS: out of memory for EA\n");
+                                pr_err("out of memory for EA\n");
                                return NULL;
                        }
                        memcpy(ret, ea_data(ea), ea_valuelen(ea));
@@ -165,7 +165,7 @@ char *hpfs_get_ea(struct super_block *s, struct fnode *fnode, char *key, int *si
                        if (ea_indirect(ea))
                                return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
                        if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
-                                printk("HPFS: out of memory for EA\n");
+                                pr_err("out of memory for EA\n");
                                return NULL;
                        }
                        if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), ret)) {
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index 3ba49c080e42..b63b75fa00e7 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -8,6 +8,11 @@
 //#define DBG
 //#define DEBUG_LOCKS
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/mutex.h>
 #include <linux/pagemap.h>
diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index 50a427313835..7ce4b74234a1 100644
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -183,7 +183,8 @@ void hpfs_write_inode(struct inode *i)
        struct inode *parent;
        if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return;
        if (hpfs_inode->i_rddir_off && !atomic_read(&i->i_count)) {
-                if (*hpfs_inode->i_rddir_off) printk("HPFS: write_inode: some position still there\n");
+                if (*hpfs_inode->i_rddir_off)
+                        pr_err("write_inode: some position still there\n");
                kfree(hpfs_inode->i_rddir_off);
                hpfs_inode->i_rddir_off = NULL;
        }
diff --git a/fs/hpfs/map.c b/fs/hpfs/map.c
index 3aa66ae1031e..442770edcdc7 100644
--- a/fs/hpfs/map.c
+++ b/fs/hpfs/map.c
@@ -65,12 +65,13 @@ unsigned char *hpfs_load_code_page(struct super_block *s, secno cps)
        struct code_page_directory *cp = hpfs_map_sector(s, cps, &bh, 0);
        if (!cp) return NULL;
        if (le32_to_cpu(cp->magic) != CP_DIR_MAGIC) {
-                printk("HPFS: Code page directory magic doesn't match (magic = %08x)\n", le32_to_cpu(cp->magic));
+                pr_err("Code page directory magic doesn't match (magic = %08x)\n",
+                        le32_to_cpu(cp->magic));
                brelse(bh);
                return NULL;
        }
        if (!le32_to_cpu(cp->n_code_pages)) {
-                printk("HPFS: n_code_pages == 0\n");
+                pr_err("n_code_pages == 0\n");
                brelse(bh);
                return NULL;
        }
@@ -79,19 +80,19 @@ unsigned char *hpfs_load_code_page(struct super_block *s, secno cps)
        brelse(bh);
        if (cpi >= 3) {
-                printk("HPFS: Code page index out of array\n");
+                pr_err("Code page index out of array\n");
                return NULL;
        }
        
        if (!(cpd = hpfs_map_sector(s, cpds, &bh, 0))) return NULL;
        if (le16_to_cpu(cpd->offs[cpi]) > 0x178) {
-                printk("HPFS: Code page index out of sector\n");
+                pr_err("Code page index out of sector\n");
                brelse(bh);
                return NULL;
        }
        ptr = (unsigned char *)cpd + le16_to_cpu(cpd->offs[cpi]) + 6;
        if (!(cp_table = kmalloc(256, GFP_KERNEL))) {
-                printk("HPFS: out of memory for code page table\n");
+                pr_err("out of memory for code page table\n");
                brelse(bh);
                return NULL;
        }
@@ -114,7 +115,7 @@ __le32 *hpfs_load_bitmap_directory(struct super_block *s, secno bmp)
        int i;
        __le32 *b;
        if (!(b = kmalloc(n * 512, GFP_KERNEL))) {
-                printk("HPFS: can't allocate memory for bitmap directory\n");
+                pr_err("can't allocate memory for bitmap directory\n");
                return NULL;
        }       
        for (i=0;i<n;i++) {
@@ -281,7 +282,9 @@ struct dnode *hpfs_map_dnode(struct super_block *s, unsigned secno,
                                hpfs_error(s, "dnode %08x does not end with \\377 entry", secno);
                                goto bail;
                        }
-                        if (b == 3) printk("HPFS: warning: unbalanced dnode tree, dnode %08x; see hpfs.txt 4 more info\n", secno);
+                        if (b == 3)
+                                pr_err("unbalanced dnode tree, dnode %08x; see hpfs.txt 4 more info\n",
+                                        secno);
                }
        return dnode;
        bail:
diff --git a/fs/hpfs/name.c b/fs/hpfs/name.c
index 9acdf338def0..b00d396d22c6 100644
--- a/fs/hpfs/name.c
+++ b/fs/hpfs/name.c
@@ -56,14 +56,15 @@ unsigned char *hpfs_translate_name(struct super_block *s, unsigned char *from,
        unsigned char *to;
        int i;
        if (hpfs_sb(s)->sb_chk >= 2) if (hpfs_is_name_long(from, len) != lng) {
-                printk("HPFS: Long name flag mismatch - name ");
+                pr_err("Long name flag mismatch - name ");
-                for (i=0; i<len; i++) printk("%c", from[i]);
+                for (i = 0; i < len; i++)
-                printk(" misidentified as %s.\n", lng ? "short" : "long");
+                        pr_cont("%c", from[i]);
-                printk("HPFS: It's nothing serious. It could happen because of bug in OS/2.\nHPFS: Set checks=normal to disable this message.\n");
+                pr_cont(" misidentified as %s.\n", lng ? "short" : "long");
+                pr_err("It's nothing serious. It could happen because of bug in OS/2.\nSet checks=normal to disable this message.\n");
        }
        if (!lc) return from;
        if (!(to = kmalloc(len, GFP_KERNEL))) {
-                printk("HPFS: can't allocate memory for name conversion buffer\n");
+                pr_err("can't allocate memory for name conversion buffer\n");
                return from;
        }
        for (i = 0; i < len; i++) to[i] = locase(hpfs_sb(s)->sb_cp_table,from[i]);
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index 1b39afdd86fd..bdbc2c3080a4 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -404,7 +404,7 @@ again:
                        d_rehash(dentry);
                } else {
                        struct iattr newattrs;
-                        /*printk("HPFS: truncating file before delete.\n");*/
+                        /*pr_info("truncating file before delete.\n");*/
                        newattrs.ia_size = 0;
                        newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
                        err = notify_change(dentry, &newattrs, NULL);
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index fe3463a43236..7cd00d3a7c9b 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -62,22 +62,26 @@ void hpfs_error(struct super_block *s, const char *fmt, ...)
        vsnprintf(err_buf, sizeof(err_buf), fmt, args);
        va_end(args);
-        printk("HPFS: filesystem error: %s", err_buf);
+        pr_err("filesystem error: %s", err_buf);
        if (!hpfs_sb(s)->sb_was_error) {
                if (hpfs_sb(s)->sb_err == 2) {
-                        printk("; crashing the system because you wanted it\n");
+                        pr_cont("; crashing the system because you wanted it\n");
                        mark_dirty(s, 0);
                        panic("HPFS panic");
                } else if (hpfs_sb(s)->sb_err == 1) {
-                        if (s->s_flags & MS_RDONLY) printk("; already mounted read-only\n");
+                        if (s->s_flags & MS_RDONLY)
+                                pr_cont("; already mounted read-only\n");
                        else {
-                                printk("; remounting read-only\n");
+                                pr_cont("; remounting read-only\n");
                                mark_dirty(s, 0);
                                s->s_flags |= MS_RDONLY;
                        }
-                } else if (s->s_flags & MS_RDONLY) printk("; going on - but anything won't be destroyed because it's read-only\n");
+                } else if (s->s_flags & MS_RDONLY)
-                else printk("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
+                                pr_cont("; going on - but anything won't be destroyed because it's read-only\n");
-        } else printk("\n");
+                else
+                        pr_cont("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
+        } else
+                pr_cont("\n");
        hpfs_sb(s)->sb_was_error = 1;
 }
@@ -292,7 +296,7 @@ static int parse_opts(char *opts, kuid_t *uid, kgid_t *gid, umode_t *umask,
        if (!opts)
                return 1;
-        /*printk("Parsing opts: '%s'\n",opts);*/
+        /*pr_info("Parsing opts: '%s'\n",opts);*/
        while ((p = strsep(&opts, ",")) != NULL) {
                substring_t args[MAX_OPT_ARGS];
@@ -387,7 +391,7 @@ static int parse_opts(char *opts, kuid_t *uid, kgid_t *gid, umode_t *umask,
 static inline void hpfs_help(void)
 {
-        printk("\n\
+        pr_info("\n\
 HPFS filesystem options:\n\
      help              do not mount and display this text\n\
      uid=xxx           set uid of files that don't have uid specified in eas\n\
@@ -434,7 +438,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
        if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase,
            &eas, &chk, &errs, &chkdsk, &timeshift))) {
-                printk("HPFS: bad mount options.\n");
+                pr_err("bad mount options.\n");
                goto out_err;
        }
        if (o == 2) {
@@ -442,7 +446,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
                goto out_err;
        }
        if (timeshift != sbi->sb_timeshift) {
-                printk("HPFS: timeshift can't be changed using remount.\n");
+                pr_err("timeshift can't be changed using remount.\n");
                goto out_err;
        }
@@ -523,7 +527,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase,
            &eas, &chk, &errs, &chkdsk, &timeshift))) {
-                printk("HPFS: bad mount options.\n");
+                pr_err("bad mount options.\n");
                goto bail0;
        }
        if (o==2) {
@@ -542,16 +546,17 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        if (/*le16_to_cpu(bootblock->magic) != BB_MAGIC
            ||*/ le32_to_cpu(superblock->magic) != SB_MAGIC
            || le32_to_cpu(spareblock->magic) != SP_MAGIC) {
-                if (!silent) printk("HPFS: Bad magic ... probably not HPFS\n");
+                if (!silent)
+                        pr_err("Bad magic ... probably not HPFS\n");
                goto bail4;
        }
        /* Check version */
        if (!(s->s_flags & MS_RDONLY) &&
              superblock->funcversion != 2 && superblock->funcversion != 3) {
-                printk("HPFS: Bad version %d,%d. Mount readonly to go around\n",
+                pr_err("Bad version %d,%d. Mount readonly to go around\n",
                        (int)superblock->version, (int)superblock->funcversion);
-                printk("HPFS: please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
+                pr_err("please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
                goto bail4;
        }
@@ -597,7 +602,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        /* Check for general fs errors*/
        if (spareblock->dirty && !spareblock->old_wrote) {
                if (errs == 2) {
-                        printk("HPFS: Improperly stopped, not mounted\n");
+                        pr_err("Improperly stopped, not mounted\n");
                        goto bail4;
                }
                hpfs_error(s, "improperly stopped");
@@ -611,22 +616,25 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        if (spareblock->hotfixes_used || spareblock->n_spares_used) {
                if (errs >= 2) {
-                        printk("HPFS: Hotfixes not supported here, try chkdsk\n");
+                        pr_err("Hotfixes not supported here, try chkdsk\n");
                        mark_dirty(s, 0);
                        goto bail4;
                }
                hpfs_error(s, "hotfixes not supported here, try chkdsk");
-                if (errs == 0) printk("HPFS: Proceeding, but your filesystem will be probably corrupted by this driver...\n");
+                if (errs == 0)
-                else printk("HPFS: This driver may read bad files or crash when operating on disk with hotfixes.\n");
+                        pr_err("Proceeding, but your filesystem will be probably corrupted by this driver...\n");
+                else
+                        pr_err("This driver may read bad files or crash when operating on disk with hotfixes.\n");
        }
        if (le32_to_cpu(spareblock->n_dnode_spares) != le32_to_cpu(spareblock->n_dnode_spares_free)) {
                if (errs >= 2) {
-                        printk("HPFS: Spare dnodes used, try chkdsk\n");
+                        pr_err("Spare dnodes used, try chkdsk\n");
                        mark_dirty(s, 0);
                        goto bail4;
                }
                hpfs_error(s, "warning: spare dnodes used, try chkdsk");
-                if (errs == 0) printk("HPFS: Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
+                if (errs == 0)
+                        pr_err("Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
        }
        if (chk) {
                unsigned a;
@@ -645,12 +653,13 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
                        goto bail4;
                }
                sbi->sb_dirband_size = a;
-        } else printk("HPFS: You really don't want any checks? You are crazy...\n");
+        } else
+                pr_err("You really don't want any checks? You are crazy...\n");
        /* Load code page table */
        if (le32_to_cpu(spareblock->n_code_pages))
                if (!(sbi->sb_cp_table = hpfs_load_code_page(s, le32_to_cpu(spareblock->code_page_dir))))
-                        printk("HPFS: Warning: code page support is disabled\n");
+                        pr_err("code page support is disabled\n");
        brelse(bh2);
        brelse(bh1);
diff --git a/fs/inode.c b/fs/inode.c
index f96d2a6f88cc..2feb9b69f1be 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -105,7 +105,7 @@ long get_nr_dirty_inodes(void)
 * Handle nr_inode sysctl
 */
 #ifdef CONFIG_SYSCTL
-int proc_nr_inodes(ctl_table *table, int write,
+int proc_nr_inodes(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
        inodes_stat.nr_inodes = get_nr_inodes();
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 2b60ce1996aa..bb9cebc9ca8a 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -75,10 +75,13 @@ void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
 static int jffs2_garbage_collect_thread(void *_c)
 {
        struct jffs2_sb_info *c = _c;
+        sigset_t hupmask;
+        siginitset(&hupmask, sigmask(SIGHUP));
        allow_signal(SIGKILL);
        allow_signal(SIGSTOP);
        allow_signal(SIGCONT);
+        allow_signal(SIGHUP);
        c->gc_task = current;
        complete(&c->gc_thread_start);
@@ -87,7 +90,7 @@ static int jffs2_garbage_collect_thread(void *_c)
        set_freezable();
        for (;;) {
-                allow_signal(SIGHUP);
+                sigprocmask(SIG_UNBLOCK, &hupmask, NULL);
        again:
                spin_lock(&c->erase_completion_lock);
                if (!jffs2_thread_should_wake(c)) {
@@ -95,10 +98,9 @@ static int jffs2_garbage_collect_thread(void *_c)
                        spin_unlock(&c->erase_completion_lock);
                        jffs2_dbg(1, "%s(): sleeping...\n", __func__);
                        schedule();
-                } else
+                } else {
                        spin_unlock(&c->erase_completion_lock);
-                        
+                }
                /* Problem - immediately after bootup, the GCD spends a lot
                 * of time in places like jffs2_kill_fragtree(); so much so
                 * that userspace processes (like gdm and X) are starved
@@ -150,7 +152,7 @@ static int jffs2_garbage_collect_thread(void *_c)
                        }
                }
                /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */
-                disallow_signal(SIGHUP);
+                sigprocmask(SIG_BLOCK, &hupmask, NULL);
                jffs2_dbg(1, "%s(): pass\n", __func__);
                if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 6bf06a07f3e0..de051cb1f553 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -436,7 +436,7 @@ EXPORT_SYMBOL_GPL(lockd_down);
 * Sysctl parameters (same as module parameters, different interface).
 */
-static ctl_table nlm_sysctls[] = {
+static struct ctl_table nlm_sysctls[] = {
        {
                .procname       = "nlm_grace_period",
                .data           = &nlm_grace_period,
@@ -490,7 +490,7 @@ static ctl_table nlm_sysctls[] = {
        { }
 };
-static ctl_table nlm_sysctl_dir[] = {
+static struct ctl_table nlm_sysctl_dir[] = {
        {
                .procname       = "nfs",
                .mode           = 0555,
@@ -499,7 +499,7 @@ static ctl_table nlm_sysctl_dir[] = {
        { }
 };
-static ctl_table nlm_sysctl_root[] = {
+static struct ctl_table nlm_sysctl_root[] = {
        {
                .procname       = "fs",
                .mode           = 0555,
diff --git a/fs/nfs/nfs4sysctl.c b/fs/nfs/nfs4sysctl.c
index 2628d921b7e3..b6ebe7e445f6 100644
--- a/fs/nfs/nfs4sysctl.c
+++ b/fs/nfs/nfs4sysctl.c
@@ -16,7 +16,7 @@ static const int nfs_set_port_min = 0;
 static const int nfs_set_port_max = 65535;
 static struct ctl_table_header *nfs4_callback_sysctl_table;
-static ctl_table nfs4_cb_sysctls[] = {
+static struct ctl_table nfs4_cb_sysctls[] = {
        {
                .procname = "nfs_callback_tcpport",
                .data = &nfs_callback_set_tcpport,
@@ -36,7 +36,7 @@ static ctl_table nfs4_cb_sysctls[] = {
        { }
 };
-static ctl_table nfs4_cb_sysctl_dir[] = {
+static struct ctl_table nfs4_cb_sysctl_dir[] = {
        {
                .procname = "nfs",
                .mode = 0555,
@@ -45,7 +45,7 @@ static ctl_table nfs4_cb_sysctl_dir[] = {
        { }
 };
-static ctl_table nfs4_cb_sysctl_root[] = {
+static struct ctl_table nfs4_cb_sysctl_root[] = {
        {
                .procname = "fs",
                .mode = 0555,
diff --git a/fs/nfs/sysctl.c b/fs/nfs/sysctl.c
index 6b3f2535a3ec..bb6ed810fa6f 100644
--- a/fs/nfs/sysctl.c
+++ b/fs/nfs/sysctl.c
@@ -13,7 +13,7 @@
 static struct ctl_table_header *nfs_callback_sysctl_table;
-static ctl_table nfs_cb_sysctls[] = {
+static struct ctl_table nfs_cb_sysctls[] = {
        {
                .procname       = "nfs_mountpoint_timeout",
                .data           = &nfs_mountpoint_expiry_timeout,
@@ -31,7 +31,7 @@ static ctl_table nfs_cb_sysctls[] = {
        { }
 };
-static ctl_table nfs_cb_sysctl_dir[] = {
+static struct ctl_table nfs_cb_sysctl_dir[] = {
        {
                .procname = "nfs",
                .mode = 0555,
@@ -40,7 +40,7 @@ static ctl_table nfs_cb_sysctl_dir[] = {
        { }
 };
-static ctl_table nfs_cb_sysctl_root[] = {
+static struct ctl_table nfs_cb_sysctl_root[] = {
        {
                .procname = "fs",
                .mode = 0555,
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index 78a2ca3966c3..cc423a30a0c8 100644
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -57,7 +57,7 @@ static struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
 static int zero;
-ctl_table inotify_table[] = {
+struct ctl_table inotify_table[] = {
        {
                .procname       = "max_user_instances",
                .data           = &inotify_max_user_instances,
diff --git a/fs/ntfs/sysctl.c b/fs/ntfs/sysctl.c
index 1927170a35ce..a503156ec15f 100644
--- a/fs/ntfs/sysctl.c
+++ b/fs/ntfs/sysctl.c
@@ -34,7 +34,7 @@
 #include "debug.h"
 /* Definition of the ntfs sysctl. */
-static ctl_table ntfs_sysctls[] = {
+static struct ctl_table ntfs_sysctls[] = {
        {
                .procname       = "ntfs-debug",
                .data           = &debug_msgs,          /* Data pointer and size. */
@@ -46,7 +46,7 @@ static ctl_table ntfs_sysctls[] = {
 };
 /* Define the parent directory /proc/sys/fs. */
-static ctl_table sysctls_root[] = {
+static struct ctl_table sysctls_root[] = {
        {
                .procname       = "fs",
                .mode           = 0555,
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 48cbe4c0b2a5..5d9da22e29b0 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -1418,10 +1418,10 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
        seq_printf(m, "%08lx %s", vma->vm_start, buffer);
        if (file) {
-                seq_printf(m, " file=");
+                seq_puts(m, " file=");
                seq_path(m, &file->f_path, "\n\t= ");
        } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
-                seq_printf(m, " heap");
+                seq_puts(m, " heap");
        } else {
                pid_t tid = vm_is_stack(task, vma, is_pid);
                if (tid != 0) {
@@ -1431,14 +1431,14 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
                         */
                        if (!is_pid || (vma->vm_start <= mm->start_stack &&
                            vma->vm_end >= mm->start_stack))
-                                seq_printf(m, " stack");
+                                seq_puts(m, " stack");
                        else
                                seq_printf(m, " stack:%d", tid);
                }
        }
        if (is_vm_hugetlb_page(vma))
-                seq_printf(m, " huge");
+                seq_puts(m, " huge");
        walk_page_range(vma->vm_start, vma->vm_end, &walk);
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 6a8e785b29da..382aa890e228 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -42,7 +42,7 @@ static size_t elfnotes_sz;
 /* Total size of vmcore file. */
 static u64 vmcore_size;
-static struct proc_dir_entry *proc_vmcore = NULL;
+static struct proc_dir_entry *proc_vmcore;
 /*
 * Returns > 0 for RAM pages, 0 for non-RAM pages, < 0 on error
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 46d269e38706..0a9b72cdfeca 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -18,6 +18,8 @@
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
+#define pr_fmt(fmt) "pstore: " fmt
 #include <linux/atomic.h>
 #include <linux/types.h>
 #include <linux/errno.h>
@@ -224,14 +226,12 @@ static void allocate_buf_for_compression(void)
                        zlib_inflate_workspacesize());
                stream.workspace = kmalloc(size, GFP_KERNEL);
                if (!stream.workspace) {
-                        pr_err("pstore: No memory for compression workspace; "
+                        pr_err("No memory for compression workspace; skipping compression\n");
-                                "skipping compression\n");
                        kfree(big_oops_buf);
                        big_oops_buf = NULL;
                }
        } else {
-                pr_err("No memory for uncompressed data; "
+                pr_err("No memory for uncompressed data; skipping compression\n");
-                        "skipping compression\n");
                stream.workspace = NULL;
        }
@@ -455,8 +455,7 @@ int pstore_register(struct pstore_info *psi)
                add_timer(&pstore_timer);
        }
-        pr_info("pstore: Registered %s as persistent store backend\n",
+        pr_info("Registered %s as persistent store backend\n", psi->name);
-                psi->name);
        return 0;
 }
@@ -502,8 +501,8 @@ void pstore_get_records(int quiet)
                                size = unzipped_len;
                                compressed = false;
                        } else {
-                                pr_err("pstore: decompression failed;"
+                                pr_err("decompression failed;returned %d\n",
-                                        "returned %d\n", unzipped_len);
+                                       unzipped_len);
                                compressed = true;
                        }
                }
@@ -524,8 +523,8 @@ out:
        mutex_unlock(&psi->read_mutex);
        if (failed)
-                printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n",
+                pr_warn("failed to load %d record(s) from '%s'\n",
-                       failed, psi->name);
+                        failed, psi->name);
 }
 static void pstore_dowork(struct work_struct *work)
diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c
index ff7e3d4df5a1..34a1e5aa848c 100644
--- a/fs/pstore/ram_core.c
+++ b/fs/pstore/ram_core.c
@@ -12,6 +12,8 @@
 *
 */
+#define pr_fmt(fmt) "persistent_ram: " fmt
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -205,12 +207,10 @@ static void persistent_ram_ecc_old(struct persistent_ram_zone *prz)
                        size = buffer->data + prz->buffer_size - block;
                numerr = persistent_ram_decode_rs8(prz, block, size, par);
                if (numerr > 0) {
-                        pr_devel("persistent_ram: error in block %p, %d\n",
+                        pr_devel("error in block %p, %d\n", block, numerr);
-                               block, numerr);
                        prz->corrected_bytes += numerr;
                } else if (numerr < 0) {
-                        pr_devel("persistent_ram: uncorrectable error in block %p\n",
+                        pr_devel("uncorrectable error in block %p\n", block);
-                                block);
                        prz->bad_blocks++;
                }
                block += prz->ecc_info.block_size;
@@ -257,7 +257,7 @@ static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
        prz->rs_decoder = init_rs(prz->ecc_info.symsize, prz->ecc_info.poly,
                                  0, 1, prz->ecc_info.ecc_size);
        if (prz->rs_decoder == NULL) {
-                pr_info("persistent_ram: init_rs failed\n");
+                pr_info("init_rs failed\n");
                return -EINVAL;
        }
@@ -267,10 +267,10 @@ static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
        numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
                                           prz->par_header);
        if (numerr > 0) {
-                pr_info("persistent_ram: error in header, %d\n", numerr);
+                pr_info("error in header, %d\n", numerr);
                prz->corrected_bytes += numerr;
        } else if (numerr < 0) {
-                pr_info("persistent_ram: uncorrectable error in header\n");
+                pr_info("uncorrectable error in header\n");
                prz->bad_blocks++;
        }
@@ -317,7 +317,7 @@ void persistent_ram_save_old(struct persistent_ram_zone *prz)
                prz->old_log = kmalloc(size, GFP_KERNEL);
        }
        if (!prz->old_log) {
-                pr_err("persistent_ram: failed to allocate buffer\n");
+                pr_err("failed to allocate buffer\n");
                return;
        }
@@ -396,8 +396,8 @@ static void *persistent_ram_vmap(phys_addr_t start, size_t size)
        pages = kmalloc(sizeof(struct page *) * page_count, GFP_KERNEL);
        if (!pages) {
-                pr_err("%s: Failed to allocate array for %u pages\n", __func__,
+                pr_err("%s: Failed to allocate array for %u pages\n",
-                        page_count);
+                       __func__, page_count);
                return NULL;
        }
@@ -462,19 +462,17 @@ static int persistent_ram_post_init(struct persistent_ram_zone *prz, u32 sig,
        if (prz->buffer->sig == sig) {
                if (buffer_size(prz) > prz->buffer_size ||
                    buffer_start(prz) > buffer_size(prz))
-                        pr_info("persistent_ram: found existing invalid buffer,"
+                        pr_info("found existing invalid buffer, size %zu, start %zu\n",
-                                " size %zu, start %zu\n",
+                                buffer_size(prz), buffer_start(prz));
-                               buffer_size(prz), buffer_start(prz));
                else {
-                        pr_debug("persistent_ram: found existing buffer,"
+                        pr_debug("found existing buffer, size %zu, start %zu\n",
-                                " size %zu, start %zu\n",
+                                 buffer_size(prz), buffer_start(prz));
-                               buffer_size(prz), buffer_start(prz));
                        persistent_ram_save_old(prz);
                        return 0;
                }
        } else {
-                pr_debug("persistent_ram: no valid data in buffer"
+                pr_debug("no valid data in buffer (sig = 0x%08x)\n",
-                        " (sig = 0x%08x)\n", prz->buffer->sig);
+                         prz->buffer->sig);
        }
        prz->buffer->sig = sig;
@@ -509,7 +507,7 @@ struct persistent_ram_zone *persistent_ram_new(phys_addr_t start, size_t size,
        prz = kzalloc(sizeof(struct persistent_ram_zone), GFP_KERNEL);
        if (!prz) {
-                pr_err("persistent_ram: failed to allocate persistent ram zone\n");
+                pr_err("failed to allocate persistent ram zone\n");
                goto err;
        }
diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index dc9a6829f7c6..1bcffeab713c 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -142,7 +142,6 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
        int org = *beg;
        BUG_ON(!th->t_trans_id);
        RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "
               "range (0..%u)", bmap_n, reiserfs_bmap_count(s) - 1);
        PROC_INFO_INC(s, scan_bitmap.bmap);
@@ -321,7 +320,6 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
        unsigned int off_max = s->s_blocksize << 3;
        BUG_ON(!th->t_trans_id);
        PROC_INFO_INC(s, scan_bitmap.call);
        if (SB_FREE_BLOCKS(s) <= 0)
                return 0;       // No point in looking for more free blocks
@@ -388,9 +386,7 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
        unsigned int nr, offset;
        BUG_ON(!th->t_trans_id);
        PROC_INFO_INC(s, free_block);
        rs = SB_DISK_SUPER_BLOCK(s);
        sbh = SB_BUFFER_WITH_SB(s);
        apbi = SB_AP_BITMAP(s);
@@ -435,8 +431,8 @@ void reiserfs_free_block(struct reiserfs_transaction_handle *th,
                         int for_unformatted)
 {
        struct super_block *s = th->t_super;
-        BUG_ON(!th->t_trans_id);
+        BUG_ON(!th->t_trans_id);
        RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
        if (!is_reusable(s, block, 1))
                return;
@@ -471,6 +467,7 @@ static void __discard_prealloc(struct reiserfs_transaction_handle *th,
        unsigned long save = ei->i_prealloc_block;
        int dirty = 0;
        struct inode *inode = &ei->vfs_inode;
        BUG_ON(!th->t_trans_id);
 #ifdef CONFIG_REISERFS_CHECK
        if (ei->i_prealloc_count < 0)
@@ -494,6 +491,7 @@ void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
                               struct inode *inode)
 {
        struct reiserfs_inode_info *ei = REISERFS_I(inode);
        BUG_ON(!th->t_trans_id);
        if (ei->i_prealloc_count)
                __discard_prealloc(th, ei);
@@ -504,7 +502,6 @@ void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
        struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
        BUG_ON(!th->t_trans_id);
        while (!list_empty(plist)) {
                struct reiserfs_inode_info *ei;
                ei = list_entry(plist->next, struct reiserfs_inode_info,
@@ -562,7 +559,7 @@ int reiserfs_parse_alloc_options(struct super_block *s, char *options)
                if (!strcmp(this_char, "displacing_new_packing_localities")) {
                        SET_OPTION(displacing_new_packing_localities);
                        continue;
-                };
+                }
                if (!strcmp(this_char, "old_hashed_relocation")) {
                        SET_OPTION(old_hashed_relocation);
@@ -729,6 +726,7 @@ void show_alloc_options(struct seq_file *seq, struct super_block *s)
 static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
 {
        char *hash_in;
        if (hint->formatted_node) {
                hash_in = (char *)&hint->key.k_dir_id;
        } else {
@@ -757,6 +755,7 @@ static void dirid_groups(reiserfs_blocknr_hint_t * hint)
        __u32 dirid = 0;
        int bm = 0;
        struct super_block *sb = hint->th->t_super;
        if (hint->inode)
                dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
        else if (hint->formatted_node)
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index b14706a05d52..615cd9ab7940 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -228,10 +228,10 @@ const struct reiserfs_key MIN_KEY = { 0, 0, {{0, 0},} };
 /* Maximal possible key. It is never in the tree. */
 static const struct reiserfs_key MAX_KEY = {
-        __constant_cpu_to_le32(0xffffffff),
+        cpu_to_le32(0xffffffff),
-        __constant_cpu_to_le32(0xffffffff),
+        cpu_to_le32(0xffffffff),
-        {{__constant_cpu_to_le32(0xffffffff),
+        {{cpu_to_le32(0xffffffff),
-          __constant_cpu_to_le32(0xffffffff)},}
+          cpu_to_le32(0xffffffff)},}
 };
 /* Get delimiting key of the buffer by looking for it in the buffers in the path, starting from the bottom
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 0ab1de4b39a5..7bc20809c99e 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -24,7 +24,7 @@
 #define INVBLOCK ((u64)-1L)
-static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned, int *);
+static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned);
 static u64 ufs_alloc_fragments(struct inode *, unsigned, u64, unsigned, int *);
 static u64 ufs_alloccg_block(struct inode *, struct ufs_cg_private_info *, u64, int *);
 static u64 ufs_bitmap_search (struct super_block *, struct ufs_cg_private_info *, u64, unsigned);
@@ -52,7 +52,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
        if (ufs_fragnum(fragment) + count > uspi->s_fpg)
                ufs_error (sb, "ufs_free_fragments", "internal error");
        
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
        
        cgno = ufs_dtog(uspi, fragment);
        bit = ufs_dtogd(uspi, fragment);
@@ -116,12 +116,12 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
                ubh_sync_block(UCPI_UBH(ucpi));
        ufs_mark_sb_dirty(sb);
        
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
        UFSD("EXIT\n");
        return;
 failed:
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
        UFSD("EXIT (FAILED)\n");
        return;
 }
@@ -151,7 +151,7 @@ void ufs_free_blocks(struct inode *inode, u64 fragment, unsigned count)
                goto failed;
        }
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
        
 do_more:
        overflow = 0;
@@ -211,12 +211,12 @@ do_more:
        }
        ufs_mark_sb_dirty(sb);
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
        UFSD("EXIT\n");
        return;
 failed_unlock:
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
 failed:
        UFSD("EXIT (FAILED)\n");
        return;
@@ -357,7 +357,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
        usb1 = ubh_get_usb_first(uspi);
        *err = -ENOSPC;
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
        tmp = ufs_data_ptr_to_cpu(sb, p);
        if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
@@ -378,19 +378,19 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                                  "fragment %llu, tmp %llu\n",
                                  (unsigned long long)fragment,
                                  (unsigned long long)tmp);
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                        return INVBLOCK;
                }
                if (fragment < UFS_I(inode)->i_lastfrag) {
                        UFSD("EXIT (ALREADY ALLOCATED)\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                        return 0;
                }
        }
        else {
                if (tmp) {
                        UFSD("EXIT (ALREADY ALLOCATED)\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                        return 0;
                }
        }
@@ -399,7 +399,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
         * There is not enough space for user on the device
         */
        if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                UFSD("EXIT (FAILED)\n");
                return 0;
        }
@@ -424,7 +424,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                        ufs_clear_frags(inode, result + oldcount,
                                        newcount - oldcount, locked_page != NULL);
                }
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                UFSD("EXIT, result %llu\n", (unsigned long long)result);
                return result;
        }
@@ -432,14 +432,14 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
        /*
         * resize block
         */
-        result = ufs_add_fragments (inode, tmp, oldcount, newcount, err);
+        result = ufs_add_fragments(inode, tmp, oldcount, newcount);
        if (result) {
                *err = 0;
                UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
                                                fragment + count);
                ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
                                locked_page != NULL);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                UFSD("EXIT, result %llu\n", (unsigned long long)result);
                return result;
        }
@@ -477,7 +477,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                *err = 0;
                UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
                                                fragment + count);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                if (newcount < request)
                        ufs_free_fragments (inode, result + newcount, request - newcount);
                ufs_free_fragments (inode, tmp, oldcount);
@@ -485,13 +485,13 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                return result;
        }
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
        UFSD("EXIT (FAILED)\n");
        return 0;
 }               
 static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
-                             unsigned oldcount, unsigned newcount, int *err)
+                             unsigned oldcount, unsigned newcount)
 {
        struct super_block * sb;
        struct ufs_sb_private_info * uspi;
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 98f7211599ff..a9cc75ffa925 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -69,11 +69,11 @@ void ufs_free_inode (struct inode * inode)
        
        ino = inode->i_ino;
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
        if (!((ino > 1) && (ino < (uspi->s_ncg * uspi->s_ipg )))) {
                ufs_warning(sb, "ufs_free_inode", "reserved inode or nonexistent inode %u\n", ino);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                return;
        }
        
@@ -81,7 +81,7 @@ void ufs_free_inode (struct inode * inode)
        bit = ufs_inotocgoff (ino);
        ucpi = ufs_load_cylinder (sb, cg);
        if (!ucpi) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                return;
        }
        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
@@ -115,7 +115,7 @@ void ufs_free_inode (struct inode * inode)
                ubh_sync_block(UCPI_UBH(ucpi));
        
        ufs_mark_sb_dirty(sb);
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
        UFSD("EXIT\n");
 }
@@ -193,7 +193,7 @@ struct inode *ufs_new_inode(struct inode *dir, umode_t mode)
        sbi = UFS_SB(sb);
        uspi = sbi->s_uspi;
-        mutex_lock(&sbi->s_lock);
+        lock_ufs(sb);
        /*
         * Try to place the inode in its parent directory
@@ -328,21 +328,20 @@ cg_found:
                        sync_dirty_buffer(bh);
                brelse(bh);
        }
+        unlock_ufs(sb);
-        mutex_unlock(&sbi->s_lock);
        UFSD("allocating inode %lu\n", inode->i_ino);
        UFSD("EXIT\n");
        return inode;
 fail_remove_inode:
-        mutex_unlock(&sbi->s_lock);
+        unlock_ufs(sb);
        clear_nlink(inode);
        iput(inode);
        UFSD("EXIT (FAILED): err %d\n", err);
        return ERR_PTR(err);
 failed:
-        mutex_unlock(&sbi->s_lock);
+        unlock_ufs(sb);
        make_bad_inode(inode);
        iput (inode);
        UFSD("EXIT (FAILED): err %d\n", err);
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index c1183f9f69dc..b879f1ba3439 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -697,7 +697,6 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
        unsigned flags;
        lock_ufs(sb);
-        mutex_lock(&UFS_SB(sb)->s_lock);
        UFSD("ENTER\n");
@@ -715,7 +714,6 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
        ufs_put_cstotal(sb);
        UFSD("EXIT\n");
-        mutex_unlock(&UFS_SB(sb)->s_lock);
        unlock_ufs(sb);
        return 0;
@@ -760,6 +758,7 @@ static void ufs_put_super(struct super_block *sb)
        ubh_brelse_uspi (sbi->s_uspi);
        kfree (sbi->s_uspi);
+        mutex_destroy(&sbi->mutex);
        kfree (sbi);
        sb->s_fs_info = NULL;
        UFSD("EXIT\n");
@@ -786,6 +785,14 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        flags = 0;
        
        UFSD("ENTER\n");
+#ifndef CONFIG_UFS_FS_WRITE
+        if (!(sb->s_flags & MS_RDONLY)) {
+                printk("ufs was compiled with read-only support, "
+                       "can't be mounted as read-write\n");
+                return -EROFS;
+        }
+#endif
                
        sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
        if (!sbi)
@@ -795,15 +802,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
        
-#ifndef CONFIG_UFS_FS_WRITE
-        if (!(sb->s_flags & MS_RDONLY)) {
-                printk("ufs was compiled with read-only support, "
-                "can't be mounted as read-write\n");
-                goto failed;
-        }
-#endif
        mutex_init(&sbi->mutex);
-        mutex_init(&sbi->s_lock);
        spin_lock_init(&sbi->work_lock);
        INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
        /*
@@ -1257,6 +1256,7 @@ magic_found:
        return 0;
 failed:
+        mutex_destroy(&sbi->mutex);
        if (ubh)
                ubh_brelse_uspi (uspi);
        kfree (uspi);
@@ -1280,7 +1280,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
        sync_filesystem(sb);
        lock_ufs(sb);
-        mutex_lock(&UFS_SB(sb)->s_lock);
        uspi = UFS_SB(sb)->s_uspi;
        flags = UFS_SB(sb)->s_flags;
        usb1 = ubh_get_usb_first(uspi);
@@ -1294,7 +1293,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
        new_mount_opt = 0;
        ufs_set_opt (new_mount_opt, ONERROR_LOCK);
        if (!ufs_parse_options (data, &new_mount_opt)) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                unlock_ufs(sb);
                return -EINVAL;
        }
@@ -1302,14 +1300,12 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                new_mount_opt |= ufstype;
        } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
                printk("ufstype can't be changed during remount\n");
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                unlock_ufs(sb);
                return -EINVAL;
        }
        if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
                UFS_SB(sb)->s_mount_opt = new_mount_opt;
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                unlock_ufs(sb);
                return 0;
        }
@@ -1334,7 +1330,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 #ifndef CONFIG_UFS_FS_WRITE
                printk("ufs was compiled with read-only support, "
                "can't be mounted as read-write\n");
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                unlock_ufs(sb);
                return -EINVAL;
 #else
@@ -1344,13 +1339,11 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                    ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
                    ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
                        printk("this ufstype is read-only supported\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
                        unlock_ufs(sb);
                        return -EINVAL;
                }
                if (!ufs_read_cylinder_structures(sb)) {
                        printk("failed during remounting\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
                        unlock_ufs(sb);
                        return -EPERM;
                }
@@ -1358,7 +1351,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 #endif
        }
        UFS_SB(sb)->s_mount_opt = new_mount_opt;
-        mutex_unlock(&UFS_SB(sb)->s_lock);
        unlock_ufs(sb);
        return 0;
 }
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index ff2c15ab81aa..343e6fc571e5 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -24,7 +24,6 @@ struct ufs_sb_info {
        int work_queued; /* non-zero if the delayed work is queued */
        struct delayed_work sync_work; /* FS sync delayed work */
        spinlock_t work_lock; /* protects sync_work and work_queued */
-        struct mutex s_lock;
 };
 struct ufs_inode_info {