Merge branch 'akpm' (Andrew's patch-bomb)

Merge Andrew's first set of patches:
 "Non-MM patches:

   - lots of misc bits

   - tree-wide have_clk() cleanups

   - quite a lot of printk tweaks.  I draw your attention to "printk:
     convert the format for KERN_<LEVEL> to a 2 byte pattern" which
     looks a bit scary.  But afaict it's solid.

   - backlight updates

   - lib/ feature work (notably the addition and use of memweight())

   - checkpatch updates

   - rtc updates

   - nilfs updates

   - fatfs updates (partial, still waiting for acks)

   - kdump, proc, fork, IPC, sysctl, taskstats, pps, etc

   - new fault-injection feature work"

* Merge emailed patches from Andrew Morton <akpm@linux-foundation.org>: (128 commits)
  drivers/misc/lkdtm.c: fix missing allocation failure check
  lib/scatterlist: do not re-write gfp_flags in __sg_alloc_table()
  fault-injection: add tool to run command with failslab or fail_page_alloc
  fault-injection: add selftests for cpu and memory hotplug
  powerpc: pSeries reconfig notifier error injection module
  memory: memory notifier error injection module
  PM: PM notifier error injection module
  cpu: rewrite cpu-notifier-error-inject module
  fault-injection: notifier error injection
  c/r: fcntl: add F_GETOWNER_UIDS option
  resource: make sure requested range is included in the root range
  include/linux/aio.h: cpp->C conversions
  fs: cachefiles: add support for large files in filesystem caching
  pps: return PTR_ERR on error in device_create
  taskstats: check nla_reserve() return
  sysctl: suppress kmemleak messages
  ipc: use Kconfig options for __ARCH_WANT_[COMPAT_]IPC_PARSE_VERSION
  ipc: compat: use signed size_t types for msgsnd and msgrcv
  ipc: allow compat IPC version field parsing if !ARCH_WANT_OLD_COMPAT_IPC
  ipc: add COMPAT_SHMLBA support
  ...

5 files changed, 161 insertions, 143 deletions

diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 6eaa28c98ad1..dc49ed2cbffa 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -35,6 +35,11 @@
 #define FAT_MAX_UNI_CHARS       ((MSDOS_SLOTS - 1) * 13 + 1)
 #define FAT_MAX_UNI_SIZE        (FAT_MAX_UNI_CHARS * sizeof(wchar_t))
 
+static inline unsigned char fat_tolower(unsigned char c)
+{
+        return ((c >= 'A') && (c <= 'Z')) ? c+32 : c;
+}
+
 static inline loff_t fat_make_i_pos(struct super_block *sb,
                                     struct buffer_head *bh,
                                     struct msdos_dir_entry *de)
@@ -333,6 +338,124 @@ parse_long:
         return 0;
 }
 
