Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Conflicts:
	drivers/net/ethernet/emulex/benet/be_main.c
	drivers/net/ethernet/intel/igb/igb_main.c
	drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
	include/net/scm.h
	net/batman-adv/routing.c
	net/ipv4/tcp_input.c

The e{uid,gid} --> {uid,gid} credentials fix conflicted with the
cleanup in net-next to now pass cred structs around.

The be2net driver had a bug fix in 'net' that overlapped with the VLAN
interface changes by Patrick McHardy in net-next.

An IGB conflict existed because in 'net' the build_skb() support was
reverted, and in 'net-next' there was a comment style fix within that
code.

Several batman-adv conflicts were resolved by making sure that all
calls to batadv_is_my_mac() are changed to have a new bat_priv first
argument.

Eric Dumazet's TS ECR fix in TCP in 'net' conflicted with the F-RTO
rewrite in 'net-next', mostly overlapping changes.

Thanks to Stephen Rothwell and Antonio Quartulli for help with several
of these merge resolutions.

Signed-off-by: David S. Miller <davem@davemloft.net>

28 files changed, 351 insertions, 261 deletions

diff --git a/include/asm-generic/tlb.h b/include/asm-generic/tlb.h
index 25f01d0bc149..b1b1fa6ffffe 100644
--- a/include/asm-generic/tlb.h
+++ b/include/asm-generic/tlb.h
@@ -99,7 +99,12 @@ struct mmu_gather {
         unsigned int            need_flush : 1, /* Did free PTEs */
                                 fast_mode  : 1; /* No batching   */
 
-        unsigned int            fullmm;
+        /* we are in the middle of an operation to clear
+         * a full mm and can make some optimizations */
+        unsigned int            fullmm : 1,
+        /* we have performed an operation which
+         * requires a complete flush of the tlb */
+                                need_flush_all : 1;
 
         struct mmu_gather_batch *active;
         struct mmu_gather_batch local;
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 8f7a3d68371a..ee0bd9524055 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -954,7 +954,7 @@ static inline int atapi_cdb_len(const u16 *dev_id)
         }
 }
 
-static inline bool atapi_command_packet_set(const u16 *dev_id)
+static inline int atapi_command_packet_set(const u16 *dev_id)
 {
         return (dev_id[ATA_ID_CONFIG] >> 8) & 0x1f;
 }
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 0ea61e07a91c..7c2e030e72f1 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -12,7 +12,6 @@
 
 struct blk_trace {
         int trace_state;
-        bool rq_based;
         struct rchan *rchan;
         unsigned long __percpu *sequence;
         unsigned char __percpu *msg_data;
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 98503b792369..d9a4f7f40f32 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -35,6 +35,7 @@ struct cpu_vfs_cap_data {
 #define _KERNEL_CAP_T_SIZE     (sizeof(kernel_cap_t))
 
 
+struct file;
 struct inode;
 struct dentry;
 struct user_namespace;
@@ -211,6 +212,7 @@ extern bool capable(int cap);
 extern bool ns_capable(struct user_namespace *ns, int cap);
 extern bool nsown_capable(int cap);
 extern bool inode_capable(const struct inode *inode, int cap);
+extern bool file_ns_capable(const struct file *file, struct user_namespace *ns, int cap);
 
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 9bf2f1fcae27..3d7df3d32c66 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -333,6 +333,7 @@ typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
                                               unsigned long count,
                                               u64 *max_size,
                                               int *reset_type);
+typedef efi_status_t efi_query_variable_store_t(u32 attributes, unsigned long size);
 
 /*
  *  EFI Configuration Table and GUID definitions
@@ -575,9 +576,15 @@ extern void efi_enter_virtual_mode (void);	/* switch EFI to virtual mode, if pos
 #ifdef CONFIG_X86
 extern void efi_late_init(void);
 extern void efi_free_boot_services(void);
+extern efi_status_t efi_query_variable_store(u32 attributes, unsigned long size);
 #else
 static inline void efi_late_init(void) {}
 static inline void efi_free_boot_services(void) {}
+
+static inline efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
+{
+        return EFI_SUCCESS;
+}
 #endif
 extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
 extern u64 efi_get_iobase (void);
@@ -731,7 +738,7 @@ struct efivar_operations {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
-        efi_query_variable_info_t *query_variable_info;
+        efi_query_variable_store_t *query_variable_store;
 };
 
 struct efivars {
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index e5ca8ef50e9b..52da2a250795 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -89,6 +89,7 @@ typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
  *            that the call back has its own recursion protection. If it does
  *            not set this, then the ftrace infrastructure will add recursion
  *            protection for the caller.
+ * STUB   - The ftrace_ops is just a place holder.
  */
 enum {
         FTRACE_OPS_FL_ENABLED                   = 1 << 0,
@@ -98,6 +99,7 @@ enum {
         FTRACE_OPS_FL_SAVE_REGS                 = 1 << 4,
         FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED    = 1 << 5,
         FTRACE_OPS_FL_RECURSION_SAFE            = 1 << 6,
+        FTRACE_OPS_FL_STUB                      = 1 << 7,
 };
 
 struct ftrace_ops {
@@ -394,7 +396,6 @@ ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
                             size_t cnt, loff_t *ppos);
 ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
                              size_t cnt, loff_t *ppos);
-loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int whence);
 int ftrace_regex_release(struct inode *inode, struct file *file);
 
 void __init
