11 files changed, 165 insertions, 131 deletions

diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index be1e8f91c0a..4666780f315 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -282,7 +282,7 @@ static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
         byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
         byte_count += total_in_buf2;
         /* don't allow buffer to overflow */
-        if (byte_count > CIFSMaxBufSize)
+        if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4)
                 return -ENOBUFS;
         pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
 
@@ -2122,7 +2122,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                 warned_on_ntlm = true;
                 cERROR(1, "default security mechanism requested.  The default "
                         "security mechanism will be upgraded from ntlm to "
-                        "ntlmv2 in kernel release 3.2");
+                        "ntlmv2 in kernel release 3.3");
         }
         ses->overrideSecFlg = volume_info->secFlg;
 
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 51352de88ef..a10e428b32b 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -1506,35 +1506,6 @@ static long do_ioctl_trans(int fd, unsigned int cmd,
         return -ENOIOCTLCMD;
 }
 
-static void compat_ioctl_error(struct file *filp, unsigned int fd,
-                unsigned int cmd, unsigned long arg)
-{
-        char buf[10];
-        char *fn = "?";
-        char *path;
-
-        /* find the name of the device. */
-        path = (char *)__get_free_page(GFP_KERNEL);
-        if (path) {
-                fn = d_path(&filp->f_path, path, PAGE_SIZE);
-                if (IS_ERR(fn))
-                        fn = "?";
-        }
-
-         sprintf(buf,"'%c'", (cmd>>_IOC_TYPESHIFT) & _IOC_TYPEMASK);
-        if (!isprint(buf[1]))
-                sprintf(buf, "%02x", buf[1]);
-        compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
-                        "cmd(%08x){t:%s;sz:%u} arg(%08x) on %s\n",
-                        current->comm, current->pid,
-                        (int)fd, (unsigned int)cmd, buf,
-                        (cmd >> _IOC_SIZESHIFT) & _IOC_SIZEMASK,
-                        (unsigned int)arg, fn);
-
-        if (path)
-                free_page((unsigned long)path);
-}
-
 static int compat_ioctl_check_table(unsigned int xcmd)
 {
         int i;
@@ -1621,13 +1592,8 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
                 goto found_handler;
 
         error = do_ioctl_trans(fd, cmd, arg, filp);
-        if (error == -ENOIOCTLCMD) {
-                static int count;
-
-                if (++count <= 50)
-                        compat_ioctl_error(filp, fd, cmd, arg);
-                error = -EINVAL;
-        }
+        if (error == -ENOIOCTLCMD)
+                error = -ENOTTY;
 
         goto out_fput;
 
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index d5016606fb2..f65d4455c5e 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -15,9 +15,11 @@
 
 #include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/seq_file.h>
 #include <linux/pagemap.h>
 #include <linux/namei.h>
 #include <linux/debugfs.h>
+#include <linux/io.h>
 
 static ssize_t default_read_file(struct file *file, char __user *buf,
                                  size_t count, loff_t *ppos)
@@ -525,3 +527,96 @@ struct dentry *debugfs_create_blob(const char *name, umode_t mode,
         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_blob);
+
+#ifdef CONFIG_HAS_IOMEM
+
+/*
+ * The regset32 stuff is used to print 32-bit registers using the
+ * seq_file utilities. We offer printing a register set in an already-opened
+ * sequential file or create a debugfs file that only prints a regset32.
+ */
+
+/**
+ * debugfs_print_regs32 - use seq_print to describe a set of registers
+ * @s: the seq_file structure being used to generate output
+ * @regs: an array if struct debugfs_reg32 structures
+ * @mregs: the length of the above array
+ * @base: the base address to be used in reading the registers
+ * @prefix: a string to be prefixed to every output line
+ *
+ * This function outputs a text block describing the current values of
+ * some 32-bit hardware registers. It is meant to be used within debugfs
+ * files based on seq_file that need to show registers, intermixed with other
+ * information. The prefix argument may be used to specify a leading string,
+ * because some peripherals have several blocks of identical registers,
+ * for example configuration of dma channels
+ */
+int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+                           int nregs, void __iomem *base, char *prefix)
+{
+        int i, ret = 0;
+
+        for (i = 0; i < nregs; i++, regs++) {
+                if (prefix)
+                        ret += seq_printf(s, "%s", prefix);
+                ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
+                                  readl(base + regs->offset));
+        }
+        return ret;
+}
+EXPORT_SYMBOL_GPL(debugfs_print_regs32);
+
+static int debugfs_show_regset32(struct seq_file *s, void *data)
+{
+        struct debugfs_regset32 *regset = s->private;
+
+        debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
+        return 0;
+}
+
+static int debugfs_open_regset32(struct inode *inode, struct file *file)
+{
+        return single_open(file, debugfs_show_regset32, inode->i_private);
+}
+
+static const struct file_operations fops_regset32 = {
+        .open =         debugfs_open_regset32,
+        .read =         seq_read,
+        .llseek =       seq_lseek,
+        .release =      single_release,
+};
+
+/**
+ * debugfs_create_regset32 - create a debugfs file that returns register values
+ * @name: a pointer to a string containing the name of the file to create.
+ * @mode: the permission that the file should have
+ * @parent: a pointer to the parent dentry for this file.  This should be a
+ *          directory dentry if set.  If this parameter is %NULL, then the
+ *          file will be created in the root of the debugfs filesystem.
+ * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
+ *          to an array of register definitions, the array size and the base
+ *          address where the register bank is to be found.
+ *
+ * This function creates a file in debugfs with the given name that reports
+ * the names and values of a set of 32-bit registers. If the @mode variable
+ * is so set it can be read from. Writing is not supported.
+ *
+ * This function will return a pointer to a dentry if it succeeds.  This
+ * pointer must be passed to the debugfs_remove() function when the file is
+ * to be removed (no automatic cleanup happens if your module is unloaded,
+ * you are responsible here.)  If an error occurs, %NULL will be returned.
+ *
+ * If debugfs is not enabled in the kernel, the value -%ENODEV will be
+ * returned.  It is not wise to check for this value, but rather, check for
+ * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
+ * code.
+ */
+struct dentry *debugfs_create_regset32(const char *name, mode_t mode,
+                                       struct dentry *parent,
+                                       struct debugfs_regset32 *regset)
+{
+        return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
+}
+EXPORT_SYMBOL_GPL(debugfs_create_regset32);
+
+#endif /* CONFIG_HAS_IOMEM */
diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index 990626e7da8..0b3109ee425 100644
--- a/fs/dlm/lowcomms.c
+++ b/fs/dlm/lowcomms.c
@@ -281,7 +281,7 @@ static int nodeid_to_addr(int nodeid, struct sockaddr *retaddr)
         } else {
                 struct sockaddr_in6 *in6  = (struct sockaddr_in6 *) &addr;
                 struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) retaddr;