+/**
+ * fat_parse_short - Parse MS-DOS (short) directory entry.
+ * @sb:         superblock
+ * @de:         directory entry to parse
+ * @name:       FAT_MAX_SHORT_SIZE array in which to place extracted name
+ * @dot_hidden: Nonzero == prepend '.' to names with ATTR_HIDDEN
+ *
+ * Returns the number of characters extracted into 'name'.
+ */
+static int fat_parse_short(struct super_block *sb,
+                           const struct msdos_dir_entry *de,
+                           unsigned char *name, int dot_hidden)
+{
+        const struct msdos_sb_info *sbi = MSDOS_SB(sb);
+        int isvfat = sbi->options.isvfat;
+        int nocase = sbi->options.nocase;
+        unsigned short opt_shortname = sbi->options.shortname;
+        struct nls_table *nls_disk = sbi->nls_disk;
+        wchar_t uni_name[14];
+        unsigned char c, work[MSDOS_NAME];
+        unsigned char *ptname = name;
+        int chi, chl, i, j, k;
+        int dotoffset = 0;
+        int name_len = 0, uni_len = 0;
+
+        if (!isvfat && dot_hidden && (de->attr & ATTR_HIDDEN)) {
+                *ptname++ = '.';
+                dotoffset = 1;
+        }
+
+        memcpy(work, de->name, sizeof(work));
+        /* see namei.c, msdos_format_name */
+        if (work[0] == 0x05)
+                work[0] = 0xE5;
+
+        /* Filename */
+        for (i = 0, j = 0; i < 8;) {
+                c = work[i];
+                if (!c)
+                        break;
+                chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
+                                        &uni_name[j++], opt_shortname,
+                                        de->lcase & CASE_LOWER_BASE);
+                if (chl <= 1) {
+                        if (!isvfat)
+                                ptname[i] = nocase ? c : fat_tolower(c);
+                        i++;
+                        if (c != ' ') {
+                                name_len = i;
+                                uni_len  = j;
+                        }
+                } else {
+                        uni_len = j;
+                        if (isvfat)
+                                i += min(chl, 8-i);
+                        else {
+                                for (chi = 0; chi < chl && i < 8; chi++, i++)
+                                        ptname[i] = work[i];
+                        }
+                        if (chl)
+                                name_len = i;
+                }
+        }
+
+        i = name_len;
+        j = uni_len;
+        fat_short2uni(nls_disk, ".", 1, &uni_name[j++]);
+        if (!isvfat)
+                ptname[i] = '.';
+        i++;
+
+        /* Extension */
+        for (k = 8; k < MSDOS_NAME;) {
+                c = work[k];
+                if (!c)
+                        break;
+                chl = fat_shortname2uni(nls_disk, &work[k], MSDOS_NAME - k,
+                                        &uni_name[j++], opt_shortname,
+                                        de->lcase & CASE_LOWER_EXT);
+                if (chl <= 1) {
+                        k++;
+                        if (!isvfat)
+                                ptname[i] = nocase ? c : fat_tolower(c);
+                        i++;
+                        if (c != ' ') {
+                                name_len = i;
+                                uni_len  = j;
+                        }
+                } else {
+                        uni_len = j;
+                        if (isvfat) {
+                                int offset = min(chl, MSDOS_NAME-k);
+                                k += offset;
+                                i += offset;
+                        } else {
+                                for (chi = 0; chi < chl && k < MSDOS_NAME;
+                                     chi++, i++, k++) {
+                                                ptname[i] = work[k];
+                                }
+                        }
+                        if (chl)
+                                name_len = i;
+                }
+        }
+
+        if (name_len > 0) {
+                name_len += dotoffset;
+
+                if (sbi->options.isvfat) {
+                        uni_name[uni_len] = 0x0000;
+                        name_len = fat_uni_to_x8(sb, uni_name, name,
+                                                 FAT_MAX_SHORT_SIZE);
+                }
+        }
+
+        return name_len;
+}
+
 /*
  * Return values: negative -> error, 0 -> not found, positive -> found,
  * value is the total amount of slots, including the shortname entry.
@@ -344,15 +467,11 @@ int fat_search_long(struct inode *inode, const unsigned char *name,
         struct msdos_sb_info *sbi = MSDOS_SB(sb);
         struct buffer_head *bh = NULL;
         struct msdos_dir_entry *de;
-        struct nls_table *nls_disk = sbi->nls_disk;
         unsigned char nr_slots;
-        wchar_t bufuname[14];
         wchar_t *unicode = NULL;
-        unsigned char work[MSDOS_NAME];
         unsigned char bufname[FAT_MAX_SHORT_SIZE];
-        unsigned short opt_shortname = sbi->options.shortname;
         loff_t cpos = 0;
-        int chl, i, j, last_u, err, len;
+        int err, len;
 
         err = -ENOENT;
         while (1) {
@@ -380,47 +499,16 @@ parse_record:
                                 goto end_of_dir;
                 }
 
-                memcpy(work, de->name, sizeof(de->name));
-                /* see namei.c, msdos_format_name */
-                if (work[0] == 0x05)
-                        work[0] = 0xE5;
-                for (i = 0, j = 0, last_u = 0; i < 8;) {
-                        if (!work[i])
-                                break;
-                        chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
-                                                &bufuname[j++], opt_shortname,
-                                                de->lcase & CASE_LOWER_BASE);
-                        if (chl <= 1) {
-                                if (work[i] != ' ')
-                                        last_u = j;
-                        } else {
-                                last_u = j;
-                        }
-                        i += chl;
-                }
-                j = last_u;
-                fat_short2uni(nls_disk, ".", 1, &bufuname[j++]);
-                for (i = 8; i < MSDOS_NAME;) {
-                        if (!work[i])
-                                break;
-                        chl = fat_shortname2uni(nls_disk, &work[i],
-                                                MSDOS_NAME - i,
-                                                &bufuname[j++], opt_shortname,
-                                                de->lcase & CASE_LOWER_EXT);
-                        if (chl <= 1) {
-                                if (work[i] != ' ')
-                                        last_u = j;
-                        } else {
-                                last_u = j;
-                        }
-                        i += chl;
-                }
-                if (!last_u)
+                /* Never prepend '.' to hidden files here.
+                 * That is done only for msdos mounts (and only when
+                 * 'dotsOK=yes'); if we are executing here, it is in the
+                 * context of a vfat mount.
+                 */
+                len = fat_parse_short(sb, de, bufname, 0);
+                if (len == 0)
                         continue;
 
                 /* Compare shortname */
-                bufuname[last_u] = 0x0000;
-                len = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));
                 if (fat_name_match(sbi, name, name_len, bufname, len))
                         goto found;
 