@@ -567,6 +568,8 @@ static inline int
 ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
+loff_t ftrace_filter_lseek(struct file *file, loff_t offset, int whence);
+
 /* totally disable ftrace - can not re-enable after this */
 void ftrace_kill(void);
 
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index d2e6927bbaae..d78d28a733b1 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -200,6 +200,8 @@ extern size_t vmcoreinfo_max_size;
 
 int __init parse_crashkernel(char *cmdline, unsigned long long system_ram,
                 unsigned long long *crash_size, unsigned long long *crash_base);
+int parse_crashkernel_high(char *cmdline, unsigned long long system_ram,
+                unsigned long long *crash_size, unsigned long long *crash_base);
 int parse_crashkernel_low(char *cmdline, unsigned long long system_ram,
                 unsigned long long *crash_size, unsigned long long *crash_base);
 int crash_shrink_memory(unsigned long new_size);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index cad77fe09d77..c13958251927 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -518,7 +518,7 @@ int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
 int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
                            void *data, unsigned long len);
 int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
-                              gpa_t gpa);
+                              gpa_t gpa, unsigned long len);
 int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
 int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
 struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index fa7cc7244cbd..b0bcce0ddc95 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -71,6 +71,7 @@ struct gfn_to_hva_cache {
         u64 generation;
         gpa_t gpa;
         unsigned long hva;
+        unsigned long len;
         struct kvm_memory_slot *memslot;
 };
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 91c9d109e5f1..eae7a053dc51 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -398,6 +398,7 @@ enum {
         ATA_HORKAGE_NOSETXFER   = (1 << 14),    /* skip SETXFER, SATA only */
         ATA_HORKAGE_BROKEN_FPDMA_AA     = (1 << 15),    /* skip AA */
         ATA_HORKAGE_DUMP_ID     = (1 << 16),    /* dump IDENTIFY data */
+        ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),  /* Set max sects to 65535 */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index e19ff30ad0a2..e2091b88d24c 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1611,6 +1611,8 @@ int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
                         unsigned long pfn);
 int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
                         unsigned long pfn);