-                ipv6_addr_copy(&ret6->sin6_addr, &in6->sin6_addr);
+                ret6->sin6_addr = in6->sin6_addr;
         }
 
         return 0;
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 1d9b9fcb2db..066836e8184 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -42,7 +42,7 @@ static long vfs_ioctl(struct file *filp, unsigned int cmd,
 
         error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
         if (error == -ENOIOCTLCMD)
-                error = -EINVAL;
+                error = -ENOTTY;
  out:
         return error;
 }
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index c811c19d31b..fa8b612b8ce 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -262,23 +262,6 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
                 goto out_no_root;
         }
 
-        ret = -ENOMEM;
-        s->s_root = d_alloc_root(root_inode);
-        if (!s->s_root)
-                goto out_iput;
-
-        if (!(s->s_flags & MS_RDONLY)) {
-                if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
-                        ms->s_state &= ~MINIX_VALID_FS;
-                mark_buffer_dirty(bh);
-        }
-        if (!(sbi->s_mount_state & MINIX_VALID_FS))
-                printk("MINIX-fs: mounting unchecked file system, "
-                        "running fsck is recommended\n");
-        else if (sbi->s_mount_state & MINIX_ERROR_FS)
-                printk("MINIX-fs: mounting file system with errors, "
-                        "running fsck is recommended\n");
-
         /* Apparently minix can create filesystems that allocate more blocks for
          * the bitmaps than needed.  We simply ignore that, but verify it didn't
          * create one with not enough blocks and bail out if so.
@@ -299,6 +282,23 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
                 goto out_iput;
         }
 
+        ret = -ENOMEM;
+        s->s_root = d_alloc_root(root_inode);
+        if (!s->s_root)
+                goto out_iput;
+
+        if (!(s->s_flags & MS_RDONLY)) {
+                if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
+                        ms->s_state &= ~MINIX_VALID_FS;
+                mark_buffer_dirty(bh);
+        }
+        if (!(sbi->s_mount_state & MINIX_VALID_FS))
+                printk("MINIX-fs: mounting unchecked file system, "
+                        "running fsck is recommended\n");
+        else if (sbi->s_mount_state & MINIX_ERROR_FS)
+                printk("MINIX-fs: mounting file system with errors, "
+                        "running fsck is recommended\n");
+
         return 0;
 
 out_iput:
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 3a1dafd228d..8c344f037bd 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -394,8 +394,8 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
 
         sigemptyset(&sigign);
         sigemptyset(&sigcatch);
-        cutime = cstime = utime = stime = cputime_zero;
-        cgtime = gtime = cputime_zero;
+        cutime = cstime = utime = stime = 0;
+        cgtime = gtime = 0;
 
         if (lock_task_sighand(task, &flags)) {
                 struct signal_struct *sig = task->signal;
@@ -423,14 +423,14 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                         do {
                                 min_flt += t->min_flt;
                                 maj_flt += t->maj_flt;
-                                gtime = cputime_add(gtime, t->gtime);
+                                gtime += t->gtime;
                                 t = next_thread(t);
                         } while (t != task);
 
                         min_flt += sig->min_flt;
                         maj_flt += sig->maj_flt;
                         thread_group_times(task, &utime, &stime);
-                        gtime = cputime_add(gtime, sig->gtime);
+                        gtime += sig->gtime;
                 }
 
                 sid = task_session_nr_ns(task, ns);
diff --git a/fs/proc/stat.c b/fs/proc/stat.c
index 0855e6f2039..d76ca6ae2b1 100644
--- a/fs/proc/stat.c
+++ b/fs/proc/stat.c
@@ -22,29 +22,27 @@
 #define arch_idle_time(cpu) 0
 #endif
 
-static cputime64_t get_idle_time(int cpu)
+static u64 get_idle_time(int cpu)
 {
-        u64 idle_time = get_cpu_idle_time_us(cpu, NULL);
-        cputime64_t idle;
+        u64 idle, idle_time = get_cpu_idle_time_us(cpu, NULL);
 
         if (idle_time == -1ULL) {
                 /* !NO_HZ so we can rely on cpustat.idle */