@@ -469,20 +557,15 @@ static int __fat_readdir(struct inode *inode, struct file *filp, void *dirent,
         struct msdos_sb_info *sbi = MSDOS_SB(sb);
         struct buffer_head *bh;
         struct msdos_dir_entry *de;
-        struct nls_table *nls_disk = sbi->nls_disk;
         unsigned char nr_slots;
-        wchar_t bufuname[14];
         wchar_t *unicode = NULL;
-        unsigned char c, work[MSDOS_NAME];
-        unsigned char bufname[FAT_MAX_SHORT_SIZE], *ptname = bufname;
-        unsigned short opt_shortname = sbi->options.shortname;
+        unsigned char bufname[FAT_MAX_SHORT_SIZE];
         int isvfat = sbi->options.isvfat;
-        int nocase = sbi->options.nocase;
         const char *fill_name = NULL;
         unsigned long inum;
         unsigned long lpos, dummy, *furrfu = &lpos;
         loff_t cpos;
-        int chi, chl, i, i2, j, last, last_u, dotoffset = 0, fill_len = 0;
+        int short_len = 0, fill_len = 0;
         int ret = 0;
 
         lock_super(sb);
@@ -556,74 +639,10 @@ parse_record:
                 }
         }
 
-        if (sbi->options.dotsOK) {
-                ptname = bufname;
-                dotoffset = 0;
-                if (de->attr & ATTR_HIDDEN) {
-                        *ptname++ = '.';
-                        dotoffset = 1;
-                }
-        }
-
-        memcpy(work, de->name, sizeof(de->name));
-        /* see namei.c, msdos_format_name */
-        if (work[0] == 0x05)
-                work[0] = 0xE5;
-        for (i = 0, j = 0, last = 0, last_u = 0; i < 8;) {
-                if (!(c = work[i]))
-                        break;
-                chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
-                                        &bufuname[j++], opt_shortname,
-                                        de->lcase & CASE_LOWER_BASE);
-                if (chl <= 1) {
-                        ptname[i++] = (!nocase && c>='A' && c<='Z') ? c+32 : c;
-                        if (c != ' ') {
-                                last = i;
-                                last_u = j;
-                        }
-                } else {
-                        last_u = j;
-                        for (chi = 0; chi < chl && i < 8; chi++) {
-                                ptname[i] = work[i];
-                                i++; last = i;
-                        }
-                }
-        }
-        i = last;
-        j = last_u;
-        fat_short2uni(nls_disk, ".", 1, &bufuname[j++]);
-        ptname[i++] = '.';
-        for (i2 = 8; i2 < MSDOS_NAME;) {
-                if (!(c = work[i2]))
-                        break;
-                chl = fat_shortname2uni(nls_disk, &work[i2], MSDOS_NAME - i2,
-                                        &bufuname[j++], opt_shortname,
-                                        de->lcase & CASE_LOWER_EXT);
-                if (chl <= 1) {
-                        i2++;
-                        ptname[i++] = (!nocase && c>='A' && c<='Z') ? c+32 : c;
-                        if (c != ' ') {
-                                last = i;
-                                last_u = j;
-                        }
-                } else {
-                        last_u = j;
-                        for (chi = 0; chi < chl && i2 < MSDOS_NAME; chi++) {
-                                ptname[i++] = work[i2++];
-                                last = i;
-                        }
-                }
-        }
-        if (!last)
+        short_len = fat_parse_short(sb, de, bufname, sbi->options.dotsOK);
+        if (short_len == 0)
                 goto record_end;
 
-        i = last + dotoffset;
-        j = last_u;
-
-        if (isvfat) {
-                bufuname[j] = 0x0000;
-                i = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));
-        }
         if (nr_slots) {
                 /* hack for fat_ioctl_filldir() */
                 struct fat_ioctl_filldir_callback *p = dirent;
@@ -631,12 +650,12 @@ parse_record:
                 p->longname = fill_name;
                 p->long_len = fill_len;
                 p->shortname = bufname;
-                p->short_len = i;
+                p->short_len = short_len;
                 fill_name = NULL;
                 fill_len = 0;
         } else {
                 fill_name = bufname;
-                fill_len = i;
+                fill_len = short_len;
         }
 
 start_filldir:
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index fc35c5c69136..2deeeb86f331 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -217,6 +217,21 @@ static inline void fat16_towchar(wchar_t *dst, const __u8 *src, size_t len)
 #endif
 }
 