+int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len);
+
 
 struct page *follow_page_mask(struct vm_area_struct *vma,
                               unsigned long address, unsigned int foll_flags,
diff --git a/include/linux/netfilter/ipset/ip_set_ahash.h b/include/linux/netfilter/ipset/ip_set_ahash.h
index 01d25e6fc792..0214c4c146fa 100644
--- a/include/linux/netfilter/ipset/ip_set_ahash.h
+++ b/include/linux/netfilter/ipset/ip_set_ahash.h
@@ -291,6 +291,7 @@ ip_set_hash_destroy(struct ip_set *set)
 #define type_pf_data_tlist      TOKEN(TYPE, PF, _data_tlist)
 #define type_pf_data_next       TOKEN(TYPE, PF, _data_next)
 #define type_pf_data_flags      TOKEN(TYPE, PF, _data_flags)
+#define type_pf_data_reset_flags TOKEN(TYPE, PF, _data_reset_flags)
 #ifdef IP_SET_HASH_WITH_NETS
 #define type_pf_data_match      TOKEN(TYPE, PF, _data_match)
 #else
@@ -385,9 +386,9 @@ type_pf_resize(struct ip_set *set, bool retried)
         struct ip_set_hash *h = set->data;
         struct htable *t, *orig = h->table;
         u8 htable_bits = orig->htable_bits;
-        const struct type_pf_elem *data;
+        struct type_pf_elem *data;
         struct hbucket *n, *m;
-        u32 i, j;
+        u32 i, j, flags = 0;
         int ret;
 
 retry:
@@ -412,9 +413,16 @@ retry:
                 n = hbucket(orig, i);
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_data(n, j);
+#ifdef IP_SET_HASH_WITH_NETS
+                        flags = 0;
+                        type_pf_data_reset_flags(data, &flags);
+#endif
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_add(m, data, AHASH_MAX(h), 0);
+                        ret = type_pf_elem_add(m, data, AHASH_MAX(h), flags);
                         if (ret < 0) {
+#ifdef IP_SET_HASH_WITH_NETS
+                                type_pf_data_flags(data, flags);
+#endif
                                 read_unlock_bh(&set->lock);
                                 ahash_destroy(t);
                                 if (ret == -EAGAIN)
@@ -836,9 +844,9 @@ type_pf_tresize(struct ip_set *set, bool retried)
         struct ip_set_hash *h = set->data;
         struct htable *t, *orig = h->table;
         u8 htable_bits = orig->htable_bits;
-        const struct type_pf_elem *data;
+        struct type_pf_elem *data;
         struct hbucket *n, *m;
-        u32 i, j;
+        u32 i, j, flags = 0;
         int ret;
 
         /* Try to cleanup once */
@@ -873,10 +881,17 @@ retry:
                 n = hbucket(orig, i);
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_tdata(n, j);
+#ifdef IP_SET_HASH_WITH_NETS
+                        flags = 0;
+                        type_pf_data_reset_flags(data, &flags);
+#endif
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h), 0,
-                                                ip_set_timeout_get(type_pf_data_timeout(data)));
+                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h), flags,
+                                ip_set_timeout_get(type_pf_data_timeout(data)));
                         if (ret < 0) {
+#ifdef IP_SET_HASH_WITH_NETS
+                                type_pf_data_flags(data, flags);
+#endif
                                 read_unlock_bh(&set->lock);
                                 ahash_destroy(t);
                                 if (ret == -EAGAIN)
@@ -1187,6 +1202,7 @@ type_pf_gc_init(struct ip_set *set)
 #undef type_pf_data_tlist
 #undef type_pf_data_next
 #undef type_pf_data_flags
+#undef type_pf_data_reset_flags
 #undef type_pf_data_match
 
 #undef type_pf_elem
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 2461033a7987..710067f3618c 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -916,6 +916,7 @@ void pci_disable_rom(struct pci_dev *pdev);
 void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
 void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
 size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
+void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
 
 /* Power management related routines */
 int pci_save_state(struct pci_dev *dev);
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 5a710b9c578e..87a03c746f17 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -93,14 +93,20 @@ do { \
 
 #else /* !CONFIG_PREEMPT_COUNT */
 
-#define preempt_disable()               do { } while (0)
-#define sched_preempt_enable_no_resched()       do { } while (0)
-#define preempt_enable_no_resched()     do { } while (0)
-#define preempt_enable()                do { } while (0)
-
-#define preempt_disable_notrace()               do { } while (0)
-#define preempt_enable_no_resched_notrace()     do { } while (0)
-#define preempt_enable_notrace()                do { } while (0)
+/*
+ * Even if we don't have any preemption, we need preempt disable/enable
+ * to be barriers, so that we don't have things like get_user/put_user
+ * that can cause faults and scheduling migrate into our preempt-protected
+ * region.
+ */
+#define preempt_disable()               barrier()
+#define sched_preempt_enable_no_resched()       barrier()
+#define preempt_enable_no_resched()     barrier()
+#define preempt_enable()                barrier()
+
+#define preempt_disable_notrace()               barrier()
+#define preempt_enable_no_resched_notrace()     barrier()
+#define preempt_enable_notrace()                barrier()
 
 #endif /* CONFIG_PREEMPT_COUNT */
 
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 8307f2f94d86..94dfb2aa5533 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -117,6 +117,7 @@ struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
                                 const struct file_operations *proc_fops,
                                 void *data);
 extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
+extern int remove_proc_subtree(const char *name, struct proc_dir_entry *parent);
 
 struct pid_namespace;
 
@@ -202,6 +203,7 @@ static inline struct proc_dir_entry *proc_create_data(const char *name,
         return NULL;
 }
 #define remove_proc_entry(name, parent) do {} while (0)
+#define remove_proc_subtree(name, parent) do {} while (0)
 
 static inline struct proc_dir_entry *proc_symlink(const char *name,
                 struct proc_dir_entry *parent,const char *dest) {return NULL;}
diff --git a/include/linux/sched.h b/include/linux/sched.h
index d35d2b6ddbfb..e692a022527b 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -163,9 +163,10 @@ print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 #define TASK_DEAD               64
 #define TASK_WAKEKILL           128
 #define TASK_WAKING             256
-#define TASK_STATE_MAX          512
+#define TASK_PARKED             512
+#define TASK_STATE_MAX          1024
 
-#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKW"
+#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"
 
 extern char ___assert_task_state[1 - 2*!!(
                 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
diff --git a/include/linux/security.h b/include/linux/security.h
index eee7478cda70..032c366ef1c6 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1012,6 +1012,10 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      This hook can be used by the module to update any security state
  *      associated with the TUN device's security structure.
  *      @security pointer to the TUN devices's security structure.
+ * @skb_owned_by:
+ *      This hook sets the packet's owning sock.
+ *      @skb is the packet.
+ *      @sk the sock which owns the packet.
  *
  * Security hooks for XFRM operations.
  *
@@ -1638,6 +1642,7 @@ struct security_operations {
         int (*tun_dev_attach_queue) (void *security);
         int (*tun_dev_attach) (struct sock *sk, void *security);
         int (*tun_dev_open) (void *security);
+        void (*skb_owned_by) (struct sk_buff *skb, struct sock *sk);
 #endif  /* CONFIG_SECURITY_NETWORK */
 
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
@@ -2588,6 +2593,8 @@ int security_tun_dev_attach_queue(void *security);
 int security_tun_dev_attach(struct sock *sk, void *security);
 int security_tun_dev_open(void *security);
 
+void security_skb_owned_by(struct sk_buff *skb, struct sock *sk);
+
 #else   /* CONFIG_SECURITY_NETWORK */
 static inline int security_unix_stream_connect(struct sock *sock,
                                                struct sock *other,
@@ -2779,6 +2786,11 @@ static inline int security_tun_dev_open(void *security)
 {
         return 0;
 }
+
+static inline void security_skb_owned_by(struct sk_buff *skb, struct sock *sk)
+{
+}
+
 #endif  /* CONFIG_SECURITY_NETWORK */
 
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
diff --git a/include/linux/spinlock_up.h b/include/linux/spinlock_up.h
index a26e2fb604e6..e2369c167dbd 100644
--- a/include/linux/spinlock_up.h
+++ b/include/linux/spinlock_up.h
@@ -16,7 +16,10 @@
  * In the debug case, 1 means unlocked, 0 means locked. (the values
  * are inverted, to catch initialization bugs)
  *
- * No atomicity anywhere, we are on UP.
+ * No atomicity anywhere, we are on UP. However, we still need
+ * the compiler barriers, because we do not want the compiler to
+ * move potentially faulting instructions (notably user accesses)
+ * into the locked sequence, resulting in non-atomic execution.
  */
 
 #ifdef CONFIG_DEBUG_SPINLOCK
@@ -25,6 +28,7 @@
 static inline void arch_spin_lock(arch_spinlock_t *lock)
 {
         lock->slock = 0;
+        barrier();
 }
 
 static inline void
@@ -32,6 +36,7 @@ arch_spin_lock_flags(arch_spinlock_t *lock, unsigned long flags)
 {
         local_irq_save(flags);
         lock->slock = 0;
+        barrier();
 }
 
 static inline int arch_spin_trylock(arch_spinlock_t *lock)
@@ -39,32 +44,34 @@ static inline int arch_spin_trylock(arch_spinlock_t *lock)
         char oldval = lock->slock;
 
         lock->slock = 0;
+        barrier();
 
         return oldval > 0;
 }
 
 static inline void arch_spin_unlock(arch_spinlock_t *lock)
 {
+        barrier();
         lock->slock = 1;
 }
 
 /*
  * Read-write spinlocks. No debug version.
  */
-#define arch_read_lock(lock)            do { (void)(lock); } while (0)
-#define arch_write_lock(lock)           do { (void)(lock); } while (0)
-#define arch_read_trylock(lock) ({ (void)(lock); 1; })
-#define arch_write_trylock(lock)        ({ (void)(lock); 1; })
-#define arch_read_unlock(lock)          do { (void)(lock); } while (0)
-#define arch_write_unlock(lock) do { (void)(lock); } while (0)
+#define arch_read_lock(lock)            do { barrier(); (void)(lock); } while (0)
+#define arch_write_lock(lock)           do { barrier(); (void)(lock); } while (0)
+#define arch_read_trylock(lock) ({ barrier(); (void)(lock); 1; })
+#define arch_write_trylock(lock)        ({ barrier(); (void)(lock); 1; })
+#define arch_read_unlock(lock)          do { barrier(); (void)(lock); } while (0)
+#define arch_write_unlock(lock) do { barrier(); (void)(lock); } while (0)
 
 #else /* DEBUG_SPINLOCK */
 #define arch_spin_is_locked(lock)       ((void)(lock), 0)
 /* for sched.c and kernel_lock.c: */
-# define arch_spin_lock(lock)           do { (void)(lock); } while (0)
-# define arch_spin_lock_flags(lock, flags)      do { (void)(lock); } while (0)
-# define arch_spin_unlock(lock) do { (void)(lock); } while (0)
-# define arch_spin_trylock(lock)        ({ (void)(lock); 1; })
+# define arch_spin_lock(lock)           do { barrier(); (void)(lock); } while (0)
+# define arch_spin_lock_flags(lock, flags)      do { barrier(); (void)(lock); } while (0)
+# define arch_spin_unlock(lock) do { barrier(); (void)(lock); } while (0)
+# define arch_spin_trylock(lock)        ({ barrier(); (void)(lock); 1; })
 #endif /* DEBUG_SPINLOCK */
 
 #define arch_spin_is_contended(lock)    (((void)(lock), 0))
diff --git a/include/linux/ssb/ssb_driver_chipcommon.h b/include/linux/ssb/ssb_driver_chipcommon.h
index 9e492be5244b..6fcfe99bd999 100644
--- a/include/linux/ssb/ssb_driver_chipcommon.h
+++ b/include/linux/ssb/ssb_driver_chipcommon.h
@@ -219,6 +219,7 @@
 #define SSB_CHIPCO_PMU_CTL                      0x0600 /* PMU control */
 #define  SSB_CHIPCO_PMU_CTL_ILP_DIV             0xFFFF0000 /* ILP div mask */
 #define  SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT       16
+#define  SSB_CHIPCO_PMU_CTL_PLL_UPD             0x00000400
 #define  SSB_CHIPCO_PMU_CTL_NOILPONW            0x00000200 /* No ILP on wait */
 #define  SSB_CHIPCO_PMU_CTL_HTREQEN             0x00000100 /* HT req enable */
 #define  SSB_CHIPCO_PMU_CTL_ALPREQEN            0x00000080 /* ALP req enable */
@@ -667,5 +668,6 @@ enum ssb_pmu_ldo_volt_id {
 void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc,
                              enum ssb_pmu_ldo_volt_id id, u32 voltage);
 void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on);
+void ssb_pmu_spuravoid_pllupdate(struct ssb_chipcommon *cc, int spuravoid);
 
 #endif /* LINUX_SSB_CHIPCO_H_ */
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 2de42f9401d2..a5ffd32642fd 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -25,6 +25,7 @@ extern int swiotlb_force;
 extern void swiotlb_init(int verbose);
 int swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
 extern unsigned long swiotlb_nr_tbl(void);
+unsigned long swiotlb_size_or_default(void);
 extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
 
 /*
diff --git a/include/linux/ucs2_string.h b/include/linux/ucs2_string.h
new file mode 100644
index 000000000000..cbb20afdbc01
--- /dev/null
+++ b/include/linux/ucs2_string.h
@@ -0,0 +1,14 @@
+#ifndef _LINUX_UCS2_STRING_H_
+#define _LINUX_UCS2_STRING_H_
+
+#include <linux/types.h>        /* for size_t */
+#include <linux/stddef.h>       /* for NULL */
+
+typedef u16 ucs2_char_t;
+
+unsigned long ucs2_strnlen(const ucs2_char_t *s, size_t maxlength);
+unsigned long ucs2_strlen(const ucs2_char_t *s);
+unsigned long ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength);
+int ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len);
+
+#endif /* _LINUX_UCS2_STRING_H_ */
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 40be2a0d8ae1..84a6440f1f19 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -199,6 +199,7 @@ extern bool ipv6_chk_acast_addr(struct net *net, struct net_device *dev,
 /* Device notifier */
 extern int register_inet6addr_notifier(struct notifier_block *nb);
 extern int unregister_inet6addr_notifier(struct notifier_block *nb);
+extern int inet6addr_notifier_call_chain(unsigned long val, void *v);
 
 extern void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
                                          struct ipv6_devconf *devconf);
diff --git a/include/net/irda/irlmp.h b/include/net/irda/irlmp.h
index f74109144d3f..f132924cc9da 100644
--- a/include/net/irda/irlmp.h
+++ b/include/net/irda/irlmp.h
@@ -256,7 +256,8 @@ static inline __u32 irlmp_get_daddr(const struct lsap_cb *self)
         return (self && self->lap) ? self->lap->daddr : 0;
 }
 