-                idle = kstat_cpu(cpu).cpustat.idle;
-                idle = cputime64_add(idle, arch_idle_time(cpu));
+                idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE];
+                idle += arch_idle_time(cpu);
         } else
                 idle = usecs_to_cputime64(idle_time);
 
         return idle;
 }
 
-static cputime64_t get_iowait_time(int cpu)
+static u64 get_iowait_time(int cpu)
 {
-        u64 iowait_time = get_cpu_iowait_time_us(cpu, NULL);
-        cputime64_t iowait;
+        u64 iowait, iowait_time = get_cpu_iowait_time_us(cpu, NULL);
 
         if (iowait_time == -1ULL)
                 /* !NO_HZ so we can rely on cpustat.iowait */
-                iowait = kstat_cpu(cpu).cpustat.iowait;
+                iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT];
         else
                 iowait = usecs_to_cputime64(iowait_time);
 
@@ -55,33 +53,30 @@ static int show_stat(struct seq_file *p, void *v)
 {
         int i, j;
         unsigned long jif;
-        cputime64_t user, nice, system, idle, iowait, irq, softirq, steal;
-        cputime64_t guest, guest_nice;
+        u64 user, nice, system, idle, iowait, irq, softirq, steal;
+        u64 guest, guest_nice;
         u64 sum = 0;
         u64 sum_softirq = 0;
         unsigned int per_softirq_sums[NR_SOFTIRQS] = {0};
         struct timespec boottime;
 
         user = nice = system = idle = iowait =
-                irq = softirq = steal = cputime64_zero;
-        guest = guest_nice = cputime64_zero;
+                irq = softirq = steal = 0;
+        guest = guest_nice = 0;
         getboottime(&boottime);
         jif = boottime.tv_sec;
 
         for_each_possible_cpu(i) {
-                user = cputime64_add(user, kstat_cpu(i).cpustat.user);
-                nice = cputime64_add(nice, kstat_cpu(i).cpustat.nice);
-                system = cputime64_add(system, kstat_cpu(i).cpustat.system);
-                idle = cputime64_add(idle, get_idle_time(i));
-                iowait = cputime64_add(iowait, get_iowait_time(i));
-                irq = cputime64_add(irq, kstat_cpu(i).cpustat.irq);
-                softirq = cputime64_add(softirq, kstat_cpu(i).cpustat.softirq);
-                steal = cputime64_add(steal, kstat_cpu(i).cpustat.steal);
-                guest = cputime64_add(guest, kstat_cpu(i).cpustat.guest);
-                guest_nice = cputime64_add(guest_nice,
-                        kstat_cpu(i).cpustat.guest_nice);
-                sum += kstat_cpu_irqs_sum(i);
-                sum += arch_irq_stat_cpu(i);
+                user += kcpustat_cpu(i).cpustat[CPUTIME_USER];
+                nice += kcpustat_cpu(i).cpustat[CPUTIME_NICE];
+                system += kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM];
+                idle += get_idle_time(i);
+                iowait += get_iowait_time(i);
+                irq += kcpustat_cpu(i).cpustat[CPUTIME_IRQ];
+                softirq += kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ];
+                steal += kcpustat_cpu(i).cpustat[CPUTIME_STEAL];
+                guest += kcpustat_cpu(i).cpustat[CPUTIME_GUEST];
+                guest_nice += kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE];
 
                 for (j = 0; j < NR_SOFTIRQS; j++) {
                         unsigned int softirq_stat = kstat_softirqs_cpu(j, i);
@@ -106,16 +101,16 @@ static int show_stat(struct seq_file *p, void *v)
                 (unsigned long long)cputime64_to_clock_t(guest_nice));
         for_each_online_cpu(i) {
                 /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
-                user = kstat_cpu(i).cpustat.user;
-                nice = kstat_cpu(i).cpustat.nice;
-                system = kstat_cpu(i).cpustat.system;
+                user = kcpustat_cpu(i).cpustat[CPUTIME_USER];
+                nice = kcpustat_cpu(i).cpustat[CPUTIME_NICE];
+                system = kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM];
                 idle = get_idle_time(i);
                 iowait = get_iowait_time(i);