+static inline int fat_get_start(const struct msdos_sb_info *sbi,
+                                const struct msdos_dir_entry *de)
+{
+        int cluster = le16_to_cpu(de->start);
+        if (sbi->fat_bits == 32)
+                cluster |= (le16_to_cpu(de->starthi) << 16);
+        return cluster;
+}
+
+static inline void fat_set_start(struct msdos_dir_entry *de, int cluster)
+{
+        de->start   = cpu_to_le16(cluster);
+        de->starthi = cpu_to_le16(cluster >> 16);
+}
+
 static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)
 {
 #ifdef __BIG_ENDIAN
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 0038b32cb362..05e897fe9866 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -369,10 +369,7 @@ static int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
                 inode->i_op = sbi->dir_ops;
                 inode->i_fop = &fat_dir_operations;
 
-                MSDOS_I(inode)->i_start = le16_to_cpu(de->start);
-                if (sbi->fat_bits == 32)
-                        MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16);
-
+                MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
                 error = fat_calc_dir_size(inode);
                 if (error < 0)
@@ -385,9 +382,7 @@ static int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
                 inode->i_mode = fat_make_mode(sbi, de->attr,
                         ((sbi->options.showexec && !is_exec(de->name + 8))
                          ? S_IRUGO|S_IWUGO : S_IRWXUGO));
-                MSDOS_I(inode)->i_start = le16_to_cpu(de->start);
-                if (sbi->fat_bits == 32)
-                        MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16);
+                MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
 
                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
                 inode->i_size = le32_to_cpu(de->size);
@@ -613,8 +608,7 @@ retry:
         else
                 raw_entry->size = cpu_to_le32(inode->i_size);
         raw_entry->attr = fat_make_attrs(inode);
-        raw_entry->start = cpu_to_le16(MSDOS_I(inode)->i_logstart);
-        raw_entry->starthi = cpu_to_le16(MSDOS_I(inode)->i_logstart >> 16);
+        fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
         fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time,
                           &raw_entry->date, NULL);
         if (sbi->options.isvfat) {
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index 70d993a93805..b0e12bf9f4a1 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -246,8 +246,7 @@ static int msdos_add_entry(struct inode *dir, const unsigned char *name,
         de.ctime_cs = 0;
         de.time = time;
         de.date = date;
-        de.start = cpu_to_le16(cluster);
-        de.starthi = cpu_to_le16(cluster >> 16);
+        fat_set_start(&de, cluster);
         de.size = 0;
 
         err = fat_add_entries(dir, &de, 1, sinfo);
@@ -530,9 +529,7 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
                 mark_inode_dirty(old_inode);
 
         if (update_dotdot) {
-                int start = MSDOS_I(new_dir)->i_logstart;
-                dotdot_de->start = cpu_to_le16(start);
-                dotdot_de->starthi = cpu_to_le16(start >> 16);
+                fat_set_start(dotdot_de, MSDOS_I(new_dir)->i_logstart);
                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
                 if (IS_DIRSYNC(new_dir)) {
                         err = sync_dirty_buffer(dotdot_bh);
@@ -572,9 +569,7 @@ error_dotdot:
         corrupt = 1;
 
         if (update_dotdot) {
-                int start = MSDOS_I(old_dir)->i_logstart;
-                dotdot_de->start = cpu_to_le16(start);
-                dotdot_de->starthi = cpu_to_le16(start >> 16);
+                fat_set_start(dotdot_de, MSDOS_I(old_dir)->i_logstart);
                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
                 corrupt |= sync_dirty_buffer(dotdot_bh);
         }
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 6cc480652433..6a6d8c0715a1 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -651,8 +651,7 @@ shortname:
         de->time = de->ctime = time;
         de->date = de->cdate = de->adate = date;
         de->ctime_cs = time_cs;
-        de->start = cpu_to_le16(cluster);
-        de->starthi = cpu_to_le16(cluster >> 16);
+        fat_set_start(de, cluster);
         de->size = 0;
 out_free:
         __putname(uname);
@@ -965,9 +964,7 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
                 mark_inode_dirty(old_inode);
 
         if (update_dotdot) {
-                int start = MSDOS_I(new_dir)->i_logstart;
-                dotdot_de->start = cpu_to_le16(start);
-                dotdot_de->starthi = cpu_to_le16(start >> 16);
+                fat_set_start(dotdot_de, MSDOS_I(new_dir)->i_logstart);
                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
                 if (IS_DIRSYNC(new_dir)) {
                         err = sync_dirty_buffer(dotdot_bh);
@@ -1009,9 +1006,7 @@ error_dotdot:
         corrupt = 1;
 
         if (update_dotdot) {
-                int start = MSDOS_I(old_dir)->i_logstart;
-                dotdot_de->start = cpu_to_le16(start);
-                dotdot_de->starthi = cpu_to_le16(start >> 16);
+                fat_set_start(dotdot_de, MSDOS_I(old_dir)->i_logstart);
                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
                 corrupt |= sync_dirty_buffer(dotdot_bh);
         }