-extern const char *irlmp_reasons[];
+const char *irlmp_reason_str(LM_REASON reason);
+
 extern int sysctl_discovery_timeout;
 extern int sysctl_discovery_slots;
 extern int sysctl_discovery;
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index cc7c19732389..714cc9a54a4c 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -130,6 +130,14 @@ struct iucv_sock {
                                                enum iucv_tx_notify n);
 };
 
+struct iucv_skb_cb {
+        u32     class;          /* target class of message */
+        u32     tag;            /* tag associated with message */
+        u32     offset;         /* offset for skb receival */
+};
+
+#define IUCV_SKB_CB(__skb)      ((struct iucv_skb_cb *)&((__skb)->cb[0]))
+
 /* iucv socket options (SOL_IUCV) */
 #define SO_IPRMDATA_MSG 0x0080          /* send/recv IPRM_DATA msgs */
 #define SO_MSGLIMIT     0x1000          /* get/set IUCV MSGLIMIT */
diff --git a/include/net/scm.h b/include/net/scm.h
index 5a4c6a9eb122..8de2d37d2077 100644
--- a/include/net/scm.h
+++ b/include/net/scm.h
@@ -78,7 +78,7 @@ static __inline__ int scm_send(struct socket *sock, struct msghdr *msg,
         scm->creds.uid = INVALID_UID;
         scm->creds.gid = INVALID_GID;
         if (forcecreds)
-                scm_set_cred(scm, task_tgid(current), current_euid(), current_egid());
+                scm_set_cred(scm, task_tgid(current), current_uid(), current_gid());
         unix_get_peersec_dgram(sock, scm);
         if (msg->msg_controllen <= 0)
                 return 0;
diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index 9961726523d0..9c1467357b03 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -257,6 +257,7 @@ TRACE_EVENT(block_bio_bounce,
 
 /**
  * block_bio_complete - completed all work on the block operation
+ * @q: queue holding the block operation
  * @bio: block operation completed
  * @error: io error value
  *
@@ -265,9 +266,9 @@ TRACE_EVENT(block_bio_bounce,
  */
 TRACE_EVENT(block_bio_complete,
 
-        TP_PROTO(struct bio *bio, int error),
+        TP_PROTO(struct request_queue *q, struct bio *bio, int error),
 
-        TP_ARGS(bio, error),
+        TP_ARGS(q, bio, error),
 
         TP_STRUCT__entry(
                 __field( dev_t,         dev             )
@@ -278,8 +279,7 @@ TRACE_EVENT(block_bio_complete,
         ),
 
         TP_fast_assign(
-                __entry->dev            = bio->bi_bdev ?
-                                          bio->bi_bdev->bd_dev : 0;
+                __entry->dev            = bio->bi_bdev->bd_dev;
                 __entry->sector         = bio->bi_sector;
                 __entry->nr_sector      = bio->bi_size >> 9;
                 __entry->error          = error;
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index 5a8671e8a67f..e5586caff67a 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -147,7 +147,7 @@ TRACE_EVENT(sched_switch,
                   __print_flags(__entry->prev_state & (TASK_STATE_MAX-1), "|",
                                 { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
                                 { 16, "Z" }, { 32, "X" }, { 64, "x" },
-                                { 128, "W" }) : "R",
+                                { 128, "K" }, { 256, "W" }, { 512, "P" }) : "R",
                 __entry->prev_state & TASK_STATE_MAX ? "+" : "",
                 __entry->next_comm, __entry->next_pid, __entry->next_prio)
 );
diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
index 4c43b4448792..706d035fa748 100644
--- a/include/uapi/linux/fuse.h
+++ b/include/uapi/linux/fuse.h
@@ -95,15 +95,10 @@
 #ifndef _LINUX_FUSE_H
 #define _LINUX_FUSE_H
 
-#ifdef __linux__
+#ifdef __KERNEL__
 #include <linux/types.h>
 #else
 #include <stdint.h>
-#define __u64 uint64_t
-#define __s64 int64_t
-#define __u32 uint32_t
-#define __s32 int32_t
-#define __u16 uint16_t
 #endif
 
 /*
@@ -139,42 +134,42 @@
    userspace works under 64bit kernels */
 
 struct fuse_attr {
-        __u64   ino;
-        __u64   size;
-        __u64   blocks;
-        __u64   atime;
-        __u64   mtime;
-        __u64   ctime;
-        __u32   atimensec;
-        __u32   mtimensec;
-        __u32   ctimensec;
-        __u32   mode;
-        __u32   nlink;
-        __u32   uid;
-        __u32   gid;
-        __u32   rdev;
-        __u32   blksize;
-        __u32   padding;
+        uint64_t        ino;
+        uint64_t        size;
+        uint64_t        blocks;
+        uint64_t        atime;
+        uint64_t        mtime;
+        uint64_t        ctime;
+        uint32_t        atimensec;
+        uint32_t        mtimensec;
+        uint32_t        ctimensec;
+        uint32_t        mode;
+        uint32_t        nlink;
+        uint32_t        uid;
+        uint32_t        gid;
+        uint32_t        rdev;
+        uint32_t        blksize;
+        uint32_t        padding;
 };
 
 struct fuse_kstatfs {
-        __u64   blocks;
-        __u64   bfree;
-        __u64   bavail;
-        __u64   files;
-        __u64   ffree;
-        __u32   bsize;
-        __u32   namelen;
-        __u32   frsize;
-        __u32   padding;
-        __u32   spare[6];
+        uint64_t        blocks;
+        uint64_t        bfree;
+        uint64_t        bavail;
+        uint64_t        files;
+        uint64_t        ffree;
+        uint32_t        bsize;
+        uint32_t        namelen;
+        uint32_t        frsize;
+        uint32_t        padding;
+        uint32_t        spare[6];
 };
 
 struct fuse_file_lock {
-        __u64   start;
-        __u64   end;
-        __u32   type;
-        __u32   pid; /* tgid */
+        uint64_t        start;
+        uint64_t        end;
+        uint32_t        type;
+        uint32_t        pid; /* tgid */
 };
 
 /**
@@ -364,143 +359,143 @@ enum fuse_notify_code {
 #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
 
 struct fuse_entry_out {
-        __u64   nodeid;         /* Inode ID */
-        __u64   generation;     /* Inode generation: nodeid:gen must
-                                   be unique for the fs's lifetime */
-        __u64   entry_valid;    /* Cache timeout for the name */
-        __u64   attr_valid;     /* Cache timeout for the attributes */
-        __u32   entry_valid_nsec;
-        __u32   attr_valid_nsec;
+        uint64_t        nodeid;         /* Inode ID */
+        uint64_t        generation;     /* Inode generation: nodeid:gen must
+                                           be unique for the fs's lifetime */
+        uint64_t        entry_valid;    /* Cache timeout for the name */
+        uint64_t        attr_valid;     /* Cache timeout for the attributes */
+        uint32_t        entry_valid_nsec;
+        uint32_t        attr_valid_nsec;
         struct fuse_attr attr;
 };
 
 struct fuse_forget_in {
-        __u64   nlookup;
+        uint64_t        nlookup;
 };
 
 struct fuse_forget_one {
-        __u64   nodeid;
-        __u64   nlookup;
+        uint64_t        nodeid;
+        uint64_t        nlookup;
 };
 
 struct fuse_batch_forget_in {
-        __u32   count;
-        __u32   dummy;
+        uint32_t        count;
+        uint32_t        dummy;
 };
 
 struct fuse_getattr_in {
-        __u32   getattr_flags;
-        __u32   dummy;
-        __u64   fh;
+        uint32_t        getattr_flags;
+        uint32_t        dummy;
+        uint64_t        fh;
 };
 
 #define FUSE_COMPAT_ATTR_OUT_SIZE 96
 
 struct fuse_attr_out {
-        __u64   attr_valid;     /* Cache timeout for the attributes */
-        __u32   attr_valid_nsec;
-        __u32   dummy;
+        uint64_t        attr_valid;     /* Cache timeout for the attributes */
+        uint32_t        attr_valid_nsec;
+        uint32_t        dummy;
         struct fuse_attr attr;
 };
 
 #define FUSE_COMPAT_MKNOD_IN_SIZE 8
 
 struct fuse_mknod_in {
-        __u32   mode;
-        __u32   rdev;
-        __u32   umask;
-        __u32   padding;
+        uint32_t        mode;
+        uint32_t        rdev;
+        uint32_t        umask;
+        uint32_t        padding;
 };
 
 struct fuse_mkdir_in {
-        __u32   mode;
-        __u32   umask;
+        uint32_t        mode;
+        uint32_t        umask;
 };
 
 struct fuse_rename_in {
-        __u64   newdir;
+        uint64_t        newdir;
 };
 
 struct fuse_link_in {
-        __u64   oldnodeid;
+        uint64_t        oldnodeid;
 };
 
 struct fuse_setattr_in {
-        __u32   valid;
-        __u32   padding;
-        __u64   fh;
-        __u64   size;
-        __u64   lock_owner;
-        __u64   atime;
-        __u64   mtime;
-        __u64   unused2;
-        __u32   atimensec;
-        __u32   mtimensec;
-        __u32   unused3;
-        __u32   mode;
-        __u32   unused4;
-        __u32   uid;
-        __u32   gid;
-        __u32   unused5;
+        uint32_t        valid;
+        uint32_t        padding;
+        uint64_t        fh;
+        uint64_t        size;
+        uint64_t        lock_owner;
+        uint64_t        atime;
+        uint64_t        mtime;
+        uint64_t        unused2;
+        uint32_t        atimensec;
+        uint32_t        mtimensec;
+        uint32_t        unused3;
+        uint32_t        mode;
+        uint32_t        unused4;
+        uint32_t        uid;
+        uint32_t        gid;
+        uint32_t        unused5;
 };
 
 struct fuse_open_in {
-        __u32   flags;
-        __u32   unused;
+        uint32_t        flags;
+        uint32_t        unused;
 };
 
 struct fuse_create_in {
-        __u32   flags;
-        __u32   mode;
-        __u32   umask;
-        __u32   padding;
+        uint32_t        flags;
+        uint32_t        mode;
+        uint32_t        umask;
+        uint32_t        padding;
 };
 
 struct fuse_open_out {
-        __u64   fh;
-        __u32   open_flags;
-        __u32   padding;
+        uint64_t        fh;
+        uint32_t        open_flags;
+        uint32_t        padding;
 };
 
 struct fuse_release_in {
-        __u64   fh;
-        __u32   flags;
-        __u32   release_flags;
-        __u64   lock_owner;
+        uint64_t        fh;
+        uint32_t        flags;
+        uint32_t        release_flags;
+        uint64_t        lock_owner;
 };
 
 struct fuse_flush_in {
-        __u64   fh;
-        __u32   unused;
-        __u32   padding;
-        __u64   lock_owner;
+        uint64_t        fh;
+        uint32_t        unused;
+        uint32_t        padding;
+        uint64_t        lock_owner;
 };
 
 struct fuse_read_in {
-        __u64   fh;
-        __u64   offset;
-        __u32   size;
-        __u32   read_flags;
-        __u64   lock_owner;
-        __u32   flags;
-        __u32   padding;
+        uint64_t        fh;
+        uint64_t        offset;
+        uint32_t        size;
+        uint32_t        read_flags;
+        uint64_t        lock_owner;
+        uint32_t        flags;
+        uint32_t        padding;
 };
 
 #define FUSE_COMPAT_WRITE_IN_SIZE 24
 
 struct fuse_write_in {
-        __u64   fh;
-        __u64   offset;
-        __u32   size;
-        __u32   write_flags;
-        __u64   lock_owner;
-        __u32   flags;
-        __u32   padding;
+        uint64_t        fh;
+        uint64_t        offset;
+        uint32_t        size;
+        uint32_t        write_flags;
+        uint64_t        lock_owner;
+        uint32_t        flags;
+        uint32_t        padding;
 };
 
 struct fuse_write_out {
-        __u32   size;
-        __u32   padding;
+        uint32_t        size;
+        uint32_t        padding;
 };
 
 #define FUSE_COMPAT_STATFS_SIZE 48
@@ -510,32 +505,32 @@ struct fuse_statfs_out {
 };
 
 struct fuse_fsync_in {
-        __u64   fh;
-        __u32   fsync_flags;
-        __u32   padding;
+        uint64_t        fh;
+        uint32_t        fsync_flags;
+        uint32_t        padding;
 };
 
 struct fuse_setxattr_in {
-        __u32   size;
-        __u32   flags;
+        uint32_t        size;
+        uint32_t        flags;
 };
 
 struct fuse_getxattr_in {
-        __u32   size;
-        __u32   padding;
+        uint32_t        size;
+        uint32_t        padding;
 };
 
 struct fuse_getxattr_out {
-        __u32   size;
-        __u32   padding;
+        uint32_t        size;
+        uint32_t        padding;
 };
 
 struct fuse_lk_in {
-        __u64   fh;
-        __u64   owner;
+        uint64_t        fh;
+        uint64_t        owner;
         struct fuse_file_lock lk;
-        __u32   lk_flags;
-        __u32   padding;
+        uint32_t        lk_flags;
+        uint32_t        padding;
 };
 
 struct fuse_lk_out {
@@ -543,134 +538,135 @@ struct fuse_lk_out {
 };
 
 struct fuse_access_in {
-        __u32   mask;
-        __u32   padding;
+        uint32_t        mask;
+        uint32_t        padding;
 };
 
 struct fuse_init_in {
-        __u32   major;
-        __u32   minor;
-        __u32   max_readahead;
-        __u32   flags;
+        uint32_t        major;
+        uint32_t        minor;
+        uint32_t        max_readahead;
+        uint32_t        flags;
 };
 
 struct fuse_init_out {
-        __u32   major;
-        __u32   minor;
-        __u32   max_readahead;
-        __u32   flags;
-        __u16   max_background;
-        __u16   congestion_threshold;
-        __u32   max_write;
+        uint32_t        major;
+        uint32_t        minor;
+        uint32_t        max_readahead;
+        uint32_t        flags;
+        uint16_t        max_background;
+        uint16_t        congestion_threshold;
+        uint32_t        max_write;
 };
 
 #define CUSE_INIT_INFO_MAX 4096
 
 struct cuse_init_in {
-        __u32   major;
-        __u32   minor;
-        __u32   unused;
-        __u32   flags;
+        uint32_t        major;
+        uint32_t        minor;
+        uint32_t        unused;
+        uint32_t        flags;
 };
 
 struct cuse_init_out {
-        __u32   major;
-        __u32   minor;
-        __u32   unused;
-        __u32   flags;
-        __u32   max_read;
-        __u32   max_write;
-        __u32   dev_major;              /* chardev major */
-        __u32   dev_minor;              /* chardev minor */
-        __u32   spare[10];
+        uint32_t        major;
+        uint32_t        minor;
+        uint32_t        unused;
+        uint32_t        flags;
+        uint32_t        max_read;
+        uint32_t        max_write;
+        uint32_t        dev_major;              /* chardev major */
+        uint32_t        dev_minor;              /* chardev minor */
+        uint32_t        spare[10];
 };
 
 struct fuse_interrupt_in {
-        __u64   unique;
+        uint64_t        unique;
 };
 
 struct fuse_bmap_in {
-        __u64   block;
-        __u32   blocksize;
-        __u32   padding;
+        uint64_t        block;
+        uint32_t        blocksize;
+        uint32_t        padding;
 };
 
 struct fuse_bmap_out {
-        __u64   block;
+        uint64_t        block;
 };
 
 struct fuse_ioctl_in {
-        __u64   fh;
-        __u32   flags;
-        __u32   cmd;
-        __u64   arg;
-        __u32   in_size;
-        __u32   out_size;
+        uint64_t        fh;
+        uint32_t        flags;
+        uint32_t        cmd;
+        uint64_t        arg;
+        uint32_t        in_size;
+        uint32_t        out_size;
 };
 
 struct fuse_ioctl_iovec {
-        __u64   base;
-        __u64   len;
+        uint64_t        base;
+        uint64_t        len;
 };
 
 struct fuse_ioctl_out {
-        __s32   result;
-        __u32   flags;
-        __u32   in_iovs;
-        __u32   out_iovs;
+        int32_t         result;
+        uint32_t        flags;
+        uint32_t        in_iovs;
+        uint32_t        out_iovs;
 };
 
 struct fuse_poll_in {
-        __u64   fh;
-        __u64   kh;
-        __u32   flags;
-        __u32   events;
+        uint64_t        fh;
+        uint64_t        kh;
+        uint32_t        flags;
+        uint32_t        events;
 };
 
 struct fuse_poll_out {
-        __u32   revents;
-        __u32   padding;
+        uint32_t        revents;
+        uint32_t        padding;
 };
 
 struct fuse_notify_poll_wakeup_out {
-        __u64   kh;
+        uint64_t        kh;
 };
 
 struct fuse_fallocate_in {
-        __u64   fh;
-        __u64   offset;
-        __u64   length;
-        __u32   mode;
-        __u32   padding;
+        uint64_t        fh;
+        uint64_t        offset;
+        uint64_t        length;
+        uint32_t        mode;
+        uint32_t        padding;
 };
 
 struct fuse_in_header {
-        __u32   len;
-        __u32   opcode;
-        __u64   unique;
-        __u64   nodeid;
-        __u32   uid;
-        __u32   gid;
-        __u32   pid;
-        __u32   padding;
+        uint32_t        len;
+        uint32_t        opcode;
+        uint64_t        unique;
+        uint64_t        nodeid;
+        uint32_t        uid;
+        uint32_t        gid;
+        uint32_t        pid;
+        uint32_t        padding;
 };
 
 struct fuse_out_header {
-        __u32   len;
-        __s32   error;
-        __u64   unique;
+        uint32_t        len;
+        int32_t         error;
+        uint64_t        unique;
 };
 
 struct fuse_dirent {
-        __u64   ino;
-        __u64   off;
-        __u32   namelen;
-        __u32   type;
+        uint64_t        ino;
+        uint64_t        off;
+        uint32_t        namelen;
+        uint32_t        type;
         char name[];
 };
 
 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
-#define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
+#define FUSE_DIRENT_ALIGN(x) \
+        (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
 #define FUSE_DIRENT_SIZE(d) \
         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
 
@@ -685,47 +681,47 @@ struct fuse_direntplus {
         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
 
 struct fuse_notify_inval_inode_out {
-        __u64   ino;
-        __s64   off;
-        __s64   len;
+        uint64_t        ino;
+        int64_t         off;
+        int64_t         len;
 };
 
 struct fuse_notify_inval_entry_out {
-        __u64   parent;
-        __u32   namelen;
-        __u32   padding;
+        uint64_t        parent;
+        uint32_t        namelen;
+        uint32_t        padding;
 };
 
 struct fuse_notify_delete_out {
-        __u64   parent;
-        __u64   child;
-        __u32   namelen;
-        __u32   padding;
+        uint64_t        parent;
+        uint64_t        child;
+        uint32_t        namelen;
+        uint32_t        padding;
 };
 
 struct fuse_notify_store_out {
-        __u64   nodeid;
-        __u64   offset;
-        __u32   size;
-        __u32   padding;
+        uint64_t        nodeid;
+        uint64_t        offset;
+        uint32_t        size;
+        uint32_t        padding;
 };
 
 struct fuse_notify_retrieve_out {
-        __u64   notify_unique;
-        __u64   nodeid;
-        __u64   offset;
-        __u32   size;
-        __u32   padding;
+        uint64_t        notify_unique;
+        uint64_t        nodeid;
+        uint64_t        offset;
+        uint32_t        size;
+        uint32_t        padding;
 };
 
 /* Matches the size of fuse_write_in */
 struct fuse_notify_retrieve_in {
-        __u64   dummy1;
-        __u64   offset;
-        __u32   size;
-        __u32   dummy2;
-        __u64   dummy3;
-        __u64   dummy4;
+        uint64_t        dummy1;
+        uint64_t        offset;
+        uint32_t        size;
+        uint32_t        dummy2;
+        uint64_t        dummy3;
+        uint64_t        dummy4;
 };
 
 #endif /* _LINUX_FUSE_H */