-                irq = kstat_cpu(i).cpustat.irq;
-                softirq = kstat_cpu(i).cpustat.softirq;
-                steal = kstat_cpu(i).cpustat.steal;
-                guest = kstat_cpu(i).cpustat.guest;
-                guest_nice = kstat_cpu(i).cpustat.guest_nice;
+                irq = kcpustat_cpu(i).cpustat[CPUTIME_IRQ];
+                softirq = kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ];
+                steal = kcpustat_cpu(i).cpustat[CPUTIME_STEAL];
+                guest = kcpustat_cpu(i).cpustat[CPUTIME_GUEST];
+                guest_nice = kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE];
                 seq_printf(p,
                         "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu "
                         "%llu\n",
diff --git a/fs/proc/uptime.c b/fs/proc/uptime.c
index 766b1d45605..9610ac772d7 100644
--- a/fs/proc/uptime.c
+++ b/fs/proc/uptime.c
@@ -11,15 +11,20 @@ static int uptime_proc_show(struct seq_file *m, void *v)
 {
         struct timespec uptime;
         struct timespec idle;
+        u64 idletime;
+        u64 nsec;
+        u32 rem;
         int i;
-        cputime_t idletime = cputime_zero;
 
+        idletime = 0;
         for_each_possible_cpu(i)
-                idletime = cputime64_add(idletime, kstat_cpu(i).cpustat.idle);
+                idletime += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE];
 
         do_posix_clock_monotonic_gettime(&uptime);
         monotonic_to_bootbased(&uptime);
-        cputime_to_timespec(idletime, &idle);
+        nsec = cputime64_to_jiffies64(idletime) * TICK_NSEC;
+        idle.tv_sec = div_u64_rem(nsec, NSEC_PER_SEC, &rem);
+        idle.tv_nsec = rem;
         seq_printf(m, "%lu.%02lu %lu.%02lu\n",
                         (unsigned long) uptime.tv_sec,
                         (uptime.tv_nsec / (NSEC_PER_SEC / 100)),
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index 379a02dc121..b3b426edb2f 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -80,7 +80,8 @@ static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct pstore_private *p = dentry->d_inode->i_private;
 
-        p->psi->erase(p->type, p->id, p->psi);
+        if (p->psi->erase)
+                p->psi->erase(p->type, p->id, p->psi);
 
         return simple_unlink(dir, dentry);
 }
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 57bbf9078ac..9ec22d3b429 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -122,7 +122,7 @@ static void pstore_dump(struct kmsg_dumper *dumper,
                 memcpy(dst, s1 + s1_start, l1_cpy);
                 memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
 
-                ret = psinfo->write(PSTORE_TYPE_DMESG, &id, part,
+                ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part,
                                    hsize + l1_cpy + l2_cpy, psinfo);
                 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted())
                         pstore_new_entry = 1;
@@ -207,8 +207,7 @@ void pstore_get_records(int quiet)
                 return;
 
         mutex_lock(&psi->read_mutex);
-        rc = psi->open(psi);
-        if (rc)
+        if (psi->open && psi->open(psi))
                 goto out;
 
         while ((size = psi->read(&id, &type, &time, &buf, psi)) > 0) {
@@ -219,7 +218,8 @@ void pstore_get_records(int quiet)
                 if (rc && (rc != -EEXIST || !quiet))
                         failed++;
         }
-        psi->close(psi);
+        if (psi->close)
+                psi->close(psi);
 out:
         mutex_unlock(&psi->read_mutex);
 
@@ -243,33 +243,5 @@ static void pstore_timefunc(unsigned long dummy)
         mod_timer(&pstore_timer, jiffies + PSTORE_INTERVAL);
 }
 
-/*
- * Call platform driver to write a record to the
- * persistent store.
- */
-int pstore_write(enum pstore_type_id type, char *buf, size_t size)
-{
-        u64             id;
-        int             ret;
-        unsigned long   flags;
-
-        if (!psinfo)
-                return -ENODEV;
-
-        if (size > psinfo->bufsize)
-                return -EFBIG;
-
-        spin_lock_irqsave(&psinfo->buf_lock, flags);
-        memcpy(psinfo->buf, buf, size);
-        ret = psinfo->write(type, &id, 0, size, psinfo);
-        if (ret == 0 && pstore_is_mounted())
-                pstore_mkfile(PSTORE_TYPE_DMESG, psinfo->name, id, psinfo->buf,
-                              size, CURRENT_TIME, psinfo);
-        spin_unlock_irqrestore(&psinfo->buf_lock, flags);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(pstore_write);
-
 module_param(backend, charp, 0444);
 MODULE_PARM_DESC(backend, "Pstore backend to use");